enumerator.hpp

Go to the documentation of this file.

#pragma once
#include "ienumerator.hpp"
#include "../../helpers/throw_helper.hpp"
#include "../../new_ptr.hpp"
#include "../../object.hpp"
#include "../../static.hpp"

namespace xtd {
  namespace collections {
    namespace generic {
      template<typename type_t = std::nullptr_t>
      struct enumerator;
      
      template<typename type_t>
      struct enumerator : xtd::object, 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;
        
        
        [[nodiscard]] const type_t& current() const override {return enumerator_->current();}
        
        
        [[nodiscard]] bool move_next() override {return enumerator_->move_next();}
        
        void reset() override {enumerator_->reset();}
        
      private:
        ptr<ienumerator<type_t>> enumerator_;
      };
      
      template <>
      struct enumerator<> static_ {
        
        template<typename collection_t, typename version_t = std::nullptr_t>
        static auto create(const collection_t& items, const version_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 version_t* current_version) : items_(items), version_(current_version ? * current_version : version_t {}), current_version_(current_version) {}
            
            [[nodiscard]] const value_type& current() const override {
              if (iterator_ == items_.cend()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation);
              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.");
              return *iterator_;
            }
            
            [[nodiscard]] 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 (index_++ && iterator_ != items_.cend()) ++iterator_;
              else iterator_ = items_.cbegin();
              return iterator_ != items_.cend();
            }
            
            void reset() override {
              index_ = 0;
              version_ = current_version_ ? *current_version_ : version_t {};
              iterator_ = items_.cend();
            }
            
          protected:
            xtd::usize index_ = 0;
            const collection_t& items_;
            const_iterator iterator_ = items_.cend();
            version_t version_ = version_t {};
            const version_t* current_version_ = nullptr;
          };
          return enumerator<value_type> {new_ptr<internal_enumerator>(items, current_version)};
        }

      };
    }
  }
}