interface.hh

#ifndef __DUNE_ACFEM_EXPRESSIONS_INTERFACE_HH__
#define __DUNE_ACFEM_EXPRESSIONS_INTERFACE_HH__
 
#include "../common/literals.hh"
#include "../common/typetraits.hh"
#include "expressiontraits.hh"
#include "storage.hh"
#include "optimizationbase.hh"
 
namespace Dune
{
 
  namespace ACFem
  {
 
    namespace Expressions
    {
 
      template<class T, class SFINAE = void>
      struct IsClosure
        : FalseType
      {};
 
      template<class T>
      struct IsClosure<T, std::enable_if_t<!IsDecay<T>::value> >
        : IsClosure<std::decay_t<T> >
      {};
 
      template<class T, class SFINAE = void>
      struct ClosureTraits
      {
        using ExpressionType = T;
      };
 
      template<class T>
      struct ClosureTraits<T, std::enable_if_t<IsClosure<T>::value> >
      {
        using ExpressionType = Operand<0, T>;
      };
 
      template<class T>
      using EnclosedType = typename ClosureTraits<T>::ExpressionType;
 
      template<class T>
      using AsExpression = RemoveRValueReferenceType<decltype(asExpression(std::declval<T>()))>;
 
      template<
        class T,
        std::enable_if_t<(Expressions::IsClosure<T>::value
                          || (!IsExpression<T>::value
                              && IsScalar<T>::value)
        ), int> = 0>
      constexpr decltype(auto) expressionClosure(T&& t)
      {
        return std::forward<T>(t);
      }
 
      struct Closure
      {
        template<class T>
        constexpr decltype(auto) operator()(T&& t) const
        {
          return expressionClosure(std::forward<T>(t));
        }
      };
 
      struct Disclosure
      {
        template<class T>
        constexpr decltype(auto) operator()(T&& t) const
        {
          return std::forward<T>(t);
        }
      };
 
      template<
        class T,
        std::enable_if_t<(IsExpression<T>::value
                          && !IsClosure<T>::value
        ), int> = 0>
      constexpr decltype(auto) asExpression(T&& t)
      {
        return std::forward<T>(t);
      }
 
      template<
        class T,
        std::enable_if_t<(IsExpression<T>::value
                          && IsClosure<T>::value
        ), int> = 0>
      constexpr decltype(auto) asExpression(T&& t)
      {
        using namespace Literals;
        danglingReferenceCheck<0>(std::forward<T>(t));
        return std::forward<T>(t).operand(0_c);
      }
 
      template<class T>
      using IsPromotedTopLevel = BoolConstant<IsClosure<T>::value || IsTypedValueReference<T>::value || IsIntegralConstant<T>::value>;
 
      template<std::size_t N, class... T,
               std::enable_if_t<(NthIs<N, IsClosure, T...>::value && !AnyIs<IsIntegralConstant, T...>::value), int> = 0>
      constexpr decltype(auto) operandPromotion(T&&... t)
      {
        return asExpression(get<N>(std::forward_as_tuple(std::forward<T>(t)...)));
      }
 
      template<std::size_t N, class... T,
               std::enable_if_t<(!NthIs<N, IsClosure, T...>::value
                                 && NthIs<N, IsTypedValueReference, T...>::value
                                 && !AnyIs<IsIntegralConstant, T...>::value
        ), int> = 0>
      constexpr auto operandPromotion(T&&... t)
      {
        return std::decay_t<TupleElement<N, std::tuple<T...> > >(get<N>(std::forward_as_tuple(std::forward<T>(t)...)));
      }
 
      template<std::size_t N, class... T,
               std::enable_if_t<(AnyIs<IsPromotedTopLevel, T...>::value
                                 && !NthIs<N, IsPromotedTopLevel, T...>::value
       ), int> = 0>
      constexpr decltype(auto) operandPromotion(T&&... t)
      {
        return std::forward<TupleElement<N, std::tuple<T...> > >(get<N>(std::forward_as_tuple(std::forward<T>(t)...)));
      }
 
 
 
    } // Expressions
 
    using Expressions::asExpression;
 
  } // ACFem
 
} // Dune
 
#endif // __DUNE_ACFEM_EXPRESSIONS_INTERFACE_HH__