filter.hh

#ifndef __DUNE_ACFEM_MPL_FILTER_HH__
#define __DUNE_ACFEM_MPL_FILTER_HH__
 
#include "transform.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    template<class F, class Input>
    struct UnaryFilterFunctor
    {
      template<class Tin, Tin V, class Tout, Tout FV, std::size_t N>
      struct Apply
        : BoolConstant<F::template Apply<Tin, V, N>::value>
      {};
    };
 
    template<typename Int, Int... I0, Int... I1>
    constexpr auto sequenceCat(Sequence<Int, I0...>, Sequence<Int, I1...>)
    {
      return Sequence<Int, I0..., I1...>{};
    }
 
    template<typename Int, Int... I0, Int... I1, class Seq, class... RestSeq>
    constexpr auto sequenceCat(Sequence<Int, I0...>, Sequence<Int, I1...>, Seq, RestSeq...)
    {
      return sequenceCat(Sequence<Int, I0..., I1...>{}, Seq{}, RestSeq{}...);
    }
 
    template<class Seq>
    constexpr auto sequenceCat(Seq)
    {
      return Seq{};
    }
 
    template<class F, class Seq>
    using FilteredSequence = TransformSequence<Seq, Sequence<typename Seq::value_type>, IdentityFunctor, UnaryFilterFunctor<F, typename Seq::value_type> >;
 
    struct UnaryAcceptAllFunctor
    {
      template<class T, T>
      using Apply = TrueType;
    };
 
    template<class F>
    struct UnaryNotFunctor
    {
      template<class T, T V, std::size_t N>
      struct Apply
        : BoolConstant<!F::template Apply<T, V, N>::value>
      {};
    };
 
    template<std::size_t... Indices>
    struct UnaryKeepAtFunctor
    {
      template<class T, T V, std::size_t N>
      struct Apply
        : ContainsValue<IndexSequence<Indices...>, N>
      {};
    };
 
 
    namespace {
      template<std::size_t N, class S1, class S2>
      struct CommonHeadHelper
      {
        static constexpr std::size_t value = N;
      };
 
      template<std::size_t N,
               class T, T Head, T... Rest1, T... Rest2>
      struct CommonHeadHelper<N, Sequence<T, Head, Rest1...>, Sequence<T, Head, Rest2...> >
      {
        static constexpr std::size_t value =
          CommonHeadHelper<N+1, Sequence<T, Rest1...>, Sequence<T, Rest2...> >::value;
      };
    }
 
    template<class Seq1, class Seq2>
    using CommonHead = IndexConstant<CommonHeadHelper<0UL, Seq1, Seq2>::value>;
 
 
 
 
  } // ACFem::
 
} // Dune::
 
#endif // __DUNE_ACFEM_MPL_FILTER_HH__