AbstractProperty.h

#pragma once
 
 
#include <Foundation/Basics.h>
 
#include <Foundation/Containers/HashSet.h>
#include <Foundation/Containers/HashTable.h>
#include <Foundation/Containers/Map.h>
#include <Foundation/Containers/Set.h>
#include <Foundation/Containers/SmallArray.h>
#include <Foundation/Containers/StaticArray.h>
#include <Foundation/Reflection/Implementation/RTTI.h>
#include <Foundation/Types/Bitflags.h>
#include <Foundation/Types/Enum.h>
 
class plRTTI;
class plPropertyAttribute;
 
template <typename T>
struct plIsBitflags
{
  static constexpr bool value = false;
};
 
template <typename T>
struct plIsBitflags<plBitflags<T>>
{
  static constexpr bool value = true;
};
 
template <typename T>
struct plIsEnum
{
  static constexpr bool value = std::is_enum<T>::value;
};
 
template <typename T>
struct plIsEnum<plEnum<T>>
{
  static constexpr bool value = true;
};
 
struct plPropertyFlags
{
  using StorageType = plUInt16;
 
  enum Enum : plUInt16
  {
    StandardType = PL_BIT(0), 
    IsEnum = PL_BIT(1),       
    Bitflags = PL_BIT(2),     
    Class = PL_BIT(3),        
 
    Const = PL_BIT(4),        
    Reference = PL_BIT(5),    
    Pointer = PL_BIT(6),      
 
    PointerOwner = PL_BIT(7), 
    ReadOnly = PL_BIT(8),     
    Hidden = PL_BIT(9),       
    Phantom = PL_BIT(10),     
 
    VarOut = PL_BIT(11),      
    VarInOut = PL_BIT(12),    
 
    Default = 0,
    Void = 0
  };
 
  struct Bits
  {
    StorageType StandardType : 1;
    StorageType IsEnum : 1;
    StorageType Bitflags : 1;
    StorageType Class : 1;
 
    StorageType Const : 1;
    StorageType Reference : 1;
    StorageType Pointer : 1;
 
    StorageType PointerOwner : 1;
    StorageType ReadOnly : 1;
    StorageType Hidden : 1;
    StorageType Phantom : 1;
  };
 
  template <class Type>
  static plBitflags<plPropertyFlags> GetParameterFlags()
  {
    using CleanType = typename plTypeTraits<Type>::NonConstReferencePointerType;
    plBitflags<plPropertyFlags> flags;
    constexpr plVariantType::Enum type = static_cast<plVariantType::Enum>(plVariantTypeDeduction<CleanType>::value);
    if constexpr (std::is_same<CleanType, plVariant>::value ||
                  std::is_same<Type, const char*>::value || // We treat const char* as a basic type and not a pointer.
                  (type >= plVariantType::FirstStandardType && type <= plVariantType::LastStandardType))
      flags.Add(plPropertyFlags::StandardType);
    else if constexpr (plIsEnum<CleanType>::value)
      flags.Add(plPropertyFlags::IsEnum);
    else if constexpr (plIsBitflags<CleanType>::value)
      flags.Add(plPropertyFlags::Bitflags);
    else
      flags.Add(plPropertyFlags::Class);
 
    if constexpr (std::is_const<typename plTypeTraits<Type>::NonReferencePointerType>::value)
      flags.Add(plPropertyFlags::Const);
 
    if constexpr (std::is_pointer<Type>::value && !std::is_same<Type, const char*>::value)
      flags.Add(plPropertyFlags::Pointer);
 
    if constexpr (std::is_reference<Type>::value)
      flags.Add(plPropertyFlags::Reference);
 
    return flags;
  }
};
 
template <>
inline plBitflags<plPropertyFlags> plPropertyFlags::GetParameterFlags<void>()
{
  return plBitflags<plPropertyFlags>();
}
 
PL_DECLARE_FLAGS_OPERATORS(plPropertyFlags)
 
 
struct plPropertyCategory
{
  using StorageType = plUInt8;
 
  enum Enum
  {
    Constant, 
    Member,   
    Function, 
    Array,    
    Set,      
    Map,      
    Default = Member
  };
};
 
class PL_FOUNDATION_DLL plAbstractProperty
{
public:
  plAbstractProperty(const char* szPropertyName) { m_szPropertyName = szPropertyName; }
 
  virtual ~plAbstractProperty() = default;
 
  const char* GetPropertyName() const { return m_szPropertyName; }
 
  virtual const plRTTI* GetSpecificType() const = 0;
 
  virtual plPropertyCategory::Enum GetCategory() const = 0; // [tested]
 
  const plBitflags<plPropertyFlags>& GetFlags() const { return m_Flags; };
 
  plAbstractProperty* AddFlags(plBitflags<plPropertyFlags> flags)
  {
    m_Flags.Add(flags);
    return this;
  };
 
  plAbstractProperty* AddAttributes(plPropertyAttribute* pAttrib1, plPropertyAttribute* pAttrib2 = nullptr, plPropertyAttribute* pAttrib3 = nullptr,
    plPropertyAttribute* pAttrib4 = nullptr, plPropertyAttribute* pAttrib5 = nullptr, plPropertyAttribute* pAttrib6 = nullptr)
  {
    PL_ASSERT_DEV(pAttrib1 != nullptr, "invalid attribute");
 
    m_Attributes.PushBack(pAttrib1);
    if (pAttrib2)
      m_Attributes.PushBack(pAttrib2);
    if (pAttrib3)
      m_Attributes.PushBack(pAttrib3);
    if (pAttrib4)
      m_Attributes.PushBack(pAttrib4);
    if (pAttrib5)
      m_Attributes.PushBack(pAttrib5);
    if (pAttrib6)
      m_Attributes.PushBack(pAttrib6);
    return this;
  };
 
  plArrayPtr<const plPropertyAttribute* const> GetAttributes() const { return m_Attributes; }
 
  template <typename Type>
  const Type* GetAttributeByType() const;
 
protected:
  plBitflags<plPropertyFlags> m_Flags;
  const char* m_szPropertyName;
  plHybridArray<const plPropertyAttribute*, 2, plStaticsAllocatorWrapper> m_Attributes; // Do not track RTTI data.
};
 
class PL_FOUNDATION_DLL plAbstractConstantProperty : public plAbstractProperty
{
public:
  plAbstractConstantProperty(const char* szPropertyName)
    : plAbstractProperty(szPropertyName)
  {
  }
 
  virtual plPropertyCategory::Enum GetCategory() const override { return plPropertyCategory::Constant; } // [tested]
 
  virtual void* GetPropertyPointer() const = 0;
 
  virtual plVariant GetConstant() const = 0;
};
 
class PL_FOUNDATION_DLL plAbstractMemberProperty : public plAbstractProperty
{
public:
  plAbstractMemberProperty(const char* szPropertyName)
    : plAbstractProperty(szPropertyName)
  {
  }
 
  virtual plPropertyCategory::Enum GetCategory() const override { return plPropertyCategory::Member; }
 
  virtual void* GetPropertyPointer(const void* pInstance) const = 0;
 
  virtual void GetValuePtr(const void* pInstance, void* out_pObject) const = 0;
 
  virtual void SetValuePtr(void* pInstance, const void* pObject) const = 0;
};
 
 
class PL_FOUNDATION_DLL plAbstractArrayProperty : public plAbstractProperty
{
public:
  plAbstractArrayProperty(const char* szPropertyName)
    : plAbstractProperty(szPropertyName)
  {
  }
 
  virtual plPropertyCategory::Enum GetCategory() const override { return plPropertyCategory::Array; }
 
  virtual plUInt32 GetCount(const void* pInstance) const = 0;
 
  virtual void GetValue(const void* pInstance, plUInt32 uiIndex, void* pObject) const = 0;
 
  virtual void SetValue(void* pInstance, plUInt32 uiIndex, const void* pObject) const = 0;
 
  virtual void Insert(void* pInstance, plUInt32 uiIndex, const void* pObject) const = 0;
 
  virtual void Remove(void* pInstance, plUInt32 uiIndex) const = 0;
 
  virtual void Clear(void* pInstance) const = 0;
 
  virtual void SetCount(void* pInstance, plUInt32 uiCount) const = 0;
 
  virtual void* GetValuePointer(void* pInstance, plUInt32 uiIndex) const { return nullptr; }
};
 
 
class PL_FOUNDATION_DLL plAbstractSetProperty : public plAbstractProperty
{
public:
  plAbstractSetProperty(const char* szPropertyName)
    : plAbstractProperty(szPropertyName)
  {
  }
 
  virtual plPropertyCategory::Enum GetCategory() const override { return plPropertyCategory::Set; }
 
  virtual bool IsEmpty(const void* pInstance) const = 0;
 
  virtual void Clear(void* pInstance) const = 0;
 
  virtual void Insert(void* pInstance, const void* pObject) const = 0;
 
  virtual void Remove(void* pInstance, const void* pObject) const = 0;
 
  virtual bool Contains(const void* pInstance, const void* pObject) const = 0;
 
  virtual void GetValues(const void* pInstance, plDynamicArray<plVariant>& out_keys) const = 0;
};
 
 
class PL_FOUNDATION_DLL plAbstractMapProperty : public plAbstractProperty
{
public:
  plAbstractMapProperty(const char* szPropertyName)
    : plAbstractProperty(szPropertyName)
  {
  }
 
  virtual plPropertyCategory::Enum GetCategory() const override { return plPropertyCategory::Map; }
 
  virtual bool IsEmpty(const void* pInstance) const = 0;
 
  virtual void Clear(void* pInstance) const = 0;
 
  virtual void Insert(void* pInstance, const char* szKey, const void* pObject) const = 0;
 
  virtual void Remove(void* pInstance, const char* szKey) const = 0;
 
  virtual bool Contains(const void* pInstance, const char* szKey) const = 0;
 
  virtual bool GetValue(const void* pInstance, const char* szKey, void* pObject) const = 0;
 
  virtual void GetKeys(const void* pInstance, plHybridArray<plString, 16>& out_keys) const = 0;
};
 
template <int _Index, class... Args>
struct getArgument;
 
template <class Head, class... Tail>
struct getArgument<0, Head, Tail...>
{
  using Type = Head;
};
 
template <int _Index, class Head, class... Tail>
struct getArgument<_Index, Head, Tail...>
{
  using Type = typename getArgument<_Index - 1, Tail...>::Type;
};
 
template <int I, typename FUNC>
struct plFunctionParameterTypeResolver
{
};
 
template <int I, typename R, typename... P>
struct plFunctionParameterTypeResolver<I, R (*)(P...)>
{
  enum Constants
  {
    Arguments = sizeof...(P),
  };
  static_assert(I < Arguments, "I needs to be smaller than the number of function parameters.");
  using ParameterType = typename getArgument<I, P...>::Type;
  using ReturnType = R;
};
 
template <int I, class Class, typename R, typename... P>
struct plFunctionParameterTypeResolver<I, R (Class::*)(P...)>
{
  enum Constants
  {
    Arguments = sizeof...(P),
  };
  static_assert(I < Arguments, "I needs to be smaller than the number of function parameters.");
  using ParameterType = typename getArgument<I, P...>::Type;
  using ReturnType = R;
};
 
template <int I, class Class, typename R, typename... P>
struct plFunctionParameterTypeResolver<I, R (Class::*)(P...) const>
{
  enum Constants
  {
    Arguments = sizeof...(P),
  };
  static_assert(I < Arguments, "I needs to be smaller than the number of function parameters.");
  using ParameterType = typename getArgument<I, P...>::Type;
  using ReturnType = R;
};
 
template <typename FUNC>
struct plMemberFunctionParameterTypeResolver
{
};
 
template <class Class, typename R, typename P>
struct plMemberFunctionParameterTypeResolver<R (Class::*)(P)>
{
  using ParameterType = P;
  using ReturnType = R;
};
 
template <typename CONTAINER>
struct plContainerSubTypeResolver
{
};
 
template <typename T>
struct plContainerSubTypeResolver<plArrayPtr<T>>
{
  using Type = typename plTypeTraits<T>::NonConstReferenceType;
};
 
template <typename T>
struct plContainerSubTypeResolver<plDynamicArray<T>>
{
  using Type = typename plTypeTraits<T>::NonConstReferenceType;
};
 
template <typename T, plUInt32 Size>
struct plContainerSubTypeResolver<plHybridArray<T, Size>>
{
  using Type = typename plTypeTraits<T>::NonConstReferenceType;
};
 
template <typename T, plUInt32 Size>
struct plContainerSubTypeResolver<plStaticArray<T, Size>>
{
  using Type = typename plTypeTraits<T>::NonConstReferenceType;
};
 
template <typename T, plUInt16 Size>
struct plContainerSubTypeResolver<plSmallArray<T, Size>>
{
  using Type = typename plTypeTraits<T>::NonConstReferenceType;
};
 
template <typename T>
struct plContainerSubTypeResolver<plDeque<T>>
{
  using Type = typename plTypeTraits<T>::NonConstReferenceType;
};
 
template <typename T>
struct plContainerSubTypeResolver<plSet<T>>
{
  using Type = typename plTypeTraits<T>::NonConstReferenceType;
};
 
template <typename T>
struct plContainerSubTypeResolver<plHashSet<T>>
{
  using Type = typename plTypeTraits<T>::NonConstReferenceType;
};
 
template <typename K, typename T>
struct plContainerSubTypeResolver<plHashTable<K, T>>
{
  using Type = typename plTypeTraits<T>::NonConstReferenceType;
};
 
template <typename K, typename T>
struct plContainerSubTypeResolver<plMap<K, T>>
{
  using Type = typename plTypeTraits<T>::NonConstReferenceType;
};
 
 
struct plFunctionType
{
  using StorageType = plUInt8;
 
  enum Enum
  {
    Member,       
    StaticMember, 
    Constructor,  
    Default = Member
  };
};
 
class PL_FOUNDATION_DLL plAbstractFunctionProperty : public plAbstractProperty
{
public:
  plAbstractFunctionProperty(const char* szPropertyName)
    : plAbstractProperty(szPropertyName)
  {
  }
 
  virtual plPropertyCategory::Enum GetCategory() const override { return plPropertyCategory::Function; }
  virtual plFunctionType::Enum GetFunctionType() const = 0;
  virtual const plRTTI* GetReturnType() const = 0;
  virtual plBitflags<plPropertyFlags> GetReturnFlags() const = 0;
  virtual plUInt32 GetArgumentCount() const = 0;
  virtual const plRTTI* GetArgumentType(plUInt32 uiParamIndex) const = 0;
  virtual plBitflags<plPropertyFlags> GetArgumentFlags(plUInt32 uiParamIndex) const = 0;
 
  virtual void Execute(void* pInstance, plArrayPtr<plVariant> arguments, plVariant& out_returnValue) const = 0;
 
  virtual const plRTTI* GetSpecificType() const override { return GetReturnType(); }
 
  plAbstractFunctionProperty* AddFlags(plBitflags<plPropertyFlags> flags)
  {
    return static_cast<plAbstractFunctionProperty*>(plAbstractProperty::AddFlags(flags));
  }
 
  plAbstractFunctionProperty* AddAttributes(plPropertyAttribute* pAttrib1, plPropertyAttribute* pAttrib2 = nullptr, plPropertyAttribute* pAttrib3 = nullptr,
    plPropertyAttribute* pAttrib4 = nullptr, plPropertyAttribute* pAttrib5 = nullptr, plPropertyAttribute* pAttrib6 = nullptr)
  {
    return static_cast<plAbstractFunctionProperty*>(plAbstractProperty::AddAttributes(pAttrib1, pAttrib2, pAttrib3, pAttrib4, pAttrib5, pAttrib6));
  }
};