PropertyKeyedCollection.h

#pragma once
//-----------------------------------------------------------------------
// <copyright file="PropertyKeyedCollection.cs" company="Aspose Pty Ltd">
//   Copyright (c) 2002-2024 Aspose Pty Ltd. All Rights Reserved.
// </copyright>
//-----------------------------------------------------------------------
 
#include <system/type_info.h>
#include <system/object_ext.h>
#include <system/exceptions.h>
#include <system/enumerator_adapter.h>
#include <system/details/pointer_collection_helpers.h>
#include <system/constraints.h>
#include <system/collections/keyvalue_pair.h>
#include <system/collections/ienumerator.h>
#include <system/collections/icollection.h>
#include <system/collections/dictionary.h>
#include <system/array.h>
#include <cstdint>
 
#include "aspose.tasks.cpp/PropertyCollections/PropertyCollection.h"
#include "aspose.tasks.cpp/PropertyCollections/Property.h"
 
namespace Aspose
{
namespace Tasks
{
namespace Properties
{
class CustomProjectPropertyWrapperCollection;
template <typename> class PropertyCollection;
} // namespace Properties
} // namespace Tasks
} // namespace Aspose
 
namespace Aspose {
 
namespace Tasks {
 
namespace Properties {
 
/// <summary>
/// A base class of collection of properties.
/// </summary>
/// <typeparam name="T">The type of property.</typeparam>
template<typename T>
class PropertyKeyedCollection : public Aspose::Tasks::Properties::PropertyCollection<T>, public System::Collections::Generic::ICollection<T>
{
    typedef Property BaseT_Property;
    assert_is_base_of(BaseT_Property, T);
    
    typedef PropertyKeyedCollection<T> ThisType;
    typedef Aspose::Tasks::Properties::PropertyCollection<T> BaseType;
    typedef System::Collections::Generic::ICollection<T> BaseType1;
    
    typedef ::System::BaseTypesInfo<BaseType, BaseType1> ThisTypeBaseTypesInfo;
    RTTI_INFO_TEMPLATE_CLASS(ThisType, ThisTypeBaseTypesInfo);
    
    friend class Aspose::Tasks::Properties::CustomProjectPropertyWrapperCollection;
    template<typename FT0> friend class Aspose::Tasks::Properties::PropertyKeyedCollection;
    
public:
 
    /// <summary>
    /// Gets the collection of all property names.
    /// </summary>
    System::SharedPtr<System::Collections::Generic::ICollection<System::String>> get_Names()
    {
        return this->dictionary->get_Keys();
    }
    
    /// <summary>
    /// Gets the number of properties in the collection.
    /// </summary>
    int32_t get_Count() const override
    {
        return this->dictionary->get_Count();
    }
    
    /// <summary>
    /// Gets a value indicating whether this collection is read-only; otherwise, false.
    /// </summary>
    bool get_IsReadOnly() const override = 0;
    
    /// <summary>
    /// Gets the Property associated with the specified key.
    /// </summary>
    /// <param name="name">The name of the Property to get.</param>
    /// <returns>The Property associated with the specified name.</returns>
    T idx_get(const System::String& name)
    {
        return this->Get(name);
    }
    
    /// <inheritdoc ></inheritdoc>
    void Clear() override
    {
        this->ThrowIfReadOnly();
        this->ClearInternal();
    }
    
    /// <summary>
    /// Determines whether the <see cref="Aspose::Tasks::Properties::PropertyCollection{T}"></see> contains a property with the specified name.
    /// </summary>
    /// <param name="name">The name of a property</param>
    /// <returns>true if the <see cref="Aspose::Tasks::Properties::PropertyCollection{T}"></see> contains a property with the specified name; otherwise, false.</returns>
    bool Contains(const System::String& name) const
    {
        return this->dictionary->ContainsKey(name);
    }
    
    /// <summary>
    /// Creates a new custom property.
    /// </summary>
    /// <param name="item">The property to add.</param>
    void Add(const T& item) override
    {
        this->ThrowIfReadOnly();
        this->AddInternal(item);
    }
    
    void SetTemplateWeakPtr(uint32_t argument) override
    {
        switch (argument)
        {
            case 0:
                System::Details::CollectionHelpers::SetWeakPointer(0, dictionary);
                BaseType::SetTemplateWeakPtr(0);
                break;
                
        }
    }
    
protected:
 
    /// <summary>Initializes a new instance of the <see cref="PropertyKeyedCollection{T}"></see> class.</summary>
    PropertyKeyedCollection()
        : dictionary(System::MakeObject<System::Collections::Generic::Dictionary<System::String, T>>())
    {
    }
    
    /// <summary>
    /// Gets the Property associated with the specified key.
    /// </summary>
    /// <param name="name">The name of the Property to get.</param>
    /// <param name="value">The Property associated with the specified name.</param>
    void idx_set(const System::String& name, T value)
    {
        this->ThrowIfReadOnly();
        this->Set(name, value);
    }
    
    System::SharedPtr<System::Collections::Generic::IEnumerator<T>> GetEnumeratorInternal() override
    {
        return this->dictionary->get_Values()->GetEnumerator();
    }
    
    bool TryGetValue(const System::String& key, T& value)
    {
        return this->dictionary->TryGetValue(key, value);
    }
    
    /// <summary>
    /// Adds the passed property into collection.
    /// </summary>
    /// <param name="value">The property to add.</param>
    /// <exception cref="ArgumentNullException">is thrown when value is null.</exception>
    void AddInternal(T value)
    {
        if (System::ObjectExt::UnknownIsNull(value))
        {
            throw System::ArgumentNullException(u"value");
        }
        
        this->dictionary->Add(value->get_Name(), value);
    }
    
    /// <summary>
    /// Remove a property from the collection by string key.
    /// </summary>
    /// <param name="key">The property name to remove.</param>
    bool RemoveInternal(const System::String& key)
    {
        return this->dictionary->Remove(key);
    }
    
    /// <summary>
    /// Clears the collection.
    /// </summary>
    virtual void ClearInternal()
    {
        this->dictionary->Clear();
    }
    
    void ThrowIfReadOnly()
    {
        if (this->get_IsReadOnly())
        {
            throw System::NotSupportedException(this->GetType().get_Name() + u" is read-only.");
        }
    }
    
    /// <summary>
    /// Remove a property from the collection.
    /// </summary>
    /// <param name="item">The property to remove.</param>
    bool RemoveInternal(T item)
    {
        System::String key;
        for (auto&& kvp : this->dictionary)
        {
            if (System::ObjectExt::Equals(kvp.get_Value(), item))
            {
                key = kvp.get_Key();
            }
        }
        
        return key != nullptr && this->RemoveInternal(key);
    }
    
    /// <summary>
    /// Sets the property by string key.
    /// </summary>
    /// <param name="key">
    /// The key.
    /// </param>
    /// <param name="value">
    /// The value.
    /// </param>
    virtual void Set(System::String key, T value)
    {
        this->dictionary->idx_set(key, value);
    }
    
    /// <summary>
    /// Gets the property by string key.
    /// </summary>
    /// <param name="key">
    /// The key.
    /// </param>
    virtual T Get(System::String key)
    {
        return this->dictionary->idx_get(key);
    }
    
    virtual ~PropertyKeyedCollection()
    {
    }
    
    #ifdef ASPOSE_GET_SHARED_MEMBERS
    void GetSharedMembers(System::Object::shared_members_type& result) const override
    {
        Aspose::Tasks::Properties::PropertyCollection<T>::GetSharedMembers(result);
        
        result.Add("Aspose::Tasks::Properties::PropertyKeyedCollection::dictionary", this->dictionary);
    }
    #endif
    
    
    
private:
 
    System::SharedPtr<System::Collections::Generic::Dictionary<System::String, T>> dictionary;
    
    /// <inheritdoc ></inheritdoc>
    bool Contains(const T& item) const override
    {
        for (auto&& kvp : this->dictionary)
        {
            if (System::ObjectExt::Equals(kvp.get_Value(), item))
            {
                return true;
            }
        }
        
        return false;
    }
    
    /// <inheritdoc ></inheritdoc>
    bool Remove(const T& item) override
    {
        this->ThrowIfReadOnly();
        return this->RemoveInternal(item);
    }
    
    /// <inheritdoc ></inheritdoc>
    void CopyTo(System::ArrayPtr<T> array, int32_t arrayIndex) override
    {
        this->dictionary->get_Values()->CopyTo(array, arrayIndex);
    }
    
    
};
 
} // namespace Properties
} // namespace Tasks
} // namespace Aspose