enumerator.hpp

Go to the documentation of this file.

 
#pragma once
#include "ienumerator.hpp"
#include "../../helpers/throw_helper.hpp"
#include "../../new_ptr.hpp"
#include "../../static.hpp"
 
namespace xtd {
  namespace collections {
    namespace generic {
      template <class type_t = std::nullptr_t>
      struct enumerator;
      
      template<class type_t>
      struct enumerator : ienumerator<type_t> {
        
        enumerator() = default;
        enumerator(ptr<ienumerator<type_t>> enumerator) : enumerator_ {enumerator} {} // Can't be explicit by design.
        
        enumerator(enumerator&& enumerator) = default;
        enumerator(const enumerator& enumerator) = default;
        enumerator& operator =(enumerator&& enumerator) = default;
        enumerator& operator =(const enumerator& enumerator) = default;
        
        
        const type_t& current() const override {return enumerator_->current();}
        
        
        bool move_next() override {return enumerator_->move_next();}
        
        void reset() override {enumerator_->reset();}
      
      private:
        ptr<ienumerator<type_t>> enumerator_;
      };
 
      template <>
      struct enumerator<> static_ {
        
        template <class collection_t, class vertion_t = std::nullptr_t>
        static auto create(const collection_t& items, const vertion_t* current_version = nullptr) noexcept {
          using value_type = typename collection_t::value_type;
          using const_iterator = typename collection_t::const_iterator;
          struct internal_enumerator : public ienumerator<value_type> {
          public:
            explicit internal_enumerator(const collection_t& items, const vertion_t* current_version) : items_(items), version_(current_version ? *current_version : vertion_t {}), current_version_(current_version) {}
            
            const value_type& current() const override {
              if (current_version_ && version_ != *current_version_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation, "Collection was modified; enumeration operation may not execute.");
              if (iterator_ != items_.cend()) return *iterator_;
              static auto default_value_type = value_type {};
              return default_value_type;
            }
            
            bool move_next() override {
              if (current_version_ && version_ != *current_version_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation, "Collection was modified; enumeration operation may not execute.");
              if (!reset_) return ++iterator_ != items_.cend();
              reset_ = false;
              iterator_ = items_.cbegin();
              return iterator_ != items_.cend();
            }
            
            void reset() override {
              reset_ = true;
              version_ = current_version_ ? *current_version_ : vertion_t {};
              iterator_ = items_.cend();
            }
            
          protected:
            bool reset_ = true;
            const collection_t& items_;
            const_iterator iterator_ = items_.cend();
            vertion_t version_ = vertion_t {};
            const vertion_t* current_version_ = nullptr;
          };
          return enumerator<value_type> {new_ptr<internal_enumerator>(items, current_version)};
        }
      };
    }
  }
}