MemberProperty.h

#pragma once
 
 
#include <Foundation/Reflection/Implementation/AbstractProperty.h>
#include <Foundation/Reflection/Implementation/StaticRTTI.h>
#include <Foundation/Types/Variant.h>
 
// ***********************************************
// ***** Base class for accessing properties *****
 
 
template <typename Type>
class plTypedMemberProperty : public plAbstractMemberProperty
{
public:
  plTypedMemberProperty(const char* szPropertyName)
    : plAbstractMemberProperty(szPropertyName)
  {
    m_Flags = plPropertyFlags::GetParameterFlags<Type>();
    static_assert(
      !std::is_pointer<Type>::value ||
        plVariant::TypeDeduction<typename plTypeTraits<Type>::NonConstReferencePointerType>::value == plVariantType::Invalid,
      "Pointer to standard types are not supported.");
  }
 
  virtual const plRTTI* GetSpecificType() const override // [tested]
  {
    return plGetStaticRTTI<typename plTypeTraits<Type>::NonConstReferencePointerType>();
  }
 
  virtual Type GetValue(const void* pInstance) const = 0; // [tested]
 
  virtual void SetValue(void* pInstance, Type value) const = 0; // [tested]
 
  virtual void GetValuePtr(const void* pInstance, void* pObject) const override { *static_cast<Type*>(pObject) = GetValue(pInstance); };
  virtual void SetValuePtr(void* pInstance, const void* pObject) const override { SetValue(pInstance, *static_cast<const Type*>(pObject)); };
};
 
template <>
class plTypedMemberProperty<const char*> : public plAbstractMemberProperty
{
public:
  plTypedMemberProperty(const char* szPropertyName)
    : plAbstractMemberProperty(szPropertyName)
  {
    // We treat const char* as a basic type and not a pointer.
    m_Flags = plPropertyFlags::GetParameterFlags<const char*>();
  }
 
  virtual const plRTTI* GetSpecificType() const override // [tested]
  {
    return plGetStaticRTTI<const char*>();
  }
 
  virtual const char* GetValue(const void* pInstance) const = 0;
  virtual void SetValue(void* pInstance, const char* value) const = 0;
  virtual void GetValuePtr(const void* pInstance, void* pObject) const override { *static_cast<const char**>(pObject) = GetValue(pInstance); };
  virtual void SetValuePtr(void* pInstance, const void* pObject) const override { SetValue(pInstance, *static_cast<const char* const*>(pObject)); };
};
 
 
// *******************************************************************
// ***** Class for properties that use custom accessor functions *****
 
template <typename Class, typename Type>
class plAccessorProperty : public plTypedMemberProperty<typename plTypeTraits<Type>::NonConstReferenceType>
{
public:
  using RealType = typename plTypeTraits<Type>::NonConstReferenceType;
  using GetterFunc = Type (Class::*)() const;
  using SetterFunc = void (Class::*)(Type value);
 
  plAccessorProperty(const char* szPropertyName, GetterFunc getter, SetterFunc setter)
    : plTypedMemberProperty<RealType>(szPropertyName)
  {
    PL_ASSERT_DEBUG(getter != nullptr, "The getter of a property cannot be nullptr.");
 
    m_Getter = getter;
    m_Setter = setter;
 
    if (m_Setter == nullptr)
      plAbstractMemberProperty::m_Flags.Add(plPropertyFlags::ReadOnly);
  }
 
  virtual void* GetPropertyPointer(const void* pInstance) const override
  {
    // No access to sub-properties, if we have accessors for this property
    return nullptr;
  }
 
  virtual RealType GetValue(const void* pInstance) const override // [tested]
  {
    return (static_cast<const Class*>(pInstance)->*m_Getter)();
  }
 
  virtual void SetValue(void* pInstance, RealType value) const override // [tested]
  {
    PL_ASSERT_DEV(m_Setter != nullptr, "The property '{0}' has no setter function, thus it is read-only.", plAbstractProperty::GetPropertyName());
 
    if (m_Setter)
      (static_cast<Class*>(pInstance)->*m_Setter)(value);
  }
 
private:
  GetterFunc m_Getter;
  SetterFunc m_Setter;
};
 
 
// *************************************************************
// ***** Classes for properties that are accessed directly *****
 
template <typename Class, typename Type, Type Class::*Member>
struct plPropertyAccessor
{
  static Type GetValue(const Class* pInstance) { return (*pInstance).*Member; }
 
  static void SetValue(Class* pInstance, Type value) { (*pInstance).*Member = value; }
 
  static void* GetPropertyPointer(const Class* pInstance) { return (void*)&((*pInstance).*Member); }
};
 
 
template <typename Class, typename Type>
class plMemberProperty : public plTypedMemberProperty<Type>
{
public:
  using GetterFunc = Type (*)(const Class* pInstance);
  using SetterFunc = void (*)(Class* pInstance, Type value);
  using PointerFunc = void* (*)(const Class* pInstance);
 
  plMemberProperty(const char* szPropertyName, GetterFunc getter, SetterFunc setter, PointerFunc pointer)
    : plTypedMemberProperty<Type>(szPropertyName)
  {
    PL_ASSERT_DEBUG(getter != nullptr, "The getter of a property cannot be nullptr.");
 
    m_Getter = getter;
    m_Setter = setter;
    m_Pointer = pointer;
 
    if (m_Setter == nullptr)
      plAbstractMemberProperty::m_Flags.Add(plPropertyFlags::ReadOnly);
  }
 
  virtual void* GetPropertyPointer(const void* pInstance) const override { return m_Pointer(static_cast<const Class*>(pInstance)); }
 
  virtual Type GetValue(const void* pInstance) const override { return m_Getter(static_cast<const Class*>(pInstance)); }
 
  virtual void SetValue(void* pInstance, Type value) const override
  {
    PL_ASSERT_DEV(m_Setter != nullptr, "The property '{0}' has no setter function, thus it is read-only.", plAbstractProperty::GetPropertyName());
 
    if (m_Setter)
      m_Setter(static_cast<Class*>(pInstance), value);
  }
 
private:
  GetterFunc m_Getter;
  SetterFunc m_Setter;
  PointerFunc m_Pointer;
};