ienumerator.h

 
#pragma once
 
#include <system/object.h>
#include <defines.h>
#include <system/exceptions.h>
#include <system/idisposable.h>
#include <system/make_const_ref.h>
#include <system/collections/virtualized_iterator.h>
#include <numeric>
#include <utility>
 
namespace System {
namespace Collections {
namespace Generic {
 
template<typename T>
class ASPOSECPP_SHARED_CLASS IEnumerator
    : virtual public IDisposable
    , public System::Details::EnumeratorBasedIterator<T>
    , protected System::Details::IteratorPointerUpdater<T, false>
{
    RTTI_INFO_TEMPLATE_CLASS(System::Collections::Generic::IEnumerator<T>, System::BaseTypesInfo<System::IDisposable>);
 
    using System::Details::IteratorPointerUpdater<T, false>::UpdateIteratorPointer;
    using System::Details::IteratorPointerUpdater<T, false>::InitializeIteratorPointer;
 
public:
    IEnumerator()
        : System::Details::EnumeratorBasedIterator<T>(std::numeric_limits<std::ptrdiff_t>::max())
        , m_owned_by_virtualized_iterator(false)
    {}
 
    virtual ~IEnumerator()
    {
        if (m_owned_by_virtualized_iterator)
            Object::SharedRefRemovedSafe();
    }
 
    typedef T ValueType;
 
    // There no need to define an empty virtual dtor, virtual dtor for inheritance already defined in the Object class
    virtual MakeConstRef_t<T> Current() const { return get_Current(); }
    virtual MakeConstRef_t<T> get_Current() const = 0;
    virtual bool MoveNext() = 0;
    virtual void Reset() { throw System::NotImplementedException(); }
 
    void InitializeIterator() override
    {
        InitializeIteratorPointer(System::Details::VirtualizedIteratorBase<T>::m_pointer);
        if (MoveNext())
        {
            m_offset = 0;
            UpdateIteratorPointer(System::Details::VirtualizedIteratorBase<T>::m_pointer, get_Current());
            System::Details::VirtualizedIteratorBase<T>::m_is_end = false;
        }
        else
            System::Details::VirtualizedIteratorBase<T>::m_is_end = true;
    }
    void IncrementIterator() override
    {
        if (MoveNext())
        {
            ++m_offset;
            UpdateIteratorPointer(System::Details::VirtualizedIteratorBase<T>::m_pointer, get_Current());
        }
        else
        {
            m_offset = std::numeric_limits<std::ptrdiff_t>::max();
            System::Details::VirtualizedIteratorBase<T>::m_pointer = nullptr;
            System::Details::VirtualizedIteratorBase<T>::m_is_end = true;
        }
    }
    System::Details::VirtualizedIteratorBase<T>* CloneIterator() const override
    {
        throw System::NotImplementedException();
    }
    IEnumerator* AsVirtualizedIterator()
    {
        InitializeIterator();
        SharedRefAdded();
        return this;
    }
    void MarkOwnedByVirtualizedIterator()
    {
        m_owned_by_virtualized_iterator = true;
    }
 
protected:
    IEnumerator(const IEnumerator &other)
        : System::Details::EnumeratorBasedIterator<T>(other.m_offset)
        , m_owned_by_virtualized_iterator(false)
    {}
 
    using System::Details::EnumeratorBasedIterator<T>::m_offset;
    bool m_owned_by_virtualized_iterator;
};
 
template <typename Element>
class EnumeratorWrapperIterator : public System::Details::VirtualizedIteratorBase<Element>
{
public:
    EnumeratorWrapperIterator(const SharedPtr<IEnumerator<Element>> &enumerator)
        : System::Details::VirtualizedIteratorBase<Element>(false, enumerator->IsEndIterator())
        , m_enumerator(enumerator)
    {
        System::Details::VirtualizedIteratorBase<Element>::m_pointer = m_enumerator->GetElementPointer();
    }
 
    virtual ~EnumeratorWrapperIterator() = default;
 
    void IncrementIterator() override
    {
        m_enumerator->IncrementIterator();
        System::Details::VirtualizedIteratorBase<Element>::m_pointer = m_enumerator->GetElementPointer();
        System::Details::VirtualizedIteratorBase<Element>::m_is_end = m_enumerator->IsEndIterator();
    }
    bool IteratorEquals(System::Details::VirtualizedIteratorBase<Element> *other) const override
    {
        return m_enumerator->IteratorEquals(other);
    }
    System::Details::VirtualizedIteratorBase<Element>* CloneIterator() const override
    {
        return m_enumerator->CloneIterator();
    }
 
protected:
    const SharedPtr<IEnumerator<Element>> m_enumerator;
};
 
 
#define CODEPORTING_NO_API_KEYWORD
 
#define CODEPORTING_ABSTRACT_ENUMERATOR_ITERATOR_METHODS_DECLARATION(element_type, api_keyword) \
public: \
    api_keyword ::System::Details::VirtualizedIteratorBase<element_type>* CloneIterator() const override; \
    api_keyword void InitializeIterator() override; \
    api_keyword void IncrementIterator() override;
 
#define CODEPORTING_ABSTRACT_ENUMERATOR_ITERATOR_MEMBERS_INLINE(element_type) \
public: \
    ::System::Details::VirtualizedIteratorBase<element_type>* CloneIterator() const \
    { \
        throw System::NotImplementedException(); \
    } \
    void InitializeIterator() override \
    { \
        ::System::Collections::Generic::IEnumerator<element_type>::InitializeIterator(); \
    } \
    void IncrementIterator() override \
    { \
        ::System::Collections::Generic::IEnumerator<element_type>::IncrementIterator(); \
    }
 
#define CODEPORTING_ABSTRACT_ENUMERATOR_ITERATOR_MEMBERS_IMPLEMENTATION(element_type, type_name) \
    ::System::Details::VirtualizedIteratorBase<element_type>* type_name::CloneIterator() const \
    { \
        throw System::NotImplementedException(); \
    } \
    void type_name::InitializeIterator() \
    { \
        ::System::Collections::Generic::IEnumerator<element_type>::InitializeIterator(); \
    } \
    void type_name::IncrementIterator() \
    { \
        ::System::Collections::Generic::IEnumerator<element_type>::IncrementIterator(); \
    }
 
#define CODEPORTING_ENUMERATOR_ITERATOR_METHODS_DECLARATION(element_type, api_keyword) \
public: \
    api_keyword ::System::Details::VirtualizedIteratorBase<element_type>* CloneIterator() const override; \
    api_keyword void InitializeIterator() override; \
    api_keyword void IncrementIterator() override; \
 
#define CODEPORTING_ENUMERATOR_ITERATOR_MEMBERS_INLINE(element_type, this_type, ptr_type) \
public: \
    ::System::Details::VirtualizedIteratorBase<element_type>* CloneIterator() const override \
    { \
        if (::System::Details::VirtualizedIteratorBase<element_type>::IsEndIterator()) \
            return new ::System::Details::EnumeratorBasedEndIterator<element_type>(); \
        if (::System::Details::EnumeratorBasedIterator<element_type>::m_offset != 0) \
            throw ::System::NotSupportedException(u"Cloning intermediate state enumerator-based iterator"); \
        this_type *const copy = new this_type(*this); \
        std::unique_ptr<ptr_type> holder(copy); \
        copy->::System::Details::VirtualizedIteratorBase<element_type>::m_is_end = ::System::Details::VirtualizedIteratorBase<element_type>::m_is_end; \
        copy->::System::Details::IteratorPointerUpdater<element_type, false>::InitializeIteratorPointer(copy->::System::Details::VirtualizedIteratorBase<element_type>::m_pointer); \
        copy->::System::Details::VirtualizedIteratorBase<element_type>::m_pointer = copy->GetCurrentElementPointer(); \
        holder.release(); \
        return copy; \
    } \
    void InitializeIterator() override \
    { \
        ::System::Details::IteratorPointerUpdater<element_type, false>::InitializeIteratorPointer(::System::Details::EnumeratorBasedIterator<element_type>::m_pointer); \
        if (MoveNextImplementation()) \
        { \
            ::System::Details::EnumeratorBasedIterator<element_type>::m_offset = 0; \
            ::System::Details::VirtualizedIteratorBase<element_type>::m_pointer = GetCurrentElementPointer(); \
            ::System::Details::VirtualizedIteratorBase<element_type>::m_is_end = false; \
        } \
        else \
        { \
            ::System::Details::VirtualizedIteratorBase<element_type>::m_is_end = true; \
        } \
    } \
    void IncrementIterator() override \
    { \
        if (MoveNextImplementation()) \
        { \
            ++::System::Details::EnumeratorBasedIterator<element_type>::m_offset; \
            ::System::Details::VirtualizedIteratorBase<element_type>::m_pointer = GetCurrentElementPointer(); \
        } \
        else \
        { \
            ::System::Details::EnumeratorBasedIterator<element_type>::m_offset = std::numeric_limits<std::ptrdiff_t>::max(); \
            ::System::Details::VirtualizedIteratorBase<element_type>::m_pointer = nullptr; \
            ::System::Details::VirtualizedIteratorBase<element_type>::m_is_end = true; \
        } \
    }
 
#define CODEPORTING_ENUMERATOR_ITERATOR_MEMBERS_IMPLEMENTATION(element_type, type_name, ptr_type) \
    ::System::Details::VirtualizedIteratorBase<element_type>* type_name::CloneIterator() const \
    { \
        if (::System::Details::VirtualizedIteratorBase<element_type>::IsEndIterator()) \
            return new ::System::Details::EnumeratorBasedEndIterator<element_type>(); \
        if (::System::Details::EnumeratorBasedIterator<element_type>::m_offset != 0) \
            throw ::System::NotSupportedException(u"Cloning intermediate state enumerator-based iterator"); \
        type_name *const copy = new type_name(*this); \
        std::unique_ptr<ptr_type> holder(copy); \
        copy->::System::Details::VirtualizedIteratorBase<element_type>::m_is_end = ::System::Details::VirtualizedIteratorBase<element_type>::m_is_end; \
        copy->::System::Details::IteratorPointerUpdater<element_type, false>::InitializeIteratorPointer(copy->::System::Details::VirtualizedIteratorBase<element_type>::m_pointer); \
        copy->::System::Details::VirtualizedIteratorBase<element_type>::m_pointer = copy->GetCurrentElementPointer(); \
        holder.release(); \
        return copy; \
    } \
    void type_name::InitializeIterator() \
    { \
        ::System::Details::IteratorPointerUpdater<element_type, false>::InitializeIteratorPointer(::System::Details::EnumeratorBasedIterator<element_type>::m_pointer); \
        if (MoveNextImplementation()) \
        { \
            ::System::Details::EnumeratorBasedIterator<element_type>::m_offset = 0; \
            ::System::Details::VirtualizedIteratorBase<element_type>::m_pointer = GetCurrentElementPointer(); \
            ::System::Details::VirtualizedIteratorBase<element_type>::m_is_end = false; \
        } \
        else \
        { \
            ::System::Details::VirtualizedIteratorBase<element_type>::m_is_end = true; \
        } \
    } \
    void type_name::IncrementIterator() \
    { \
        if (MoveNextImplementation()) \
        { \
            ++::System::Details::EnumeratorBasedIterator<element_type>::m_offset; \
            ::System::Details::VirtualizedIteratorBase<element_type>::m_pointer = GetCurrentElementPointer(); \
        } \
        else \
        { \
            ::System::Details::EnumeratorBasedIterator<element_type>::m_offset = std::numeric_limits<std::ptrdiff_t>::max(); \
            ::System::Details::VirtualizedIteratorBase<element_type>::m_pointer = nullptr; \
            ::System::Details::VirtualizedIteratorBase<element_type>::m_is_end = true; \
        } \
    }
 
 
} // namespace Generic
} // namespace Collections
} // namespace System