RangeView.h

#pragma once
 
#include <Foundation/Types/Delegate.h>
 
template <typename ValueType, typename IteratorType>
class plRangeView
{
public:
  using BeginCallback = plDelegate<IteratorType()>;
  using EndCallback = plDelegate<IteratorType()>;
  using NextCallback = plDelegate<void(IteratorType&)>;
  using ValueCallback = plDelegate<ValueType(const IteratorType&)>;
 
  PL_ALWAYS_INLINE plRangeView(BeginCallback begin, EndCallback end, NextCallback next, ValueCallback value);
 
  struct ConstIterator
  {
    PL_DECLARE_POD_TYPE();
 
    using iterator_category = std::forward_iterator_tag;
    using value_type = ConstIterator;
    using pointer = ConstIterator*;
    using reference = ConstIterator&;
 
    PL_ALWAYS_INLINE ConstIterator(const ConstIterator& rhs) = default;
    PL_FORCE_INLINE void Next();
    PL_FORCE_INLINE ValueType Value() const;
    PL_ALWAYS_INLINE ValueType operator*() const { return Value(); }
    PL_ALWAYS_INLINE void operator++() { Next(); }
    PL_FORCE_INLINE bool operator==(const typename plRangeView<ValueType, IteratorType>::ConstIterator& it2) const;
    PL_FORCE_INLINE bool operator!=(const typename plRangeView<ValueType, IteratorType>::ConstIterator& it2) const;
 
  protected:
    PL_FORCE_INLINE explicit ConstIterator(const plRangeView<ValueType, IteratorType>* view, IteratorType pos);
 
    friend class plRangeView<ValueType, IteratorType>;
    const plRangeView<ValueType, IteratorType>* m_pView = nullptr;
    IteratorType m_Pos;
  };
 
  struct Iterator : public ConstIterator
  {
    PL_DECLARE_POD_TYPE();
 
    using iterator_category = std::forward_iterator_tag;
    using value_type = Iterator;
    using pointer = Iterator*;
    using reference = Iterator&;
 
    using ConstIterator::Value;
    PL_ALWAYS_INLINE Iterator(const Iterator& rhs) = default;
    PL_FORCE_INLINE ValueType Value();
    PL_ALWAYS_INLINE ValueType operator*() { return Value(); }
 
  protected:
    PL_FORCE_INLINE explicit Iterator(const plRangeView<ValueType, IteratorType>* view, IteratorType pos);
  };
 
  Iterator begin() { return Iterator(this, m_Begin()); }
  Iterator end() { return Iterator(this, m_End()); }
  ConstIterator begin() const { return ConstIterator(this, m_Begin()); }
  ConstIterator end() const { return ConstIterator(this, m_End()); }
  ConstIterator cbegin() const { return ConstIterator(this, m_Begin()); }
  ConstIterator cend() const { return ConstIterator(this, m_End()); }
 
private:
  friend struct Iterator;
  friend struct ConstIterator;
 
  BeginCallback m_Begin;
  EndCallback m_End;
  NextCallback m_Next;
  ValueCallback m_Value;
};
 
template <typename V, typename I>
typename plRangeView<V, I>::Iterator begin(plRangeView<V, I>& in_container)
{
  return in_container.begin();
}
 
template <typename V, typename I>
typename plRangeView<V, I>::ConstIterator begin(const plRangeView<V, I>& container)
{
  return container.cbegin();
}
 
template <typename V, typename I>
typename plRangeView<V, I>::ConstIterator cbegin(const plRangeView<V, I>& container)
{
  return container.cbegin();
}
 
template <typename V, typename I>
typename plRangeView<V, I>::Iterator end(plRangeView<V, I>& in_container)
{
  return in_container.end();
}
 
template <typename V, typename I>
typename plRangeView<V, I>::ConstIterator end(const plRangeView<V, I>& container)
{
  return container.cend();
}
 
template <typename V, typename I>
typename plRangeView<V, I>::ConstIterator cend(const plRangeView<V, I>& container)
{
  return container.cend();
}
 
#include <Foundation/Types/Implementation/RangeView_inl.h>