list_iterator.h

// With iterator.h as base by camilo on 2022-09-12 04:02 <3ThomasBorregaardSorensen!!
#pragma once
 
 
//#include "_iterator.h"
//
      //auto & operator = (const THIS_ITERATOR & iterator) { m_p = iterator.m_p; return *this; }
//
//
 
 
template < typename BASE_ITERATOR_TYPE >
class list_iterator_node :
   public BASE_ITERATOR_TYPE
{
public:
 
 
   using iterator = ::list_iterator_node < typename BASE_ITERATOR_TYPE::iterator >;
   using const_iterator = ::list_iterator_node < typename BASE_ITERATOR_TYPE::const_iterator >;
   using this_iterator = ::list_iterator_node < BASE_ITERATOR_TYPE >;
 
 
   using ITEM = typename BASE_ITERATOR_TYPE::ITEM;
   using node = BASE_ITERATOR_TYPE;
 
 
   using ITEM_POINTER = typename BASE_ITERATOR_TYPE::ITEM_POINTER;
   using CONST_ITEM_POINTER = typename BASE_ITERATOR_TYPE::CONST_ITEM_POINTER;
   using THIS_ITEM_POINTER = typename BASE_ITERATOR_TYPE::THIS_ITEM_POINTER;
 
 
   using BASE_ITERATOR_TYPE::BASE_ITERATOR_TYPE;
 
 
   list_iterator_node(CONST_ITEM_POINTER p) : BASE_ITERATOR_TYPE(p) {}
   list_iterator_node(const iterator & iterator) : BASE_ITERATOR_TYPE((const BASE_ITERATOR_TYPE &)iterator) {}
   list_iterator_node(const const_iterator & iterator) : BASE_ITERATOR_TYPE((const BASE_ITERATOR_TYPE&)iterator) {}
 
 
   auto & topic() { return BASE_ITERATOR_TYPE::topic(); }
   auto & topic() const { return BASE_ITERATOR_TYPE::topic(); }
 
   auto & item() { return BASE_ITERATOR_TYPE::item(); }
   auto & item() const { return BASE_ITERATOR_TYPE::item(); }
 
   auto transfer_topic() { return ::transfer(BASE_ITERATOR_TYPE::transfer_topic()); }
 
   auto transfer() { return ::transfer(*this); }
 
 
};
 
 
template < typename BASE_ITERATOR_TYPE >
class list_iterator_element1 :
   public BASE_ITERATOR_TYPE
{
public:
 
 
   using iterator = ::list_iterator_element1 < typename BASE_ITERATOR_TYPE::iterator >;
   using const_iterator = ::list_iterator_element1 < typename BASE_ITERATOR_TYPE::const_iterator >;
   using THIS_ITERATOR = ::list_iterator_element1 < typename BASE_ITERATOR_TYPE::THIS_ITERATOR >;
 
 
   using ITEM = typename BASE_ITERATOR_TYPE::ITEM::ELEMENT1;
   using node = ITEM;
 
 
   using BASE_ITERATOR_TYPE::BASE_ITERATOR_TYPE;
 
 
   list_iterator_element1(const iterator & iterator) : BASE_ITERATOR_TYPE(*(BASE_ITERATOR_TYPE *)&iterator) {}
   list_iterator_element1(const const_iterator & iterator) : BASE_ITERATOR_TYPE(*(BASE_ITERATOR_TYPE *)&iterator) {}
 
 
   auto & topic() { return this->m_p->key(); }
   auto & topic() const { return this->m_p->key(); }
 
   auto & item() { return this->m_p->key(); }
   auto & item() const { return this->m_p->key(); }
 
   auto transfer_topic() { return ::transfer(this->m_p->transfer_item()); }
 
 
};
 
 
template < typename BASE_ITERATOR_TYPE >
class list_iterator_element2 :
   public BASE_ITERATOR_TYPE
{
public:
 
 
 
   using iterator = ::list_iterator_element2 < typename BASE_ITERATOR_TYPE::iterator >;
   using const_iterator = ::list_iterator_element2 < typename BASE_ITERATOR_TYPE::const_iterator >;
   using THIS_ITERATOR = ::list_iterator_element2 < typename BASE_ITERATOR_TYPE::THIS_ITERATOR >;
 
 
   using ITEM = typename BASE_ITERATOR_TYPE::ITEM::ELEMENT2;
   using node = ITEM;
 
 
   using BASE_ITERATOR_TYPE::BASE_ITERATOR_TYPE;
 
 
   list_iterator_element2(const iterator & iterator) : BASE_ITERATOR_TYPE(*(BASE_ITERATOR_TYPE *)&iterator) {}
   list_iterator_element2(const const_iterator & iterator) : BASE_ITERATOR_TYPE(*(BASE_ITERATOR_TYPE *)&iterator) {}
 
 
   auto & topic() { return this->m_p->payload(); }
   auto & topic() const { return this->m_p->payload(); }
 
   auto & item() { return this->m_p->payload(); }
   auto & item() const { return this->m_p->payload(); }
 
   auto transfer_topic() { return ::transfer(this->m_p->transfer_payload()); }
 
};
 
 
template < typename BASE_ITERATOR_TYPE >
class make_list_iterator :
   public BASE_ITERATOR_TYPE
{
public:
 
 
   using ITERATOR_TYPE = BASE_ITERATOR_TYPE;
 
 
   using ITEM_POINTER = typename ITERATOR_TYPE::ITEM_POINTER;
   using CONST_ITEM_POINTER = typename ITERATOR_TYPE::CONST_ITEM_POINTER;
   using LIST_ITEM_POINTER = typename ITERATOR_TYPE::ITEM_POINTER;
 
 
   using BASE_ITERATOR = typename BASE_ITERATOR_TYPE::iterator;
   using BASE_CONST_ITERATOR = typename BASE_ITERATOR_TYPE::const_iterator;
   using BASE_THIS_ITERATOR = typename BASE_ITERATOR_TYPE::THIS_ITERATOR;
 
 
   using iterator = ::make_list_iterator < typename BASE_ITERATOR_TYPE::iterator >;
   using const_iterator = ::make_list_iterator < typename BASE_ITERATOR_TYPE::const_iterator >;
   using THIS_ITERATOR = ::make_list_iterator < BASE_ITERATOR_TYPE >;
 
 
   using node = typename BASE_ITERATOR_TYPE::node;
   using const_node = const node;
 
 
   using ITEM = typename BASE_ITERATOR_TYPE::ITEM;
   using CONST_ITEM = const ITEM;
 
 
   using BASE_ITERATOR_TYPE::BASE_ITERATOR_TYPE;
 
 
   make_list_iterator(CONST_ITEM_POINTER itempointer) : BASE_ITERATOR_TYPE(itempointer) {}
   make_list_iterator(const iterator & iterator) : BASE_ITERATOR_TYPE(*(BASE_ITERATOR_TYPE *)&iterator) {}
   make_list_iterator(const const_iterator & iterator) : BASE_ITERATOR_TYPE(*(BASE_ITERATOR_TYPE *)&iterator) {}
 
 
   constexpr ::collection::index index() const
   {
 
      ::collection::index i = -1;
 
      auto iterator = *this;
 
      while (iterator.is_set())
      {
 
         i++;
 
         iterator--;
 
      }
 
      return i;
      
   }
 
 
   static constexpr bool difference(::collection::count & c, const_iterator a, const_iterator b)
   {
 
      c = 0;
 
      while (::is_set(b) && b != a)
      {
 
         c++;
 
         b++;
 
      }
 
      return b.is_set();
 
   }
 
 
   template < prototype_integral INTEGRAL >
   THIS_ITERATOR & operator += (INTEGRAL c)
   { 
      
      while (c-- > 0)
      {
 
         ++ * this;
 
      }
      
      
      return *this; 
   
   }
 
 
   template < prototype_integral INTEGRAL >
   constexpr THIS_ITERATOR operator + (INTEGRAL c) const
   {
 
      auto iterator = *this;
 
      iterator += c;
 
      return iterator;
 
   }
 
 
   template < prototype_integral INTEGRAL >
   THIS_ITERATOR & operator -= (INTEGRAL c)
   { 
      
      while (c-- > 0)
      { 
         
         --*this; 
      
      } 
      
      return *this; 
   
   }
 
 
   template < prototype_integral INTEGRAL >
   constexpr THIS_ITERATOR operator - (INTEGRAL c) const
   {
 
      auto iterator = *this;
 
      iterator += c;
 
      return iterator;
 
   }
 
 
   constexpr ::collection::count operator - (THIS_ITERATOR iterator) const
   {
 
      {
 
         auto i = *this;
 
         ::collection::count c = 0;
 
         while (i.is_set())
         {
 
            if (i == iterator)
            {
 
               return c;
 
            }
 
            i--;
 
            c++;
 
         }
 
      }
 
      {
 
         auto i = iterator;
 
         ::collection::count c = 0;
 
         while (i.is_set())
         {
 
            if (i == *this)
            {
 
               return -c;
 
            }
 
            i--;
 
            c++;
 
         }
 
      }
 
      throw "iterator is not part of list_base";
 
   }
 
 
   THIS_ITERATOR & operator =(ITEM_POINTER p) { this->m_p = p;  return *this; }
   THIS_ITERATOR & operator =(const iterator & iterator) { this->m_p = (ITEM_POINTER) iterator.get();  return *this;}
   THIS_ITERATOR & operator =(const const_iterator & iterator) { this->m_p = (ITEM_POINTER) iterator.get();  return *this; }
   THIS_ITERATOR & operator =(nullptr_t) { this->m_p = nullptr;  return *this; }
 
 
   template < typename ITERATOR >
   constexpr bool operator == (ITERATOR iterator) const
   {
 
      return this->get() == iterator.get();
 
   }
 
   
   constexpr std::strong_ordering operator <=> (const THIS_ITERATOR & iterator) const
   {
 
      return this->index() <=> iterator.index();
 
   }
 
 
   THIS_ITERATOR & operator ++()
   {
 
      *this = this->next();
 
      return *this;
 
   }
 
 
   THIS_ITERATOR operator ++(::i32)
   {
 
      auto iterator = *this;
 
      ++ * this;
 
      return iterator;
 
   }
 
 
   THIS_ITERATOR & operator --()
   {
 
      *this = this->back();
 
      return *this;
 
   }
 
 
   THIS_ITERATOR operator --(::i32)
   {
 
      auto iterator = *this;
 
      -- * this;
 
      return iterator;
 
   }
 
   constexpr bool is_set() const { return ::is_set(this) && ::is_set(this->get());  }
   constexpr bool is_null() const { return !is_set(); }
   constexpr bool is_ok() const { return is_set(); }
   constexpr bool operator !() const { return this->is_null(); }
   //https://www.artima.com/articles/the-safe-bool-idiom BEGIN
   typedef void (const_iterator:: * bool_type)() const;
   constexpr void this_type_does_not_support_comparisons() const {}
   constexpr operator bool_type() const { return this->is_set() ? &const_iterator::this_type_does_not_support_comparisons : 0; }
   //https://www.artima.com/articles/the-safe-bool-idiom END
 
 
 
   auto & operator *() { return this->item(); }
   auto & operator *() const { return this->item(); }
 
 
   auto operator ->() { return &this->item(); }
   auto operator ->() const { return &this->item(); }
 
 
   auto & back() { return this->get()->back(); }
   auto & back() const { return this->get()->back(); }
 
   auto & next() { return this->get()->next(); }
   auto & next() const { return this->get()->next(); }
 
 
};
 
 
template < typename ITERATOR_TYPE >
::collection::index index_as_of_iterator(::make_list_iterator < ITERATOR_TYPE > iterator)
{
   
   return iterator.index();
 
}
 
 
template < typename BASE_ITERATOR_TYPE >
inline auto & get(make_list_iterator<BASE_ITERATOR_TYPE> & p)
{
 
   return p.topic();
 
}
 
 
template < typename BASE_ITERATOR_TYPE >
inline auto & get(const make_list_iterator<BASE_ITERATOR_TYPE> & p)
{
 
   return p.topic();
 
}
//template < typename LIST_ITEM >
//using list_iterator = ::make_list_iterator < ::list_iterator_item < ::iterator_base < LIST_ITEM > > >;
 
//template < typename LIST_ITEM >
//using const_list_iterator = ::make_list_iterator < ::list_iterator_item < ::const_iterator_base < LIST_ITEM > > >;
 
 
template < typename LIST_ITEM >
using list_iterator = ::make_list_iterator < ::list_iterator_node < ::iterator_base < LIST_ITEM > > >;
 
template < typename LIST_ITEM >
using const_list_iterator = ::make_list_iterator < ::list_iterator_node < ::const_iterator_base < LIST_ITEM > > >;
 
 
 
template < typename LIST_ITEM >
using element1_list_iterator = ::make_list_iterator < ::list_iterator_element1 < ::iterator_base < LIST_ITEM > > >;
 
template < typename LIST_ITEM >
using const_element1_list_iterator = ::make_list_iterator < ::list_iterator_element1 < ::const_iterator_base < LIST_ITEM > > >;
 
 
 
template < typename LIST_ITEM >
using element2_list_iterator = ::make_list_iterator < ::list_iterator_element2 < ::iterator_base < LIST_ITEM > > >;
 
template < typename LIST_ITEM >
using const_element2_list_iterator = ::make_list_iterator < ::list_iterator_element2 < ::const_iterator_base < LIST_ITEM > > >;