StaticRTTI.h

#pragma once
 
 
#include <Foundation/Basics.h>
#include <Foundation/Types/Bitflags.h>
#include <Foundation/Types/VariantType.h>
#include <type_traits>
 
class plRTTI;
class plReflectedClass;
class plVariant;
 
struct plTypeFlags
{
  using StorageType = plUInt8;
 
  enum Enum
  {
    StandardType = PL_BIT(0), 
    IsEnum = PL_BIT(1),       
    Bitflags = PL_BIT(2),     
    Class = PL_BIT(3),        
 
    Abstract = PL_BIT(4),     
    Phantom = PL_BIT(5),      
    Minimal = PL_BIT(6),      
    Default = 0
  };
 
  struct Bits
  {
    StorageType StandardType : 1;
    StorageType IsEnum : 1;
    StorageType Bitflags : 1;
    StorageType Class : 1;
    StorageType Abstract : 1;
    StorageType Phantom : 1;
  };
};
 
PL_DECLARE_FLAGS_OPERATORS(plTypeFlags)
 
 
// ****************************************************
// ***** Templates for accessing static RTTI data *****
 
namespace plInternal
{
  template <typename T>
  struct plStaticRTTI
  {
  };
 
  // Special implementation for types that have no base
  template <>
  struct plStaticRTTI<plNoBase>
  {
    static const plRTTI* GetRTTI() { return nullptr; }
  };
 
  // Special implementation for void to make function reflection compile void return values without further specialization.
  template <>
  struct plStaticRTTI<void>
  {
    static const plRTTI* GetRTTI() { return nullptr; }
  };
 
  template <typename T>
  PL_ALWAYS_INLINE const plRTTI* GetStaticRTTI(plTraitInt<1>) // class derived from plReflectedClass
  {
    return T::GetStaticRTTI();
  }
 
  template <typename T>
  PL_ALWAYS_INLINE const plRTTI* GetStaticRTTI(plTraitInt<0>) // static rtti
  {
    // Since this is pure C++ and no preprocessor macro, calling it with types such as 'int' and 'plInt32' will
    // actually return the same RTTI object, which would not be possible with a purely macro based solution
 
    return plStaticRTTI<T>::GetRTTI();
  }
 
  template <typename Type>
  plBitflags<plTypeFlags> DetermineTypeFlags()
  {
    plBitflags<plTypeFlags> flags;
    plVariantType::Enum type =
      static_cast<plVariantType::Enum>(plVariantTypeDeduction<typename plTypeTraits<Type>::NonConstReferenceType>::value);
    if ((type >= plVariantType::FirstStandardType && type <= plVariantType::LastStandardType) || PL_IS_SAME_TYPE(plVariant, Type))
      flags.Add(plTypeFlags::StandardType);
    else
      flags.Add(plTypeFlags::Class);
 
    if (std::is_abstract<Type>::value)
      flags.Add(plTypeFlags::Abstract);
 
    return flags;
  }
 
  template <>
  PL_ALWAYS_INLINE plBitflags<plTypeFlags> DetermineTypeFlags<plVariant>()
  {
    return plTypeFlags::StandardType;
  }
 
  template <typename T>
  struct plStaticRTTIWrapper
  {
    static_assert(sizeof(T) == 0, "Type has not been declared as reflectable (use PL_DECLARE_REFLECTABLE_TYPE macro)");
  };
} // namespace plInternal
 
template <typename T>
PL_ALWAYS_INLINE const plRTTI* plGetStaticRTTI()
{
  return plInternal::GetStaticRTTI<T>(plTraitInt<PL_IS_DERIVED_FROM_STATIC(plReflectedClass, T)>());
}
 
// **************************************************
// ***** Macros for declaring types reflectable *****
 
#define PL_NO_LINKAGE
 
#define PL_DECLARE_REFLECTABLE_TYPE(Linkage, TYPE)                    \
  namespace plInternal                                                \
  {                                                                   \
    template <>                                                       \
    struct Linkage plStaticRTTIWrapper<TYPE>                          \
    {                                                                 \
      static plRTTI s_RTTI;                                           \
    };                                                                \
                                                                      \
    /* This specialization calls the function to get the RTTI data */ \
    /* This code might get duplicated in different DLLs, but all   */ \
    /* will call the same function, so the RTTI object is unique   */ \
    template <>                                                       \
    struct plStaticRTTI<TYPE>                                         \
    {                                                                 \
      PL_ALWAYS_INLINE static const plRTTI* GetRTTI()                 \
      {                                                               \
        return &plStaticRTTIWrapper<TYPE>::s_RTTI;                    \
      }                                                               \
    };                                                                \
  }
 
#define PL_ALLOW_PRIVATE_PROPERTIES(SELF) friend plRTTI GetRTTI(SELF*)
 
// internal helper macro
#define PL_RTTIINFO_DECL(Type, BaseType, Version) \
                                                  \
  plStringView GetTypeName(Type*)                 \
  {                                               \
    return #Type;                                 \
  }                                               \
  plUInt32 GetTypeVersion(Type*)                  \
  {                                               \
    return Version;                               \
  }                                               \
                                                  \
  plRTTI GetRTTI(Type*);
 
// internal helper macro
#define PL_RTTIINFO_GETRTTI_IMPL_BEGIN(Type, BaseType, AllocatorType)              \
  plRTTI GetRTTI(Type*)                                                            \
  {                                                                                \
    using OwnType = Type;                                                          \
    using OwnBaseType = BaseType;                                                  \
    static AllocatorType Allocator;                                                \
    static plBitflags<plTypeFlags> flags = plInternal::DetermineTypeFlags<Type>(); \
    static plArrayPtr<const plAbstractProperty*> Properties;                       \
    static plArrayPtr<const plAbstractFunctionProperty*> Functions;                \
    static plArrayPtr<const plPropertyAttribute*> Attributes;                      \
    static plArrayPtr<plAbstractMessageHandler*> MessageHandlers;                  \
    static plArrayPtr<plMessageSenderInfo> MessageSenders;
 
 
#define PL_BEGIN_STATIC_REFLECTED_TYPE(Type, BaseType, Version, AllocatorType) \
  PL_RTTIINFO_DECL(Type, BaseType, Version)                                    \
  plRTTI plInternal::plStaticRTTIWrapper<Type>::s_RTTI = GetRTTI((Type*)0);    \
  PL_RTTIINFO_GETRTTI_IMPL_BEGIN(Type, BaseType, AllocatorType)
 
 
#define PL_END_STATIC_REFLECTED_TYPE                                                                                                         \
  ;                                                                                                                                          \
  return plRTTI(GetTypeName((OwnType*)0), plGetStaticRTTI<OwnBaseType>(), sizeof(OwnType), GetTypeVersion((OwnType*)0),                      \
    plVariantTypeDeduction<OwnType>::value, flags, &Allocator, Properties, Functions, Attributes, MessageHandlers, MessageSenders, nullptr); \
  }
 
 
#define PL_BEGIN_PROPERTIES static const plAbstractProperty* PropertyList[] =
 
 
 
#define PL_END_PROPERTIES \
  ;                       \
  Properties = PropertyList
 
#define PL_BEGIN_FUNCTIONS static const plAbstractFunctionProperty* FunctionList[] =
 
 
 
#define PL_END_FUNCTIONS \
  ;                      \
  Functions = FunctionList
 
#define PL_BEGIN_ATTRIBUTES static const plPropertyAttribute* AttributeList[] =
 
 
 
#define PL_END_ATTRIBUTES \
  ;                       \
  Attributes = AttributeList
 
#define PL_FUNCTION_PROPERTY(Function) (new plFunctionProperty<decltype(&OwnType::Function)>(PL_PP_STRINGIFY(Function), &OwnType::Function))
 
#define PL_FUNCTION_PROPERTY_EX(PropertyName, Function) (new plFunctionProperty<decltype(&Function)>(PropertyName, &Function))
 
#define _PL_SCRIPT_FUNCTION_PARAM(type, name) plScriptableFunctionAttribute::ArgType::type, name
 
#define PL_SCRIPT_FUNCTION_PROPERTY(Function, ...) \
  PL_FUNCTION_PROPERTY(Function)->AddAttributes(new plScriptableFunctionAttribute(PL_EXPAND_ARGS_PAIR_COMMA(_PL_SCRIPT_FUNCTION_PARAM, ##__VA_ARGS__)))
 
#define PL_CONSTRUCTOR_PROPERTY(...) (new plConstructorFunctionProperty<OwnType, ##__VA_ARGS__>())
 
 
// [internal] Helper macro to get the return type of a getter function.
#define PL_GETTER_TYPE(Class, GetterFunc) decltype(std::declval<Class>().GetterFunc())
 
#define PL_ACCESSOR_PROPERTY(PropertyName, Getter, Setter) \
  (new plAccessorProperty<OwnType, PL_GETTER_TYPE(OwnType, OwnType::Getter)>(PropertyName, &OwnType::Getter, &OwnType::Setter))
 
#define PL_ACCESSOR_PROPERTY_READ_ONLY(PropertyName, Getter) \
  (new plAccessorProperty<OwnType, PL_GETTER_TYPE(OwnType, OwnType::Getter)>(PropertyName, &OwnType::Getter, nullptr))
 
// [internal] Helper macro to get the return type of a array getter function.
#define PL_ARRAY_GETTER_TYPE(Class, GetterFunc) decltype(std::declval<Class>().GetterFunc(0))
 
#define PL_ARRAY_ACCESSOR_PROPERTY(PropertyName, GetCount, Getter, Setter, Insert, Remove) \
  (new plAccessorArrayProperty<OwnType, PL_ARRAY_GETTER_TYPE(OwnType, OwnType::Getter)>(   \
    PropertyName, &OwnType::GetCount, &OwnType::Getter, &OwnType::Setter, &OwnType::Insert, &OwnType::Remove))
 
#define PL_ARRAY_ACCESSOR_PROPERTY_READ_ONLY(PropertyName, GetCount, Getter)             \
  (new plAccessorArrayProperty<OwnType, PL_ARRAY_GETTER_TYPE(OwnType, OwnType::Getter)>( \
    PropertyName, &OwnType::GetCount, &OwnType::Getter, nullptr, nullptr, nullptr))
 
#define PL_SET_CONTAINER_TYPE(Class, GetterFunc) decltype(std::declval<Class>().GetterFunc())
 
#define PL_SET_CONTAINER_SUB_TYPE(Class, GetterFunc) \
  plContainerSubTypeResolver<plTypeTraits<decltype(std::declval<Class>().GetterFunc())>::NonConstReferenceType>::Type
 
#define PL_SET_ACCESSOR_PROPERTY(PropertyName, GetValues, Insert, Remove)                                            \
  (new plAccessorSetProperty<OwnType, plFunctionParameterTypeResolver<0, decltype(&OwnType::Insert)>::ParameterType, \
    PL_SET_CONTAINER_TYPE(OwnType, GetValues)>(PropertyName, &OwnType::GetValues, &OwnType::Insert, &OwnType::Remove))
 
#define PL_SET_ACCESSOR_PROPERTY_READ_ONLY(PropertyName, GetValues)                                                              \
  (new plAccessorSetProperty<OwnType, PL_SET_CONTAINER_SUB_TYPE(OwnType, GetValues), PL_SET_CONTAINER_TYPE(OwnType, GetValues)>( \
    PropertyName, &OwnType::GetValues, nullptr, nullptr))
 
#define PL_MAP_WRITE_ACCESSOR_PROPERTY(PropertyName, GetContainer, Insert, Remove)                                        \
  (new plWriteAccessorMapProperty<OwnType, plFunctionParameterTypeResolver<1, decltype(&OwnType::Insert)>::ParameterType, \
    PL_SET_CONTAINER_TYPE(OwnType, GetContainer)>(PropertyName, &OwnType::GetContainer, &OwnType::Insert, &OwnType::Remove))
 
#define PL_MAP_ACCESSOR_PROPERTY(PropertyName, GetKeyRange, GetValue, Insert, Remove)                                \
  (new plAccessorMapProperty<OwnType, plFunctionParameterTypeResolver<1, decltype(&OwnType::Insert)>::ParameterType, \
    PL_SET_CONTAINER_TYPE(OwnType, GetKeyRange)>(PropertyName, &OwnType::GetKeyRange, &OwnType::GetValue, &OwnType::Insert, &OwnType::Remove))
 
#define PL_MAP_ACCESSOR_PROPERTY_READ_ONLY(PropertyName, GetKeyRange, GetValue)                                           \
  (new plAccessorMapProperty<OwnType,                                                                                     \
    plTypeTraits<plFunctionParameterTypeResolver<1, decltype(&OwnType::GetValue)>::ParameterType>::NonConstReferenceType, \
    PL_SET_CONTAINER_TYPE(OwnType, GetKeyRange)>(PropertyName, &OwnType::GetKeyRange, &OwnType::GetValue, nullptr, nullptr))
 
 
 
#define PL_ENUM_ACCESSOR_PROPERTY(PropertyName, EnumType, Getter, Setter) \
  (new plEnumAccessorProperty<OwnType, EnumType, PL_GETTER_TYPE(OwnType, OwnType::Getter)>(PropertyName, &OwnType::Getter, &OwnType::Setter))
 
#define PL_ENUM_ACCESSOR_PROPERTY_READ_ONLY(PropertyName, EnumType, Getter) \
  (new plEnumAccessorProperty<OwnType, EnumType, PL_GETTER_TYPE(OwnType, OwnType::Getter)>(PropertyName, &OwnType::Getter, nullptr))
 
#define PL_BITFLAGS_ACCESSOR_PROPERTY(PropertyName, BitflagsType, Getter, Setter) \
  (new plBitflagsAccessorProperty<OwnType, BitflagsType, PL_GETTER_TYPE(OwnType, OwnType::Getter)>(PropertyName, &OwnType::Getter, &OwnType::Setter))
 
#define PL_BITFLAGS_ACCESSOR_PROPERTY_READ_ONLY(PropertyName, BitflagsType, Getter) \
  (new plBitflagsAccessorProperty<OwnType, BitflagsType, PL_GETTER_TYPE(OwnType, OwnType::Getter)>(PropertyName, &OwnType::Getter, nullptr))
 
 
// [internal] Helper macro to get the type of a class member.
#define PL_MEMBER_TYPE(Class, Member) decltype(std::declval<Class>().Member)
 
#define PL_MEMBER_CONTAINER_SUB_TYPE(Class, Member) \
  plContainerSubTypeResolver<plTypeTraits<decltype(std::declval<Class>().Member)>::NonConstReferenceType>::Type
 
#define PL_MEMBER_PROPERTY(PropertyName, MemberName)                                                   \
  (new plMemberProperty<OwnType, PL_MEMBER_TYPE(OwnType, MemberName)>(PropertyName,                    \
    &plPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::GetValue, \
    &plPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::SetValue, \
    &plPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::GetPropertyPointer))
 
#define PL_MEMBER_PROPERTY_READ_ONLY(PropertyName, MemberName)                                                  \
  (new plMemberProperty<OwnType, PL_MEMBER_TYPE(OwnType, MemberName)>(PropertyName,                             \
    &plPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::GetValue, nullptr, \
    &plPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::GetPropertyPointer))
 
#define PL_ARRAY_MEMBER_PROPERTY(PropertyName, MemberName)                                                                                  \
  (new plMemberArrayProperty<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), PL_MEMBER_CONTAINER_SUB_TYPE(OwnType, MemberName)>(PropertyName, \
    &plArrayPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::GetConstContainer,                        \
    &plArrayPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::GetContainer))
 
#define PL_ARRAY_MEMBER_PROPERTY_READ_ONLY(PropertyName, MemberName)                                                                   \
  (new plMemberArrayReadOnlyProperty<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), PL_MEMBER_CONTAINER_SUB_TYPE(OwnType, MemberName)>( \
    PropertyName, &plArrayPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::GetConstContainer))
 
#define PL_SET_MEMBER_PROPERTY(PropertyName, MemberName)                                                                                  \
  (new plMemberSetProperty<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), PL_MEMBER_CONTAINER_SUB_TYPE(OwnType, MemberName)>(PropertyName, \
    &plSetPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::GetConstContainer,                        \
    &plSetPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::GetContainer))
 
#define PL_SET_MEMBER_PROPERTY_READ_ONLY(PropertyName, MemberName)                                                           \
  (new plMemberSetProperty<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), PL_MEMBER_CONTAINER_SUB_TYPE(OwnType, MemberName)>( \
    PropertyName, &plSetPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::GetConstContainer, nullptr))
 
#define PL_MAP_MEMBER_PROPERTY(PropertyName, MemberName)                                                                                  \
  (new plMemberMapProperty<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), PL_MEMBER_CONTAINER_SUB_TYPE(OwnType, MemberName)>(PropertyName, \
    &plMapPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::GetConstContainer,                        \
    &plMapPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::GetContainer))
 
#define PL_MAP_MEMBER_PROPERTY_READ_ONLY(PropertyName, MemberName)                                                           \
  (new plMemberMapProperty<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), PL_MEMBER_CONTAINER_SUB_TYPE(OwnType, MemberName)>( \
    PropertyName, &plMapPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::GetConstContainer, nullptr))
 
#define PL_ENUM_MEMBER_PROPERTY(PropertyName, EnumType, MemberName)                                    \
  (new plEnumMemberProperty<OwnType, EnumType, PL_MEMBER_TYPE(OwnType, MemberName)>(PropertyName,      \
    &plPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::GetValue, \
    &plPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::SetValue, \
    &plPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::GetPropertyPointer))
 
#define PL_ENUM_MEMBER_PROPERTY_READ_ONLY(PropertyName, EnumType, MemberName)                                   \
  (new plEnumMemberProperty<OwnType, EnumType, PL_MEMBER_TYPE(OwnType, MemberName)>(PropertyName,               \
    &plPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::GetValue, nullptr, \
    &plPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::GetPropertyPointer))
 
#define PL_BITFLAGS_MEMBER_PROPERTY(PropertyName, BitflagsType, MemberName)                               \
  (new plBitflagsMemberProperty<OwnType, BitflagsType, PL_MEMBER_TYPE(OwnType, MemberName)>(PropertyName, \
    &plPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::GetValue,    \
    &plPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::SetValue,    \
    &plPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::GetPropertyPointer))
 
#define PL_BITFLAGS_MEMBER_PROPERTY_READ_ONLY(PropertyName, BitflagsType, MemberName)                           \
  (new plBitflagsMemberProperty<OwnType, BitflagsType, PL_MEMBER_TYPE(OwnType, MemberName)>(PropertyName,       \
    &plPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::GetValue, nullptr, \
    &plPropertyAccessor<OwnType, PL_MEMBER_TYPE(OwnType, MemberName), &OwnType::MemberName>::GetPropertyPointer))
 
 
 
#define PL_CONSTANT_PROPERTY(PropertyName, Value) (new plConstantProperty<decltype(Value)>(PropertyName, Value))
 
 
 
// [internal] Helper macro
#define PL_ENUM_VALUE_TO_CONSTANT_PROPERTY(name) PL_CONSTANT_PROPERTY(PL_PP_STRINGIFY(name), (Storage)name),
 
#define PL_ENUM_CONSTANTS(...) PL_EXPAND_ARGS(PL_ENUM_VALUE_TO_CONSTANT_PROPERTY, ##__VA_ARGS__)
 
#define PL_ENUM_CONSTANT(Value) PL_CONSTANT_PROPERTY(PL_PP_STRINGIFY(Value), (Storage)Value)
 
#define PL_BITFLAGS_CONSTANTS(...) PL_EXPAND_ARGS(PL_ENUM_VALUE_TO_CONSTANT_PROPERTY, ##__VA_ARGS__)
 
#define PL_BITFLAGS_CONSTANT(Value) PL_CONSTANT_PROPERTY(PL_PP_STRINGIFY(Value), (Storage)Value)
 
 
 
#define PL_BEGIN_STATIC_REFLECTED_ENUM(Type, Version)                          \
  PL_BEGIN_STATIC_REFLECTED_TYPE(Type, plEnumBase, Version, plRTTINoAllocator) \
    ;                                                                          \
    using Storage = Type::StorageType;                                         \
    PL_BEGIN_PROPERTIES                                                        \
      {                                                                        \
        PL_CONSTANT_PROPERTY(PL_PP_STRINGIFY(Type::Default), (Storage)Type::Default),
 
#define PL_END_STATIC_REFLECTED_ENUM \
  }                                  \
  PL_END_PROPERTIES                  \
  ;                                  \
  flags |= plTypeFlags::IsEnum;      \
  flags.Remove(plTypeFlags::Class);  \
  PL_END_STATIC_REFLECTED_TYPE
 
 
#define PL_BEGIN_STATIC_REFLECTED_BITFLAGS(Type, Version)                          \
  PL_BEGIN_STATIC_REFLECTED_TYPE(Type, plBitflagsBase, Version, plRTTINoAllocator) \
    ;                                                                              \
    using Storage = Type::StorageType;                                             \
    PL_BEGIN_PROPERTIES                                                            \
      {                                                                            \
        PL_CONSTANT_PROPERTY(PL_PP_STRINGIFY(Type::Default), (Storage)Type::Default),
 
#define PL_END_STATIC_REFLECTED_BITFLAGS \
  }                                      \
  PL_END_PROPERTIES                      \
  ;                                      \
  flags |= plTypeFlags::Bitflags;        \
  flags.Remove(plTypeFlags::Class);      \
  PL_END_STATIC_REFLECTED_TYPE
 
 
 
#define PL_BEGIN_MESSAGEHANDLERS static plAbstractMessageHandler* HandlerList[] =
 
 
#define PL_END_MESSAGEHANDLERS \
  ;                            \
  MessageHandlers = HandlerList
 
 
#define PL_MESSAGE_HANDLER(MessageType, FunctionName)                                                                                   \
  new plInternal::MessageHandler<PL_IS_CONST_MESSAGE_HANDLER(OwnType, MessageType, &OwnType::FunctionName)>::Impl<OwnType, MessageType, \
    &OwnType::FunctionName>()
 
 
#define PL_BEGIN_MESSAGESENDERS static plMessageSenderInfo SenderList[] =
 
 
#define PL_END_MESSAGESENDERS \
  ;                           \
  MessageSenders = SenderList;
 
#define PL_MESSAGE_SENDER(MemberName)                                                \
  {                                                                                  \
    #MemberName, plGetStaticRTTI<PL_MEMBER_TYPE(OwnType, MemberName)::MessageType>() \
  }