ReflectionUtils.h

#pragma once
 
#include <Foundation/Containers/Set.h>
#include <Foundation/Reflection/Reflection.h>
 
class plVariant;
class plAbstractProperty;
 
class PL_FOUNDATION_DLL plReflectionUtils
{
public:
  static const plRTTI* GetCommonBaseType(const plRTTI* pRtti1, const plRTTI* pRtti2);
 
  static bool IsBasicType(const plRTTI* pRtti);
 
  static bool IsValueType(const plAbstractProperty* pProp);
 
  static const plRTTI* GetTypeFromVariant(const plVariant& value);
  static const plRTTI* GetTypeFromVariant(plVariantType::Enum type);
 
  static plUInt32 GetComponentCount(plVariantType::Enum type);
  static void SetComponent(plVariant& ref_vector, plUInt32 uiComponent, double fValue);                             // [tested]
  static double GetComponent(const plVariant& vector, plUInt32 uiComponent);
 
  static plVariant GetMemberPropertyValue(const plAbstractMemberProperty* pProp, const void* pObject);              // [tested] via ToolsFoundation
  static void SetMemberPropertyValue(const plAbstractMemberProperty* pProp, void* pObject, const plVariant& value); // [tested] via ToolsFoundation
 
  static plVariant GetArrayPropertyValue(const plAbstractArrayProperty* pProp, const void* pObject, plUInt32 uiIndex);
  static void SetArrayPropertyValue(const plAbstractArrayProperty* pProp, void* pObject, plUInt32 uiIndex, const plVariant& value);
 
  static void InsertSetPropertyValue(const plAbstractSetProperty* pProp, void* pObject, const plVariant& value);
  static void RemoveSetPropertyValue(const plAbstractSetProperty* pProp, void* pObject, const plVariant& value);
 
  static plVariant GetMapPropertyValue(const plAbstractMapProperty* pProp, const void* pObject, const char* szKey);
  static void SetMapPropertyValue(const plAbstractMapProperty* pProp, void* pObject, const char* szKey, const plVariant& value);
 
  static void InsertArrayPropertyValue(const plAbstractArrayProperty* pProp, void* pObject, const plVariant& value, plUInt32 uiIndex);
  static void RemoveArrayPropertyValue(const plAbstractArrayProperty* pProp, void* pObject, plUInt32 uiIndex);
 
  static const plAbstractMemberProperty* GetMemberProperty(const plRTTI* pRtti, plUInt32 uiPropertyIndex);
  static const plAbstractMemberProperty* GetMemberProperty(const plRTTI* pRtti, const char* szPropertyName); // [tested] via ToolsFoundation
 
  static void GatherTypesDerivedFromClass(const plRTTI* pRtti, plSet<const plRTTI*>& out_types);
 
  static void GatherDependentTypes(const plRTTI* pRtti, plSet<const plRTTI*>& inout_typesAsSet, plDynamicArray<const plRTTI*>* out_pTypesAsStack = nullptr);
 
  static plResult CreateDependencySortedTypeArray(const plSet<const plRTTI*>& types, plDynamicArray<const plRTTI*>& out_sortedTypes);
 
  struct EnumConversionMode
  {
    enum Enum
    {
      FullyQualifiedName,
      ValueNameOnly,
      Default = FullyQualifiedName
    };
 
    using StorageType = plUInt8;
  };
 
  static bool EnumerationToString(const plRTTI* pEnumerationRtti, plInt64 iValue, plStringBuilder& out_sOutput,
    plEnum<EnumConversionMode> conversionMode = EnumConversionMode::Default); // [tested]
 
  template <typename T>
  static bool EnumerationToString(plEnum<T> value, plStringBuilder& out_sOutput, plEnum<EnumConversionMode> conversionMode = EnumConversionMode::Default)
  {
    return EnumerationToString(plGetStaticRTTI<T>(), value.GetValue(), out_sOutput, conversionMode);
  }
 
  template <typename T>
  static bool BitflagsToString(plBitflags<T> value, plStringBuilder& out_sOutput, plEnum<EnumConversionMode> conversionMode = EnumConversionMode::Default)
  {
    return EnumerationToString(plGetStaticRTTI<T>(), value.GetValue(), out_sOutput, conversionMode);
  }
 
  struct EnumKeyValuePair
  {
    plString m_sKey;
    plInt32 m_iValue = 0;
  };
 
  static void GetEnumKeysAndValues(const plRTTI* pEnumerationRtti, plDynamicArray<EnumKeyValuePair>& ref_entries, plEnum<EnumConversionMode> conversionMode = EnumConversionMode::Default);
 
  static bool StringToEnumeration(const plRTTI* pEnumerationRtti, const char* szValue, plInt64& out_iValue); // [tested]
 
  template <typename T>
  static bool StringToEnumeration(const char* szValue, plEnum<T>& out_value)
  {
    plInt64 value;
    const auto retval = StringToEnumeration(plGetStaticRTTI<T>(), szValue, value);
    out_value = static_cast<typename T::Enum>(value);
    return retval;
  }
 
  static plInt64 DefaultEnumerationValue(const plRTTI* pEnumerationRtti); // [tested]
 
  static plInt64 MakeEnumerationValid(const plRTTI* pEnumerationRtti, plInt64 iValue); // [tested]
 
  template <typename T>
  static bool IsEqual(const T* pObject, const T* pObject2)
  {
    return IsEqual(pObject, pObject2, plGetStaticRTTI<T>());
  }
 
  static bool IsEqual(const void* pObject, const void* pObject2, const plRTTI* pType); // [tested]
 
  static bool IsEqual(const void* pObject, const void* pObject2, const plAbstractProperty* pProp);
 
  static void DeleteObject(void* pObject, const plAbstractProperty* pOwnerProperty);
 
  static plVariant GetDefaultVariantFromType(plVariant::Type::Enum type); // [tested]
 
  static plVariant GetDefaultVariantFromType(const plRTTI* pRtti);
 
  static plVariant GetDefaultValue(const plAbstractProperty* pProperty, plVariant index = plVariant());
 
 
  static void SetAllMemberPropertiesToDefault(const plRTTI* pRtti, void* pObject);
 
  static plResult ClampValue(plVariant& value, const plClampValueAttribute* pAttrib);
};