examine.hh

#ifndef __DUNE_ACFEM_EXPRESSIONS_EXAMINE_HH__
#define __DUNE_ACFEM_EXPRESSIONS_EXAMINE_HH__
 
#include "../mpl/typetuple.hh"
#include "storage.hh"
#include "terminal.hh"
 
namespace Dune::ACFem::Expressions {
 
  namespace ExamineImpl {
 
    namespace {
 
      template<class E, template<class... Arg> class F, class ArgIndex, class SFINAE = void>
      struct TraverseHelper;
 
      template<class T>
      struct MakeAritySequence
      {
        using Type = MakeIndexSequence<Arity<T>::value>;
      };
 
      template<class T, class... Rest>
      struct MakeAritySequence<MPL::TypeTuple<T, Rest...> >
      {
        using Type = MakeIndexSequence<Arity<T>::value>;
      };
 
      template<class T>
      using AritySequence = typename MakeAritySequence<T>::Type;
 
      template<class E, template<class... Arg> class F, std::size_t... ArgIndex>
      struct TraverseHelper<
        E, F, IndexSequence<ArgIndex...>,
        std::enable_if_t<!MPL::IsTypeTupleV<E> && !IsSelfExpression<E>::value && IsExpression<E>::value> >
      {
        using Type =
          typename F<E,
                     typename TraverseHelper<Operand<ArgIndex, E>, F,
                                             AritySequence<Operand<ArgIndex, E> > >::Type...>::Type;
      };
 
      template<class E, template<class... Arg> class F, std::size_t... ArgIndex>
      struct TraverseHelper<
        E, F, IndexSequence<ArgIndex...>,
        std::enable_if_t<!MPL::IsTypeTupleV<E> && (IsSelfExpression<E>::value || !IsExpression<E>::value)> >
      {
        using Type = typename F<E>::Type;
      };
 
      template<class E, std::size_t... TreePos, template<class... Arg> class F, std::size_t... ArgIndex>
      struct TraverseHelper<
        MPL::TypeTuple<E, IndexSequence<TreePos...> >, F, IndexSequence<ArgIndex...>,
        std::enable_if_t<!IsSelfExpression<E>::value && IsExpression<E>::value> >
      {
        using Type =
          typename F<MPL::TypeTuple<E, IndexSequence<TreePos...> >,
                     typename TraverseHelper<MPL::TypeTuple<Operand<ArgIndex, E>, IndexSequence<TreePos..., ArgIndex> >, F,
                                             AritySequence<Operand<ArgIndex, E> > >::Type...>::Type;
      };
 
      template<class E, std::size_t... TreePos, template<class... Arg> class F, std::size_t... ArgIndex>
      struct TraverseHelper<
        MPL::TypeTuple<E, IndexSequence<TreePos...> >, F, IndexSequence<ArgIndex...>,
        std::enable_if_t<IsSelfExpression<E>::value || !IsExpression<E>::value> >
      {
        using Type = typename F<MPL::TypeTuple<E, IndexSequence<TreePos...> > >::Type;
      };
 
      template<class E, class Parent, template<class... Arg> class F, std::size_t... ArgIndex>
      struct TraverseHelper<
        MPL::TypeTuple<E, Parent>, F, IndexSequence<ArgIndex...>,
        std::enable_if_t<!IsSequence<Parent>::value && !IsSelfExpression<E>::value && IsExpression<E>::value> >
      {
        using Type =
          typename F<MPL::TypeTuple<E, Parent>,
                     typename TraverseHelper<
                       MPL::TypeTuple<Operand<ArgIndex, E>, E>,
                       F,
                       AritySequence<Operand<ArgIndex, E> >
                       >::Type...
                     >::Type;
      };
 
      template<class E, class Parent, template<class... Arg> class F, std::size_t... ArgIndex>
      struct TraverseHelper<
        MPL::TypeTuple<E, Parent>, F, IndexSequence<ArgIndex...>,
        std::enable_if_t<!IsSequence<Parent>::value && (IsSelfExpression<E>::value || !IsExpression<E>::value)> >
      {
        using Type = typename F<MPL::TypeTuple<E, Parent> >::Type;
      };
 
      template<class E, std::size_t... TreePos, class Parent, template<class... Arg> class F, std::size_t... ArgIndex>
      struct TraverseHelper<
        MPL::TypeTuple<E, IndexSequence<TreePos...>, Parent>, F, IndexSequence<ArgIndex...>,
        std::enable_if_t<!IsSelfExpression<E>::value && IsExpression<E>::value> >
      {
        using Type =
          typename F<MPL::TypeTuple<E, IndexSequence<TreePos...>, Parent>,
                     typename TraverseHelper<
                       MPL::TypeTuple<Operand<ArgIndex, E>, IndexSequence<TreePos..., ArgIndex>, E>,
                       F,
                       AritySequence<Operand<ArgIndex, E> >
                       >::Type...
                     >::Type;
      };
 
      template<class E, class TreePos, class Parent, template<class... Arg> class F, std::size_t... ArgIndex>
      struct TraverseHelper<
        MPL::TypeTuple<E, TreePos, Parent>, F, IndexSequence<ArgIndex...>,
        std::enable_if_t<IsSelfExpression<E>::value || !IsExpression<E>::value> >
      {
        using Type = typename F<MPL::TypeTuple<E, TreePos, Parent> >::Type;
      };
 
    }
 
    template<class E, template<class... Arg> class F>
    using Traverse = typename TraverseHelper<E, F, AritySequence<E> >::Type;
 
    template<class T, template<class ...> class AccuFunctor, template<class... Arg> class ExprPredicate, class... Rest>
    struct FunctorFactory
    {
      template<class E, class... Args>
      struct Accumulate
      {
        using Type = AccuFunctor<Sequence<T, ExprPredicate<E, Rest...>::value, Args::value...> >;
      };
 
      template<class E, class... Args>
      struct Recurse
      {
        using Type = ExprPredicate<E, AccuFunctor<Sequence<T, Args::value...> >, Rest...>;
      };
    };
 
    template<class E, class T, template<class...> class AccuFunctor, template<class...> class ExprPredicate, class... Rest>
    using ExamineRecurse = Traverse<E, FunctorFactory<T, AccuFunctor, ExprPredicate, Rest...>::template Recurse>;
 
    template<class E, class T, template<class...> class AccuFunctor, template<class... Arg> class ExprPredicate, class... Rest>
    using Examine = Traverse<E, FunctorFactory<T, AccuFunctor, ExprPredicate, Rest...>::template Accumulate>;
 
  } // NS ExamineImpl
 
  using ExamineImpl::Examine;
  using ExamineImpl::ExamineRecurse;
 
  template<class E, template<class... Arg> class ExprPredicate, class... Rest>
  using ExamineOr = BoolConstant<Examine<E, bool, LogicalOr, ExprPredicate, Rest...>::value>;
 
  template<class E, template<class... Arg> class F, class... Rest>
  using ExamineAnd = BoolConstant<Examine<E, bool, LogicalAnd, F, Rest...>::value>;
 
  template<class E, template<class... Arg> class F, class... Rest>
  using ExamineAdd = IndexConstant<Examine<E, std::size_t, Sum, F, Rest...>::value>;
 
  template<class E, class TreePos, class Parent, template<class...> class F, class... Rest>
  struct ExamineTreeOr
    : ExamineOr<MPL::TypeTuple<E, TreePos, Parent>, F, Rest...>
  {};
 
  template<class E, class TreePos, template<class...> class F, class... Rest>
  struct ExamineTreeOr<E, TreePos, FalseType, F, Rest...>
    : ExamineOr<MPL::TypeTuple<E, TreePos>, F, Rest...>
  {};
 
  template<class E, class Parent, template<class...> class F, class... Rest>
  struct ExamineTreeOr<E, FalseType, Parent, F, Rest...>
    : ExamineOr<MPL::TypeTuple<E, Parent>, F, Rest...>
  {};
 
  template<class E, template<class...> class F, class... Rest>
  struct ExamineTreeOr<E, FalseType, FalseType, F, Rest...>
    : ExamineOr<E, F, Rest...>
  {};
 
  template<class E, class TreePos, class Parent, template<class...> class F, class... Rest>
  struct ExamineTreeAnd
    : ExamineAnd<MPL::TypeTuple<E, TreePos, Parent>, F, Rest...>
  {};
 
  template<class E, class TreePos, template<class...> class F, class... Rest>
  struct ExamineTreeAnd<E, TreePos, FalseType, F, Rest...>
    : ExamineAnd<MPL::TypeTuple<E, TreePos>, F, Rest...>
  {};
 
  template<class E, class Parent, template<class...> class F, class... Rest>
  struct ExamineTreeAnd<E, FalseType, Parent, F, Rest...>
    : ExamineAnd<MPL::TypeTuple<E, Parent>, F, Rest...>
  {};
 
  template<class E, template<class...> class F, class... Rest>
  struct ExamineTreeAnd<E, FalseType, FalseType, F, Rest...>
    : ExamineAnd<E, F, Rest...>
  {};
 
} // NS Dune::ACFem::Expressions
 
#endif // __DUNE_ACFEM_EXPRESSIONS_EXAMINE_HH__