constructor.hh

// 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 __CONSTRUCTOR_HH
# define __CONSTRUCTOR_HH

# include <string>
# include "../lists/list_concept.hh"
# include "../lists/listable.hh"
# include "../max_shared/max_shared_ptr.hh"
# include "../memory/pool_allocator.hh"

namespace aurelia {

  template <typename Pool>
  struct untyped_term;

  template <typename Pool, typename List>
  struct untyped_pattern;

  template <typename Pool>
  struct untyped_constructor;

  template <typename T>
  struct pattern_model;

  template <typename Pool, typename T>
  struct is_term_traits : public std::false_type {
  };

  template <typename Pool>
  struct is_term_traits<Pool, untyped_term<Pool> > : public std::true_type {
  };

  template <typename Pool>
  struct is_term_traits<Pool, untyped_constructor<Pool> > : public std::true_type {
  };

  template <typename Pool>
  struct is_term {
    template <typename T>
    struct traits : public is_term_traits<Pool, T> {
    };
  };

  template <typename Pool, typename T>
  struct is_pattern_traits;

  template <typename Pool>
  struct is_pattern {
    template <typename T>
    struct traits: public is_pattern_traits<Pool, T> {
    };
  };

struct untyped_constructor_core {
private:
  std::string _name;
  unsigned _arity;
  unsigned _hash;

public:
  untyped_constructor_core(const std::string& n, unsigned a):
    _name(n), _arity(a) {
    _hash = a;
    for (std::string::const_iterator i = n.begin();
         i != n.end();
         ++i) {
      _hash ^= (unsigned char)*i;
      _hash = (_hash << 11) | (_hash >> 21);
    }
  }

  untyped_constructor_core(): _arity(0), _hash(0) {}
  untyped_constructor_core(untyped_constructor_core&& other):
    _name(""), _arity(0), _hash(0) {
    *this = std::move(other);
  }

  untyped_constructor_core& operator=(const untyped_constructor_core& other) {
    return *this = untyped_constructor_core(other);
  }

  untyped_constructor_core& operator=(untyped_constructor_core&& other) {
    std::swap(_name, other._name);
    std::swap(_arity, other._arity);
    std::swap(_hash, other._hash);
    return *this;
  }

  untyped_constructor_core(const untyped_constructor_core& o)
  : _name(o._name), _arity(o._arity), _hash(o._hash) {
  }

  unsigned hash() const {
    return _hash;
  }

  bool operator==(const untyped_constructor_core& other) const {
    if (_arity != other._arity)
      return false;
    return (_name == other._name);
  }

  unsigned arity() const {
    return _arity;
  }

  const std::string& name() const {
    return _name;
  }
};

  template <typename Pool>
  struct untyped_constructor:
    public max_shared_ptr<untyped_constructor_core,
                          member_hash,
                          std::equal_to<untyped_constructor_core>,
                          pool_allocator<untyped_constructor_core> > {
    typedef max_shared_ptr<untyped_constructor_core,
                           member_hash,
                           std::equal_to<untyped_constructor_core>,
                           pool_allocator<untyped_constructor_core> > super;

  public:
    untyped_constructor(): super() {
    }

    untyped_constructor(untyped_constructor&& other): super((super&&)std::move(other)) {
    }

    untyped_constructor(const untyped_constructor& other): super((const super&)other) {
    }

    template <typename OtherPool,
              typename =
              typename
              std::enable_if<!std::is_same<Pool, OtherPool>::value>::type>
    untyped_constructor(const untyped_constructor<OtherPool>& other)
      : super(other) {
    }

    untyped_constructor(const std::string& n, unsigned a)
      : super(n, a) {
    }

    untyped_constructor(const std::string& n)
      : super(n, 0) {
    }

    unsigned arity() const {
      return (*this)->arity();
    }

    const std::string& name() const {
      return (*this)->name();
    }

    unsigned hash() const {
      return (*this)->hash();
    }

    static untyped_constructor AS_INT;
    static untyped_constructor AS_REAL;
    static untyped_constructor AS_BLOB;
    static untyped_constructor AS_LIST;
    static untyped_constructor AS_EMPTY_LIST;
    static untyped_constructor AS_ANNOTATION;

    template <typename L,
              typename = typename list_model<L>::model,
              template <typename> class Predicate =
              is_term<Pool>::template traits,
              typename = typename
              std::enable_if<all_elements<Predicate, L>::value>::type>
    untyped_term<Pool> operator[](const L&) const;

    untyped_term<Pool> operator[](const untyped_term<Pool>& t) const {
      return (*this)[list_cons<untyped_term<Pool>, list_nil>(t, list_nil())];
    }

    untyped_term<Pool> operator[](const untyped_constructor<Pool>& c) const {
      return (*this)[list_cons<untyped_term<Pool>, list_nil>(c, list_nil())];
    }

    template <typename P,
              typename = typename pattern_model<P>::model>
    untyped_pattern<Pool, list_cons<P, list_nil> >
    operator[](const P& p) const {
      return (*this)[list_cons<P, list_nil>(p, list_nil())];
    }

    template <typename L,
              typename = typename list_model<L>::model,
              template <typename> class untyped_termPredicate =
              is_term<Pool>::template traits,
              template <typename> class PatternPredicate =
              is_pattern<Pool>::template traits,
              typename = typename
              std::enable_if<!(all_elements<untyped_termPredicate, L>::value)>::type,
              typename = typename
              std::enable_if<all_elements<PatternPredicate, L>::value>::type>
    untyped_pattern<Pool, L> operator[](const L& l) const;
  };

  template <typename Pool>
  untyped_constructor<Pool> untyped_constructor<Pool>::AS_INT("<int>", 0);
  template <typename Pool>
  untyped_constructor<Pool> untyped_constructor<Pool>::AS_REAL("<read>", 0);
  template <typename Pool>
  untyped_constructor<Pool> untyped_constructor<Pool>::AS_BLOB("<blob>", 0);
  template <typename Pool>
  untyped_constructor<Pool> untyped_constructor<Pool>::AS_LIST("[_,_]", 2);
  template <typename Pool>
  untyped_constructor<Pool> untyped_constructor<Pool>::AS_EMPTY_LIST("[]",0);
  template <typename Pool>
  untyped_constructor<Pool> untyped_constructor<Pool>::AS_ANNOTATION("{}",2);

  template <typename Stream, typename Pool>
  Stream& operator<<(Stream& s, const untyped_constructor<Pool>& t) {
    s << t.name() << "(" << t.arity() << ")";
    return s;
  }

  template <typename Pool>
  struct listable_model<untyped_constructor<Pool> > {
    struct model {
      typedef untyped_constructor<Pool> type;
    };
  };

}

#endif