enumerable_iterators.hpp

Go to the documentation of this file.

 
#pragma once
#include "../enumerator.hpp"
#include "../../../icomparable.hpp"
#include "../../../iequatable.hpp"
#include "../../../ptrdiff.hpp"
#include "../../../size.hpp"
#include <limits>
 
namespace xtd {
  namespace collections {
    namespace generic {
      namespace extensions {
        template<class type_t, class enumerable_t, class iterator_tag_t =  std::bidirectional_iterator_tag>
        class enumerable_iterators {
          class enumerable_iterator : public xtd::icomparable<enumerable_iterator>, public xtd::iequatable<enumerable_iterator> {
          public:
            using value_type = type_t;
            using iterator_category = iterator_tag_t;
            using iterator_concept  = iterator_tag_t;
            using difference_type = xtd::ptrdiff;
            using pointer = value_type*;
            using const_pointer = const value_type*;
            using reference = value_type&;
            using const_reference = const value_type&;
 
            static constexpr xtd::size npos() {return std::numeric_limits<xtd::size>::max();}
 
            enumerable_iterator() = default;
            enumerable_iterator(const enumerable_t* enumerable, xtd::size 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();}
            enumerable_iterator& operator =(enumerable_iterator&& value) noexcept = default;
            enumerable_iterator& operator =(const enumerable_iterator& value) const noexcept {
              enumerable_ = value.enumerable_;
              enumerator_ = value.enumerable_->get_enumerator();
              pos_ = value.pos_;
              reset();
              return const_cast<enumerable_iterator&>(*this);
            }
            enumerable_iterator& operator =(const enumerable_iterator& value) noexcept {
              enumerable_ = value.enumerable_;
              enumerator_ = value.enumerable_->get_enumerator();
              pos_ = value.pos_;
              reset();
              return const_cast<enumerable_iterator&>(*this);
            }
            
            int32 compare_to(const enumerable_iterator& rhs) const noexcept override {return pos_ < rhs.pos_ ? -1 : pos_ > rhs.pos_ ? 1 : 0;}
            bool equals(const enumerable_iterator& rhs) const noexcept override {return pos_ == rhs.pos_;}
 
            const_reference operator *() const {return enumerator_.current();}
            reference operator *() {return const_cast<reference>(enumerator_.current());}
            const_pointer operator ->() const {return &operator*();}
            pointer operator ->() {return &operator*();}
            
            enumerable_iterator& operator ++() const noexcept {
              if (pos_ != std::numeric_limits<xtd::size>::max()) pos_ = enumerator_.move_next() ? pos_ + 1 : std::numeric_limits<xtd::size>::max();
              return const_cast<enumerable_iterator&>(*this);
            }
            enumerable_iterator operator ++(int) const noexcept {
              auto current = *this;
              operator ++();
              return current;
            }
            
            enumerable_iterator& operator --() const noexcept {
              if (pos_ != 0) pos_ = enumerator_.move_next() ? pos_ - 1 : std::numeric_limits<xtd::size>::max();
              return const_cast<enumerable_iterator&>(*this);
            }
            enumerable_iterator operator --(int) const noexcept {
              auto current = *this;
              operator --();
              return current;
            }
            
            template<class value_t>
            enumerable_iterator operator +(value_t value) const noexcept {return enumerable_iterator {enumerable_, pos_ + value};}
            template<class value_t>
            enumerable_iterator& operator +=(value_t value) noexcept {
              *this = *this + value;
              return *this;
            }
            difference_type operator -(enumerable_iterator value) const noexcept {
              if (pos_ == std::numeric_limits<xtd::size>::max()) return std::numeric_limits<xtd::size>::max();
              return static_cast<difference_type>(pos_ - value.pos_);
            }
            
          private:
            void reset() const {
              enumerator_.reset();
              if (pos_ == std::numeric_limits<xtd::size>::max()) return;
              for (auto index = xtd::size {}; index <= pos_; ++index)
                if (enumerator_.move_next() == false) {
                  pos_ = std::numeric_limits<xtd::size>::max();
                  break;
                }
            }
            
            mutable const enumerable_t* enumerable_ = nullptr;
            mutable enumerator<type_t> enumerator_;
            mutable xtd::size pos_ = 0;
          };
          
        public:
          
          using iterator = enumerable_iterator;
          using const_iterator = const enumerable_iterator;
          
          
          virtual const_iterator begin() const {return cbegin();}
          virtual iterator begin() {return iterator {static_cast<enumerable_t*>(this), 0};}
          
          virtual const_iterator cbegin() const {return const_iterator {static_cast<const enumerable_t*>(this), 0};}
          
          virtual const_iterator cend() const {return const_iterator {static_cast<const enumerable_t*>(this), const_iterator::npos()};}
          
          virtual const_iterator end() const {return cend();}
          virtual iterator end() {return iterator {static_cast<enumerable_t*>(this), iterator::npos()};}
 
          
          template<class source_collection_t, class target_collection_t>
          static typename target_collection_t::const_iterator to_iterator(typename source_collection_t::const_iterator& value, const source_collection_t& source_collection, const target_collection_t& target_collection) noexcept {
            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 = ptrdiff {}; index < std::distance(source_collection.cbegin(), value); ++index, ++result);
            return result;
          }
          
          template<class source_collection_t, class target_collection_t>
          static typename target_collection_t::iterator to_iterator(typename source_collection_t::iterator& value, const source_collection_t& source_collection, const target_collection_t& target_collection) noexcept {
            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 = ptrdiff {}; index < std::distance(source_collection.begin(), value); ++index, ++result);
            return result;
          }
          
          template<class source_collection_t, class target_collection_t>
          static typename target_collection_t::const_iterator to_iterator(typename source_collection_t::const_iterator& value, source_collection_t& source_collection, target_collection_t& target_collection) noexcept {
            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 = ptrdiff {}; index < std::distance(source_collection.cbegin(), value); ++index, ++result);
            return result;
          }
          
          template<class source_collection_t, class target_collection_t>
          static typename target_collection_t::iterator to_iterator(typename source_collection_t::iterator& value, source_collection_t& source_collection, target_collection_t& target_collection) noexcept {
            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 = ptrdiff {}; index < std::distance(source_collection.begin(), value); ++index, ++result);
            return result;
          }
        };
      }
    }
  }
}