reduce_pattern.h

Go to the documentation of this file.

/*
 * Copyright 2018 Universidad Carlos III de Madrid
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#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() && (static_cast<int>(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 &&){
    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