seq/pipeline.h

Go to the documentation of this file.

#ifndef GRPPI_SEQ_PIPELINE_H
#define GRPPI_SEQ_PIPELINE_H

#include "sequential_execution.h"

#include "../common/pack_traits.h"
#include "../common/patterns.h"

namespace grppi {

template <typename Input, int Index, typename ... MoreTransformers,
          internal::requires_index_last<Index,MoreTransformers...> = 0>
auto composed_pipeline(Input in, 
                       const pipeline_info<
                           sequential_execution,
                           MoreTransformers...> & pipeline_obj)
{
  return std::get<Index>(pipeline_obj.stages)(in);
}

template <typename Input, int Index, typename ... MoreTransformers,
          internal::requires_index_not_last<Index,MoreTransformers...> = 0>
auto composed_pipeline(Input in, 
                       const pipeline_info<
                           sequential_execution, 
                           MoreTransformers...> & pipeline_obj)
{
  return composed_pipeline<Input, Index+1, MoreTransformers...>(
      std::get<Index>(pipeline_obj.stages)(in),
      pipeline_obj);
}

//Last stage
template <typename Item, typename Transformer>
void pipeline_impl(sequential_execution &s, Item && item, 
                   Transformer && transform_op) 
{
  transform_op(std::forward<Item>(item));
}

//Filter stage
template <typename Item, typename Filter, typename... MoreTransformers>
void pipeline_impl(sequential_execution & ex, Item && item, 
                   const filter_info<sequential_execution,Filter> & filter_obj, 
                   MoreTransformers && ... more_transform_ops)
{
  pipeline_impl(ex, std::forward<Item>(item), 
      std::forward<filter_info<sequential_execution,Filter>>(filter_obj), 
      std::forward<MoreTransformers>(more_transform_ops)...);
}

template <typename Item, typename Transformer, typename... MoreTransformers>
void pipeline_impl(sequential_execution & ex, Item && item, 
                   filter_info<sequential_execution, Transformer> && transf_filter, 
                   MoreTransformers && ... more_transform_ops) 
{
  if(transf_filter.task(item))
    pipeline_impl(ex, std::forward<Item>(item),
        std::forward<MoreTransformers>(more_transform_ops)...);
}

//Farm stage
template <typename Item, typename Transformer, typename... MoreTransformers>
void pipeline_impl(sequential_execution & ex, Item && item, 
                   farm_info<sequential_execution, Transformer> & transf_farm, 
                   MoreTransformers && ... more_transform_ops) 
{
  pipeline_impl(ex, std::forward<Item>(item), 
      std::forward<farm_info<sequential_execution,Transformer>>(transf_farm), 
      std::forward<MoreTransformers>(more_transform_ops)... );
}

template <typename Item, typename Transformer, typename... MoreTransformers>
void pipeline_impl(sequential_execution & ex, Item && item, 
                   farm_info<sequential_execution, Transformer> && transform_farm, 
                   MoreTransformers && ... more_transform_ops) 
{
  pipeline_impl(ex, transform_farm.task(item), 
      std::forward<MoreTransformers>(more_transform_ops)...);
}



//Intermediate stages
template <typename Item, typename Transformer, typename ... MoreTransformers>
void pipeline_impl(sequential_execution & ex, Item && item, 
                   Transformer && transform_op, 
                   MoreTransformers && ... more_transform_ops) 
{
  pipeline_impl(ex, transform_op(item), 
      std::forward<MoreTransformers>(more_transform_ops)...);
}

template <typename Generator, 
          typename ... Transformers,
          typename = typename std::result_of<Generator()>::type> // TODO: Intention?
void pipeline(sequential_execution & ex, Generator && generator_op, 
              Transformers && ... transform_ops) 
{
  for (;;) {
    auto item = generator_op();
    if(!item) break;
    pipeline_impl(ex, *item, std::forward<Transformers>(transform_ops) ... );
  }
}

}

#endif