enumerable_iterators.hpp

Go to the documentation of this file.

#pragma once
#include "../enumerator.hpp"
#include "../../../npos.hpp"
#include "../../../ptrdiff.hpp"
#include "../../../self.hpp"
#include "../../../usize.hpp"
#include <compare>
#include <limits>

namespace xtd {
  namespace collections {
    namespace generic {
      namespace extensions {
        template<typename type_t, typename enumerable_t>
        class enumerable_iterators {
          template<typename iterator_enumerable_t>
          class enumerable_iterator {
          public:
            using value_type = type_t;
            using iterator_category = std::forward_iterator_tag;
            using iterator_concept = std::forward_iterator_tag;
            using difference_type = xtd::ptrdiff;
            using pointer = value_type*;
            using reference = value_type&;
            
            static constexpr auto npos() -> xtd::usize {return std::numeric_limits<xtd::usize>::max();}
            
            enumerable_iterator() = default;
            enumerable_iterator(iterator_enumerable_t& enumerable, xtd::usize pos) : enumerable_ {&enumerable}, enumerator_ {enumerable.get_enumerator()}, pos_ {pos} {reset();}
            enumerable_iterator(enumerable_iterator&& value) noexcept = default;
            enumerable_iterator(const enumerable_iterator& value) noexcept : enumerable_(value.enumerable_), enumerator_(value.enumerable_->get_enumerator()), pos_ {value.pos_} {reset();}
            auto operator =(enumerable_iterator&& value) noexcept -> enumerable_iterator& = default;
            auto operator =(const enumerable_iterator& value) noexcept -> enumerable_iterator& {
              enumerable_ = value.enumerable_;
              enumerator_ = value.enumerable_->get_enumerator();
              pos_ = value.pos_;
              reset();
              return const_cast<enumerable_iterator&>(*this);
            }
            
            auto operator <=>(const enumerable_iterator& rhs) const noexcept -> std::strong_ordering {return pos_ <=> rhs.pos_;}
            auto operator ==(const enumerable_iterator& rhs) const noexcept -> bool {return pos_ == rhs.pos_;}
            auto operator *() const -> reference {return const_cast<value_type&>(enumerator_.current());}
            auto operator ->() const -> pointer {return &operator*();}
            
            auto operator ++() -> enumerable_iterator& {
              if (pos_ != npos()) pos_ = enumerator_.move_next() ? pos_ + 1 : npos();
              return const_cast<enumerable_iterator&>(*this);
            }
            auto operator ++(int) -> enumerable_iterator {
              auto current = *this;
              operator ++();
              return current;
            }
            
            template<typename value_t>
            auto operator +(value_t value) const noexcept -> const enumerable_iterator {return enumerable_iterator {*enumerable_, pos_ + value};}
            template<typename value_t>
            auto operator +(value_t value) noexcept -> enumerable_iterator {return enumerable_iterator {*enumerable_, pos_ + value};}
            template<typename value_t>
            auto operator +=(value_t value) noexcept -> enumerable_iterator& {
              *this = *this + value;
              return *this;
            }
            auto operator -(enumerable_iterator value) const noexcept -> difference_type {
              if (pos_ == npos()) return npos();
              return static_cast<difference_type>(pos_ - value.pos_);
            }
            
            explicit operator enumerable_iterator<const iterator_enumerable_t>() const noexcept {return enumerable_iterator<const iterator_enumerable_t>(*enumerable_, pos_);}
            
          private:
            auto reset() -> void {
              if (pos_ == npos()) return;
              try {
                enumerator_.reset();
              } catch(...) {
                if (pos_ != 0 && pos_ != npos()) throw;
                if (enumerator_.move_next() == false) pos_ = npos();
                return;
              }
              for (auto index = xtd::usize {}; index <= pos_; ++index)
                if (enumerator_.move_next() == false) {
                  pos_ = npos();
                  break;
                }
            }
            
            iterator_enumerable_t* enumerable_ = nullptr;
            enumerator<type_t> enumerator_;
            xtd::usize pos_ = 0;
          };
          
        public:
          
          using iterator = enumerable_iterator<enumerable_t>;
          using const_iterator = enumerable_iterator<const enumerable_t>;
          
          
          auto begin() const -> const_iterator {return cbegin();}
          auto begin() -> iterator {return iterator {self(), 0};}
          
          auto cbegin() const -> const_iterator {return const_iterator {self(), 0};}
          
          auto cend() const -> const_iterator {return const_iterator {self(), const_iterator::npos()};}
          
          auto end() const -> const_iterator {return cend();}
          auto end() -> iterator {return iterator {self(), iterator::npos()};}
          
          
          template<typename source_collection_t, typename target_collection_t>
          static auto to_const_iterator(typename source_collection_t::const_iterator& value, const source_collection_t& source_collection, const target_collection_t& target_collection) noexcept -> typename target_collection_t::const_iterator {
            if (value == source_collection.cbegin()) return target_collection.cbegin();
            if (value == source_collection.cend()) return target_collection.cend();
            
            auto result = target_collection.cbegin();
            for (auto index = xtd::ptrdiff {}; index < std::distance(source_collection.cbegin(), value); ++index, ++result);
            return result;
          }
          
          template<typename source_collection_t, typename target_collection_t>
          static auto to_const_iterator(typename source_collection_t::const_iterator& value, source_collection_t& source_collection, target_collection_t& target_collection) noexcept -> typename target_collection_t::const_iterator {
            if (value == source_collection.cbegin()) return target_collection.cbegin();
            if (value == source_collection.cend()) return target_collection.cend();
            
            auto result = target_collection.cbegin();
            for (auto index = xtd::ptrdiff {}; index < std::distance(source_collection.cbegin(), value); ++index, ++result);
            return result;
          }
          
          template<typename source_collection_t, typename target_collection_t>
          static auto to_iterator(typename source_collection_t::const_iterator& value, const source_collection_t& source_collection, const target_collection_t& target_collection) noexcept -> typename target_collection_t::const_iterator {
            if (value == source_collection.cbegin()) return target_collection.cbegin();
            if (value == source_collection.cend()) return target_collection.cend();
            
            auto result = target_collection.cbegin();
            for (auto index = xtd::ptrdiff {}; index < std::distance(source_collection.cbegin(), value); ++index, ++result);
            return result;
          }
          
          template<typename source_collection_t, typename target_collection_t>
          static auto to_iterator(typename source_collection_t::iterator& value, const source_collection_t& source_collection, const target_collection_t& target_collection) noexcept -> typename target_collection_t::iterator {
            if (value == source_collection.begin()) return target_collection.begin();
            if (value == source_collection.end()) return target_collection.end();
            
            auto result = target_collection.begin();
            for (auto index = xtd::ptrdiff {}; index < std::distance(source_collection.begin(), value); ++index, ++result);
            return result;
          }
          
          template<typename source_collection_t, typename target_collection_t>
          static auto to_iterator(typename source_collection_t::const_iterator& value, source_collection_t& source_collection, target_collection_t& target_collection) noexcept -> typename target_collection_t::const_iterator {
            if (value == source_collection.cbegin()) return target_collection.cbegin();
            if (value == source_collection.cend()) return target_collection.cend();
            
            auto result = target_collection.cbegin();
            for (auto index = xtd::ptrdiff {}; index < std::distance(source_collection.cbegin(), value); ++index, ++result);
            return result;
          }
          
          template<typename source_collection_t, typename target_collection_t>
          static auto to_iterator(typename source_collection_t::iterator& value, source_collection_t& source_collection, target_collection_t& target_collection) noexcept -> typename target_collection_t::iterator {
            if (value == source_collection.begin()) return target_collection.begin();
            if (value == source_collection.end()) return target_collection.end();
            
            auto result = target_collection.begin();
            for (auto index = xtd::ptrdiff {}; index < std::distance(source_collection.begin(), value); ++index, ++result);
            return result;
          }

          
        private:
          auto self() const noexcept -> const enumerable_t& {return static_cast<const enumerable_t&>(self_);}
          auto self() noexcept -> enumerable_t& {return static_cast<enumerable_t&>(self_);}
        };
      }
    }
  }
}

namespace std {
  template<typename type_t, typename enumerable_t>
  struct iterator_traits<typename xtd::collections::generic::extensions::enumerable_iterators<type_t, enumerable_t>> {
    using value_type = type_t;
    using reference = const type_t&;
    using pointer = const type_t*;
    using difference_type = std::ptrdiff_t;
    using iterator_category = std::input_iterator_tag;
  };
}