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 enumerable_iterators {
          template<class iterator_enumerable_t>
          class enumerable_iterator : public xtd::icomparable<enumerable_iterator<iterator_enumerable_t>>, public xtd::iequatable<enumerable_iterator<iterator_enumerable_t >> {
          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 xtd::size npos() {return std::numeric_limits<xtd::size>::max();}
            
            enumerable_iterator() = default;
            enumerable_iterator(iterator_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) 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_;}
            
            reference operator *() const {return const_cast<value_type&>(enumerator_.current());}
            pointer operator ->() const {return &operator*();}
            
            enumerable_iterator& operator ++() noexcept {
              if (pos_ != npos()) pos_ = enumerator_.move_next() ? pos_ + 1 : npos();
              return const_cast<enumerable_iterator&>(*this);
            }
            enumerable_iterator operator ++(int) noexcept {
              auto current = *this;
              operator ++();
              return current;
            }
            
            template<class value_t>
            const 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 {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_ == npos()) return npos();
              return static_cast<difference_type>(pos_ - value.pos_);
            }
            
            operator enumerable_iterator<const iterator_enumerable_t>() const noexcept {
              return enumerable_iterator<const iterator_enumerable_t>(enumerable_, pos_);
            }
            
          private:
            void reset() {
              if (pos_ == npos()) return;
              enumerator_.reset();
              for (auto index = xtd::size {}; index <= pos_; ++index)
                if (enumerator_.move_next() == false) {
                  pos_ = npos();
                  break;
                }
            }
            
            iterator_enumerable_t* enumerable_ = nullptr;
            enumerator<type_t> enumerator_;
            xtd::size pos_ = 0;
          };
          
        public:
          
          using iterator = enumerable_iterator<enumerable_t>;
          using const_iterator = enumerable_iterator<const enumerable_t>;
          
          
          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_const_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;
          }
          static typename target_collection_t::const_iterator to_const_iterator(typename source_collection_t::const_iterator& value, const source_collection_t& source_collection, const target_collection_t& target_collection) noexcept {…}
          
          template<class source_collection_t, class target_collection_t>
          static typename target_collection_t::const_iterator to_const_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;
          }
          static typename target_collection_t::const_iterator to_const_iterator(typename source_collection_t::const_iterator& value, source_collection_t& source_collection, target_collection_t& target_collection) noexcept {…}
          
          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;
          }
          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 {…}
          
          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;
          }
          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 {…}
          
          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;
          }
          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 {…}
          
          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;
          }
          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 {…}

        };
        class enumerable_iterators {…};
      }
    }
  }
}

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;
  };
}