box.hh

Go to the documentation of this file.

// This file is a part of Aurelia.
// Copyright (C) 2010  Valentin David
// Copyright (C) 2010  University of Bergen
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#ifndef __BOX_HH
# define __BOX_HH

# include <iostream>
# include <string>
# include <memory>

namespace aurelia {

  struct virtual_box {
    virtual ~virtual_box() {}

    virtual unsigned to_text(std::ostream& s, unsigned pos) const = 0;
  };

  template <typename ExactType>
  struct box: public virtual_box {
    operator ExactType&() {
      return *static_cast<ExactType*>(this);
    }

    operator const ExactType&() const {
      return *static_cast<const ExactType*>(this);
    }
  };

  struct string_box: public box<string_box> {
  private:
    std::string s;

  public:
    string_box(const std::string& s): s(s) {}

    string_box(const string_box& other): s(other.s) {}

    operator std::string() const {
      return s;
    }

    string_box& operator=(string_box other) {
      this->swap(other);
      return *this;
    }

    void swap(string_box& other) {
      std::swap(this->s, other.s);
    }

    virtual unsigned to_text(std::ostream& s, unsigned pos) const;
  };

  typedef string_box S;

  enum Dir : unsigned {
    HDir, VDir, HVDir
  };

  struct h_box {
    enum { dir = HDir };
  };
  struct v_box {
    enum { dir = VDir };
  };
  struct hv_box {
    enum { dir = HVDir };
  };

  struct virtual_boxList {
    virtual ~virtual_boxList() {}

    virtual unsigned to_text(std::ostream& s, unsigned pos,
                             unsigned VS, unsigned HS, unsigned IS,
                             Dir direction, bool first) const = 0;
  };

  template <typename ExactType>
  struct box_list: public virtual_boxList {
    operator ExactType&() {
      return *static_cast<ExactType*>(this);
    }

    operator const ExactType&() const {
      return *static_cast<const ExactType*>(this);
    }
  };


  struct box_list_end:
    public box_list<box_list_end> {
    virtual unsigned to_text(std::ostream&, unsigned pos,
                             unsigned, unsigned, unsigned,
                             Dir, bool) const {
      return pos;
    }
  };

  template <typename Head, typename Tail>
  struct box_list_cons: public box_list<box_list_cons<Head, Tail> > {
  private:
    Head _head;
    Tail _tail;

  public:
    box_list_cons(const Head& _head, const Tail& _tail):
      _head(_head), _tail(_tail) {}

    const Head& head() const {
      return _head;
    }

    const Tail& tail() const {
      return _tail;
    }

    virtual unsigned to_text(std::ostream& s, unsigned pos,
                             unsigned HS, unsigned VS, unsigned IS,
                             Dir direction, bool first)
      const {
      if (direction == HDir) {
        pos = box_to_text(s, pos, head());
        for (unsigned i = 0; i < HS; ++i)
          s << " ";
        pos += HS;
        return tail().to_text(s, pos, HS, VS, IS, direction, false);
      } else if (direction == VDir) {
        if (!first) {
          for (unsigned i = 0; i <= VS; ++i)
            s << "\n";
          for (unsigned i = 0; i < pos; ++i)
            s << " ";
        }
        box_to_text(s, pos, head());
        if (first)
          pos += IS;
        return tail().to_text(s, pos, HS, VS, IS, direction, false);
      }

      return pos;
    }
  };


  struct any_box_list: public box_list<any_box_list> {
  private:
    std::shared_ptr<virtual_boxList> list;

  public:
    template <typename ExactType>
    any_box_list(const box_list<ExactType>& l): list(new ExactType(l)) {}

    any_box_list(const any_box_list& other): list(other.list) {}

    any_box_list& operator=(any_box_list other) {
      this->swap(other);
      return *this;
    }

    void swap(any_box_list& other) {
      std::swap(this->list, other.list);
    }

    virtual unsigned to_text(std::ostream& s, unsigned pos,
                             unsigned VS, unsigned HS, unsigned IS,
                             Dir direction, bool first) const {
      return list->to_text(s, pos, VS, HS, IS, direction, first);
    }
  };

  template <typename Direction, unsigned VS, unsigned HS, unsigned IS,
            typename List>
  struct container_box:
    public box<container_box<Direction, VS, HS, IS, List> > {
  private:
    List list;
  public:
    container_box(const List& list): list(list) {}

    container_box(const container_box& other): list(other.list) {}

    const List* operator->() const {
      return &list;
    }

    const List& operator*() const {
      return list;
    }

    container_box& operator=(container_box other) {
      this->swap(other);
      return *this;
    }

    void swap(container_box& other) {
      this->list.swap(other.list);
    }

    virtual unsigned to_text(std::ostream& s, unsigned pos) const {
      return box_to_text(s, pos, *this);
    }
  };

  struct any_box: public box<any_box> {
  private:
    std::shared_ptr<virtual_box> _box;

  public:
    template <typename RealType>
    explicit any_box(const box<RealType>& b): _box(new RealType(b)) {}

    any_box(const any_box& other): _box(other._box) {}

    any_box& operator=(any_box other) {
      this->swap(other);
      return (*this);
    }

    void swap(any_box& other) {
      std::swap(this->_box, other._box);
    }

    virtual unsigned to_text(std::ostream&s, unsigned pos) const;
  };

  template <typename ExactBox>
  box_list_cons<ExactBox, box_list_end>
  append(const box_list_end&, const box<ExactBox>& b) {
    return box_list_cons<ExactBox, box_list_end>(b, box_list_end());
  }

  template <typename B, typename Tail, typename ExactBox>
  box_list_cons<B,decltype(append(std::declval<Tail>(),
                                std::declval<ExactBox>()))>
  append(const box_list_cons<B, Tail>& l, const box<ExactBox>& b) {
    return box_list_cons<B,decltype(append(std::declval<Tail>(),
                                         std::declval<ExactBox>()))>
    (l.head(), append(l.tail(), b));
  }

  template <typename ExactBox, typename ExactList>
  decltype(append(std::declval<ExactList>(), std::declval<ExactBox>()))
  operator,(const box_list<ExactList>& l, const box<ExactBox>& s) {
    return append(ExactList(l), s);
  }

  template <typename ExactBox, typename ExactBox2>
  box_list_cons<ExactBox, box_list_cons<ExactBox2, box_list_end> >
  operator,(const box<ExactBox>& s, const box<ExactBox2>& t) {
    return box_list_cons<ExactBox, box_list_cons<ExactBox2, box_list_end> >
      (s, box_list_cons<ExactBox2, box_list_end>(t, box_list_end()));
  }

  template <unsigned VS, unsigned HS, unsigned IS>
  struct space_conf {};

  template <unsigned VS>
  space_conf<VS, 0, 0> Vs() {
    return space_conf<VS, 0, 0>();
  }

  template <unsigned HS>
  space_conf<0, HS, 0> Hs() {
    return space_conf<0, HS, 0>();
  }

  template <unsigned IS>
  space_conf<0, 0, IS> Is() {
    return space_conf<0, 0, IS>();
  }

  template <unsigned a, unsigned b>
  struct max {
    enum : unsigned { ret = (a>b)?a:b };
  };


  template <unsigned VS1, unsigned HS1, unsigned IS1,
            unsigned VS2, unsigned HS2, unsigned IS2>
  space_conf<max<VS1, VS2>::ret,
            max<HS1, HS2>::ret,
            max<IS1, IS2>::ret>
  operator,(const space_conf<VS1, HS1, IS1>&,
            const space_conf<VS2, HS2, IS2>&) {
    return space_conf<max<VS1, VS2>::ret,
      max<HS1, HS2>::ret,
      max<IS1, IS2>::ret>();
  }

  template <typename Direction, unsigned VS, unsigned HS, unsigned IS>
  struct box_artifact {
    template <typename ExactList>
    container_box<Direction, VS, HS, IS, ExactList>
    operator[](const box_list<ExactList>& l) const {
      return container_box<Direction, VS, HS, IS, ExactList>(l);
    }

    template <typename ExactBox>
    container_box<Direction, VS, HS, IS, box_list_cons<ExactBox, box_list_end> >
    operator[](const box<ExactBox>& l) const {
      return
        container_box<Direction, VS, HS, IS, box_list_cons<ExactBox, box_list_end> >
        (box_list_cons<ExactBox, box_list_end>(l, box_list_end()));
    }
  };

  template <unsigned VS, unsigned HS, unsigned IS>
  box_artifact<h_box, VS, HS, IS> H(const space_conf<VS, HS, IS>&) {
    return box_artifact<h_box, VS, HS, IS>();
  }

  box_artifact<h_box, 0, 1, 0> H() {
    return box_artifact<h_box, 0, 1, 0>();
  }

  template <unsigned VS, unsigned HS, unsigned IS>
  box_artifact<v_box, VS, HS, IS> V(const space_conf<VS, HS, IS>&) {
    return box_artifact<v_box, VS, HS, IS>();
  }

  box_artifact<v_box, 0, 0, 0> V() {
    return box_artifact<v_box, 0, 0, 0>();
  }

  template <unsigned VS, unsigned HS, unsigned IS>
  box_artifact<hv_box, VS, HS, IS> HV(const space_conf<VS, HS, IS>&) {
    return box_artifact<hv_box, VS, HS, IS>();
  }

  box_artifact<hv_box, 0, 1, 0> HV() {
    return box_artifact<hv_box, 0, 1, 0>();
  }

  template <typename Stream, unsigned VS, unsigned HS, unsigned IS,
            typename Head, typename Head2, typename Tail>
  unsigned box_to_text(Stream& s, unsigned pos, const v_box&,
                       const space_conf<VS, HS, IS>&,
                       const box_list_cons<Head,
                       box_list_cons<Head2, Tail> >& bl) {
    box_to_text(s, pos, bl.head());
    for (unsigned i = 0; i < (VS + 1); ++i)
      s << std::endl;
    for (unsigned i = 0; i < pos; ++i)
      s << " ";
    return box_to_text(s, pos, v_box(), space_conf<VS, HS, IS>(), bl.tail());
  }

  template <typename Stream, unsigned VS, unsigned HS, unsigned IS,
            typename Head>
  unsigned box_to_text(Stream& s, unsigned pos, const v_box&,
                       const space_conf<VS, HS, IS>&,
                       const box_list_cons<Head, box_list_end>& bl) {
    return box_to_text(s, pos, bl.head());
  }

  template <typename Stream, unsigned VS, unsigned HS, unsigned IS>
  unsigned box_to_text(Stream&, unsigned pos, const v_box&,
                       const space_conf<VS, HS, IS>&,
                       const box_list_end&) {
    return pos;
  }

  template <unsigned HS>
  struct print_space {
    template <typename Stream>
    static void doit(Stream& s) {
      for (unsigned i = 0; i < HS; ++i)
        s << " ";
    }
  };

  template <>
  struct print_space<0U> {
    template <typename Stream>
    static void doit(Stream&) {}
  };

  template <typename Stream, unsigned VS, unsigned HS, unsigned IS,
            typename Head, typename Head2, typename Tail>
  unsigned box_to_text(Stream& s, unsigned pos, const h_box&,
                       const space_conf<VS, HS, IS>&,
                       const box_list_cons<Head,
                       box_list_cons<Head2, Tail> >& bl) {
    pos = box_to_text(s, pos, bl.head());
    print_space<HS>::doit(s);
    pos += HS;
    return box_to_text(s, pos, h_box(), space_conf<VS, HS, IS>(), bl.tail());
  }

  template <typename Stream, unsigned VS, unsigned HS, unsigned IS,
            typename Head>
  unsigned box_to_text(Stream& s, unsigned pos, const h_box&,
                       const space_conf<VS, HS, IS>&,
                       const box_list_cons<Head, box_list_end>& bl) {
    return box_to_text(s, pos, bl.head());
  }


  template <typename Stream, unsigned VS, unsigned HS, unsigned IS>
  unsigned box_to_text(Stream&, unsigned pos, const h_box&,
                       const space_conf<VS, HS, IS>&,
                       const box_list_end&) {
    return pos;
  }

  template <typename Stream>
  unsigned box_to_text(Stream& s, unsigned pos, const string_box& str) {
    s << std::string(str);
    return pos + std::string(str).size();
  }

  template <typename Stream>
  unsigned box_to_text(Stream& s, unsigned pos, const any_box& b) {
    return b.to_text(s, pos);
  }

  template <typename Stream, unsigned VS, unsigned HS, unsigned IS,
            typename Head, typename Tail>
  unsigned box_to_text(Stream& s, unsigned pos,
                       const container_box<v_box, VS, HS, IS,
                       box_list_cons<Head, Tail> >& b) {
    box_to_text(s, pos, b->head());
    for (unsigned i = 0; i < (VS + 1); ++i)
      s << std::endl;
    pos+=IS;
    for (unsigned i = 0; i < pos; ++i)
      s << " ";
    return box_to_text(s, pos, v_box(), (Vs<VS>(), Is<IS>()), b->tail());
  }

  template <typename Stream, unsigned VS, unsigned HS, unsigned IS>
  unsigned box_to_text(Stream& s, unsigned pos,
                       const container_box<v_box, VS, HS, IS, box_list_end>&) {
    return pos;
  }

  template <typename Stream, unsigned VS, unsigned HS, unsigned IS,
            typename Head, typename Tail>
  unsigned box_to_text(Stream& s, unsigned pos,
                       const container_box<h_box, VS, HS, IS,
                       box_list_cons<Head, Tail> >& b) {
    return box_to_text(s, pos, h_box(), (Hs<HS>()), *b);
  }

  template <typename Stream, unsigned VS, unsigned HS, unsigned IS>
  unsigned box_to_text(Stream& s, unsigned pos,
                       const container_box<h_box, VS, HS, IS,
                       any_box_list>& b) {
    return b->to_text(s, pos, VS, HS, IS, HDir, true);
  }

  template <typename Stream, unsigned VS, unsigned HS, unsigned IS>
  unsigned box_to_text(Stream& s, unsigned pos,
                       const container_box<v_box, VS, HS, IS,
                       any_box_list>& b) {
    return b->to_text(s, pos, VS, HS, IS, VDir, true);
  }

  template <typename Stream, unsigned VS, unsigned HS, unsigned IS>
  unsigned box_to_text(Stream& s, unsigned pos,
                       const container_box<h_box, VS, HS, IS, box_list_end>&) {
    return pos;
  }

  template <typename Stream, typename ExactBox>
  Stream& operator<<(Stream& s, const box<ExactBox>& b) {
    box_to_text(s, 0U, (const ExactBox&)(b));
    return s;
  }

  unsigned string_box::to_text(std::ostream& s, unsigned pos) const {
    return box_to_text(s, pos, *this);
  }

  unsigned any_box::to_text(std::ostream& s, unsigned pos) const {
    return this->_box->to_text(s, pos);
  }
}

#endif