FlatBufferCodec.h

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
 
#include "flatbuffers/flatbuffers.h"
 
#include "Network/Codec/MessageFrame.h"
#include "Network/Schema/generated/ember_protocol_generated.h"
 
namespace Ember {
namespace Network {
 
class FlatBufferCodec {
  public:
    FlatBufferCodec();
    ~FlatBufferCodec();
 
    void Reset();
 
    flatbuffers::FlatBufferBuilder &GetBuilder();
 
    MessageFrame BuildHandshake(const std::string &version, const std::string &clientId,
                                const std::string &clientName = "", const std::vector<std::string> &capabilities = {});
 
    MessageFrame BuildHandshakeAck(const std::string &version, const std::string &sessionId, bool accepted = true,
                                   const std::string &error = "");
 
    MessageFrame BuildTreeInit(const std::string &treeId, const std::string &treeName,
                               flatbuffers::Offset<Protocol::NodeDefinition> rootOffset,
                               const std::vector<flatbuffers::Offset<Protocol::BlackboardDefinition>> &blackboards = {},
                               const std::vector<flatbuffers::Offset<Protocol::KeyValue>> &metadata = {});
 
    MessageFrame BuildTreeInitAck(const std::string &treeId, bool success = true, int32_t nodeCount = 0,
                                  const std::string &error = "");
 
    MessageFrame BuildTickUpdate(const std::string &treeId, int64_t tickNumber, int64_t tickTimestampMs,
                                 float deltaTimeMs, bool isDelta,
                                 const std::vector<flatbuffers::Offset<Protocol::NodeState>> &states,
                                 const std::vector<int64_t> &executionPath = {});
 
    MessageFrame
    BuildBlackboardUpdate(const std::string &treeId, const std::string &blackboardId, int64_t tickNumber,
                          const std::vector<flatbuffers::Offset<Protocol::BlackboardUpdateEntry>> &updates);
 
    MessageFrame BuildTreeReset(const std::string &treeId, int64_t tickNumber, const std::string &reason = "");
 
    MessageFrame BuildDisconnect(const std::string &reason = "", const std::string &message = "");
 
    MessageFrame BuildError(Protocol::ErrorCode code, const std::string &message, bool fatal = false);
 
    flatbuffers::Offset<Protocol::NodeDefinition>
    CreateNodeDefinition(int64_t id, Protocol::NodeType nodeType, const std::string &subtype, const std::string &name,
                         const std::string &description = "",
                         const std::vector<flatbuffers::Offset<Protocol::KeyValue>> &attributes = {},
                         const std::vector<flatbuffers::Offset<Protocol::NodeDefinition>> &children = {});
 
    flatbuffers::Offset<Protocol::NodeState>
    CreateNodeState(int64_t id, Protocol::NodeStatus status,
                    Protocol::NodeStatus lastResult = Protocol::NodeStatus_Idle, int64_t tickCount = 0,
                    const std::string &message = "");
 
    flatbuffers::Offset<Protocol::KeyValue> CreateKeyValue(const std::string &key, const std::string &value);
 
    flatbuffers::Offset<Protocol::BlackboardEntry> CreateBlackboardEntry(const std::string &key,
                                                                         const std::string &valueType,
                                                                         const std::string &value,
                                                                         const std::string &description = "");
 
    flatbuffers::Offset<Protocol::BlackboardDefinition>
    CreateBlackboardDefinition(const std::string &id, const std::string &name,
                               const std::vector<flatbuffers::Offset<Protocol::BlackboardEntry>> &entries);
 
    flatbuffers::Offset<Protocol::BlackboardUpdateEntry>
    CreateBlackboardUpdateEntry(const std::string &key, const std::string &value, const std::string &previousValue);
 
    template <typename T> static bool Verify(const uint8_t *data, size_t size) {
        flatbuffers::Verifier verifier(data, size);
        return verifier.VerifyBuffer<T>(nullptr);
    }
 
    template <typename T> static const T *GetRoot(const uint8_t *data) { return flatbuffers::GetRoot<T>(data); }
 
    template <typename T> static const T *GetRoot(const std::vector<uint8_t> &data) {
        return flatbuffers::GetRoot<T>(data.data());
    }
 
  private:
    std::unique_ptr<flatbuffers::FlatBufferBuilder> m_builder;
};
 
} // namespace Network
} // namespace Ember