sorted_dictionary.h

 
#ifndef _aspose_system_collections_sorted_dictionary_h_
#define _aspose_system_collections_sorted_dictionary_h_
 
#include "system/object.h"
#include "system/collections/base_dictionary.h"
#include "system/collections/keyvalue_collection.h"
#include "system/cycles_detection.h"
 
#include <map>
 
namespace System {
namespace Collections {
namespace Generic {
 
template<typename T, typename V> class SortedDictionary;
 
template<typename T, typename V>
class ASPOSECPP_SHARED_CLASS SortedDictionaryPtr : public SharedPtr<SortedDictionary<T, V> >
{
public:
    SortedDictionaryPtr() 
    { }
    SortedDictionaryPtr(const SharedPtr<SortedDictionary<T, V> >& obj) : SharedPtr<SortedDictionary<T, V> >(obj)
    { }
 
    V& operator[] (const T& key) const
    {
        return (*(this->GetPointer()))[key];
    }
};
 
template<typename TKey, typename TValue>
class ASPOSECPP_SHARED_CLASS SortedDictionary
    : public BaseDictionary<std::map<TKey, TValue, ComparerAdapter<typename BasePointerType<TKey>::type>, ASPOSE_MAP_ALLOCATOR_TYPE(TKey, TValue)> >
{
    typedef SortedDictionary<TKey, TValue> _ThisType;
    typedef BaseDictionary<std::map<TKey, TValue, ComparerAdapter<typename BasePointerType<TKey>::type>, ASPOSE_MAP_ALLOCATOR_TYPE(TKey, TValue)> > _BaseType;
    RTTI_INFO_TEMPLATE_CLASS(_ThisType, System::BaseTypesInfo<_BaseType>);
 
protected:
    using _BaseType::m_map;
 
public:
    typedef ICollection<TKey>   KeyCollection;
    typedef ICollection<TValue> ValueCollection;
    typedef std::map<TKey, TValue, ComparerAdapter<typename BasePointerType<TKey>::type>, ASPOSE_MAP_ALLOCATOR_TYPE(TKey, TValue)> map_t;
    typedef SortedDictionary<TKey, TValue> this_t;
    typedef SharedPtr<this_t> Ptr;
    typedef KeyValuePair<TKey, TValue> KVPair;
    typedef SharedPtr< IEnumerable<KVPair> > IEnumerablePtr;
    typedef SharedPtr< IEnumerator<KVPair> > IEnumeratorPtr;
 
    typedef typename _BaseType::iterator iterator;
    typedef typename _BaseType::const_iterator const_iterator;
    typedef typename map_t::reverse_iterator reverse_iterator;
    typedef typename map_t::const_reverse_iterator const_reverse_iterator;
 
    static SharedPtr<IComparer<typename BasePointerType<TKey>::type>> GetDefaultKeyComparer()
    {
        static SharedPtr<IComparer<typename BasePointerType<TKey>::type>> value;
        static std::once_flag once;
        std::call_once(once, [] { value = MakeObject<DefaultComparer<typename BasePointerType<TKey>::type>>(); });
        return value;
    }
 
    SortedDictionary()
    {
        m_comparer = SortedDictionary::GetDefaultKeyComparer();
    }
    SortedDictionary(const SharedPtr<IComparer<typename BasePointerType<TKey>::type> >& comparer)
        : _BaseType(0, ComparerAdapter<typename BasePointerType<TKey>::type>(comparer))
    {
        m_comparer = comparer;
    }
    SortedDictionary(const SharedPtr<IDictionary<TKey, TValue>>& src)
        : _BaseType(src.get())
    {
        m_comparer = SortedDictionary::GetDefaultKeyComparer();
    }
 
    SortedDictionary(const SharedPtr<IDictionary<TKey, TValue>>& src,
                     const SharedPtr<IComparer<typename BasePointerType<TKey>::type>>& comparer)
        : _BaseType(src.get(), comparer)
    {
        m_comparer = comparer;
    }
 
    SharedPtr<System::Collections::Generic::IComparer<TKey>> get_Comparer() const
    {
        return m_comparer;
    }
 
    class Enumerator : public SimpleEnumerator<map_t, KVPair>
    {
    public:
        Enumerator(const Ptr& dict) : SimpleEnumerator<map_t, KVPair>(dict, dict->m_map) { }
        typedef typename SortedDictionary<TKey, TValue>::Enumerator EnumeratorType;
        RTTI_INFO_TEMPLATE_CLASS(Enumerator, System::BaseTypesInfo<System::Object>);
    };
    IEnumeratorPtr GetEnumerator() override
    {
        return MakeObject<Enumerator>(MakeSharedPtr(this));
    }
 
    reverse_iterator rbegin() noexcept
    {
        return m_map.rbegin();
    }
    reverse_iterator rend() noexcept
    {
        return m_map.rend();
    }
 
    const_reverse_iterator rbegin() const noexcept
    {
        return m_map.rbegin();
    }
    const_reverse_iterator rend() const noexcept
    {
        return m_map.rend();
    }
 
    const_reverse_iterator crbegin() const noexcept
    {
        return rbegin();
    }
    const_reverse_iterator crend() const noexcept
    {
        return rend();
    }
 
protected:
    ~SortedDictionary() override {}
 
    SharedPtr<KeyCollection> get_KeysInternal() const override
    {
        return MakeObject<_KeyCollection<SortedDictionary<TKey, TValue>>>(MakeSharedPtr(this));
    }
    SharedPtr<ValueCollection> get_ValuesInternal() const override
    {
        return MakeObject<_ValueCollection<SortedDictionary<TKey, TValue>>>(MakeSharedPtr(this));
    }
#ifdef ASPOSE_GET_SHARED_MEMBERS
    DEFINE_GET_SHARED_MEMBERS(_BaseType::m_map)
#endif
 
private:
    SharedPtr<IComparer<typename BasePointerType<TKey>::type>> m_comparer;
};
 
} // namespace Generic
} // namespace Collections
} // namespace System
 
#endif // _aspose_system_collections_sorted_dictionary_h_