functor.hh

#ifndef __DUNE_ACFEM_FUNCTOR_HH__
#define __DUNE_ACFEM_FUNCTOR_HH__
 
#include <cstddef>
#include <utility>
#include <tuple>
 
namespace Dune {
 
  namespace ACFem {
 
    template<class LocalArray, class GlobalArray>
    struct ExtractFunctor
    {
      explicit ExtractFunctor(LocalArray& localArray,
                              const GlobalArray& globalArray)
        : localArray_(localArray), globalArray_(globalArray)
      {}
 
      template<class GlobalKey>
      void operator()(const std::size_t local, const GlobalKey &global) const
      {
        localArray_[local] = globalArray_[global];
      }
 
    private:
      LocalArray& localArray_;
      const GlobalArray& globalArray_;
    };
 
    template<class T, class GlobalArray>
    struct ExtractFunctor<T *, GlobalArray>
    {
      explicit ExtractFunctor(T *localArray,
                              const GlobalArray& globalArray)
        : localArray_(localArray), globalArray_(globalArray)
      {}
 
      template<class GlobalKey>
      void operator()(const std::size_t local, const GlobalKey &global) const
      {
        localArray_[local] = globalArray_[global];
      }
 
    private:
      T* localArray_;
      const GlobalArray& globalArray_;
    };
 
    template<class FunctorOne, class FunctorTwo>
    struct PairFunctor
    {
      explicit PairFunctor(FunctorOne&& one, FunctorTwo&& two)
        : one_(one), two_(two)
      {}
 
      template<class Value>
      void operator()(const std::size_t local, const Value& value) const
      {
        one_(local, value);
        two_(local, value);
      }
 
     private:
      FunctorOne& one_;
      FunctorTwo& two_;
    };
 
    template<class FunctorOne, class FunctorTwo>
    PairFunctor<FunctorOne, FunctorTwo> makePairFunctor(FunctorOne&& func1, FunctorTwo&& func2)
    {
      return PairFunctor<FunctorOne, FunctorTwo>(std::forward<FunctorOne>(func1),
                                                 std::forward<FunctorTwo>(func2));
    }
 
    template<class... Types>
    struct TupleFunctor
    {
      typedef std::tuple<Types&...> TupleType;
 
      TupleFunctor(const TupleType& arg)
        : functorTuple_(arg)
      {}
 
      template<class Value>
      void operator()(const std::size_t local, const Value& value) const
      {
        FunctorHelper<TupleType, std::tuple_size<TupleType>::value-1>::apply(
          functorTuple_, local, value);
      }
 
     private:
      template<class Tuple, unsigned index>
      struct FunctorHelper
      {
        template<class Value>
        static void apply(const Tuple& tuple, const std::size_t local, const Value& value)
        {
          FunctorHelper<Tuple, index - 1>::apply(tuple, local, value);
          std::get<index>(tuple)(local, value);
        }
      };
      template<class Tuple>
      struct FunctorHelper<Tuple, 0>
      {
        template<class Value>
        static void apply(const Tuple& tuple, const std::size_t local, const Value& value)
        {
          std::get<0>(tuple)(local, value);
        }
      };
 
      const TupleType functorTuple_;
    };
 
    template<class... Types>
    TupleFunctor<Types...> makeTupleFunctor(Types&&... args)
    {
      //return TupleFunctor<Types...>(std::tuple<Types&&...>(std::forward<Types>(args)...));
      return TupleFunctor<Types...>(std::forward_as_tuple(std::forward<Types>(args)...));
    }
 
 
  } // ACFem::
 
} // Dune::
 
#endif // __DUNE_ACFEM_FUNCTOR_HH__