counter.hpp

Go to the documentation of this file.

 
#ifndef RUSH_COUNTER_HPP
#define RUSH_COUNTER_HPP
 
#include <limits>
#include <utility>
 
namespace rush {
 
template <typename T = unsigned long>
class Counter {
public:
  explicit Counter(const T init = 0, const T step = 1) : init_{init}, step_{step}, counter_{init} {}
 
  T operator()() {
    return std::exchange(counter_, counter_ + step_);
  }
 
  T operator++() {
    return counter_ += step_;
  }
 
  T operator++(int) {
    return std::exchange(counter_, counter_ + step_);
  }
 
  T operator+=(const int n) {
    return std::exchange(counter_, counter_ + n * step_);
  }
 
  T operator--() {
    return counter_ -= step_;
  }
 
  T operator--(int) {
    return std::exchange(counter_, counter_ - step_);
  }
 
  T operator-=(const int n) {
    return std::exchange(counter_, counter_ - n * step_);
  }
 
  void set(const T value) {
    counter_ = value;
  }
 
  void reset() {
    counter_ = init_;
  }
 
private:
  const T init_;
  const T step_;
  T counter_;
};
 
template <typename T = unsigned long>
class RangeCounter : public Counter<T> {
public:
  explicit RangeCounter(const T init = 0, const T reset = std::numeric_limits<T>::max(), const T step = 1) : Counter<T>(0, step), offset_{init}, reset_{reset - init} {}
 
  T operator()() {
    return Counter<T>::operator()() % reset_ + offset_;
  }
 
  T operator++() {
    return Counter<T>::operator++() % reset_ + offset_;
  }
 
  T operator++(int) {
    return Counter<T>::operator++(0) % reset_ + offset_;
  }
 
  T operator+=(const int n) {
    return Counter<T>::operator+=(n) % reset_ + offset_;
  }
 
  T operator--() = delete;
  T operator--(int) = delete;
  T operator-=(const int n) = delete;
private:
  const T offset_;
  const T reset_;
};
 
} // namespace rush
 
#endif // RUSH_COUNTER_HPP