Key.h

#pragma once
//-----------------------------------------------------------------------
// <copyright file="Key.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/details/pointer_collection_helpers.h>
#include <system/constraints.h>
#include <cstdint>
 
namespace Aspose
{
namespace Tasks
{
class Asn;
namespace Connectivity
{
class MspAssn;
class MspAssnBaseLine;
class MspCal;
class MspExtAttr;
class MspTsk;
class MspTskBaseLine;
class MspTskLink;
class PmCal;
class PmCurr;
class PmRsc;
class PmRscRate;
class PmTaskLink;
} // namespace Connectivity
namespace IO
{
namespace MSProject
{
template <typename, typename> class FieldItem;
} // namespace MSProject
namespace Pwa
{
namespace InternalApi
{
class InternalApiProjectWriter;
namespace Mapping
{
class ProjectGuidPropertyMapper;
} // namespace Mapping
} // namespace InternalApi
} // namespace Pwa
} // namespace IO
class Prj;
namespace Properties
{
class BuiltInProjectProperty;
} // namespace Properties
template <typename> class PropertyContainer;
class Rsc;
class Task;
class Tsk;
} // namespace Tasks
} // namespace Aspose
 
namespace Aspose {
 
namespace Tasks {
 
/// <summary>
/// Represents a property key of a class of the specified type.
/// An instance of this class is used when getting or setting property of a container.
/// </summary>
/// <typeparam name="T">The type of property value.</typeparam>
/// <typeparam name="K">The type of property key.</typeparam>
template<typename T, typename K>
class Key : public System::Object, public System::Details::BoxableObjectBase
{
    assert_is_cs_struct(K);
    
    typedef Key<T, K> ThisType;
    typedef System::Object BaseType;
    
    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
    RTTI_INFO_TEMPLATE_CLASS(ThisType, ThisTypeBaseTypesInfo);
    
    friend class Aspose::Tasks::Asn;
    friend class Aspose::Tasks::Task;
    friend class Aspose::Tasks::IO::Pwa::InternalApi::Mapping::ProjectGuidPropertyMapper;
    friend class Aspose::Tasks::Properties::BuiltInProjectProperty;
    friend class Aspose::Tasks::IO::Pwa::InternalApi::InternalApiProjectWriter;
    template<typename FT0> friend class Aspose::Tasks::PropertyContainer;
    friend class Aspose::Tasks::Connectivity::MspAssn;
    friend class Aspose::Tasks::Connectivity::MspAssnBaseLine;
    friend class Aspose::Tasks::Connectivity::MspCal;
    friend class Aspose::Tasks::Connectivity::MspExtAttr;
    friend class Aspose::Tasks::Connectivity::MspTsk;
    friend class Aspose::Tasks::Connectivity::MspTskBaseLine;
    friend class Aspose::Tasks::Connectivity::MspTskLink;
    friend class Aspose::Tasks::Connectivity::PmCal;
    friend class Aspose::Tasks::Connectivity::PmCurr;
    friend class Aspose::Tasks::Connectivity::PmRsc;
    friend class Aspose::Tasks::Connectivity::PmRscRate;
    friend class Aspose::Tasks::Connectivity::PmTaskLink;
    template<typename FT0, typename FT1> friend class Aspose::Tasks::IO::MSProject::FieldItem;
    template<typename FT0, typename FT1> friend class Aspose::Tasks::IO::MSProject::FieldItem;
    friend class Aspose::Tasks::Prj;
    friend class Aspose::Tasks::Rsc;
    friend class Aspose::Tasks::Tsk;
    template<typename FT0, typename FT1> friend class Aspose::Tasks::Key;
    template<typename FT0, typename FT1> friend
    bool operator ==(Key<FT0, FT1> k1, Key<FT0, FT1> k2);
    template<typename FT0, typename FT1> friend
    bool operator !=(Key<FT0, FT1> k1, Key<FT0, FT1> k2);
    
public:
 
    /// <summary>
    /// Gets the key of the property.
    /// </summary>
    K get_KeyType() const
    {
        return (*this).keyType;
    }
    
    Key() : keyTypeIndex(0), propCategory(0), keyType(K())
    {
    }
    
    void SetTemplateWeakPtr(uint32_t argument) override
    {
        switch (argument)
        {
            case 0:
                break;
                
            case 1:
                System::Details::CollectionHelpers::SetWeakPointer(keyType);
                break;
                
        }
    }
    
protected:
 
    int32_t get_KeyTypeIndex() const
    {
        return (*this).keyTypeIndex;
    }
    
    uint8_t get_PropCategory() const
    {
        return (*this).propCategory;
    }
    
    System::String get_KeyName()
    {
        return System::ObjectExt::ToString((*this).keyType);
    }
    
    Key(K keyType) : Key(keyType, 0)
    {
    }
    
    MEMBER_FUNCTION_MAKE_OBJECT(Key, CODEPORTING_ARGS(K keyType), CODEPORTING_ARGS(keyType));
    
    Key(K keyType, uint8_t category) : keyTypeIndex(0), propCategory(0), keyType(K())
    {
        (*this).keyType = keyType;
        (*this).propCategory = category;
        (*this).keyTypeIndex = (uint8_t)keyType;
    }
    
    MEMBER_FUNCTION_MAKE_OBJECT(Key, CODEPORTING_ARGS(K keyType, uint8_t category), CODEPORTING_ARGS(keyType,category));
    template <typename TC>
    bool IsEqual(Key<TC, K> key)
    {
        return (*this).get_KeyTypeIndex() == key.get_KeyTypeIndex() && System::ObjectExt::GetType<T>() == System::ObjectExt::GetType<TC>();
    }
    
    #ifdef ASPOSE_GET_SHARED_MEMBERS
    void GetSharedMembers(System::Object::shared_members_type& result) const override
    {
        System::Object::GetSharedMembers(result);
        
        result.Add("Aspose::Tasks::Key::keyType", this->keyType);
    }
    #endif
    
    
    
private:
 
    uint8_t keyTypeIndex;
    uint8_t propCategory;
    
    static System::TypeInfo& UnderlyingType()
    {
        static System::TypeInfo value;
        static std::once_flag once;
        std::call_once(once, []
        {
            value = System::Enum<K>::GetUnderlyingType();
        });
        return value;
    }
    
    K keyType;
    
};
 
template<typename T, typename K>
bool operator ==(Key<T, K> k1, Key<T, K> k2)
{
    return System::ObjectExt::Equals(k1.keyType, k2.keyType);
}
 
template<typename T, typename K>
bool operator !=(Key<T, K> k1, Key<T, K> k2)
{
    return !System::ObjectExt::Equals(k1.keyType, k2.keyType);
}
 
 
} // namespace Tasks
} // namespace Aspose