transform.hh

#ifndef __DUNE_ACFEM_MPL_TRANSFORM_HH__
#define __DUNE_ACFEM_MPL_TRANSFORM_HH__
 
#include "mask.hh"
#include "generators.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    // forward
    struct IdentityFunctor;
 
    // forward
    struct AcceptAllFunctor;
 
    // forward
    template<class F, std::size_t... Index>
    struct TransformAtIndexFunctor;
 
    // forward
    template<bool acceptEqual>
    struct AcceptEqualFunctor;
 
    namespace {
      // helpers for TransformSequence template.
 
      // Forward, specialized below.
      template<class SeqIn,
               class SeqOut,
               class TransformFunctor,
               class AcceptFunctor,
               std::size_t N,
               class SFINAE = void>
      struct TransformSequenceRecursion;
 
      template<class Tin, Tin I0, Tin... RestIn, class Tout, Tout... Out,
               class F, class A, std::size_t N>
      struct TransformSequenceRecursion<
        Sequence<Tin, I0, RestIn...>,
        Sequence<Tout, Out...>,
        F, A, N,
        std::enable_if_t<A::template Apply<Tin, I0, Tout, F::template Apply<Tin, I0, N>::value, N>::value> >
      {
        static const Tout V = F::template Apply<Tin, I0, N>::value;
        using Type = typename TransformSequenceRecursion<Sequence<Tin, RestIn...>, Sequence<Tout, Out..., V>, F, A, N+1>::Type;
      };
 
      template<class Tin, Tin I0, Tin... RestIn, class Tout, Tout... Out,
               class F, class A, std::size_t N>
      struct TransformSequenceRecursion<
        Sequence<Tin, I0, RestIn...>,
        Sequence<Tout, Out...>,
        F, A, N,
        std::enable_if_t<!A::template Apply<Tin, I0, Tout, F::template Apply<Tin, I0, N>::value, N>::value> >
      {
        using Type = typename TransformSequenceRecursion<Sequence<Tin, RestIn...>, Sequence<Tout, Out...>, F, A, N+1>::Type;
      };
 
      template<class Tin, class Tout, Tout... Out, class F, class A, std::size_t N>
      struct TransformSequenceRecursion<Sequence<Tin>, Sequence<Tout, Out...>, F, A, N>
      {
        using Type = Sequence<Tout, Out...>;
      };
 
      template<class SeqIn,
               class SeqOut,
               class TransformFunctor,
               class AcceptFunctor,
               class SFINAE = void>
      struct TransformSequenceHelper
      {
        using Type = typename TransformSequenceRecursion<SeqIn, SeqOut, TransformFunctor, AcceptFunctor, 0UL>::Type;
      };
 
      template<class SeqIn, class SeqOutt, class TransformFunctor, class IndexSeq>
      struct TransformSequenceExpander;
 
      template<class Tin, Tin... In, class Tout, Tout... Out, class TransformFunctor, std::size_t... N>
      struct TransformSequenceExpander<
        Sequence<Tin, In...>, Sequence<Tout, Out...>, TransformFunctor, IndexSequence<N...> >
      {
        using Type = Sequence<Tout, Out..., TransformFunctor::template Apply<Tin, In, N>::value...>;
      };
 
      template<class Tin, Tin... In,
               class SeqOut,
               class TransformFunctor>
      struct TransformSequenceHelper<
        Sequence<Tin, In...>, SeqOut, TransformFunctor, AcceptAllFunctor>
      {
        using Type = typename TransformSequenceExpander<Sequence<Tin, In...>, SeqOut, TransformFunctor, MakeIndexSequence<sizeof...(In)> >::Type;
      };
 
      template<class Tin, class SeqOut, class TransformFunctor>
      struct TransformSequenceHelper<Sequence<Tin>, SeqOut, TransformFunctor, AcceptAllFunctor>
      {
        using Type = SeqOut;
      };
 
    }
 
    template<class SeqIn,
             class SeqOut = Sequence<typename SeqIn::value_type>,
             class TransformFunctor = IdentityFunctor,
             class AcceptFunctor = AcceptAllFunctor>
    using TransformSequence = typename TransformSequenceHelper<SeqIn, SeqOut, TransformFunctor, AcceptFunctor>::Type;
 
    template<class Seq1, class Seq2>
    using CatSequence = TransformSequence<Seq1, Seq2>;
 
    namespace {
      template<class... S>
      struct SequenceCatHelper;
 
      template<class S>
      struct SequenceCatHelper<S>
      {
        using Type = S;
      };
 
      template<class S1, class S2, class... Rest>
      struct SequenceCatHelper<S1, S2, Rest...>
      {
        using Type = TransformSequence<typename SequenceCatHelper<S2, Rest...>::Type, S1>;
      };
 
      template<class... S>
      struct SequenceCatHelper2;
 
      template<>
      struct SequenceCatHelper2<>
      {
        using Type = IndexSequence<>;
      };
 
      template<class S>
      struct SequenceCatHelper2<S>
      {
        using Type = S;
      };
 
      template<class I1, I1... Heads, class I2, I2... Tails, class... S>
      struct SequenceCatHelper2<Sequence<I1, Heads...>, Sequence<I2, Tails...>, S...>
      {
        using IType = std::decay_t<decltype(std::declval<I1>()*std::declval<I2>())>;
        using Type = typename SequenceCatHelper2<Sequence<IType, Heads..., Tails...>, S...>::Type;
      };
    }
 
    template<class... S>
    //    using SequenceCat = typename SequenceCatHelper<S...>::Type;
    using SequenceCat = typename SequenceCatHelper2<S...>::Type;
 
    template<std::ptrdiff_t Offset, class T, T... Ts>
    constexpr auto offsetSequence(Sequence<T, Ts...> = Sequence<T, Ts...>{}, IntConstant<Offset> = IntConstant<Offset>{})
    {
      return Sequence<T, (Ts+Offset)...>{};
    }
 
    template<std::ptrdiff_t Offset, class Seq>
    using OffsetSequence = std::decay_t<decltype(offsetSequence<Offset>(Seq{}))>;
 
    namespace {
      template<std::size_t N, class Seq, class Result>
      struct SequenceProdHelper;
 
      template<std::size_t N, class T, T... I, T... Out>
      struct SequenceProdHelper<N, Sequence<T, I...>, Sequence<T, Out...> >
      {
        using Type = typename SequenceProdHelper<N-1, Sequence<T, I...>, Sequence<T, Out..., I...> >::Type;
      };
 
      template<class T, T... I, T... Out>
      struct SequenceProdHelper<0, Sequence<T, I...>, Sequence<T, Out...> >
      {
        using Type = Sequence<T, Out...>;
      };
 
    }
 
    template<std::size_t N, class Seq>
    using SequenceProd = typename SequenceProdHelper<N, Seq, Sequence<typename Seq::value_type> >::Type;
 
    namespace {
      template<std::size_t, class>
      struct SequenceSpliceHelper;
 
      template<std::size_t N, class T, T... V>
      struct SequenceSpliceHelper<N, Sequence<T, V...> >
      {
        using Type = SequenceCat<MakeSequence<T, N, V, 0>...>;
      };
    }
 
    template<std::size_t count, class Seq>
    using SequenceSplice = typename SequenceSpliceHelper<count, Seq>::Type;
 
    template<class F, class Seq, class Tout = typename F::template Apply<typename Seq::value_type, 0, 0>::value_type>
    using TransformedSequence = TransformSequence<Seq, Sequence<Tout>, F>;
 
    //template<std::size_t Index, class F, class Seq, class Tout = typename F::template Apply<Index, typename Seq::value_type, Index>::value_type>
 
    template<class F, class Seq>
    using CatTransformedSequence = TransformSequence<Seq, Seq, F>;
 
    template<class F, class Seq>
    using TransformUnique = TransformSequence<Seq, Sequence<typename Seq::value_type>, F, AcceptEqualFunctor<false> >;
 
    template<class F, class Seq>
    using CatTransformUnique = TransformSequence<Seq, Seq, F, AcceptEqualFunctor<false> >;
 
    template<class F, class Seq, std::size_t... Index>
    using TransformOnly = TransformSequence<Seq, Sequence<typename Seq::value_type>, TransformAtIndexFunctor<F, Index...>, AcceptAllFunctor>;
 
    struct IdentityFunctor
    {
      template<class T, T V, std::size_t... N>
      struct Apply
        : Constant<T, V>
      {};
    };
 
    template<std::size_t Stride, std::ptrdiff_t Offset = 0>
    struct MultiplyOffsetFunctor
    {
      template<class T, T V, std::size_t... N>
      struct Apply
        : Constant<T, V*Stride+Offset>
      {};
    };
 
    template<std::ptrdiff_t Offset>
    using OffsetFunctor = MultiplyOffsetFunctor<1, Offset>;
 
    template<std::size_t Stride>
    using MultiplyFunctor = MultiplyOffsetFunctor<Stride, 0>;
 
    struct IndexFunctor
    {
      template<class T, T mask, std::size_t N>
      using Apply = Constant<T, N>;
    };
 
    template<class F, std::size_t... Index>
    struct TransformAtIndexFunctor
    {
      template<std::size_t N, class SFINAE = void>
      struct ApplyHelper
      {
        template<class T, T V>
        using Apply = typename IdentityFunctor::template Apply<T, V>;
      };
 
      template<std::size_t N>
      struct ApplyHelper<N, std::enable_if_t<ContainsValue<IndexSequence<Index...>, N>::value> >
      {
        template<class T, T V>
        using Apply = typename F::template Apply<T, V, IndexIn<IndexSequence<Index...>, N>::value>;
      };
 
      template<class T, T V, std::size_t N>
      using Apply = typename ApplyHelper<N>::template Apply<T, V>;
    };
 
    struct IsEvenFunctor
    {
      template<class T, T V, std::size_t... N>
      struct Apply
        : BoolConstant<(V & 1) == 0>
      {};
    };
 
    struct IsOddFunctor
    {
      template<class T, T V, std::size_t... N>
      struct Apply
        : BoolConstant<(V & 1) != 0>
      {};
    };
 
    template<std::size_t Bit>
    struct AddBitFunctor
    {
      template<class T, T mask, std::size_t... N>
      struct Apply
        : Constant<T, (mask | (1UL << Bit))>
      {};
    };
 
    template<std::size_t Bit, std::size_t Shift>
    struct AddBitShiftRightFunctor
    {
      template<class T, T mask, std::size_t... N>
      struct Apply
        : Constant<T, mask | ((mask & SequenceMask<Bit>::value) >> Shift)>
      {};
    };
 
    template<std::size_t Bit, std::size_t Shift>
    struct AddBitShiftLeftFunctor
    {
      template<class T, T mask, std::size_t... N>
      struct Apply
        : Constant<T, (mask | (mask & SequenceMask<Bit>::value) << Shift)>
      {};
    };
 
    template<class Values>
    struct MapSequenceFunctor
    {
      template<class T, T V, std::size_t... N>
      struct Apply
        : Constant<T, Get<V, Values>::value>
      {};
    };
 
    template<class I>
    struct MapSequenceFunctor<Sequence<I> >
      : IdentityFunctor
    {};
 
    template<class Values>
    struct InverseMapSequenceFunctor
    {
      template<class T, T V, std::size_t... N>
      struct Apply
        : Constant<T, IndexIn<Values, V>::value>
      {};
    };
 
    struct AcceptAllFunctor
    {
      template<class Tin, Tin, class Tout, Tout, std::size_t... N>
      struct Apply
        : TrueType
      {};
    };
 
    template<bool acceptEqual>
    struct AcceptEqualFunctor
    {
      template<class Tin, Tin V, class Tout, Tout FV, std::size_t... N>
      struct Apply
        : BoolConstant<(V == FV) == acceptEqual>
      {};
    };
 
    template<class T, T GivenValue, bool acceptEqual = true>
    struct AcceptInputValueFunctor
    {
      template<class Tin, Tin V, class Tout, Tout FV, std::size_t... N>
      struct Apply
        : BoolConstant<(V == GivenValue) == acceptEqual>
      {};
    };
 
    template<class T, T Begin, T End>
    struct AcceptInputInRangeFunctor
    {
      template<class Tin, Tin V, class Tout, Tout FV, std::size_t... N>
      struct Apply
        : BoolConstant<(V >= Begin && V < End)>
      {};
    };
 
    template<class T, T P, T R>
    struct AcceptModuloFunctor
    {
      template<class Tin, Tin V, class Tout, Tout FV, std::size_t... N>
      struct Apply
        : BoolConstant<(V % P == R)>
      {};
    };
 
 
 
 
  } // ACFem::
 
} // Dune::
 
#endif // __DUNE_ACFEM_MPL_MASK_HH__