pipeline_pattern.h

Go to the documentation of this file.

#ifndef GRPPI_COMMON_PIPELINE_PATTERN_H
#define GRPPI_COMMON_PIPELINE_PATTERN_H

#include <type_traits>

namespace grppi {

template <typename ... Transformers>
class pipeline_t {
public:

  using transformers_type = std::tuple<Transformers...>;

  pipeline_t(Transformers && ... others) noexcept :
    transformers_{others...}
  {}



  template <std::size_t index, typename T, typename std::enable_if< index == (sizeof...(Transformers) -1) ,int>::type = 0 >
  auto invoke_all(T item) const
  {
      return invoke<index>(item);
  }

  template <std::size_t index, typename T, typename std::enable_if< index != (sizeof...(Transformers) -1) ,int>::type = 0 >
  auto invoke_all(T item) const
  {
      return invoke_all<index+1>(invoke<index>(item));
  }
 
  template <typename T>
  auto operator()(T item) const{
    return invoke_all<0>(item);
  }

  template <std::size_t I, typename T>
  auto invoke(T && item) const {
    auto f = std::get<I>(transformers_);
    return f(std::forward<T>(item));
  }

  template <std::size_t I>
  auto stage() const noexcept {
    static_assert(I<sizeof...(Transformers),
      "Pipeline has not so many transformers");
    return std::get<I>(transformers_);
  }

  auto transformers() const noexcept {
    return transformers_;
  }

private:
  std::tuple<Transformers...> transformers_;
};

namespace internal {

template<typename T>
struct is_pipeline : std::false_type {};

template <typename ... T>
struct is_pipeline<pipeline_t<T...>> :std::true_type {};

} // namespace internal

template <typename T>
static constexpr bool is_pipeline = internal::is_pipeline<std::decay_t<T>>();

template <typename T>
using requires_pipeline = typename std::enable_if_t<is_pipeline<T>, int>;

namespace internal {

template <typename I, typename T>
struct output_value_type {
  using type = std::decay_t<typename std::result_of<T(I)>::type>;
};

template <typename I, typename T, typename ... U>
struct output_value_type<I,pipeline_t<T,U...>> {
  using first_result = std::decay_t<typename std::result_of<T(I)>::type>;
  using type = std::conditional_t<sizeof...(U)==0,
    first_result,
    typename output_value_type<first_result,U...>::type
  >;
};

}

template <typename I, typename T>
using output_value_type = typename internal::output_value_type<I,T>::type;

}

#endif