enumerable_iterators.h

Go to the documentation of this file.

 
#pragma once
#include "enumerator.h"
#include "../../ptrdiff.h"
#include "../../size.h"
#include <limits>
 
namespace xtd {
  namespace collections {
    namespace generic {
      template<typename type_t, typename enumerable_t>
      class enumerable_iterators {
      public:
        
        class iterator {
        public:
          
          using iterator_category = std::forward_iterator_tag;
          using value_type = type_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 iterator begin(const enumerable_t* enumerable) {
            auto begin = iterator {};
            begin.enumerable_ = enumerable;
            begin.enumerator_ = begin.enumerable_->get_enumerator();
            begin.pos_ = 0;
            begin.reset();
            return begin;
          }
          
          static iterator end(const enumerable_t* enumerable) {
            auto end = iterator {};
            end.enumerable_ = enumerable;
            end.enumerator_ = end.enumerable_->get_enumerator();
            end.pos_ = std::numeric_limits<xtd::size>::max();
            end.reset();
            return end;
          }
          
          
          iterator() = default;
          
          iterator(const iterator& value) noexcept : enumerable_(value.enumerable_), enumerator_(value.enumerable_->get_enumerator()), pos_ {value.pos_} {reset();}
          iterator(iterator&& value) = default;
          iterator& operator =(const iterator& value) noexcept {
            enumerable_ = value.enumerable_;
            enumerator_ = value.enumerable_->get_enumerator();
            pos_ = value.pos_;
            reset();
            return *this;
          }
 
          
          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*();}
 
          iterator& operator ++() noexcept {
            if (pos_ != std::numeric_limits<xtd::size>::max()) pos_ = enumerator_.move_next() ? pos_ + 1 : std::numeric_limits<xtd::size>::max();
            return *this;
          }
          iterator operator ++(int) noexcept {
            auto current = *this;
            operator ++();
            return current;
          }
          
          template<typename value_t>
          iterator operator +(value_t value) const noexcept {return iterator {*this, value};}
          
          difference_type operator -(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_);
          }
          
          friend bool operator ==(const iterator& a, const iterator& b) noexcept {return a.pos_ == b.pos_;}
          friend bool operator !=(const iterator& a, const iterator& b) noexcept {return !operator==(a, b);}
 
        private:
          template<typename value_t>
          iterator(const iterator& base, value_t value) noexcept : enumerable_(base.enumerable_),  enumerator_(base.enumerable_->get_enumerator()), pos_ {base.pos_ + value} {reset();}
 
          void reset() {
            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;
              }
          }
 
          const enumerable_t* enumerable_ = nullptr;
          enumerator<type_t> enumerator_;
          xtd::size pos_ = 0;
        };
 
        
        using const_iterator = const iterator;
        
        
        virtual const_iterator begin() const {return const_iterator::begin(static_cast<const enumerable_t*>(this));}
        virtual iterator begin() {return iterator::begin(static_cast<enumerable_t*>(this));}
 
        virtual const_iterator cbegin() const {return const_iterator::begin(static_cast<const enumerable_t*>(this));}
 
        virtual const_iterator cend() const {return const_iterator::end(static_cast<const enumerable_t*>(this));}
 
        virtual const_iterator end() const {return const_iterator::end(static_cast<const enumerable_t*>(this));}
        virtual iterator end() {return iterator::end(static_cast<enumerable_t*>(this));}
      };
    }
  }
}