base_dictionary.h

 
#pragma once
 
#include <system/collections/idictionary.h>
#include <system/cycles_detection.h>
#include <system/collections/base_enumerator.h>
#include <system/details/hash_quality_checker.h>
#include <system/collections/virtualized_iterator.h>
 
#include <algorithm>
#include <type_traits>
 
namespace System { namespace Collections { namespace Generic {
 
template <typename Dict>
class DictionaryIterator
    : public System::Details::NativeIteratorWrapperBase<typename Dict::KeyValuePairType, typename Dict::map_t::const_iterator>
    , private System::Details::IteratorPointerUpdater<typename Dict::KeyValuePairType, false>
{
    using System::Details::NativeIteratorWrapperBase<typename Dict::KeyValuePairType, typename Dict::map_t::const_iterator>::m_iterator;
    using System::Details::NativeIteratorWrapperBase<typename Dict::KeyValuePairType, typename Dict::map_t::const_iterator>::m_end;
    using System::Details::VirtualizedIteratorBase<typename Dict::KeyValuePairType>::m_is_end;
    using System::Details::VirtualizedIteratorBase<typename Dict::KeyValuePairType>::m_pointer;
    using System::Details::IteratorPointerUpdater<typename Dict::KeyValuePairType, false>::InitializeIteratorPointer;
    using System::Details::IteratorPointerUpdater<typename Dict::KeyValuePairType, false>::UpdateIteratorPointer;
 
public:
    DictionaryIterator(typename Dict::map_t::const_iterator &&iterator, typename Dict::map_t::const_iterator &&end) noexcept
        : System::Details::NativeIteratorWrapperBase<typename Dict::KeyValuePairType, 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, typename Dict::KeyValuePairType(m_iterator->first, m_iterator->second));
    }
    DictionaryIterator(const typename Dict::map_t::const_iterator &iterator, const typename Dict::map_t::const_iterator &end)
        : System::Details::NativeIteratorWrapperBase<typename Dict::KeyValuePairType, typename Dict::map_t::const_iterator>(iterator, end)
    {
        InitializeIteratorPointer(m_pointer);
        if (!m_is_end)
            UpdateIteratorPointer(m_pointer, typename Dict::KeyValuePairType(m_iterator->first, m_iterator->second));
    }
    DictionaryIterator(DictionaryIterator &&other) noexcept
        : System::Details::NativeIteratorWrapperBase<typename Dict::KeyValuePairType, typename Dict::map_t::const_iterator>(std::forward(other.m_iterator))
    {
        if (!m_is_end)
            UpdateIteratorPointer(m_pointer, typename Dict::KeyValuePairType(m_iterator->first, m_iterator->second));
    }
    virtual ~DictionaryIterator() = default;
 
    void IncrementIterator() override
    {
        if (System::Details::NativeIteratorWrapperBase<typename Dict::KeyValuePairType, typename Dict::map_t::const_iterator>::IteratorIncrementImplementation())
            UpdateIteratorPointer(m_pointer, typename Dict::KeyValuePairType(m_iterator->first, m_iterator->second));
    }
    void DecrementIterator() override
    {
        System::Details::IteratorDecrementer<typename Dict::map_t::const_iterator>::decrement(m_iterator);
        UpdateIteratorPointer(m_pointer, typename Dict::KeyValuePairType(m_iterator->first, m_iterator->second));
    }
    void ShiftIteratorBy(std::ptrdiff_t offset) override
    {
        if (System::Details::NativeIteratorWrapperBase<typename Dict::KeyValuePairType, typename Dict::map_t::const_iterator>::IteratorShiftImplementation(offset))
            UpdateIteratorPointer(m_pointer, typename Dict::KeyValuePairType(m_iterator->first, m_iterator->second));
    }
    System::Details::VirtualizedIteratorBase<typename Dict::KeyValuePairType>* CloneIterator() const override
    {
        return new DictionaryIterator(m_iterator, m_end);
    }
};
 
 
template<typename Map>
class ASPOSECPP_SHARED_CLASS BaseDictionary : public IDictionary<typename Map::key_type, typename Map::mapped_type>
{
    ASPOSE_MAP_POINTER_MODE_CONTROL(Map)
 
public:
    void SetTemplateWeakPtr(unsigned int argument) override
    {
        static_assert(std::is_same<decltype(m_map.get_allocator()), typename pointer_mode_t::allocator_type>::value, "Container's allocator is not set to typename pointer_mode_t::allocator_type");
        m_pointer_mode.SetWeak(argument, m_map);
    }
 
    typedef Map map_t;
 
protected:
    pointer_mode_t m_pointer_mode;
 
private:
    typedef typename Map::key_type key_t;
    typedef typename Map::mapped_type mapped_t;
    typedef typename Map::iterator mapIt_t;
    typedef typename Map::const_iterator stl_const_iterator;
 
    static_assert(std::is_same<allocator_t, typename Map::allocator_type>::value, "Using wrong map type with BaseDictionary");
 
public:
    typedef ICollection<key_t>  KeyCollection;
    typedef ICollection<mapped_t> ValueCollection;
    typedef KeyValuePair<key_t, mapped_t> KVPair;
 
    typedef IDictionary<typename Map::key_type, typename Map::mapped_type> BaseType;
 
    typedef KVPairIterator<KVPair, Map> iterator;
    typedef KVPairIterator<KVPair, Map> const_iterator;
 
    BaseDictionary() : ASPOSE_MAP_INIT_ALLOCATOR() {}
 
    template<class... Args>
    BaseDictionary(int, const Args&... args)
        : m_map(args..., ASPOSE_COLLECTION_ALLOCATOR)
    {}
 
    template<class... Args>
    BaseDictionary(BaseType* src, const Args&... args)
        : m_map(args..., ASPOSE_COLLECTION_ALLOCATOR)
    {
        CopyFrom(src);
    }
 
    BaseDictionary(BaseType* src) : ASPOSE_MAP_INIT_ALLOCATOR()
    {
        CopyFrom(src);
    }
 
    // IEnumerable
    SharedPtr< IEnumerator<KeyValuePair<key_t, mapped_t> > > GetEnumerator() override = 0;
 
    // ICollection
    int32_t get_Count() const override
    {
        return static_cast<int32_t>(m_map.size());
    }
    void Clear() override
    {
        m_map.clear();
    }
 
    // IDictionary interface
    virtual mapped_t& operator[](const key_t& key)
    {
        return m_map[key];
    }
    mapped_t idx_get(const key_t& key) const override
    {
        CheckIfNull(key);
        auto it = m_map.find(key);
        if (it == m_map.end())
        {
            throw KeyNotFoundException();
        }
 
        return it->second;
    }
    void idx_set(const key_t& key, mapped_t value) override
    {
        CheckIfNull(key);
        m_map[key] = value;
#if defined(ASPOSE_DETECT_BAD_QUALITY_HASH)
        System::Details::CheckHashFunctionQuality(m_map);
#endif
    }
    void Add(const key_t& key, const mapped_t& value) override
    {
        CheckIfNull(key);
        // insert never replaces values
        auto op_result = m_map.insert(std::make_pair(key, value));
        if (! op_result.second)
        {
            throw System::ArgumentException(u"key");
        }
#if defined(ASPOSE_DETECT_BAD_QUALITY_HASH)
        System::Details::CheckHashFunctionQuality(m_map);
#endif
    }
    bool ContainsKey(const key_t& key) const override
    {
        CheckIfNull(key);
        return m_map.find(key) != m_map.end();
    }
    bool Remove(const key_t& key) override
    {
        CheckIfNull(key);
        auto it = m_map.find(key);
 
        if (it != m_map.end())
        {
            m_map.erase(it);
            return true;
        }
 
        return false;
    }
    bool TryGetValue(const key_t& key, mapped_t& value) const override
    {
        auto it = m_map.find(key);
 
        if (it != m_map.end())
        {
            value = it->second;
            return true;
        }
 
        // There should be the System::Default<mapped_t>() call, but it has a lot of restrictions,
        // e.g. System::Default doesn't work with C# structures and delegates
        value = mapped_t();
        return false;
    }
 
    // BaseDictionary interface
    bool ContainsValue(const mapped_t& value)
    {
        for (const auto& itr : m_map)
        {
            if (itr.second == value)
                return true;
        }
        return false;
    }
 
    Map& data() { return m_map; }
    const Map& data() const { return m_map; }
    void _add_range(std::initializer_list<typename Map::value_type> list)
    {
        std::for_each(list.begin(), list.end(), [this](const typename Map::value_type &v) { m_map.insert(v); });
    }
 
    mapped_t GetValueOrDefault(const key_t& key) const override
    {
        auto it = m_map.find(key);
 
        if (it != m_map.end())
        {
            return it->second;
        }
 
        return mapped_t();
    }
 
    mapped_t GetValueOrDefault(const key_t& key, const mapped_t& defaultValue) const override
    {
        auto it = m_map.find(key);
 
        if (it != m_map.end())
        {
            return it->second;
        }
 
        return defaultValue;
    }
 
    mapped_t GetValueOrNull(const key_t& key) const override
    {
        auto it = m_map.find(key);
 
        if (it != m_map.end())
        {
            return it->second;
        }
 
        return mapped_t();
    }
 
    const_iterator begin() const noexcept
    {
        return m_map.begin();
    }
 
    const_iterator end() const noexcept
    {
        return m_map.end();
    }
 
    stl_const_iterator cbegin() const noexcept
    {
        return m_map.cbegin();
    }
 
    stl_const_iterator cend() const noexcept
    {
        return m_map.cend();
    }
 
    System::Details::VirtualizedIteratorBase<KVPair>* virtualizeBeginIterator() override
    {
        return new DictionaryIterator<BaseDictionary>(m_map.begin(), m_map.end());
    }
    System::Details::VirtualizedIteratorBase<KVPair>* virtualizeEndIterator() override
    {
        return new DictionaryIterator<BaseDictionary>(m_map.end(), m_map.end());
    }
    System::Details::VirtualizedIteratorBase<KVPair>* virtualizeBeginConstIterator() const override
    {
        return new DictionaryIterator<BaseDictionary>(m_map.begin(), m_map.end());
    }
    System::Details::VirtualizedIteratorBase<KVPair>* virtualizeEndConstIterator() const override
    {
        return new DictionaryIterator<BaseDictionary>(m_map.end(), m_map.end());
    }
 
protected:
    Map m_map;
 
    // ICollection
    bool Contains(const KeyValuePair<key_t, mapped_t>& item) const override
    {
        auto it = m_map.find(item.m_pair.first);
 
        return it != m_map.end() && it->second == item.m_pair.second;
    }
    bool Remove(const KeyValuePair<key_t, mapped_t>& item) override
    {
        auto it = m_map.find(item.m_pair.first);
 
        if (it != m_map.end() && it->second == item.m_pair.second)
        {
            m_map.erase(it);
            return true;
        }
 
        return false;
    }
 
#ifdef ASPOSE_GET_SHARED_MEMBERS
    virtual void GetSharedMembers(System::Object::shared_members_type& result) const override
    {
        Object::GetSharedMembers(result);
        result.PopulateSharedMembers("System::Collections::Generic::BaseDictionary<Map>::m_map[]", m_map);
    }
#endif
 
private:
    void CopyFrom(BaseType* src)
    {
        if (nullptr == src)
            throw ArgumentNullException(u"Argument cannot be nullptr");
 
        SharedPtr<IEnumerator<KeyValuePair<key_t, mapped_t> > > enumerator = src->GetEnumerator();
        while (enumerator->MoveNext())
            BaseDictionary<Map>::Add(enumerator->get_Current());
    }
    void Add(const KeyValuePair<key_t, mapped_t>& item) override
    {
        m_map.insert(item.m_pair);
    }
    static NotSupportedException ReadOnlyException()
    {
        return NotSupportedException(u"The collection is readonly");
    }
 
protected:
    ~BaseDictionary() override {}
 
#ifdef __DBG_FOR_EACH_MEMBER
    public:
        void DBG_for_each_member(DBG::for_each_member_visitor &visitor) const override
        {
            visitor.add_self(this);
            DBG::for_each_of_Object(this, m_map, visitor);
        }
 
        const char* DBG_class_name() const override { return "BaseDictionary<T>"; }
#endif
 
private:
    template <typename T, class = void>
    struct has_equality_operator : std::false_type {};
    template <typename T>
    struct has_equality_operator<T, typename std::enable_if<!std::is_enum<T>::value, decltype((void)(std::declval<T>() == nullptr))>::type> : std::true_type
    {};
 
    template <typename T>
    typename std::enable_if<has_equality_operator<T>::value, void>::type CheckIfNull(const T& instance) const
    {
        if (instance == nullptr) 
        {
            throw System::ArgumentNullException(u"key");
        }
    }
    template <typename T>
    typename std::enable_if<!has_equality_operator<T>::value, void>::type CheckIfNull(const T& instance) const
    {
    }
 
};
 
}}} // namespace System::Collections::Generic