ikvcollection.h

 
#ifndef _aspose_system_collections_ikvcollection_h_
#define _aspose_system_collections_ikvcollection_h_
 
#include <system/array.h>
#include <system/collections/ilist.h>
 
namespace System { namespace Collections { namespace Generic {
 
template <typename T>
class ASPOSECPP_SHARED_CLASS IKVCollection : public IList<T>
{
    RTTI_INFO_TEMPLATE_CLASS(System::Collections::Generic::IKVCollection<T>, System::BaseTypesInfo<System::Collections::Generic::IList<T>>);
 
public:
    // IEnumerable
    virtual SharedPtr<IEnumerator<T> > GetEnumerator() override = 0;
 
    // ICollection
    virtual int get_Count() const override = 0;
    virtual void Add(const T& item) override { ASPOSE_UNUSED(item); throw MakeReadonlyException(); }
    virtual void Clear() override { throw MakeReadonlyException(); }
    virtual bool Contains(const T& item) const override { ASPOSE_UNUSED(item); throw System::NotImplementedException(ASPOSE_CURRENT_FUNCTION); }
    virtual bool Remove(const T& item) override { ASPOSE_UNUSED(item); throw MakeReadonlyException(); }
    virtual bool get_IsReadOnly() const override { return true; }
 
    // IList
    virtual int IndexOf(const T& item) const override { ASPOSE_UNUSED(item); throw System::NotSupportedException(ASPOSE_CURRENT_FUNCTION); }
 
    virtual void Insert(int index, const T& item) override { ASPOSE_UNUSED(index); ASPOSE_UNUSED(item); throw MakeReadonlyException(); }
    virtual void RemoveAt(int index) override { ASPOSE_UNUSED(index); throw MakeReadonlyException(); }
 
    virtual T idx_get(int index) const override = 0;
    virtual void idx_set(int index, T value) override { ASPOSE_UNUSED(index); ASPOSE_UNUSED(value); throw MakeReadonlyException(); }
 
protected:
    ~IKVCollection() override {}
 
    static System::NotSupportedException MakeReadonlyException()
    {
        return System::NotSupportedException(u"The collection is readonly.");
    }
};
 
} } }
 
#endif // _aspose_system_collections_ikvcollection_h_