iterator.hpp

#pragma once
 
#include <concepts>
#include <cstddef>
#include <type_traits>
 
namespace tf {

template <std::integral B, std::integral E, std::integral S>
constexpr bool is_index_range_invalid(B beg, E end, S step) {
  return ((step == 0 && beg != end) ||
          (beg < end && step <=  0) ||  // positive range
          (beg > end && step >=  0));   // negative range
}

template <std::integral B, std::integral E, std::integral S>
constexpr size_t distance(B beg, E end, S step) {
  return (end - beg + step + (step > 0 ? -1 : 1)) / step;
}
 
// ----------------------------------------------------------------------------
// IndexRange
// ----------------------------------------------------------------------------

template <typename T>
class IndexRange {
 
  static_assert(std::is_integral_v<T>, "index type must be integral");
 
  public:

  using index_type = T;

  IndexRange() = default;

  explicit IndexRange(T beg, T end, T step_size)
    : _beg{beg}, _end{end}, _step_size{step_size} {}

  T begin() const { return _beg; }

  T end() const { return _end; }

  T step_size() const { return _step_size; }

  IndexRange<T>& reset(T begin, T end, T step_size) {
    _beg = begin;
    _end = end;
    _step_size = step_size;
    return *this;
  }

  IndexRange<T>& begin(T new_begin) { _beg = new_begin; return *this; }

  IndexRange<T>& end(T new_end) { _end = new_end; return *this; }

  IndexRange<T>& step_size(T new_step_size) { _step_size = new_step_size; return *this; }

  size_t size() const { return distance(_beg, _end, _step_size); }

  IndexRange unravel(size_t part_beg, size_t part_end) const {
    return IndexRange(
      static_cast<T>(part_beg) * _step_size + _beg,
      static_cast<T>(part_end) * _step_size + _beg,
      _step_size
    );
  }
 
  private:
 
  T _beg;
  T _end;
  T _step_size;
 
};
 
// ----------------------------------------------------------------------------
 
 
 
  
 
}  // end of namespace tf -----------------------------------------------------