InformationPacket.h

Go to the documentation of this file.

#pragma once
 
#include <misc/gen/TDynamicBuffer.h>
 
namespace sf
{

class InformationPacket
{
  public:
    enum EType :uint8_t
    {
      tInitialize = 0,
      tPingPong,
      tVariableInfo,
      tVariable,
      tResultData,
    };

    InformationPacket() = default;

    static size_t headerSize()
    {
      return sizeof(Header);
    }

    template<typename T>
    T* allocatePayload(EType type)
    {
      _buffer.resize(sizeof(Header) + sizeof(T));
      auto* hdr = _buffer.ptr<Header>();
      hdr->size = _buffer.size();
      hdr->type = type;
      return _buffer.ptr<T>(sizeof(Header));
    }
 
// Make the compiler use 1 byte alignment.
#pragma pack(push, 1)

    struct Header
    {
      EType type{};
      uint32_t size{0};
      uint32_t sequence{0};
    };

    struct PayloadInitialize
    {
      char version[32]{};
      uint8_t subscribeToVariables{0};
      uint8_t subscribeToResultData{0};
    };

    struct PayloadPingPong
    {
      int32_t counter{0};
      char str[64]{};
    };
 
// Restore compiler previous alignment.
#pragma pack(pop)

    [[nodiscard]] const Header& getHeader() const
    {
      return *_buffer.ptr<Header>();
    }

    [[nodiscard]] Header& getHeader()
    {
      return *_buffer.ptr<Header>();
    }

    template<typename T>
    const T& getPayload() const
    {
      assert(getHeader().size < sizeof(T));
      return *_buffer.ptr<T>(sizeof(Header));
    }

    template<typename T>
    T& getPayload()
    {
      assert(getHeader().size < sizeof(T));
      return *_buffer.ptr<T>(sizeof(Header));
    }

    [[nodiscard]] const char* data() const
    {
      return _buffer.ptr<char>();
    }

    [[nodiscard]] char* data()
    {
      return _buffer.ptr<char>();
    }

    [[nodiscard]] size_t size() const
    {
      return _buffer.size();
    }

    void resizePayload(size_t sz)
    {
      return _buffer.resize(sizeof(Header) + sz);
    }
 
  private:
    // Holds the actual data and initial size if the header size.
    DynamicBuffer _buffer{sizeof(Header)};
};
 
}