base_enumerator.h

 
#pragma once
 
#include "system/collections/ienumerator.h"
 
namespace System { namespace Collections { namespace Generic {
 
template <typename Container, typename Element>
class ASPOSECPP_SHARED_CLASS BaseEnumerator : public IEnumerator<Element>
{
protected:
    Object::ptr m_owner;
    Container& m_data;
    typename Container::iterator m_it;
    bool m_inited;
 
public:
 
    BaseEnumerator(const Object::ptr& owner, Container& cont) : m_owner(owner), m_data(cont), m_inited(false) {}
    // There no need to define an empty virtual dtor, virtual dtor for inheritance already defined in the Object class
 
    bool IsValid() const
    {
        return m_inited && m_it != m_data.end();
    }
    bool MoveNext() override
    {
        if (!m_inited)
        {
            m_it = m_data.begin();
            m_inited = true;
        }
        else if (m_it != m_data.end())
        {
            ++m_it;
        }
 
        return m_it != m_data.end();
    }
    void Reset() override { m_inited = false; }
 
protected:
#ifdef ASPOSE_GET_SHARED_MEMBERS
    virtual void GetSharedMembers(System::Object::shared_members_type& result) const override
    {
        Object::GetSharedMembers(result);
        result.Add("System::Collections::Generic::BaseEnumerator<Container,Element>::m_owner", m_owner);
    }
#endif
 
#ifdef __DBG_FOR_EACH_MEMBER
public:
    void DBG_for_each_member(DBG::for_each_member_visitor& visitor) const override
    {
        System::Object::DBG_for_each_member(visitor);
 
        visitor.add_self(this);
        visitor.add_member(this, m_owner, "m_owner");
    }
 
    const char* DBG_class_name() const override { return "BaseEnumerator<T>"; }
#endif
};
 
template <typename Container, typename Element = typename Container::value_type>
class SimpleEnumerator : public BaseEnumerator<Container, Element>
{
public:
    SimpleEnumerator(Object::ptr owner, Container& cont) : BaseEnumerator<Container, Element>(owner, cont) {}
 
    MakeConstRef_t<Element> get_Current() const override
    {
        return this->IsValid() ? *(this->m_it) : System::Default<Element>();
    }
 
    System::Details::VirtualizedIteratorBase<Element>* CloneIterator() const override
    {
        return new SimpleEnumerator(*this);
    }
};
 
 
template <typename KVPair, typename Container>
class KVPairIterator
{
public:
    using iterator_category = std::bidirectional_iterator_tag;
    using value_type = KVPair;
    using difference_type = std::ptrdiff_t;
    using pointer = value_type * ;
    using reference = value_type & ;
 
    KVPairIterator(typename Container::const_iterator current) : mCurrent(std::move(current)) {}
 
    friend bool operator==(const KVPairIterator& lhs, const KVPairIterator& rhs)
    {
        return lhs.mCurrent == rhs.mCurrent;
    }
 
    friend bool operator!=(const KVPairIterator& lhs, const KVPairIterator& rhs)
    {
        return lhs.mCurrent != rhs.mCurrent;
    }
 
    KVPair operator*() const
    {
        return KVPair(*mCurrent);
    }
 
    KVPairIterator& operator++()
    {
        ++mCurrent;
        return *this;
    }
 
    KVPairIterator operator++(int)
    {
        KVPairIterator tmp = KVPairIterator(mCurrent);
        ++mCurrent;
        return tmp;
    }
 
    KVPairIterator& operator--()
    {
        --mCurrent;
        return *this;
    }
 
    KVPairIterator operator--(int)
    {
        KVPairIterator tmp = KVPairIterator(mCurrent);
        --mCurrent;
        return tmp;
    }
private:
    typename Container::const_iterator mCurrent;
};
 
 
template <typename Container, typename Element = typename Container::value_type>
class ReverseEnumerator : public IEnumerator<Element>
{
protected:
    Object::ptr m_owner;
    Container& m_data;
    typename Container::reverse_iterator m_it;
    bool m_inited;
 
public:
 
    ReverseEnumerator(const Object::ptr& owner, Container& cont) : m_owner(owner), m_data(cont), m_inited(false) {}
    virtual ~ReverseEnumerator() {}
 
    bool IsValid() const
    {
        return m_inited && m_it != m_data.rend();
    }
    bool MoveNext() override
    {
        if (!m_inited)
        {
            m_it = m_data.rbegin();
            m_inited = true;
        }
        else if (m_it != m_data.rend())
        {
            ++m_it;
        }
 
        return m_it != m_data.rend();
    }
    virtual MakeConstRef_t<Element> get_Current() const override
    {
        return this->IsValid() ? *(this->m_it) : System::Default<Element>();
    }
    void Reset() override { m_inited = false; }
 
protected:
#ifdef ASPOSE_GET_SHARED_MEMBERS
    virtual void GetSharedMembers(System::Object::shared_members_type& result) const override
    {
        Object::GetSharedMembers(result);
        result.Add("System::Collections::Generic::ReverseEnumerator<Container,Element>::m_owner", m_owner);
    }
#endif
 
#ifdef __DBG_FOR_EACH_MEMBER
public:
    void DBG_for_each_member(DBG::for_each_member_visitor& visitor) const override
    {
        System::Object::DBG_for_each_member(visitor);
 
        visitor.add_self(this);
        visitor.add_member(this, m_owner, "m_owner");
    }
 
    const char* DBG_class_name() const override { return "ReverseEnumerator<T>"; }
#endif
};
 
}}} // namespace System::Collections::Generic