box_terms.hh

#ifndef __BOX_TERMS_HH
# define __BOX_TERMS_HH

# include "../terms/list_terms.hh"

namespace aurelia {

  struct box;
  struct vbox_constr {};
  struct hbox_constr {};
  struct hvbox_constr {};
  struct string_box_constr {};

  pattern_generator<vbox_constr> vbox;
  pattern_generator<hbox_constr> hbox;
  pattern_generator<hvbox_constr> hvbox;
  pattern_generator<string_box_constr> string_box;

  //hs, vs, is
  typedef std::tuple<unsigned, unsigned, unsigned> box_conf;

  template <>
  struct get_tuple<box, vbox_constr> {
    typedef std::tuple<box_conf, list<box> > tuple;
  };

  template <>
  struct get_tuple<box, hbox_constr> {
    typedef std::tuple<box_conf, list<box> > tuple;
  };

  template <>
  struct get_tuple<box, hvbox_constr> {
    typedef std::tuple<box_conf, list<box> > tuple;
  };

  template <>
  struct get_tuple<box, string_box_constr> {
    typedef std::tuple<std::string> tuple;
  };

  struct box: public term<box,
                          vbox_constr,
                          hbox_constr,
                          hvbox_constr,
                          string_box_constr> {
    typedef term<box,
                 vbox_constr,
                 hbox_constr,
                 hvbox_constr,
                 string_box_constr> super;
    box() = default;
    box(const super& other): super(other) {}
    box(super&& other): super(std::move(other)) {}
  };

  struct vbox_term: public std_term<vbox_term, vbox_constr, box> {
    typedef std_term<vbox_term, vbox_constr, box> super;
    vbox_term(box_conf c, list<box> l): super(typename super::tuple(c, l)) {}
    vbox_term(const vbox_term& other): super(other) {}
  };

  template <>
  struct build_type<box, vbox_constr> {
    typedef vbox_term type;
  };

  struct hbox_term: public std_term<hbox_term, hbox_constr, box> {
    typedef std_term<hbox_term, hbox_constr, box> super;
    hbox_term(box_conf c, list<box> l): super(typename super::tuple(c, l)) {}
    hbox_term(const hbox_term& other): super(other) {}
  };

  template <>
  struct build_type<box, hbox_constr> {
    typedef hbox_term type;
  };

  struct hvbox_term: public std_term<hvbox_term, hvbox_constr, box> {
    typedef std_term<hvbox_term, hvbox_constr, box> super;
    hvbox_term(box_conf c, list<box> l): super(typename super::tuple(c, l)) {}
    hvbox_term(const hvbox_term& other): super(other) {}
  };

  template <>
  struct build_type<box, hvbox_constr> {
    typedef hvbox_term type;
  };

  struct string_box_term: public std_term<string_box_term, string_box_constr, box> {
    typedef std_term<string_box_term, string_box_constr, box> super;
    string_box_term(std::string s): super(typename super::tuple(s)) {}
    string_box_term(const string_box_term& other): super(other) {}
  };

  template <>
  struct build_type<box, string_box_constr> {
    typedef string_box_term type;
  };

  template <>
  struct term_model<box> {
    struct model {
      typedef box type;
    };
  };

}

#endif