SetProperty.h

#pragma once
 
 
#include <Foundation/Reflection/Implementation/AbstractProperty.h>
 
template <typename Type>
class plTypedSetProperty : public plAbstractSetProperty
{
public:
  plTypedSetProperty(const char* szPropertyName)
    : plAbstractSetProperty(szPropertyName)
  {
    m_Flags = plPropertyFlags::GetParameterFlags<Type>();
  }
 
  virtual const plRTTI* GetSpecificType() const override { return plGetStaticRTTI<typename plTypeTraits<Type>::NonConstReferencePointerType>(); }
};
 
template <>
class plTypedSetProperty<const char*> : public plAbstractSetProperty
{
public:
  plTypedSetProperty(const char* szPropertyName)
    : plAbstractSetProperty(szPropertyName)
  {
    m_Flags = plPropertyFlags::GetParameterFlags<const char*>();
  }
 
  virtual const plRTTI* GetSpecificType() const override { return plGetStaticRTTI<const char*>(); }
};
 
 
template <typename Class, typename Type, typename Container>
class plAccessorSetProperty : public plTypedSetProperty<Type>
{
public:
  using ContainerType = typename plTypeTraits<Container>::NonConstReferenceType;
  using RealType = typename plTypeTraits<Type>::NonConstReferenceType;
 
  using InsertFunc = void (Class::*)(Type value);
  using RemoveFunc = void (Class::*)(Type value);
  using GetValuesFunc = Container (Class::*)() const;
 
  plAccessorSetProperty(const char* szPropertyName, GetValuesFunc getValues, InsertFunc insert, RemoveFunc remove)
    : plTypedSetProperty<Type>(szPropertyName)
  {
    PL_ASSERT_DEBUG(getValues != nullptr, "The get values function of an set property cannot be nullptr.");
 
    m_GetValues = getValues;
    m_Insert = insert;
    m_Remove = remove;
 
    if (m_Insert == nullptr || m_Remove == nullptr)
      plAbstractSetProperty::m_Flags.Add(plPropertyFlags::ReadOnly);
  }
 
 
  virtual bool IsEmpty(const void* pInstance) const override { return (static_cast<const Class*>(pInstance)->*m_GetValues)().IsEmpty(); }
 
  virtual void Clear(void* pInstance) const override
  {
    PL_ASSERT_DEBUG(m_Insert != nullptr && m_Remove != nullptr, "The property '{0}' has no remove and insert function, thus it is read-only",
      plAbstractProperty::GetPropertyName());
 
    // We must not cache the container c here as the Remove can make it invalid
    // e.g. plArrayPtr by value.
    while (!IsEmpty(pInstance))
    {
      // this should be decltype(auto) c = ...; but MSVC 16 is too dumb for that (MSVC 15 works fine)
      decltype((static_cast<const Class*>(pInstance)->*m_GetValues)()) c = (static_cast<const Class*>(pInstance)->*m_GetValues)();
      auto it = cbegin(c);
      RealType value = *it;
      Remove(pInstance, &value);
    }
  }
 
  virtual void Insert(void* pInstance, const void* pObject) const override
  {
    PL_ASSERT_DEBUG(m_Insert != nullptr, "The property '{0}' has no insert function, thus it is read-only.", plAbstractProperty::GetPropertyName());
    (static_cast<Class*>(pInstance)->*m_Insert)(*static_cast<const RealType*>(pObject));
  }
 
  virtual void Remove(void* pInstance, const void* pObject) const override
  {
    PL_ASSERT_DEBUG(m_Remove != nullptr, "The property '{0}' has no setter function, thus it is read-only.", plAbstractProperty::GetPropertyName());
    (static_cast<Class*>(pInstance)->*m_Remove)(*static_cast<const RealType*>(pObject));
  }
 
  virtual bool Contains(const void* pInstance, const void* pObject) const override
  {
    for (const auto& value : (static_cast<const Class*>(pInstance)->*m_GetValues)())
    {
      if (value == *static_cast<const RealType*>(pObject))
        return true;
    }
    return false;
  }
 
  virtual void GetValues(const void* pInstance, plDynamicArray<plVariant>& out_keys) const override
  {
    out_keys.Clear();
    for (const auto& value : (static_cast<const Class*>(pInstance)->*m_GetValues)())
    {
      out_keys.PushBack(plVariant(value));
    }
  }
 
private:
  GetValuesFunc m_GetValues;
  InsertFunc m_Insert;
  RemoveFunc m_Remove;
};
 
 
 
template <typename Class, typename Container, Container Class::*Member>
struct plSetPropertyAccessor
{
  using ContainerType = typename plTypeTraits<Container>::NonConstReferenceType;
  using Type = typename plTypeTraits<typename plContainerSubTypeResolver<ContainerType>::Type>::NonConstReferenceType;
 
  static const ContainerType& GetConstContainer(const Class* pInstance) { return (*pInstance).*Member; }
 
  static ContainerType& GetContainer(Class* pInstance) { return (*pInstance).*Member; }
};
 
 
template <typename Class, typename Container, typename Type>
class plMemberSetProperty : public plTypedSetProperty<typename plTypeTraits<Type>::NonConstReferenceType>
{
public:
  using RealType = typename plTypeTraits<Type>::NonConstReferenceType;
  using GetConstContainerFunc = const Container& (*)(const Class* pInstance);
  using GetContainerFunc = Container& (*)(Class* pInstance);
 
  plMemberSetProperty(const char* szPropertyName, GetConstContainerFunc constGetter, GetContainerFunc getter)
    : plTypedSetProperty<RealType>(szPropertyName)
  {
    PL_ASSERT_DEBUG(constGetter != nullptr, "The const get count function of an set property cannot be nullptr.");
 
    m_ConstGetter = constGetter;
    m_Getter = getter;
 
    if (m_Getter == nullptr)
      plAbstractSetProperty::m_Flags.Add(plPropertyFlags::ReadOnly);
  }
 
  virtual bool IsEmpty(const void* pInstance) const override { return m_ConstGetter(static_cast<const Class*>(pInstance)).IsEmpty(); }
 
  virtual void Clear(void* pInstance) const override
  {
    PL_ASSERT_DEBUG(
      m_Getter != nullptr, "The property '{0}' has no non-const set accessor function, thus it is read-only.", plAbstractProperty::GetPropertyName());
    m_Getter(static_cast<Class*>(pInstance)).Clear();
  }
 
  virtual void Insert(void* pInstance, const void* pObject) const override
  {
    PL_ASSERT_DEBUG(
      m_Getter != nullptr, "The property '{0}' has no non-const set accessor function, thus it is read-only.", plAbstractProperty::GetPropertyName());
    m_Getter(static_cast<Class*>(pInstance)).Insert(*static_cast<const RealType*>(pObject));
  }
 
  virtual void Remove(void* pInstance, const void* pObject) const override
  {
    PL_ASSERT_DEBUG(
      m_Getter != nullptr, "The property '{0}' has no non-const set accessor function, thus it is read-only.", plAbstractProperty::GetPropertyName());
    m_Getter(static_cast<Class*>(pInstance)).Remove(*static_cast<const RealType*>(pObject));
  }
 
  virtual bool Contains(const void* pInstance, const void* pObject) const override
  {
    return m_ConstGetter(static_cast<const Class*>(pInstance)).Contains(*static_cast<const RealType*>(pObject));
  }
 
  virtual void GetValues(const void* pInstance, plDynamicArray<plVariant>& out_keys) const override
  {
    out_keys.Clear();
    for (const auto& value : m_ConstGetter(static_cast<const Class*>(pInstance)))
    {
      out_keys.PushBack(plVariant(value));
    }
  }
 
private:
  GetConstContainerFunc m_ConstGetter;
  GetContainerFunc m_Getter;
};