Message.h

#pragma once
 
#include <Foundation/Algorithm/HashingUtils.h>
#include <Foundation/Reflection/Reflection.h>
#include <Foundation/Types/UniquePtr.h>
 
using plMessageId = plUInt16;
class plStreamWriter;
class plStreamReader;
 
class PL_FOUNDATION_DLL plMessage : public plReflectedClass
{
  PL_ADD_DYNAMIC_REFLECTION(plMessage, plReflectedClass);
 
protected:
  explicit plMessage(size_t messageSize)
  {
    const auto sizeOffset = (reinterpret_cast<uintptr_t>(&m_Id) - reinterpret_cast<uintptr_t>(this)) + sizeof(m_Id);
    memset((void*)plMemoryUtils::AddByteOffset(this, sizeOffset), 0, messageSize - sizeOffset);
    m_uiSize = static_cast<plUInt16>(messageSize);
#if PL_ENABLED(PL_COMPILE_FOR_DEBUG)
    m_uiDebugMessageRouting = 0;
#endif
  }
 
public:
  PL_ALWAYS_INLINE plMessage()
    : plMessage(sizeof(plMessage))
  {
  }
 
  virtual ~plMessage() = default;
 
  virtual plInt32 GetSortingKey() const { return 0; }
 
  PL_ALWAYS_INLINE plMessageId GetId() const { return m_Id; }
 
  PL_ALWAYS_INLINE plUInt16 GetSize() const { return m_uiSize; }
 
  PL_ALWAYS_INLINE plUInt64 GetHash() const { return plHashingUtils::xxHash64(this, m_uiSize); }
 
  virtual void Serialize(plStreamWriter& inout_stream) const { PL_ASSERT_NOT_IMPLEMENTED; }
 
  virtual void Deserialize(plStreamReader& inout_stream, plUInt8 uiTypeVersion) { PL_ASSERT_NOT_IMPLEMENTED; }
 
#if PL_ENABLED(PL_COMPILE_FOR_DEBUG)
  PL_ALWAYS_INLINE void SetDebugMessageRouting(bool bDebug) { m_uiDebugMessageRouting = bDebug; }
 
  PL_ALWAYS_INLINE bool GetDebugMessageRouting() const { return m_uiDebugMessageRouting; }
#endif
 
protected:
  PL_ALWAYS_INLINE static plMessageId GetNextMsgId() { return s_NextMsgId++; }
 
  plMessageId m_Id;
 
#if PL_ENABLED(PL_COMPILE_FOR_DEBUG)
  plUInt16 m_uiSize : 15;
  plUInt16 m_uiDebugMessageRouting : 1;
#else
  plUInt16 m_uiSize;
#endif
 
  static plMessageId s_NextMsgId;
 
 
  // Transferring and replicating messages
  //
 
public:
  static void PackageForTransfer(const plMessage& msg, plStreamWriter& inout_stream);
 
  static plUniquePtr<plMessage> ReplicatePackedMessage(plStreamReader& inout_stream);
 
private:
};
 
#define PL_DECLARE_MESSAGE_TYPE(messageType, baseType)      \
private:                                                    \
  PL_ADD_DYNAMIC_REFLECTION(messageType, baseType);         \
  static plMessageId MSG_ID;                                \
                                                            \
protected:                                                  \
  PL_ALWAYS_INLINE explicit messageType(size_t messageSize) \
    : baseType(messageSize)                                 \
  {                                                         \
    m_Id = messageType::MSG_ID;                             \
  }                                                         \
                                                            \
public:                                                     \
  static plMessageId GetTypeMsgId()                         \
  {                                                         \
    static plMessageId id = plMessage::GetNextMsgId();      \
    return id;                                              \
  }                                                         \
                                                            \
  PL_ALWAYS_INLINE messageType()                            \
    : messageType(sizeof(messageType))                      \
  {                                                         \
  }
 
#define PL_IMPLEMENT_MESSAGE_TYPE(messageType) plMessageId messageType::MSG_ID = messageType::GetTypeMsgId();
 
 
template <typename T>
struct plMessageSenderBase
{
  using MessageType = T;
};