seq/stream_iteration.h

Go to the documentation of this file.

#ifndef GRPPI_SEQ_STREAM_ITERATION_H
#define GRPPI_SEQ_STREAM_ITERATION_H

#include "sequential_execution.h"

namespace grppi{

template<typename Generator, typename Transformer, typename Predicate, 
         typename Consumer>
void repeat_until(sequential_execution, 
                  Generator generate_op, Transformer && transform_op, 
                  Predicate predicate_op, Consumer consume_op)
{
  for(;;) {
    auto item = generate_op();
    if (!item) break;
    auto val = *item;
    do {
      val = transform_op(val);
    } while (!predicate_op(val));
    consume_op(val);
  }
}

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


template<typename Generator, typename Transformer, typename Predicate, 
         typename Consumer>
void repeat_until(sequential_execution & ex, 
                  Generator generate_op, 
                  farm_info<sequential_execution, Transformer> && farm_obj, 
                  Predicate predicate_op, 
                  Consumer consume_op)
{
  for(;;) {
    auto item = generate_op();       
    if (!item) break;
    auto val = *item;
    do {
      val = farm_obj.task(val);
    } while (!predicate_op(val));
    consume_op(val);
  }
}

template<typename Generator, typename Predicate, typename Consumer, 
         typename ... Transformers>
void repeat_until(sequential_execution & ex, 
                  Generator && generate_op, 
                  pipeline_info<sequential_execution, 
                      Transformers...> & pipe_obj, 
                  Predicate && predicate_op, Consumer && consume_op)
{
  using namespace std;
  repeat_until(ex, 
      forward<Generator>(generate_op), 
      forward<pipeline_info<sequential_execution, 
              Transformers...> &&>(pipe), 
      forward<Predicate>(predicate_op), 
      forward<Consumer>(consume_op));
}

template<typename Generator, typename Predicate, typename Consumer, 
         typename ...Transformers>
void repeat_until(sequential_execution & ex, 
                  Generator generate_op, 
                  pipeline_info<sequential_execution, Transformers...> && pipe, 
                  Predicate predicate_op, Consumer consume_op)
{
  using namespace std;
  for (;;) {
    auto item = generate_op();
    if (!item) break; 
    auto val = *item;
    do {
      using generated_type = typename result_of<Generator()>::type;
      using generated_value_type = typename generated_type::value_type;
      using pipeline_info_type = pipeline_info<sequential_execution,
          Transformers...>;
      val = composed_pipeline<generated_value_type,0,Transformers...>(val, 
          forward<pipeline_info_type>(pipe));
    } while (!predicate_op(val));
    consume_op(val);
  }
}

}

#endif