examineutil.hh

#ifndef __DUNE_ACFEM_EXPRESSIONS_EXAMINEUTIL_HH__
#define __DUNE_ACFEM_EXPRESSIONS_EXAMINEUTIL_HH__
 
#include "../mpl/accumulate.hh"
#include "examine.hh"
#include "runtimeequal.hh"
#include "weight.hh"
 
namespace Dune
{
  namespace ACFem
  {
    namespace Expressions
    {
 
      template<class E, class T>
      using ContainsType = ExamineOr<E, std::is_same, typename ClosureTraits<T>::ExpressionType>;
 
      template<class E, class T>
      using ContainsDecayed = ExamineOr<E, SameDecay, typename ClosureTraits<T>::ExpressionType>;
 
      template<class E>
      using NumberOfTerminals = ExamineAdd<E, IsSelfExpression>;
 
      template<class E>
      constexpr inline std::size_t numberOfTerminals()
      {
        return NumberOfTerminals<E>::value;
      }
 
      template<class E>
      constexpr inline std::size_t numberOfTerminals(E&&)
      {
        return numberOfTerminals<E>();
      }
 
      template<class E, class T>
      using SubExpressionMultiplicity = ExamineAdd<EnclosedType<E>, AreRuntimeEqual, EnclosedType<T> >;
 
      template<class E, class T>
      constexpr auto subExpressionMultiplicity(E&& e = E{}, T&& t = T{})
      {
        return SubExpressionMultiplicity<E, T>::value;
      }
 
      namespace ExamineImpl
      {
        template<class Dummy, class ArgDepths>
        struct DepthFunctor
          : IndexConstant<1+ArgDepths::value>
        {};
      }
 
      template<class E>
      using Depth = ExamineRecurse<E, std::size_t, Max, ExamineImpl::DepthFunctor>;
 
      template<class E>
      constexpr std::size_t depth()
      {
        return Depth<E>::value;
      }
 
      template<class E>
      constexpr auto depth(E&& e)
      {
        return depth<E>();
      }
 
      template<class T, class SFINAE = void>
      constexpr inline std::size_t ExpressionWeightV = addLoop<Arity<T>::value>([](auto i) { return ExpressionWeightV<Operand<decltype(i)::value, T> >; }, WeightV<T>);
 
      template<class T>
      constexpr inline std::size_t ExpressionWeightV<T, std::enable_if_t<IsSelfExpression<T>::value> > = WeightV<T>;
 
      template<class E>
      constexpr auto weight()
      {
        return ExpressionWeightV<E>;
      }
 
      template<class E>
      constexpr auto weight(E&&)
      {
        return weight<E>();
      }
 
      template<std::size_t Id, class E>
      using ExplicitlyDependsOn = ExamineOr<E, IndeterminateMatch, IndexConstant<Id> >;
 
    } // NS Expressions
 
    using Expressions::ExpressionWeightV;
 
  } // NS ACFem
} // NS Dune
 
#endif // __DUNE_ACFEM_EXPRESSIONS_EXAMINEUTIL_HH__