ReadOnlyCollectionBase.h

#pragma once
//-----------------------------------------------------------------------
// <copyright file="ReadOnlyCollectionBase.cs" company="Aspose Pty Ltd">
//   Copyright (c) 2002-2025 Aspose Pty Ltd. All Rights Reserved.
// </copyright>
//-----------------------------------------------------------------------
 
#include <system/exceptions.h>
#include <system/details/pointer_collection_helpers.h>
#include <system/collections/list.h>
#include <system/collections/ilist.h>
#include <system/array.h>
#include <cstdint>
 
namespace Aspose
{
namespace Tasks
{
namespace Vba
{
class VbaProjectReader;
class VbaProjectReferencesReader;
} // namespace Vba
class VbaModuleAttributeCollection;
class VbaModuleCollection;
class VbaReferenceCollection;
} // namespace Tasks
} // namespace Aspose
namespace System
{
namespace Collections
{
namespace Generic
{
template <typename> class IEnumerator;
} // namespace Generic
} // namespace Collections
} // namespace System
 
namespace Aspose {
 
namespace Tasks {
 
/// <summary>
/// Represents a read-only collection of objects.
/// </summary>
/// <typeparam name="T">Type of collection items.</typeparam>
template<typename T>
class ReadOnlyCollectionBase : public System::Collections::Generic::IList<T>
{
    typedef ReadOnlyCollectionBase<T> ThisType;
    typedef System::Collections::Generic::IList<T> BaseType;
    
    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
    RTTI_INFO_TEMPLATE_CLASS(ThisType, ThisTypeBaseTypesInfo);
    
    template<typename FT0> friend class ReadOnlyCollectionBase;
    friend class Aspose::Tasks::Vba::VbaProjectReferencesReader;
    friend class VbaModuleAttributeCollection;
    friend class VbaReferenceCollection;
    friend class VbaModuleCollection;
    friend class Aspose::Tasks::Vba::VbaProjectReader;
    
public:
 
    /// <summary>
    /// Gets the number of objects contained in the object.
    /// </summary>
    int32_t get_Count() const override
    {
        return this->items->get_Count();
    }
    
    /// <summary>
    /// Returns the element at the specified index.
    /// </summary>
    /// <param name="index">The zero-based index of the element to get.</param>
    /// <returns>the element at the specified index.</returns>
    T idx_get(int32_t index) const override
    {
        return this->items->idx_get(index);
    }
    
    /// <summary>
    /// Returns the element at the specified index.
    /// </summary>
    /// <param name="index">The zero-based index of the element to get.</param>
    /// <param name="value">the element at the specified index.</param>
    void idx_set(int32_t index, T value) override
    {
        ASPOSE_UNUSED(index);
        ASPOSE_UNUSED(value);
        throw System::NotSupportedException(u"Collection is read-only.");
    }
    
    /// <summary>
    /// Returns an enumerator for this collection.
    /// </summary>
    /// <returns>An enumerator for this collection.</returns>
    System::SharedPtr<System::Collections::Generic::IEnumerator<T>> GetEnumerator() override
    {
        return this->items->GetEnumerator();
    }
    
    /// <summary>
    /// This is the stub implementation of ICollection's Add method, that only throws NotSupportedException
    /// </summary>
    /// <param name="item">The item to add.</param>
    void Add(const T& item) override
    {
        ASPOSE_UNUSED(item);
        throw System::NotSupportedException(u"Collection is read-only.");
    }
    
    /// <summary>
    /// Converts the collection object to a list of <see cref="VbaModule"></see> objects.
    /// </summary>
    /// <returns>List of objects.</returns>
    System::SharedPtr<System::Collections::Generic::List<T>> ToList()
    {
        return System::MakeObject<System::Collections::Generic::List<T>>(this->items);
    }
    
    void SetTemplateWeakPtr(uint32_t argument) override
    {
        switch (argument)
        {
            case 0:
                System::Details::CollectionHelpers::SetWeakPointer(0, items);
                break;
                
        }
    }
    
protected:
 
    ReadOnlyCollectionBase() : items(System::MakeObject<System::Collections::Generic::List<T>>())
    {
    }
    
    ReadOnlyCollectionBase(const System::SharedPtr<System::Collections::Generic::IList<T>>& items)
        : items(System::MakeObject<System::Collections::Generic::List<T>>())
    {
        this->items = items;
    }
    
    void AddInternal(T attribute)
    {
        this->items->Add(attribute);
    }
    
    virtual ~ReadOnlyCollectionBase()
    {
    }
    
    #ifdef ASPOSE_GET_SHARED_MEMBERS
    void GetSharedMembers(System::Object::shared_members_type& result) const override
    {
        System::Object::GetSharedMembers(result);
        
        result.Add("Aspose::Tasks::ReadOnlyCollectionBase::items", this->items);
    }
    #endif
    
    
private:
 
    System::SharedPtr<System::Collections::Generic::IList<T>> items;
    
    bool get_IsReadOnly() const override
    {
        return true;
    }
    
    int32_t IndexOf(const T& item) const override
    {
        return this->items->IndexOf(item);
    }
    
    void CopyTo(System::ArrayPtr<T> array, int32_t arrayIndex) override
    {
        this->items->CopyTo(array, arrayIndex);
    }
    
    bool Contains(const T& item) const override
    {
        return this->items->Contains(item);
    }
    
    void Insert(int32_t index, const T& item) override
    {
        ASPOSE_UNUSED(index);
        ASPOSE_UNUSED(item);
        throw System::NotSupportedException(u"Collection is read-only.");
    }
    
    bool Remove(const T& item) override
    {
        ASPOSE_UNUSED(item);
        throw System::NotSupportedException(u"Collection is read-only.");
    }
    
    void RemoveAt(int32_t index) override
    {
        ASPOSE_UNUSED(index);
        throw System::NotSupportedException(u"Collection is read-only.");
    }
    
    void Clear() override
    {
        throw System::NotSupportedException(u"Collection is read-only.");
    }
    
    
};
 
} // namespace Tasks
} // namespace Aspose