types.hh

#ifndef __DUNE_ACFEM_COMMON_TYPES_HH__
#define __DUNE_ACFEM_COMMON_TYPES_HH__
 
#include <limits>
#include <utility>
#include <cstdint>
#include <cstddef>
#include <tuple>
#include <array>
 
#include "compiler.hh"
#include "../mpl/conditional.hh"
 
#include "../core-fixes.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    template<class T, T V>
    struct integral_constant
    {
      using value_type = T;
      static constexpr T value = V;
      constexpr value_type operator()() const { return value; }
    };
 
    template<class T, T V>
    using Constant = integral_constant<T, V>;
 
    template<std::size_t V>
    using IndexConstant = Constant<std::size_t, V>;
 
    template<bool V>
    using BoolConstant = Constant<bool, V>;
 
    template<std::ptrdiff_t V>
    using IntConstant = Constant<std::ptrdiff_t, V>;
 
    template<class T, T... V>
    using Sequence = std::integer_sequence<T, V...>;
 
    template<bool... Decisions>
    using BoolSequence = Sequence<bool, Decisions...>;
 
    template<std::size_t... V>
    using IndexSequence = Sequence<std::size_t, V...>;
 
    template<std::ptrdiff_t... V>
    using IntSequence = Sequence<std::ptrdiff_t, V...>;
 
 
    template<class Const>
    using Incr = Constant<typename Const::value_type, Const::value + 1>;
 
    template<class Const>
    using Decr = Constant<typename Const::value_type, Const::value - 1>;
 
 
    template<class T>
    using IsDecay = std::is_same<T, std::decay_t<T> >;
 
    template<class T1, class T2>
    using HasSameDecay = std::is_same<std::decay_t<T1>, std::decay_t<T2> >;
 
    template<class Base, class Derived> using
    IsBaseOfDecay = std::is_base_of<std::decay_t<Base>, std::decay_t<Derived> >;
 
    using TrueType = BoolConstant<true>;
 
    using FalseType = BoolConstant<false>;
 
    constexpr auto trueType() { return TrueType{}; }
 
    constexpr auto falseType() { return FalseType{}; }
 
    template<bool Cond>
    constexpr auto boolType(BoolConstant<Cond> arg = BoolConstant<Cond>{}) { return arg; }
 
    template<class T0, class T1>
    constexpr auto forwardAsPair(T0&& t0, T1&& t1)
    {
      return std::pair<T0, T1>(std::forward<T0>(t0), std::forward<T1>(t1));
    }
 
    template<class T>
    using RefersConst = BoolConstant<(std::is_const<T>::value
                                      ||
                                      std::is_const<std::remove_reference_t<T> >::value)>;
 
    template<class T, class... Other>
    struct MakeType
    {
      using Type = T;
    };
 
    template<class... T>
    using FirstType = typename MakeType<T...>::Type;
 
    template<class... Other>
    using VoidType = typename MakeType<void, Other...>::Type;
 
    template<class... Other>
    using AlwaysFalse = typename MakeType<FalseType, Other...>::Type;
 
    template<class... Other>
    using AlwaysTrue = typename MakeType<TrueType, Other...>::Type;
 
    template<template<class...> class Predicate, class SFINAE = void>
    struct IsAlwaysTrue
      : FalseType
    {};
 
    template<template<class...> class Predicate>
    struct IsAlwaysTrue<Predicate, std::enable_if_t<Predicate<>::value> >
      : TrueType
    {};
 
    template<template<class...> class Predicate, class SFINAE = void>
    struct IsAlwaysFalse
      : FalseType
    {};
 
    template<template<class...> class Predicate>
    struct IsAlwaysFalse<Predicate, std::enable_if_t<!Predicate<>::value> >
      : TrueType
    {};
 
    template<template<class...> class P0, template<class...> class P1>
    struct AndPredicate
    {
      template<class... Arg>
      struct Predicate
        : BoolConstant<P0<Arg...>::value && P1<Arg...>::value>
      {};
    };
 
    template<template<class...> class P0, template<class...> class P1>
    struct OrPredicate
    {
      template<class... Arg>
      struct Predicate
        : BoolConstant<P0<Arg...>::value || P1<Arg...>::value>
      {};
    };
 
    template<template<class...> class F, class... Rest>
    struct PredicateProxy
    {
      template<class T, class...>
      struct ForwardFirst
        : F<T, Rest...>
      {};
 
      template<class T, class...>
      struct FirstOfPair
        : F<typename T::first_type, Rest...>
      {};
 
      template<class T1, class T2, class...>
      struct BinaryFirstOfPair
        : F<typename T1::first_type, typename T2::first_type, Rest...>
      {};
 
      template<class T, class...>
      struct SecondOfPair
        : F<typename T::second_type, Rest...>
      {};
 
      template<class T1, class T2, class...>
      struct BinarySecondOfPair
        : F<typename T1::second_type, typename T2::second_type, Rest...>
      {};
 
      template<class T>
      struct Unary
        : F<T, Rest...>
      {};
 
    };
 
    template<template<class...> class F>
    struct PredicateWrapper
    {
      template<class... Arg>
      using Predicate = F<Arg...>;
 
      template<class... Arg>
      constexpr bool operator()(Arg&&...) const
      {
        return F<Arg...>::value;
      }
    };
 
    template<class T, class SFINAE = void>
    struct IsSequence
      : FalseType
    {};
 
    template<class T>
    struct IsSequence<T, std::enable_if_t<!IsDecay<T>::value> >
      : IsSequence<std::decay_t<T> >
    {};
 
    template<class T, T... Ints>
    struct IsSequence<Sequence<T, Ints...> >
      : TrueType
    {};
 
    template<class T, class SFINAE = void>
    struct IsIndexSequence
      : FalseType
    {};
 
    template<class T>
    struct IsIndexSequence<T, std::enable_if_t<!IsDecay<T>::value> >
      : IsIndexSequence<std::decay_t<T> >
    {};
 
    template<std::size_t... Ints>
    struct IsIndexSequence<IndexSequence<Ints...> >
      : TrueType
    {};
 
    template<class T>
    struct IsIntegralConstant
      : FalseType
    {};
 
    template<class T>
    struct IsIntegralConstant<T&>
      : IsIntegralConstant<std::decay_t<T> >
    {};
 
    template<class T>
    struct IsIntegralConstant<T&&>
      : IsIntegralConstant<std::decay_t<T> >
    {};
 
    template<class T, T V>
    struct IsIntegralConstant<Constant<T, V> >
      : TrueType
    {};
 
    template<class T>
    struct IsBoolConstant
      : FalseType
    {};
 
    template<class T>
    struct IsBoolConstant<T&>
      : IsBoolConstant<std::decay_t<T> >
    {};
 
    template<class T>
    struct IsBoolConstant<T&&>
      : IsBoolConstant<std::decay_t<T> >
    {};
 
    template<bool V>
    struct IsBoolConstant<BoolConstant<V> >
      : TrueType
    {};
 
    template<class, class SFINAE = void>
    struct IsDefined
      : FalseType
    {};
 
    template<class T>
    struct IsDefined<T,
                     std::enable_if_t<(std::is_object<T>::value &&
                                      !std::is_pointer<T>::value &&
                                       (sizeof(T) >= 0))>
      > : TrueType
    {};
 
    template<class T, class SFINAE = void>
    struct IsTupleLike
      : FalseType
    {};
 
    template<class T>
    struct IsTupleLike<T, std::enable_if_t<(std::tuple_size<std::decay_t<T> >::value >= 0)> >
      : TrueType
    {};
 
    template<class T>
    struct IsTuple
      : FalseType
    {};
 
    template<class... T>
    struct IsTuple<std::tuple<T...> >
      : TrueType
    {};
 
    template<class T, class SFINAE = void>
    struct IsArray
      : FalseType
    {};
 
    template<class T>
    struct IsArray<T, std::enable_if_t<!IsDecay<T>::value> >
      : IsArray<std::decay_t<T> >
    {};
 
    template<class T, std::size_t N>
    struct IsArray<std::array<T, N> >
      : TrueType
    {};
 
    template<class T, class SFINAE = void>
    struct HasResize
      : FalseType
    {};
 
    template<class T>
    struct HasResize<T, std::enable_if_t<!IsDecay<T>::value> >
      : HasResize<std::decay_t<T> >
    {};
 
    template<class T>
    struct HasResize<T, VoidType<decltype(std::declval<T>().resize(0UL))> >
      : TrueType
    {};
 
    template<class T1, class T2>
    struct SameDecay
      : std::is_same<std::decay_t<T1>, std::decay_t<T2> >
    {};
 
    template<class T, class SFINAE = void>
    struct HasUnaryMinus
      : FalseType
    {};
 
    template<class T>
    struct HasUnaryMinus<T, std::enable_if_t<(sizeof(decltype(-std::declval<T>())) >= 0)> >
      : TrueType
    {};
 
    template<bool C, class T>
    struct Case
      : BoolConstant<C>  
    {
      using Type = T; 
    };
 
    template<class CaseType>
    using CaseNot = Case<!CaseType::value, typename CaseType::Type>;
 
    template<class A, class B = A>
    using CaseVoid = Case<std::is_same<A, void>::value, B>;
 
    template<class A, class B = A>
    using CaseNotVoid = CaseNot<CaseVoid<A, B> >;
 
    template<class A, class B, class C = A>
    using CaseSame = Case<std::is_same<A, B>::value, C>;
 
    template<class A, class B, class C = A>
    using CaseNotSame = CaseNot<CaseSame<A, B, C> >;
 
    template<class A, class B, class C = A>
    using CaseBase = Case<std::is_base_of<A, B>::value, C>;
 
    template<class A, class B, class C = A>
    using CaseNotBase = CaseNot<CaseBase<A, B, C> >;
 
    template<class Head, class... Tail>
    struct Switch
      : ConditionalType<Head::value, Head, Switch<Tail...> >
    {};
 
    template<class T>
    struct Switch<T>
    {
      using Type = T;
    };
 
    template<bool C, class T>
    struct Switch<Case<C, T> >
    {
      static_assert(C, "Type-switch without terminating \"true\" case.");
      using Type = T;
    };
 
    template<class... Cases>
    using SwitchType = typename Switch<Cases...>::Type;
 
    template<bool C, class Yes, class No = void>
    using IfElseType = SwitchType<Case<C, Yes>, No>;
 
    template<class... A>
    using OrType = SwitchType<CaseNotVoid<A>...>;
 
    template<class A, class B, class Default = void>
    using AndType = SwitchType<CaseSame<A, B>, Default>;
 
    template<class T, class U>
    struct copy_cv_reference
    {
     private:
      using R = std::remove_reference_t<T>;
      using U0 = std::decay_t<U>; // = U?
      using U1 = ConditionalType<std::is_const<R>::value, std::add_const_t<U0>, U0>;
      using U2 = ConditionalType<std::is_volatile<R>::value, std::add_volatile_t<U1>, U1>;
      using U3 = ConditionalType<std::is_lvalue_reference<T>::value, std::add_lvalue_reference_t<U2>, U2>;
      using U4 = ConditionalType<std::is_rvalue_reference<T>::value, std::add_rvalue_reference_t<U3>, U3>;
     public:
      using type = U4;
    };
 
    template<class From, class To>
    using copy_cv_reference_t = typename copy_cv_reference<From, To>::type;
 
    template<class T>
    struct remove_const
    {
      using type = ConditionalType<std::is_lvalue_reference_v<T>,
                                   std::add_lvalue_reference_t<std::remove_const<std::remove_reference_t<T> > >,
                                   std::remove_const<std::remove_reference_t<T> > >;
    };
 
    template<class T>
    using remove_const_t = typename remove_const<T>::type;
 
    template<class T>
    constexpr T forwardReturnValue(std::remove_reference_t<T>& t)
    {
      return static_cast<T>(t);
    }
 
    template<class T>
    constexpr T forwardReturnValue(std::remove_reference_t<T>&& t)
    {
      return static_cast<T&&>(t);
    }
 
 
 
  } // ACFem::
 
} // Dune::
 
#endif // __DUNE_ACFEM_COMMON_TYPES_HH__