reduce_pattern.h

Go to the documentation of this file.

#ifndef GRPPI_COMMON_REDUCE_PATTERN_H
#define GRPPI_COMMON_REDUCE_PATTERN_H


namespace grppi{

template <typename Combiner, typename Identity>
class reduce_t {
public:

  reduce_t(int wsize, int offset, Identity id, Combiner && combine_op) :
    window_size_{wsize}, offset_{offset}, 
    identity_{id}, combiner_{combine_op}
  {}

  void add_item(Identity && item) {
    if (remaining>0) {
      remaining--;
    }
    else {
      items.push_back(std::forward<Identity>(item));
    }
  }

  bool reduction_needed() const {
    return !items.empty() && (items.size() >= window_size_);
  }

  Combiner combiner() const { return combiner_; }

  int window_size() const { return window_size_; }

  int offset() const { return offset_; }

  template <typename E>
  auto reduce_window(const E & e) {
    auto red = e.reduce(items.begin(), items.size(), identity_, combiner_);
    if (offset_ > window_size_) {
      remaining = offset_ - window_size_;
      items.clear();
    }
    else {
      items.erase(items.begin(), std::next(items.begin(), offset_));
    }
    return red;
  }
  
  template<typename T>
  auto operator()(T &&item){
    return Identity{};
  }

private:
  int window_size_;
  int offset_;
  Identity identity_;
  Combiner combiner_;

  std::vector<Identity> items{};
  int remaining = 0;
};

namespace internal {

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

template <typename C, typename I>
struct is_reduce<reduce_t<C,I>> :std::true_type {};

}

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

template <typename T>
using requires_reduce = std::enable_if_t<is_reduce<T>,int>;

} // end namespace grppi

#endif