PropertyContainer.h

#pragma once
//-----------------------------------------------------------------------
// <copyright file="PropertyContainer.cs" company="Aspose Pty Ltd">
//   Copyright (c) 2002-2024 Aspose Pty Ltd. All Rights Reserved.
// </copyright>
//-----------------------------------------------------------------------
 
#include <system/exceptions.h>
#include <system/constraints.h>
#include <system/array.h>
 
#include "aspose.tasks.cpp/Item.h"
#include "aspose.tasks.cpp/IContainer.h"
#include "aspose.tasks.cpp/EntityPropertyItem.h"
#include "aspose.tasks.cpp/Key.h"
#include "aspose.tasks.cpp/aspose_tasks_api_defs.h"
 
namespace Aspose {
 
namespace Tasks {
 
/// <summary>
/// Represents property container.
/// </summary>
template<typename T>
class ASPOSE_TASKS_SHARED_CLASS PropertyContainer : public Aspose::Tasks::IContainer<T>
{
    assert_is_cs_struct(T);
    
    typedef PropertyContainer<T> ThisType;
    typedef Aspose::Tasks::IContainer<T> BaseType;
    
    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
    RTTI_INFO_TEMPLATE_CLASS(ThisType, ThisTypeBaseTypesInfo);
    
    template<typename FT0> friend class Aspose::Tasks::PropertyContainer;
    
public:
 
    PropertyContainer()
    {
        this->map = System::MakeArray<System::SharedPtr<Aspose::Tasks::Item>>(ItemsCount());
        
    }
    
    PropertyContainer(const System::SharedPtr<PropertyContainer<T>>& propertyContainer)
    {
        this->map = System::MakeArray<System::SharedPtr<Aspose::Tasks::Item>>(ItemsCount());
        
        if (propertyContainer == nullptr)
        {
            throw System::ArgumentNullException(u"propertyContainer");
        }
        
        if (propertyContainer->map->get_Length() != ItemsCount())
        {
            throw System::InvalidOperationException(u"Enum size");
        }
        
        this->map = System::MakeArray<System::SharedPtr<Aspose::Tasks::Item>>(propertyContainer->map->get_Length());
        
        for (int32_t i = 0; i < this->map->get_Length(); i++)
        {
            auto containerMap = propertyContainer->map[i];
            if (containerMap != nullptr)
            {
                this->map[i] = containerMap->Clone();
            }
        }
    }
    
    template <typename TValue>
    void Set(const Key<TValue, T>& key, const TValue& val)
    {
        this->template CheckPropAndSet<TValue>(key, val);
    }
    
    /// <summary>
    /// Maps the specified property to the specified value in this container.
    /// If this container doesn't contain record ProjectItem it will be added.
    /// </summary>
    /// <param name="key">the specified property.</param>
    /// <param name="val">the value.</param>
    template <typename TValue>
    void CheckPropAndSet(const Key<TValue, T>& key, const TValue& val)
    {
        auto& item = this->map->data_ptr()[key.get_KeyTypeIndex()];
        if (!item)
        {
            item = System::MakeObject<EntityProperty<TValue>>(val);
        }
        else
        {
            static_cast<EntityProperty<TValue>*>(item.get())->UpdateValue(val);
        }
        
    }
    template <typename TValue>
    System::MakeConstRef_t<TValue> Get(const Key<TValue, T>& key)
    {
        return this->template CheckPropAndGet<TValue>(key);
    }
    
    /// <summary>
    /// Returns the value to which the property is mapped in this container.
    /// If this container doesn't contain record ProjectItem it will be added with default value and default value will be returned.
    /// </summary>
    /// <param name="key">the specified property.</param>
    /// <returns>the value to which the property is mapped in this container or default value for property.</returns>
    template <typename TValue>
    System::MakeConstRef_t<TValue> CheckPropAndGet(const Key<TValue, T>& key)
    {
        auto& item = this->map->data_ptr()[key.get_KeyTypeIndex()];
        if (!item)
        {
           item = System::MakeObject<EntityProperty<TValue>>();
        }
        return static_cast<EntityProperty<TValue>*>(item.get())->get_Val();
        
    }
    template <typename TValue>
    void Add(const Key<TValue, T>& key, const System::SharedPtr<Item>& val)
    {
        this->map[key.get_KeyTypeIndex()] = val;
    }
    
    void SetTemplateWeakPtr(uint32_t argument) override
    {
        switch (argument)
        {
            case 0:
                break;
                
        }
    }
    
protected:
 
    #ifdef ASPOSE_GET_SHARED_MEMBERS
    void GetSharedMembers(System::Object::shared_members_type& result) const override
    {
        System::Object::GetSharedMembers(result);
        
        result.Add("Aspose::Tasks::PropertyContainer::map", this->map);
    }
    #endif
    
    
    
private:
 
    static int32_t& ItemsCount()
    {
        static int32_t value;
        static std::once_flag once;
        std::call_once(once, []
        {
            value = System::Enum<T>::GetValues()->get_Length();
        });
        return value;
    }
    
    System::ArrayPtr<System::SharedPtr<Item>> map;
    
};
 
} // namespace Tasks
} // namespace Aspose