subtuple.hh

#ifndef __DUNE_ACFEM_MPL_SUBTUPLE_HH__
#define __DUNE_ACFEM_MPL_SUBTUPLE_HH__
 
#include "access.hh"
#include "mask.hh"
#include "sort.hh"
#include "filter.hh"
#include "generators.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    namespace {
      // Helper namespace for insertAt()
 
      template<class T, class Tuple, std::size_t... Front, std::size_t... Back>
      auto insertAtInsertOne(T t, Tuple&& tuple, std::index_sequence<Front...>, std::index_sequence<Back...>)
      {
        return std::make_tuple(get<Front>(tuple)..., t, get<Back+sizeof...(Front)>(tuple)...);
      }
 
      template<std::size_t N, class PosSeq, class DataTuple, class SrcTuple,
               std::enable_if_t<(N == PosSeq::size()), int> = 0>
      auto insertAtHelper(PosSeq pos, const DataTuple& data, const SrcTuple& tuple, TrueType)
      {
        return tuple;
      }
 
      template<std::size_t N, class PosSeq, class DataTuple, class SrcTuple,
               std::enable_if_t<(N < PosSeq::size()), int> = 0>
      auto insertAtHelper(PosSeq pos, const DataTuple& data, const SrcTuple& tuple, TrueType)
      {
        constexpr std::size_t size = std::tuple_size<SrcTuple>::value;
        constexpr std::size_t index = Get<N, PosSeq>::value;
        using Front = MakeIndexSequence<index>;
        using Back = MakeIndexSequence<size - index>;
 
        return insertAtHelper<N+1>(pos, data, insertAtInsertOne(get<N>(data), tuple, Front{}, Back{}), trueType());
      }
 
      template<std::size_t N, class PosSeq, class DataTuple, class SrcTuple>
      auto insertAtHelper(PosSeq pos, const DataTuple& data, const SrcTuple& tuple, FalseType)
      {
        using Sort = SortSequence<PosSeq>;
        using SortedPos = typename Sort::Result;
        using Perm = typename Sort::Permutation;
 
        return insertAtHelper<N>(SortedPos{}, permute(Perm{}, data), tuple, trueType());
      }
 
    }
 
    template<std::size_t... Pos, class SrcTuple, class DataTuple, bool AssumeSorted = true,
             // Enable for "things" like tuples. We need std::get
             std::enable_if_t<AllowsGet<SrcTuple>::value && AllowsGet<DataTuple>::value, int> = 0>
    auto insertAt(SrcTuple&& src, DataTuple&& data, BoolConstant<AssumeSorted> = BoolConstant<AssumeSorted>{})
    {
      return insertAtHelper<0>(std::index_sequence<Pos...>{}, std::forward<DataTuple>(data), std::forward<SrcTuple>(src), BoolConstant<AssumeSorted>{});
    }
 
    template<std::size_t Where, class SrcTuple, class Data, bool AssumeSorted = true,
             // Enable for "things" like tuples. We need std::get
             std::enable_if_t<AllowsGet<SrcTuple>::value && !AllowsGet<Data>::value, int> = 0>
    auto insertAt(SrcTuple&& src, Data&& data, BoolConstant<AssumeSorted> = BoolConstant<AssumeSorted>{})
    {
      return insertAtHelper<0>(IndexSequence<Where>{}, std::forward_as_tuple(data), std::forward<SrcTuple>(src), BoolConstant<AssumeSorted>{});
    }
 
    template<std::size_t... Pos, class SrcTuple, class DataTuple, bool AssumeSorted = true,
             // Enable for "things" like tuples. We need std::get
             std::enable_if_t<AllowsGet<SrcTuple>::value && AllowsGet<DataTuple>::value, int> = 0>
    auto insertAt(SrcTuple&& src, DataTuple&& data, IndexSequence<Pos...>, BoolConstant<AssumeSorted> = BoolConstant<AssumeSorted>{})
    {
      return insertAt<Pos...>(std::forward<SrcTuple>(src), std::forward<DataTuple>(data), BoolConstant<AssumeSorted>{});
    }
 
    template<std::size_t Where, class SrcTuple, class Data, bool AssumeSorted = true,
             // Enable for "things" like tuples. We need std::get
             std::enable_if_t<AllowsGet<SrcTuple>::value && !AllowsGet<Data>::value, int> = 0>
    auto insertAt(SrcTuple&& src, Data&& data, IndexConstant<Where>, BoolConstant<AssumeSorted> = BoolConstant<AssumeSorted>{})
    {
      return insertAt<Where>(std::forward<SrcTuple>(src), std::forward<Data>(data), BoolConstant<AssumeSorted>{});
    }
 
    template<std::size_t... I, class TupleLike,
             std::enable_if_t<IsTupleLike<TupleLike>::value, int> = 0>
    auto subTuple(const TupleLike& t, IndexSequence<I...> = IndexSequence<I...>{}) {
      return std::make_tuple(std::get<I>(t)...);
    }
 
    template<std::size_t... I, class TupleLike,
             std::enable_if_t<IsTupleLike<TupleLike>::value, int> = 0>
    auto forwardSubTuple(const TupleLike& t, IndexSequence<I...> = IndexSequence<I...>{}) {
      return std::forward_as_tuple(std::get<I>(t)...);
    }
 
    template<class T, std::size_t... I>
    using SubTuple = decltype(subTuple<I...>(std::declval<T>()));
 
    template<std::size_t mask, typename... T>
    auto maskTuple(const std::tuple<T...>& t, IndexConstant<mask> = IndexConstant<mask>{})
    {
      return subTuple(t, MaskSequence<mask>());
    }
 
    template<std::size_t mask, class T>
    using MaskTuple = decltype(maskTuple<mask>(std::declval<T>()));
 
    template<class Tuple, template<class...> class F>
    struct HasPropertyFunctor
    {
      template<class T, T, std::size_t N>
      using Apply = F<TupleElement<N, Tuple> >;
    };
 
    template<template<class T, class...> class F, class Tuple>
    auto filteredTuple(Tuple&& t)
    {
      using ComponentSequence = MakeSequenceFor<Tuple>;
      using SliceSequence = FilteredSequence<HasPropertyFunctor<Tuple, F>, ComponentSequence>;
      return forwardSubTuple(std::forward<Tuple>(t), SliceSequence{});
    }
 
    template<template<class T, class...> class F, class Tuple>
    using FilteredTuple = std::decay_t<decltype(filteredTuple<F>(std::declval<Tuple>()))>;
 
    template<class T, class Tuple, std::enable_if_t<IsTupleLike<Tuple>::value, int> = 0>
    constexpr auto addFront(T&& t, Tuple&& tuple)
    {
      return std::tuple_cat(std::tuple<T>(std::forward<T>(t)), std::forward<Tuple>(tuple));
    }
 
    template<class T, class Tuple, std::enable_if_t<IsTupleLike<Tuple>::value, int> = 0>
    constexpr auto pushBack(T&& t, Tuple&& tuple)
    {
      return std::tuple_cat(std::forward<Tuple>(tuple), std::tuple<T>(std::forward<T>(t)));
    }
 
    template<class T, class Tuple>
    using AddFrontTuple = std::decay_t<decltype(addFront(std::declval<T>(), std::declval<Tuple>()))>;
 
    template<class T, class Tuple>
    using PushBackTuple = std::decay_t<decltype(pushBack(std::declval<T>(), std::declval<Tuple>()))>;
 
    template<class... Tuple>
    using TupleCat = std::decay_t<decltype(std::tuple_cat(std::declval<Tuple>()...))>;
 
 
 
 
  } // ACFem::
 
} // Dune::
 
#endif // __DUNE_ACFEM_MPL_SUBTUPLE_HH__