dictionary.h

 
#ifndef _aspose_system_collections_dictionary_h_
#define _aspose_system_collections_dictionary_h_
 
#include "system/object.h"
#include "system/collections/base_dictionary.h"
#include "system/collections/keyvalue_collection.h"
#include "system/collections/iequality_comparer.h"
#include "system/cycles_detection.h"
#include "system/iequatable.h"
 
#include <unordered_map>
 
namespace System {
namespace Collections {
namespace Generic {
 
template<typename T, typename V> class Dictionary;
 
template<typename T, typename V>
class DictionaryPtr : public SharedPtr<Dictionary<T, V> >
{
public:
    DictionaryPtr() {}
    DictionaryPtr(const SharedPtr<Dictionary<T, V> >& obj) : SharedPtr<Dictionary<T, V> >(obj) { }
 
    template<class X>
    V& operator[] (const X& key) const
    {
        return (**this)[T(key)];
    }
    V& operator[] (const T& key) const
    {
        return (**this)[key];
    }
};
 
 
template<typename TKey, typename TValue>
class ASPOSECPP_SHARED_CLASS Dictionary
    : public BaseDictionary<std::unordered_map<TKey, TValue, EqualityComparerHashAdapter<TKey>, EqualityComparerAdapter<TKey>, ASPOSE_MAP_ALLOCATOR_TYPE(TKey, TValue)> >
{
    typedef Dictionary<TKey, TValue> ThisType;
    typedef BaseDictionary<std::unordered_map<TKey, TValue, EqualityComparerHashAdapter<TKey>, EqualityComparerAdapter<TKey>, ASPOSE_MAP_ALLOCATOR_TYPE(TKey, TValue)> > BaseType;
 
    typedef IDictionary<TKey, TValue> BaseType_;
 
    RTTI_INFO_TEMPLATE_CLASS(ThisType, System::BaseTypesInfo<BaseType_>);
 
public:
    typedef ICollection<TKey>   KeyCollection;
    typedef ICollection<TValue> ValueCollection;
    typedef std::unordered_map<TKey, TValue, EqualityComparerHashAdapter<TKey>, EqualityComparerAdapter<TKey>, ASPOSE_MAP_ALLOCATOR_TYPE(TKey, TValue)>  map_t;
 
    typedef SharedPtr< Dictionary<TKey, TValue> > Ptr;
    typedef KeyValuePair<TKey, TValue> KVPair;
    typedef SharedPtr< IEnumerable<KVPair> > IEnumerablePtr;
    typedef SharedPtr< IEnumerator<KVPair> > IEnumeratorPtr;
 
    Dictionary()
        : Dictionary(GetDefaultComparer<TKey>())
    {}
    Dictionary(const map_t& map)
        : BaseType(0, map) // 0 - use forwarding ctor
    {}
    Dictionary(int capacity)
        : BaseType(0) // 0 - use forwarding ctor
    {}
    Dictionary(const SharedPtr<IDictionary<TKey, TValue> >& src)
        : BaseType(src.get())
    {}
    Dictionary(const SharedPtr<IDictionary<TKey, TValue> >& src, const SharedPtr<IEqualityComparer<TKey> >& comparer)
        : BaseType(src.get(), 8, EqualityComparerHashAdapter<TKey>(comparer), EqualityComparerAdapter<TKey>(comparer)) // 8 is a bucket count
    {}
    Dictionary(const SharedPtr<IEqualityComparer<TKey> >& comparer)
        : BaseType(0, 8, EqualityComparerHashAdapter<TKey>(comparer), EqualityComparerAdapter<TKey>(comparer)) // 0 - use forwarding ctor
    {}
    Dictionary(int capacity, const SharedPtr<IEqualityComparer<TKey> >& comparer)
        : Dictionary(comparer)
    {}
 
    class Enumerator : public SimpleEnumerator<map_t, KVPair>
    {
        typedef typename Dictionary<TKey, TValue>::Enumerator EnumeratorType;
    public:
        Enumerator(Ptr dict) : SimpleEnumerator<map_t, KVPair>(dict, dict->m_map) { }
        RTTI_INFO_TEMPLATE_CLASS(EnumeratorType, System::BaseTypesInfo<System::Object>);
        System::Details::VirtualizedIteratorBase<KVPair>* CloneIterator() const override
        {
            return new Enumerator(*this);
        }
    };
 
    virtual IEnumeratorPtr GetEnumerator() override
    {
        return MakeObject<Enumerator>(MakeSharedPtr(this));
    }
 
protected:
    ~Dictionary() override {}
 
    SharedPtr<KeyCollection> get_KeysInternal() const override
    {
        return MakeObject<_KeyCollection<Dictionary<TKey, TValue>>>(MakeSharedPtr(this));
    }
    SharedPtr<ValueCollection> get_ValuesInternal() const override
    {
        return MakeObject<_ValueCollection<Dictionary<TKey, TValue>>>(MakeSharedPtr(this));
    }
 
#ifdef ASPOSE_GET_SHARED_MEMBERS
    DEFINE_GET_SHARED_MEMBERS(BaseType::m_map)
#endif
 
    private:
        template<typename T>
        class DefaultComparer : public IEqualityComparer<T>
        {
        public:
 
            virtual bool Equals(T x, T y) const override
            {
                return x->Equals(y);
            }
 
            virtual int GetHashCode(T obj) const override
            {
                return obj->GetHashCode();
            }
        };
 
        template<typename T>
        typename std::enable_if<IsSmartPtr<T>::value && std::is_base_of<IEquatable<T>, typename T::Pointee_>::value, SharedPtr<IEqualityComparer<T>> >::type GetDefaultComparer()
        {
            return MakeObject<DefaultComparer<T>>();
        }
 
        template<typename T>
        typename std::enable_if<IsSmartPtr<T>::value && !std::is_base_of<IEquatable<T>, typename T::Pointee_>::value, SharedPtr<IEqualityComparer<T>> >::type GetDefaultComparer()
        {
            return SharedPtr<IEqualityComparer<T> >();
        }
 
        template<typename T>
        typename std::enable_if<!IsSmartPtr<T>::value, SharedPtr<IEqualityComparer<T>> >::type GetDefaultComparer()
        {
            return SharedPtr<IEqualityComparer<T> >();
        }
 
#ifdef __DBG_FOR_EACH_MEMBER
public:
    void DBG_for_each_member(DBG::for_each_member_visitor &visitor) const override
    {
        BaseType::DBG_for_each_member(visitor);
 
        visitor.add_self(this);
    }
 
    const char* DBG_class_name() const override { return "Dictionary<T>"; }
#endif
};
 
} // namespace Generic
} // namespace Collections
} // namespace System
 
#endif // _aspose_system_collections_dictionary_h_