poly/stream_iteration.h

Go to the documentation of this file.

#ifndef GRPPI_POLY_STREAM_ITERATOR_H
#define GRPPI_POLY_STREAM_ITERATOR_H

#include "polymorphic_execution.h"
#include "../common/support.h"

namespace grppi {

template<typename Generator, typename Predicate, typename Consumer,
         typename Transformer >
void repeat_until_multi_impl(polymorphic_execution & e, Generator && in,
      farm_info<polymorphic_execution,Transformer> && op, Predicate && predicate_op, Consumer && out)
{
}

template <typename E, typename ... O,
          typename Generator, typename Predicate, typename Consumer,
          typename Transformer ,
          internal::requires_execution_not_supported<E> = 0>
void repeat_until_multi_impl(polymorphic_execution & e,  Generator && in,
      pipeline_info<polymorphic_execution,Transformer> && op, Predicate && predicate_op, Consumer && out)
{
  repeat_until_multi_impl<O...>(e, std::forward<Generator>(in),
    std::forward<farm_info<polymorphic_execution,Transformer> >(op), std::forward<Predicate>(predicate_op),
    std::forward<Consumer>(out));
}

template <class E, typename ... O,
          typename Generator, typename Predicate, typename Consumer,
          typename Transformer ,
          internal::requires_execution_supported<E> = 0>
void repeat_until_multi_impl(polymorphic_execution & e, Generator && in,
      farm_info<polymorphic_execution,Transformer> && op, Predicate && predicate_op, Consumer && out)
{
  if (typeid(E) == e.type() && typeid(E) == op.exectype.type()) {
    auto & pipe_exec = op.exectype;
    auto & actual_exec = *pipe_exec. template execution_ptr<E>();
    auto transformed_farm = farm(actual_exec, std::forward<Transformer>(op.task));
    repeat_until(*e.execution_ptr<E>(),
        std::forward<Generator>(in),
        std::forward<farm_info<E,Transformer> >(transformed_farm), std::forward<Predicate>(predicate_op),
        std::forward<Consumer>(out));
  }
  else {
    repeat_until_multi_impl<O...>(e, std::forward<Generator>(in),
        std::forward<farm_info<polymorphic_execution,Transformer> >(op), std::forward<Predicate>(predicate_op),
        std::forward<Consumer>(out));
  }
}

template<typename Generator, typename Predicate, typename Consumer,
         typename ...MoreTransformers >
void repeat_until_multi_impl(polymorphic_execution & e, Generator && in,
      pipeline_info<polymorphic_execution,MoreTransformers...> && op, Predicate && predicate_op, Consumer && out)
{
}

template <typename E, typename ... O,
          typename Generator, typename Predicate, typename Consumer,
          typename ...MoreTransformers ,
          internal::requires_execution_not_supported<E> = 0>
void repeat_until_multi_impl(polymorphic_execution & e,  Generator && in,
      pipeline_info<polymorphic_execution,MoreTransformers...> && op, Predicate && predicate_op, Consumer && out)
{
  repeat_until_multi_impl<O...>(e, std::forward<Generator>(in),
    std::forward<pipeline_info<polymorphic_execution,MoreTransformers...> >(op), std::forward<Predicate>(predicate_op),
    std::forward<Consumer>(out));
}

template <class E, typename ... O,
          typename Generator, typename Predicate, typename Consumer,
          typename ...MoreTransformers ,
          internal::requires_execution_supported<E> = 0>
void repeat_until_multi_impl(polymorphic_execution & e, Generator && in,
      pipeline_info<polymorphic_execution,MoreTransformers...> && op, Predicate && predicate_op, Consumer && out)
{
  if (typeid(E) == e.type() && typeid(E) == op.exectype.type()) {
    auto & pipe_exec = op.exectype;
    auto & actual_exec = *pipe_exec. template execution_ptr<E>(); 
    auto transformed_pipe = transform_pipeline(actual_exec, std::forward<std::tuple<MoreTransformers...>>(op.stages)); 
    repeat_until(*e.execution_ptr<E>(),
        std::forward<Generator>(in),
        std::forward<pipeline_info<E,MoreTransformers...> >(transformed_pipe), std::forward<Predicate>(predicate_op),
        std::forward<Consumer>(out));
  }
  else {
    repeat_until_multi_impl<O...>(e, std::forward<Generator>(in),
        std::forward<pipeline_info<polymorphic_execution,MoreTransformers...> >(op), std::forward<Predicate>(predicate_op),
        std::forward<Consumer>(out));
  }
}

template<typename Generator, typename Predicate, typename Consumer,
         typename Operation>
void repeat_until_multi_impl(polymorphic_execution & e, Generator && in, 
      Operation && op, Predicate && predicate_op, Consumer && out)
{
}

template <typename E, typename ... O,
          typename Generator, typename Predicate, typename Consumer,
          typename Operation,
          internal::requires_execution_not_supported<E> = 0>
void repeat_until_multi_impl(polymorphic_execution & e,  Generator && in, 
      Operation && op, Predicate && predicate_op, Consumer && out) 
{
  repeat_until_multi_impl<O...>(e, std::forward<Generator>(in), 
    std::forward<Operation>(op), std::forward<Predicate>(predicate_op), 
    std::forward<Consumer>(out));
}

template <typename E, typename ... O,
          typename Generator, typename Predicate, typename Consumer,
          typename Operation,
          internal::requires_execution_supported<E> = 0>
void repeat_until_multi_impl(polymorphic_execution & e, Generator && in, 
      Operation && op, Predicate && predicate_op, Consumer && out) 
{
  if (typeid(E) == e.type()) {
    repeat_until(*e.execution_ptr<E>(), 
        std::forward<Generator>(in), 
        std::forward<Operation>(op), std::forward<Predicate>(predicate_op), 
        std::forward<Consumer>(out));
  }
  else {
    repeat_until_multi_impl<O...>(e, std::forward<Generator>(in), 
        std::forward<Operation>(op), std::forward<Predicate>(predicate_op), 
        std::forward<Consumer>(out));
  }
}

template <typename Generator, typename Predicate, typename Consumer,
          typename Transformer>
void repeat_until(polymorphic_execution & ex, 
                  Generator && generate_op,
                  farm_info<polymorphic_execution, Transformer> && farm_obj, 
                  Predicate && predicate_op, Consumer && consume_op)
{
  repeat_until_multi_impl<
    sequential_execution,
    parallel_execution_native
  >(ex, std::forward<Generator>(generate_op), 
      std::forward<farm_info<polymorphic_execution,Transformer> >(farm_obj),
      std::forward<Predicate>(predicate_op), 
      std::forward<Consumer>(consume_op));
}

template <typename Generator, typename Predicate, typename Consumer,
          typename ... Transformers>
void repeat_until(polymorphic_execution & ex, Generator && generate_op,
      pipeline_info<polymorphic_execution, Transformers...> && pipe_info, 
      Predicate && predicate_op, Consumer && consume_op)
{
  repeat_until_multi_impl<
    sequential_execution,
    parallel_execution_native
  >(ex, std::forward<Generator>(generate_op), 
      std::forward<pipeline_info<polymorphic_execution,Transformers...>>(pipe_info),
      std::forward<Predicate>(predicate_op), 
      std::forward<Consumer>(consume_op));
}

template <typename Generator, typename Transformer, typename Predicate, typename Consumer>
void repeat_until(polymorphic_execution & ex, 
                  Generator && generate_op, 
                  Transformer && transform_op, Predicate && predicate_op, 
                  Consumer && consume_op) 
{
  repeat_until_multi_impl<
    sequential_execution,
    parallel_execution_native
  >(ex, std::forward<Generator>(generate_op), std::forward<Transformer>(transform_op), 
       std::forward<Predicate>(predicate_op), std::forward<Consumer>(consume_op));
}

} // end namespace grppi

#endif