foreach.hh

#ifndef __DUNE_ACFEM_MPL_FOREACH_HH__
#define __DUNE_ACFEM_MPL_FOREACH_HH__
 
#include <dune/common/hybridutilities.hh>
#include "../common/types.hh"
#include "typetuple.hh"
#include "access.hh"
#include "filter.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    template<std::size_t... I, class F>
    constexpr void forEach(F&& f, IndexSequence<I...> = IndexSequence<I...>{})
    {
      (... , std::forward<F>(f)(IndexConstant<I>{}));
    }
 
    template<std::size_t... I, class F>
    constexpr void forEach(IndexSequence<I...>, F&& f)
    {
      (... , std::forward<F>(f)(IndexConstant<I>{}));
    }
 
    template<class... T, class F>
    constexpr void forEach(MPL::TypeTuple<T...>, F&& f)
    {
      (... , std::forward<F>(f)(MPL::TypeWrapper<T>{}));
    }
 
    template<class T, class F, std::enable_if_t<IsTupleLike<T>::value, int> = 0>
    constexpr void forEach(T&& t, F&& f)
    {
      forEach(MakeSequenceFor<T>{}, [&](auto i) {
          using I = decltype(i);
          std::forward<F>(f)(std::forward<TupleElement<I::value, T> >(get<I::value>(std::forward<T>(t))));
        });
    }
 
    /***/
    template<std::size_t N, class F>
    constexpr void forLoop(F&& f)
    {
      forEach(MakeIndexSequence<N>{}, std::forward<F>(f));
    }
 
    template<std::size_t... I, class F>
    constexpr bool forEachWhile(F&& f, IndexSequence<I...> = IndexSequence<I...>{})
    {
      return (... && (std::forward<F>(f)(IndexConstant<I>{})));
    }
 
    template<std::size_t... I, class F>
    constexpr bool forEachWhile(IndexSequence<I...>, F&& f)
    {
      return forEachWhile<I...>(std::forward<F>(f));
    }
 
    template<std::size_t... I, class F, class T>
    constexpr auto addEach(T&& init, F&& f, IndexSequence<I...> = IndexSequence<I...>{})
    {
      return (std::forward<T>(init) + ... + (std::forward<F>(f)(IndexConstant<I>{})));
    }
 
    template<std::size_t... I, class F, class T>
    constexpr auto
    addEach(IndexSequence<I...>, T&& init, F&& f)
    {
      return addEach<I...>(std::forward<F>(f), std::forward<T>(init));
    }
 
    template<std::size_t N, class F, class T>
    constexpr auto addLoop(F&& f, T&& init, IndexConstant<N> = IndexConstant<N>{})
    {
      return addEach(MakeIndexSequence<N>{}, std::forward<F>(f), std::forward<T>(init));
    }
 
    template<std::size_t... I, class F, class T>
    constexpr auto multiplyEach(T&& init, F&& f, IndexSequence<I...> = IndexSequence<I...>{})
    {
      return (std::forward<T>(init) * ... * (std::forward<F>(f)(IndexConstant<I>{})));
    }
 
    template<std::size_t... I, class F, class T>
    constexpr auto multiplyEach(IndexSequence<I...>, T&& init, F&& f)
    {
      return multiplyEach<I...>(std::forward<F>(f), std::forward<T>(init));
    }
 
    template<std::size_t N, class F, class T>
    constexpr auto multiplyLoop(T&& init, F&& f, IndexConstant<N> = IndexConstant<N>{})
    {
      return multiplyEach(MakeIndexSequence<N>{}, std::forward<F>(f), std::forward<T>(init));
    }
 
 
 
 
  } // ACFem::
 
} // Dune::
 
#endif // __DUNE_ACFEM_MPL_FOREACH_HH__