cpp-useful-iterators/include/iterator/end_aware_iterator.h

//
//  end_aware_iterator.h
//  iterator
//
//  Created by Sam Jaffe on 2/7/17.
//

#pragma once
#include <ranges>

#include <iterator/forwards.h>
#include <iterator/proxy.h>
#include <iterator/sentinel.h>

#include <iterator/detail/macro.h>

namespace iterator {
/**
 * @class end_aware_iterator
 * @brief An iterator that keeps track of the relative end of the range.
 *
 * @tparam It The underlying iterator type
 */
template <typename It>
class end_aware_iterator : public proxy<It, end_aware_iterator<It>> {
public:
  using super_t = proxy<It, end_aware_iterator<It>>;
  using sentinel_type = sentinel_t;

public:
  end_aware_iterator() = default;
  end_aware_iterator(It it, It end) : super_t(it), end_(end) {}

  end_aware_iterator(Range auto & container)
      : super_t(std::begin(container)), end_(std::end(container)) {}

  template <typename Ot>
  end_aware_iterator(end_aware_iterator<Ot> const & other)
      : super_t(other.impl()), end_(other.end_) {}

  operator std::ranges::subrange<It>() const {
    return {super_t::impl(), end()};
  }

  bool at_end() const {
    if constexpr (std::random_access_iterator<It>) {
      return super_t::impl() >= end_;
    } else {
      return super_t::impl() == end_;
    }
  }

  friend auto operator-(sentinel_type, end_aware_iterator const & self)
    requires(std::random_access_iterator<It>)
  {
    return self.end() - self.impl();
  }

protected:
  It end() const { return end_; }

private:
  template <typename O> friend class end_aware_iterator;
  It end_;
};

template <typename C>
end_aware_iterator(C &&) -> end_aware_iterator<iterator_t<C>>;
template <typename It> end_aware_iterator(It, It) -> end_aware_iterator<It>;
template <typename It>
end_aware_iterator(end_aware_iterator<It>, end_aware_iterator<It>)
    -> end_aware_iterator<It>;
}

#include <iterator/detail/undef.h>