pattern_utils.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 __PATTERN_UTILS_HH
# define __PATTERN_UTILS_HH

# include "pattern.hh"
# include "../terms/term_concept.hh"

namespace aurelia {

  template <typename T, typename Constr, size_t N,
            typename tuple, typename... SubPatterns>
  struct build_real_type;

  template <typename Constructor, typename ...SubPatterns>
  struct pattern;

  template <typename Pattern>
  struct builder;

  template <typename Constructor, typename ...SubPatterns>
  struct builder<pattern<Constructor, SubPatterns...> > {
    pattern<Constructor, SubPatterns...> p;
    builder(const pattern<Constructor, SubPatterns...>& p): p(p) {}
    builder(pattern<Constructor, SubPatterns...>&& p): p(std::move(p)) {}

    template <typename T,
              typename M = typename term_model<T>::model,
              typename = typename
              std::enable_if<std::is_convertible<
                               typename build_type<T, Constructor>::type,
                               T>::value>::type>
    operator T() {
      return build_real_type<T, Constructor, 0, std::tuple<SubPatterns...>,
                             SubPatterns...>::build(p.subpatterns);
    }
  };

  template <typename LHS, typename RHS, size_t N = 0,
            size_t Last = std::tuple_size<LHS>::value>
  struct assign_build {
    static void do_it(LHS& lhs, const RHS& rhs) {
      static_assert(std::tuple_size<LHS>::value == Last,
                    "Wrong size");
      static_assert(std::tuple_size<RHS>::value == Last,
                    "Wrong size");
      std::get<N>(lhs) = *std::get<N>(rhs);
      assign_build<LHS, RHS, N+1, Last>::do_it(lhs, rhs);
    }
  };

  template <typename LHS, typename RHS, size_t N>
  struct assign_build<LHS, RHS, N, N> {
    static void do_it(LHS&, const RHS&) {
      static_assert(std::tuple_size<LHS>::value == N,
                    "Wrong size");
      static_assert(std::tuple_size<RHS>::value == N,
                    "Wrong size");
    }
  };

  template <typename T, typename U,
            typename = decltype(std::declval<T>() =
                                *(std::declval<const U>()))>
  std::true_type has_assign_build_helper(type_traits::try_first, T, U) {
    return 0;
  }

  template <typename T, typename U>
  std::false_type has_assign_build_helper(type_traits::try_second, T, U) {
    return 0;
  }

  template <typename T, typename U>
  struct can_match:
    type_traits::itself<
    decltype(has_assign_build_helper(type_traits::try_first(),
                                     std::declval<T>(),
                                     std::declval<U>()))>::type {
  };

  template <typename T, typename U, typename... TS, typename... US>
  struct can_match<std::tuple<T, TS...>, std::tuple<U, US...> >
  {
    enum: bool { value = can_match<T,U>::value &&
                 can_match<std::tuple<TS...>, std::tuple<US...> >::value };
  };

  template <>
  struct can_match<std::tuple<>, std::tuple<> >: public std::true_type {
  };

  template <typename Constructor, typename ...SubPatterns>
  struct pattern {
    Constructor constructor;
    std::tuple<SubPatterns...> subpatterns;

    pattern(const Constructor& constructor, SubPatterns... p):
      constructor(constructor), subpatterns(p...) {}

    template <typename Term,
              typename M = typename term_model<Term>::model>
    Term
    operator=(const Term& t) throw (failure) {
      typedef typename term_concept<M>::check require;
      t.match(*this);
      return t;
    }

    template <typename... OtherSubPatterns,
              typename = typename
              std::enable_if<can_match<std::tuple<SubPatterns...>,
                                       std::tuple<OtherSubPatterns...> >
              ::value>::type>
    const builder<pattern<Constructor, OtherSubPatterns...> >&
    operator=(const builder<pattern<Constructor, OtherSubPatterns...> >& b)
      throw (failure) {
      static_assert(sizeof...(SubPatterns)==sizeof...(OtherSubPatterns),
                    "Number of children in patterns not corresponding");
      assign_build<std::tuple<SubPatterns...>,
                   std::tuple<OtherSubPatterns...> >
        ::do_it(subpatterns, b.p.subpatterns);
      return b;
    }

    builder<pattern> operator*() const {
      return builder<pattern>(*this);
    }

  };

  template <typename Constructor, typename ...SubPatterns>
  struct pattern_model<pattern<Constructor, SubPatterns...> > {
    struct model {
      typedef pattern<Constructor, SubPatterns...> type;
      typedef builder<pattern<Constructor, SubPatterns...> > build_type;
    };
  };

  template <typename Constructor>
  struct pattern_generator {
    Constructor constructor;

    pattern_generator() {}

    pattern_generator(const Constructor& constructor):
      constructor(constructor) {}

    pattern_generator(const pattern_generator& other):
      constructor(other.constructor) {}

    template <typename ...A>
    pattern<Constructor, A...> operator()(A... a) const {
      return pattern<Constructor, A...>(constructor, std::forward<A>(a)...);
    }
  };

}

#endif