keyvalue_collection.h

 
#pragma once
 
#include <system/collections/base_enumerator.h>
#include <system/collections/base_kv_collection.h>
 
namespace System { namespace Collections { namespace Generic {
 
template <typename Dict>
class KeyIterator
    : public System::Details::NativeIteratorWrapperBase<typename Dict::map_t::key_type, typename Dict::map_t::const_iterator>
    , private System::Details::IteratorPointerUpdater<typename Dict::map_t::key_type, false>
{
    using System::Details::NativeIteratorWrapperBase<typename Dict::map_t::key_type, typename Dict::map_t::const_iterator>::m_iterator;
    using System::Details::NativeIteratorWrapperBase<typename Dict::map_t::key_type, typename Dict::map_t::const_iterator>::m_end;
    using System::Details::VirtualizedIteratorBase<typename Dict::map_t::key_type>::m_is_end;
    using System::Details::VirtualizedIteratorBase<typename Dict::map_t::key_type>::m_pointer;
    using System::Details::IteratorPointerUpdater<typename Dict::map_t::key_type, false>::InitializeIteratorPointer;
    using System::Details::IteratorPointerUpdater<typename Dict::map_t::key_type, false>::UpdateIteratorPointer;
 
public:
    KeyIterator(typename Dict::map_t::const_iterator &&iterator, typename Dict::map_t::const_iterator &&end) noexcept
        : System::Details::NativeIteratorWrapperBase<typename Dict::map_t::key_type, typename Dict::map_t::const_iterator>(
            std::forward<typename Dict::map_t::const_iterator>(iterator),
            std::forward<typename Dict::map_t::const_iterator>(end)
        )
    {
        InitializeIteratorPointer(m_pointer);
        if (!m_is_end)
            UpdateIteratorPointer(m_pointer, m_iterator->first);
    }
    KeyIterator(const typename Dict::map_t::const_iterator &iterator, const typename Dict::map_t::const_iterator &end)
        : System::Details::NativeIteratorWrapperBase<typename Dict::map_t::key_type, typename Dict::map_t::const_iterator>(iterator, end)
    {
        InitializeIteratorPointer(m_pointer);
        if (!m_is_end)
            UpdateIteratorPointer(m_pointer, m_iterator->first);
    }
    KeyIterator(KeyIterator &&other) noexcept
        : System::Details::NativeIteratorWrapperBase<typename Dict::map_t::key_type, typename Dict::map_t::const_iterator>(std::forward(other.m_iterator))
    {
        if (!m_is_end)
            UpdateIteratorPointer(m_pointer, m_iterator->first);
    }
    virtual ~KeyIterator() = default;
 
    void IncrementIterator() override
    {
        if (System::Details::NativeIteratorWrapperBase<typename Dict::map_t::key_type, typename Dict::map_t::const_iterator>::IteratorIncrementImplementation())
            UpdateIteratorPointer(m_pointer, m_iterator->first);
    }
    void DecrementIterator() override
    {
        System::Details::IteratorDecrementer<typename Dict::map_t::const_iterator>::decrement(m_iterator);
        m_is_end = false;
        UpdateIteratorPointer(m_pointer, m_iterator->first);
    }
    void ShiftIteratorBy(std::ptrdiff_t offset) override
    {
        if (System::Details::NativeIteratorWrapperBase<typename Dict::map_t::key_type, typename Dict::map_t::const_iterator>::IteratorShiftImplementation(offset))
            UpdateIteratorPointer(m_pointer, m_iterator->first);
    }
    System::Details::VirtualizedIteratorBase<typename Dict::map_t::key_type>* CloneIterator() const override
    {
        return new KeyIterator(m_iterator, m_end);
    }
};
 
 
template <typename Dict>
class ASPOSECPP_SHARED_CLASS _KeyCollection : public BaseKVCollection<Dict, typename Dict::map_t::key_type>
{
public:
    typedef typename Dict::map_t::key_type TKey;
 
    _KeyCollection(const typename Dict::Ptr& dict) : BaseKVCollection<Dict, typename Dict::map_t::key_type>(dict) {}
 
    // IEnumerable
    class Enumerator : public BaseEnumerator<typename Dict::map_t, TKey>
    {
    public:
        Enumerator(const typename Dict::Ptr& dict) : BaseEnumerator<typename Dict::map_t, TKey>(dict, dict->data()) { }
        MakeConstRef_t<TKey> get_Current() const override
        {
            if (this->IsValid())
                return this->m_it->first;
            else
                return System::Default<TKey>();
        }
    };
    SharedPtr<IEnumerator<TKey> > GetEnumerator() override { return MakeObject<Enumerator>(this->m_dict); }
 
    bool Contains(const TKey& item) const override
    {
        return this->m_dict->ContainsKey(item);
    }
 
    // IList
    TKey idx_get(int index) const override { ASPOSE_UNUSED(index); throw System::InvalidOperationException(); }
 
    System::Details::VirtualizedIteratorBase<TKey>* virtualizeBeginIterator() override
    {
        return new KeyIterator<Dict>(this->m_dict->data().begin(), this->m_dict->data().end());
    }
    System::Details::VirtualizedIteratorBase<TKey>* virtualizeEndIterator() override
    {
        return new KeyIterator<Dict>(this->m_dict->data().end(), this->m_dict->data().end());
    }
    System::Details::VirtualizedIteratorBase<TKey>* virtualizeBeginConstIterator() const override
    {
        return new KeyIterator<Dict>(this->m_dict->data().begin(), this->m_dict->data().end());
    }
    System::Details::VirtualizedIteratorBase<TKey>* virtualizeEndConstIterator() const override
    {
        return new KeyIterator<Dict>(this->m_dict->data().end(), this->m_dict->data().end());
    }
 
protected:
    ~_KeyCollection() override {}
};
 
template <typename Dict>
class ValueIterator
    : public System::Details::NativeIteratorWrapperBase<typename Dict::map_t::mapped_type, typename Dict::map_t::const_iterator>
    , private System::Details::IteratorPointerUpdater<typename Dict::map_t::mapped_type, false>
{
    using System::Details::NativeIteratorWrapperBase<typename Dict::map_t::mapped_type, typename Dict::map_t::const_iterator>::m_iterator;
    using System::Details::NativeIteratorWrapperBase<typename Dict::map_t::mapped_type, typename Dict::map_t::const_iterator>::m_end;
    using System::Details::VirtualizedIteratorBase<typename Dict::map_t::mapped_type>::m_is_end;
    using System::Details::VirtualizedIteratorBase<typename Dict::map_t::mapped_type>::m_pointer;
    using System::Details::IteratorPointerUpdater<typename Dict::map_t::mapped_type, false>::InitializeIteratorPointer;
    using System::Details::IteratorPointerUpdater<typename Dict::map_t::mapped_type, false>::UpdateIteratorPointer;
 
public:
    ValueIterator(typename Dict::map_t::const_iterator &&iterator, typename Dict::map_t::const_iterator &&end) noexcept
        : System::Details::NativeIteratorWrapperBase<typename Dict::map_t::mapped_type, typename Dict::map_t::const_iterator>(
            std::forward<typename Dict::map_t::const_iterator>(iterator),
            std::forward<typename Dict::map_t::const_iterator>(end)
        )
    {
        InitializeIteratorPointer(m_pointer);
        if (!m_is_end)
            UpdateIteratorPointer(m_pointer, m_iterator->second);
    }
    ValueIterator(const typename Dict::map_t::const_iterator &iterator, const typename Dict::map_t::const_iterator &end)
        : System::Details::NativeIteratorWrapperBase<typename Dict::map_t::mapped_type, typename Dict::map_t::const_iterator>(iterator, end)
    {
        InitializeIteratorPointer(m_pointer);
        if (!m_is_end)
            UpdateIteratorPointer(m_pointer, m_iterator->second);
    }
    ValueIterator(ValueIterator &&other) noexcept
        : System::Details::NativeIteratorWrapperBase<typename Dict::map_t::mapped_type, typename Dict::map_t::const_iterator>(std::forward(other.m_iterator))
    {
        if (!m_is_end)
            UpdateIteratorPointer(m_pointer, m_iterator->second);
    }
    virtual ~ValueIterator() = default;
 
    void IncrementIterator() override
    {
        if (System::Details::NativeIteratorWrapperBase<typename Dict::map_t::mapped_type, typename Dict::map_t::const_iterator>::IteratorIncrementImplementation())
            UpdateIteratorPointer(m_pointer, m_iterator->second);
    }
    void DecrementIterator() override
    {
        System::Details::IteratorDecrementer<typename Dict::map_t::const_iterator>::decrement(m_iterator);
        m_is_end = false;
        UpdateIteratorPointer(m_pointer, m_iterator->second);
    }
    void ShiftIteratorBy(std::ptrdiff_t offset) override
    {
        if (System::Details::NativeIteratorWrapperBase<typename Dict::map_t::mapped_type, typename Dict::map_t::const_iterator>::IteratorShiftImplementation(offset))
            UpdateIteratorPointer(m_pointer, m_iterator->second);
    }
    System::Details::VirtualizedIteratorBase<typename Dict::map_t::mapped_type>* CloneIterator() const override
    {
        return new ValueIterator(m_iterator, m_end);
    }
};
 
 
template <typename Dict>
class ASPOSECPP_SHARED_CLASS _ValueCollection : public BaseKVCollection<Dict, typename Dict::map_t::mapped_type>
{
public:
    typedef typename Dict::map_t::mapped_type TValue;
 
    _ValueCollection(const typename Dict::Ptr& dict) : BaseKVCollection<Dict, typename Dict::map_t::mapped_type>(dict) {}
 
    // IEnumerable
    class Enumerator : public BaseEnumerator<typename Dict::map_t, TValue>
    {
    public:
        Enumerator(const typename Dict::Ptr& dict) : BaseEnumerator<typename Dict::map_t, TValue>(dict, dict->data()) { }
        MakeConstRef_t<TValue> get_Current() const override
        {
            if (this->IsValid())
                return this->m_it->second;
            else
                return System::Default<TValue>();
        }
    };
    SharedPtr<IEnumerator<TValue> > GetEnumerator() override { return MakeObject<Enumerator>(this->m_dict); }
 
    bool Contains(const TValue& item) const override
    {
        return this->m_dict->ContainsValue(item);
    }
 
    // IList
    TValue idx_get(int index) const override { ASPOSE_UNUSED(index); throw System::InvalidOperationException(); }
 
    System::Details::VirtualizedIteratorBase<TValue>* virtualizeBeginIterator() override
    {
        return new ValueIterator<Dict>(this->m_dict->data().begin(), this->m_dict->data().end());
    }
    System::Details::VirtualizedIteratorBase<TValue>* virtualizeEndIterator() override
    {
        return new ValueIterator<Dict>(this->m_dict->data().end(), this->m_dict->data().end());
    }
    System::Details::VirtualizedIteratorBase<TValue>* virtualizeBeginConstIterator() const override
    {
        return new ValueIterator<Dict>(this->m_dict->data().begin(), this->m_dict->data().end());
    }
    System::Details::VirtualizedIteratorBase<TValue>* virtualizeEndConstIterator() const override
    {
        return new ValueIterator<Dict>(this->m_dict->data().end(), this->m_dict->data().end());
    }
 
protected:
    ~_ValueCollection() override {}
};
 
}}} // namespace System::Collections::Generic