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 <iterator>
# include <concepts>
# include <type_traits>
# include <utility>
 
 template <class SetType>
 struct StlIterator : public SetType::Iterator
 {
  using T = typename SetType::Item_Type;
  using Itor = typename SetType::Iterator;
  using iterator_category = std::forward_iterator_tag;
  using iterator_concept = std::forward_iterator_tag;
 
  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(); }
 
  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::forward_iterator_tag;
  using iterator_concept = std::forward_iterator_tag;
 
  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(); }
 
  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