term_pattern.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 __TERM_PATTERN_HH
# define __TERM_PATTERN_HH

# include "pattern.hh"
# include "../terms/term.hh"
# include "../lists/listable.hh"

namespace aurelia {

  template <typename Pool>
  void assign(const list_nil&, const untyped_term<Pool>&) {
  }

  template <typename Pool, typename T,
            typename M = typename aurelia::list_model<T>::model,
            typename = typename
            std::enable_if<!std::is_same<void,
                                         typename M::head_t>::value>::type>
  void assign(const T& l, const untyped_term<Pool>& t) {
    typedef typename aurelia::list_concept<M>::check require;
    head(l) = t[M::size-1];
    assign(tail(l), t);
  }

  inline list_nil build(const list_nil&) {
    return list_nil();
  }

  template <typename T>
  struct build_type {
  };

  template <typename H, typename T>
  struct build_type<list_cons<H, T> > {
    typedef list_cons<typename pattern_model<H>::model::build_type,
                      typename build_type<T>::type> type;
  };

  template <>
  struct build_type<list_nil> {
    typedef list_nil type;
  };

  template <typename T, typename M = typename list_model<T>::model,
            typename = typename
            std::enable_if<!std::is_same<void,
                                         typename M::head_t>::value>::type>
  typename build_type<T>::type build(const T& l) {
    typedef typename aurelia::list_concept<M>::check require;
    return typename build_type<T>::type
      (*head(l), build(tail(l)));
  }

  template <typename Pool, typename List>
  struct untyped_pattern {
  private:
    untyped_constructor<Pool> c;
    List l;
  public:
    untyped_pattern(const untyped_constructor<Pool>& c,
                    const List& l): c(c), l(l) {
    }

    const untyped_term<Pool>& operator=(const untyped_term<Pool>& t) {
      if (c != t.constructor())
        throw failure();
      assign(l, t);
      return t;
    }

    untyped_term<Pool> operator*() const {
      return untyped_term<Pool>(c, build(l));
    }
  };

  template <typename Pool, typename List>
  struct pattern_model<untyped_pattern<Pool, List> > {
    struct model {
      typedef untyped_pattern<Pool, List> type;
      typedef untyped_term<Pool> build_type;
    };
  };

  template <typename Pool, typename List>
  struct listable_model<untyped_pattern<Pool, List> > {
    struct model {
      typedef untyped_pattern<Pool, List> type;
    };
  };

  template <typename Pool>
  template <typename L,
            typename,
            template <typename> class,
            template <typename> class,
            typename,
            typename>
  untyped_pattern<Pool, L>
  untyped_constructor<Pool>::operator[](const L& l) const {
    return untyped_pattern<Pool, L>(*this, l);
  }
}

#endif