idictionary.h

 
#ifndef _aspose_system_collections_idictionary_h_
#define _aspose_system_collections_idictionary_h_
 
#include <system/collections/ikvcollection.h>
#include <system/collections/keyvalue_pair.h>
#include <system/array.h>
 
namespace System {
namespace Collections {
namespace Generic {
 
template<typename TKey, typename TValue>
class ASPOSECPP_SHARED_CLASS IDictionary : public ICollection<KeyValuePair<TKey, TValue>>
{
    using ThisType = System::Collections::Generic::IDictionary<TKey, TValue>;
    using BaseTypesInfo = System::BaseTypesInfo<ICollection<KeyValuePair<TKey, TValue>>>;
    RTTI_INFO_TEMPLATE_CLASS(ThisType, BaseTypesInfo);
 
public:
    typedef ICollection<KeyValuePair<TKey, TValue>> BaseType;
    typedef KeyValuePair<TKey, TValue>  KeyValuePairType;
    
    using ICollection<KeyValuePair<TKey, TValue>>::Add;
    using ICollection<KeyValuePair<TKey, TValue>>::Remove;
 
    virtual void Add(const TKey& key, const TValue& value) = 0;
    virtual bool ContainsKey(const TKey& key) const = 0;
    virtual bool Remove(const TKey& key) = 0;
    virtual bool TryGetValue(const TKey& key, TValue& value) const = 0;
 
    virtual TValue idx_get(const TKey& key) const = 0;
    virtual void idx_set(const TKey& key, TValue value) = 0;
 
    virtual SharedPtr<ICollection<TKey>> get_Keys() const { return get_KeysInternal(); }
    virtual SharedPtr<ICollection<TValue>> get_Values() const { return get_ValuesInternal(); }
    
    bool get_IsFixedSize() const { return false; }
 
    // ICollection interface
    bool get_IsSynchronized() const { return false; }
    using BaseType::get_Count;
    virtual void CopyTo(ArrayPtr<KeyValuePair<TKey, TValue>> arr, int index) override
    {
        if (!arr)
            throw ArgumentNullException();
 
        if (index < 0)
            throw ArgumentOutOfRangeException();
 
        if (index + get_Count() > arr->get_Length())
            throw ArgumentException();
 
        SharedPtr<IEnumerator<KeyValuePair<TKey, TValue>>> e = this->GetEnumerator();
        while (e->MoveNext())
            (*arr)[index++] = e->get_Current();
    }
 
    virtual TValue GetValueOrDefault(const TKey& key) const
    {
        ASPOSE_UNUSED(key);
        throw System::NotImplementedException();
    }
 
    virtual TValue GetValueOrDefault(const TKey& key, const TValue& defaultValue) const
    {
        ASPOSE_UNUSED(key);
        ASPOSE_UNUSED(defaultValue);
        throw System::NotImplementedException();
    }
 
    virtual TValue GetValueOrNull(const TKey& key) const
    {
        ASPOSE_UNUSED(key);
        throw System::NotImplementedException();
    }
 
protected:
    ~IDictionary() override {}
 
    virtual SharedPtr<ICollection<TKey>> get_KeysInternal() const { throw System::NotImplementedException(ASPOSE_CURRENT_FUNCTION); };
    virtual SharedPtr<ICollection<TValue>> get_ValuesInternal() const { throw System::NotImplementedException(ASPOSE_CURRENT_FUNCTION); };
};
 
} // namespace Generic
} // namespace Collections
} // namespace System
 
#endif // _aspose_system_collections_idictionary_h_