ah-iterator.H

Go to the documentation of this file.

 
/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
#ifndef AH_ITERATOR_H
#define AH_ITERATOR_H
 
#include <compare>
#include <iterator>
#include <concepts>
#include <type_traits>
#include <utility>
 
namespace Aleph
{
  // Forward declaration only: extract_from_stl_container() below names
  // Aleph::DynList in a non-dependent qualified-id, which needs the
  // namespace and template to be visible even though the function body
  // is not instantiated until htlist.H's full definition is in scope.
  template <typename T> class DynList;
}
 
template <class I>
concept AlephRandomAccessItor = requires { typename I::aleph_random_access_iterator; } and
  std::same_as<typename I::aleph_random_access_iterator, I> and
  requires(I &it, const I &cit, long n) {
    { cit.get_pos() } -> std::convertible_to<long>;
    it.set_pos(n);
    it.prev();
  };
 
template <class SetType>
struct StlIterator : public SetType::Iterator
{
  using T = typename SetType::Item_Type;
  using Itor = typename SetType::Iterator;
 
  using iterator_category =
    std::conditional_t<AlephRandomAccessItor<Itor>, std::random_access_iterator_tag, std::forward_iterator_tag>;
  using iterator_concept = iterator_category;
 
  using difference_type = std::ptrdiff_t;
 
  using reference = decltype(std::declval<const Itor &>().get_curr());
 
  using pointer = std::add_pointer_t<std::remove_reference_t<reference>>;
 
  using value_type = T;
 
  StlIterator() noexcept = default;
 
  using Itor::Itor;
 
  StlIterator &operator ++ ()
  {
    this->next();
    return *this;
  }
 
  StlIterator operator ++ (int)
  {
    StlIterator ret_val = *this;
    this->next();
    return ret_val;
  }
 
  bool operator == (const StlIterator &it) const
  {
    if constexpr (requires(const Itor &a, const Itor &b) {
                    { a == b } -> std::convertible_to<bool>;
                  })
      return static_cast<const Itor &>(*this) == static_cast<const Itor &>(it);
 
    if (this->has_curr() and it.has_curr())
      return this->get_pos() == it.get_pos();
    // return this->get_curr() == it.get_curr();
 
    if (not this->has_curr() and not it.has_curr())
      return true;
 
    return false;
  }
 
  bool operator != (const StlIterator &it) const
  {
    return not (*this == it);
  }
 
  // Note: operator* must be const to satisfy std::indirectly_readable.
  // Constness of the iterator object does not imply constness of the element.
  reference operator * () const
  {
    return this->get_curr();
  }
 
  pointer operator ->() const
  {
    return &this->get_curr();
  }
 
  // Random-access operations. These overloads exist only when the underlying
  // Aleph iterator opts in via the `aleph_random_access_iterator` marker
  // (e.g. DynArray, Array). They operate on the logical position exposed by
  // get_pos()/set_pos(), so any physical/circular index mapping stays internal.
 
  StlIterator &operator -- ()
    requires AlephRandomAccessItor<Itor>
  {
    this->prev();
    return *this;
  }
 
  StlIterator operator -- (int)
    requires AlephRandomAccessItor<Itor>
  {
    StlIterator ret_val = *this;
    this->prev();
    return ret_val;
  }
 
  StlIterator &operator += (difference_type n)
    requires AlephRandomAccessItor<Itor>
  {
    this->set_pos(this->get_pos() + n);
    return *this;
  }
 
  StlIterator &operator -= (difference_type n)
    requires AlephRandomAccessItor<Itor>
  {
    this->set_pos(this->get_pos() - n);
    return *this;
  }
 
  StlIterator operator + (difference_type n) const
    requires AlephRandomAccessItor<Itor>
  {
    StlIterator ret_val = *this;
    ret_val += n;
    return ret_val;
  }
 
  friend StlIterator operator + (difference_type n, const StlIterator &it)
    requires AlephRandomAccessItor<Itor>
  {
    return it + n;
  }
 
  StlIterator operator - (difference_type n) const
    requires AlephRandomAccessItor<Itor>
  {
    StlIterator ret_val = *this;
    ret_val -= n;
    return ret_val;
  }
 
  difference_type operator - (const StlIterator &it) const
    requires AlephRandomAccessItor<Itor>
  {
    return static_cast<difference_type>(this->get_pos() - it.get_pos());
  }
 
  reference operator [] (difference_type n) const
    requires AlephRandomAccessItor<Itor>
  {
    StlIterator tmp = *this;
    tmp += n;
    return *tmp;
  }
 
  std::strong_ordering operator <=> (const StlIterator &it) const
    requires AlephRandomAccessItor<Itor>
  {
    return this->get_pos() <=> it.get_pos();
  }
 
  static StlIterator begin(SetType &s)
  {
    return StlIterator(s);
  }
 
  static StlIterator end(SetType &s)
  {
    StlIterator it(s);
    it.Itor::end();
    return it;
  }
};
 
template <class SetType>
struct StlConstIterator : public SetType::Iterator
{
  using T = typename SetType::Item_Type;
  using Itor = typename SetType::Iterator;
 
  using iterator_category =
    std::conditional_t<AlephRandomAccessItor<Itor>, std::random_access_iterator_tag, std::forward_iterator_tag>;
  using iterator_concept = iterator_category;
 
  using difference_type = std::ptrdiff_t;
 
  using pointer = const T *;
 
  using reference = const T &;
 
  using value_type = T;
 
  StlConstIterator() noexcept = default;
 
  using Itor::Itor;
 
  StlConstIterator &operator ++ ()
  {
    this->next();
    return *this;
  }
 
  StlConstIterator operator ++ (int)
  {
    StlConstIterator ret_val = *this;
    this->next();
    return ret_val;
  }
 
  bool operator == (const StlConstIterator &it) const
  {
    if constexpr (requires(const Itor &a, const Itor &b) {
                    { a == b } -> std::convertible_to<bool>;
                  })
      return static_cast<const Itor &>(*this) == static_cast<const Itor &>(it);
 
    if (this->has_curr() and it.has_curr())
      return this->get_pos() == it.get_pos();
 
    if (not this->has_curr() and not it.has_curr())
      return true;
 
    return false;
  }
 
  bool operator != (const StlConstIterator &it) const
  {
    return not (*this == it);
  }
 
  const T &operator * () const
  {
    return this->get_curr();
  }
 
  const T *operator ->() const
  {
    return &this->get_curr();
  }
 
  // Random-access operations, mirroring StlIterator. These overloads exist
  // only when the underlying Aleph iterator opts in via the
  // `aleph_random_access_iterator` marker (e.g. DynArray, Array). They operate
  // on the logical position exposed by get_pos()/set_pos(), so any
  // physical/circular index mapping stays internal.
 
  StlConstIterator &operator -- ()
    requires AlephRandomAccessItor<Itor>
  {
    this->prev();
    return *this;
  }
 
  StlConstIterator operator -- (int)
    requires AlephRandomAccessItor<Itor>
  {
    StlConstIterator ret_val = *this;
    this->prev();
    return ret_val;
  }
 
  StlConstIterator &operator += (difference_type n)
    requires AlephRandomAccessItor<Itor>
  {
    this->set_pos(this->get_pos() + n);
    return *this;
  }
 
  StlConstIterator &operator -= (difference_type n)
    requires AlephRandomAccessItor<Itor>
  {
    this->set_pos(this->get_pos() - n);
    return *this;
  }
 
  StlConstIterator operator + (difference_type n) const
    requires AlephRandomAccessItor<Itor>
  {
    StlConstIterator ret_val = *this;
    ret_val += n;
    return ret_val;
  }
 
  friend StlConstIterator operator + (difference_type n, const StlConstIterator &it)
    requires AlephRandomAccessItor<Itor>
  {
    return it + n;
  }
 
  StlConstIterator operator - (difference_type n) const
    requires AlephRandomAccessItor<Itor>
  {
    StlConstIterator ret_val = *this;
    ret_val -= n;
    return ret_val;
  }
 
  difference_type operator - (const StlConstIterator &it) const
    requires AlephRandomAccessItor<Itor>
  {
    return static_cast<difference_type>(this->get_pos() - it.get_pos());
  }
 
  reference operator [] (difference_type n) const
    requires AlephRandomAccessItor<Itor>
  {
    StlConstIterator tmp = *this;
    tmp += n;
    return *tmp;
  }
 
  std::strong_ordering operator <=> (const StlConstIterator &it) const
    requires AlephRandomAccessItor<Itor>
  {
    return this->get_pos() <=> it.get_pos();
  }
 
  static StlConstIterator cbegin(const SetType &s)
  {
    return StlConstIterator(s);
  }
 
  static StlConstIterator cend(const SetType &s)
  {
    StlConstIterator it(s);
    it.Itor::end();
    return it;
  }
};
 
template <class SetName>
class StlAlephIterator
{
  SetName *me()
  {
    return static_cast<SetName *>(this);
  }
 
  const SetName *const_me() const
  {
    return static_cast<const SetName *>(this);
  }
 
public:
  using iterator = StlIterator<SetName>;
 
  using const_iterator = StlConstIterator<SetName>;
 
  iterator begin() noexcept
  {
    return iterator::begin(*me());
  }
 
  iterator end() noexcept
  {
    return iterator::end(*me());
  }
 
  const_iterator begin() const noexcept
  {
    return const_iterator::cbegin(*const_me());
  }
 
  const_iterator end() const noexcept
  {
    return const_iterator::cend(*const_me());
  }
 
  const_iterator cbegin() const noexcept
  {
    return const_iterator::cbegin(*const_me());
  }
 
  const_iterator cend() const noexcept
  {
    return const_iterator::cend(*const_me());
  }
 
  friend const_iterator cbegin(const SetName &s) noexcept
  {
    return s.begin();
  }
 
  friend const_iterator cend(const SetName &s) noexcept
  {
    return s.end();
  }
 
  friend const_iterator begin(const SetName &s) noexcept
  {
    return s.begin();
  }
 
  friend const_iterator end(const SetName &s) noexcept
  {
    return s.end();
  }
 
  friend iterator begin(SetName &s) noexcept
  {
    return s.begin();
  }
 
  friend iterator end(SetName &s) noexcept
  {
    return s.end();
  }
};
 
template <class Container>
inline Aleph::DynList<typename Container::value_type> extract_from_stl_container(const Container &c)
{
  Aleph::DynList<typename Container::value_type> ret;
  for (const auto &i : c)
    ret.append(i);
  return ret;
}
 
#endif  // AH_ITERATOR_H