expressiontraits.hh

Go to the documentation of this file.

#ifndef __DUNE_ACFEM_EXPRESSIONS_EXPRESSIONTRAITS_HH__
#define __DUNE_ACFEM_EXPRESSIONS_EXPRESSIONTRAITS_HH__
 
#include "../common/types.hh"
#include "policy.hh"
#include "sign.hh"
 
namespace Dune
{
 
  namespace ACFem
  {
 
    enum TraitsPriority {
      DefaultTraitsLevel = 0
      , BaseTraitsLevel
      , DecayTraitsLevel
      , TopTraitsLevel = Expressions::Policy::TraitsLevelMax::value
      , Primary = TopTraitsLevel
      , Secondary = (int)TopTraitsLevel - 1
    };
 
    template<class T,
             class SFINAE = void,
             std::size_t Priority = TopTraitsLevel>
    struct ExpressionTraits
      : ExpressionTraits<T, void, Priority-1>
    {};
 
    template<class T>
    struct ExpressionTraits<T, void, DefaultTraitsLevel>
      : public UnknownExpressionSign
    {
      using ExpressionType = void;
 
      static constexpr bool isOne = false;
      static constexpr bool isMinusOne = false;
 
      static constexpr bool isVolatile = false;
      static constexpr bool isIndependent = false;
      static constexpr bool isConstant = false;
      static constexpr bool isTypedValue = false;
    };
 
    template<class T>
    struct ExpressionTraits<T,
      std::enable_if_t<!IsDecay<T>::value>,
      DecayTraitsLevel>
      : public ExpressionTraits<std::decay_t<T> >
    {};
 
    template<class T>
    using IsTypedValue = BoolConstant<ExpressionTraits<T>::isTypedValue>;
 
    template<class T>
    using IsTypedValueReference = BoolConstant<std::is_reference<T>::value && IsTypedValue<T>::value>;
 
    template<class T>
    struct ZeroExpressionTraits
    {
      using ExpressionType = std::decay<T>;
      static constexpr bool isNonZero = false;
      static constexpr bool isNonSingular = false;
      static constexpr bool isZero = true;
      static constexpr bool isOne = false;
      static constexpr bool isMinusOne = false;
      static constexpr bool isSemiPositive = true;
      static constexpr bool isSemiNegative = true;
      static constexpr bool isPostive = false;
      static constexpr bool isNegative = false;
 
      static constexpr bool isVolatile = false;
      static constexpr bool isIndependent = true;
      static constexpr bool isConstant = true;
      static constexpr bool isTypedValue = true;
 
      using Sign = ExpressionSign<isNonSingular, isSemiPositive, isSemiNegative, 0>;
    };
 
    template<class T, class SFINAE = void>
    struct OwnsExpressionTraits
      : FalseType
    {};
 
    template<class T>
    struct OwnsExpressionTraits<
      T,
      std::enable_if_t<(std::is_class<std::decay_t<T> >::value &&
                        SameDecay<T, typename ExpressionTraits<T>::ExpressionType>::value)> >
      : TrueType
    {};
 
    template<class Expression, class Int, Int I>
    constexpr std::enable_if_t<OwnsExpressionTraits<Expression>::value, bool>
    operator<=(const Expression&, Constant<Int, I>)
    {
      return ExpressionTraits<Expression>::isSemiNegative && I >= 0;
    }
 
    template<class Expression, class Int, Int I>
    constexpr std::enable_if_t<OwnsExpressionTraits<Expression>::value, bool>
    operator>=(const Expression&, Constant<Int, I>)
    {
      return ExpressionTraits<Expression>::isSemiPositive && I <= 0;
    }
 
    template<class Expression, class Int, Int I>
    constexpr std::enable_if_t<OwnsExpressionTraits<Expression>::value, bool>
    operator<(const Expression&, Constant<Int, I>)
    {
      return ExpressionTraits<Expression>::isNegative && I >= 0;
    }
 
    template<class Expression, class Int, Int I>
    constexpr std::enable_if_t<OwnsExpressionTraits<Expression>::value, bool>
    operator>(const Expression&, Constant<Int, I>)
    {
      return ExpressionTraits<Expression>::isPositive && I <= 0;
    }
 
    template<class Expression, class Int, Int I>
    constexpr std::enable_if_t<OwnsExpressionTraits<Expression>::value, bool>
    operator==(const Expression&, Constant<Int, I>)
    {
      return ExpressionTraits<Expression>::isZero && I == 0;
    }
 
    template<class Expression, class Int, Int I>
    constexpr std::enable_if_t<OwnsExpressionTraits<Expression>::value, bool>
    operator!=(const Expression&, Constant<Int, I>)
    {
      return ExpressionTraits<Expression>::isZero && I != 0;
    }
 
    template<class T>
    constexpr auto expressionTraits()
    {
      return ExpressionTraits<T>{};
    }
 
    template<class T>
    constexpr auto expressionTraits(T&&)
    {
      return expressionTraits<T>();
    }
 
 
 
 
  } // ACFem
 
} // Dune
 
#endif // __DUNE_ACFEM_EXPRESSIONS_EXPRESSIONTRAITS_HH__