FlatBufferCodec.cpp

Go to the documentation of this file.

#include "Network/Codec/FlatBufferCodec.h"
 
namespace Ember {
namespace Network {
 
FlatBufferCodec::FlatBufferCodec() : m_builder(std::make_unique<flatbuffers::FlatBufferBuilder>(1024)) {}
 
FlatBufferCodec::~FlatBufferCodec() = default;
 
void FlatBufferCodec::Reset() { m_builder->Clear(); }
 
flatbuffers::FlatBufferBuilder &FlatBufferCodec::GetBuilder() { return *m_builder; }
 
MessageFrame FlatBufferCodec::BuildHandshake(const std::string &version, const std::string &clientId,
                                             const std::string &clientName,
                                             const std::vector<std::string> &capabilities) {
    Reset();
 
    auto versionOffset = m_builder->CreateString(version);
    auto clientIdOffset = m_builder->CreateString(clientId);
    auto clientNameOffset = clientName.empty() ? 0 : m_builder->CreateString(clientName);
 
    std::vector<flatbuffers::Offset<flatbuffers::String>> capOffsets;
    for (const auto &cap : capabilities) {
        capOffsets.push_back(m_builder->CreateString(cap));
    }
    auto capsVector = capabilities.empty() ? 0 : m_builder->CreateVector(capOffsets);
 
    Protocol::HandshakeBuilder hsBuilder(*m_builder);
    hsBuilder.add_version(versionOffset);
    hsBuilder.add_client_id(clientIdOffset);
    if (!clientName.empty()) {
        hsBuilder.add_client_name(clientNameOffset);
    }
    if (!capabilities.empty()) {
        hsBuilder.add_capabilities(capsVector);
    }
 
    auto handshake = hsBuilder.Finish();
    m_builder->Finish(handshake);
 
    return MessageFrame(Protocol::MessageType_Handshake, m_builder->GetBufferPointer(), m_builder->GetSize());
}
 
MessageFrame FlatBufferCodec::BuildHandshakeAck(const std::string &version, const std::string &sessionId, bool accepted,
                                                const std::string &error) {
    Reset();
 
    auto versionOffset = m_builder->CreateString(version);
    auto sessionIdOffset = m_builder->CreateString(sessionId);
    auto errorOffset = error.empty() ? 0 : m_builder->CreateString(error);
 
    Protocol::HandshakeAckBuilder builder(*m_builder);
    builder.add_version(versionOffset);
    builder.add_session_id(sessionIdOffset);
    builder.add_accepted(accepted);
    if (!error.empty()) {
        builder.add_error(errorOffset);
    }
 
    auto ack = builder.Finish();
    m_builder->Finish(ack);
 
    return MessageFrame(Protocol::MessageType_HandshakeAck, m_builder->GetBufferPointer(), m_builder->GetSize());
}
 
MessageFrame
FlatBufferCodec::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) {
    auto treeIdOffset = m_builder->CreateString(treeId);
    auto treeNameOffset = treeName.empty() ? 0 : m_builder->CreateString(treeName);
    auto blackboardsVector = blackboards.empty() ? 0 : m_builder->CreateVector(blackboards);
    auto metadataVector = metadata.empty() ? 0 : m_builder->CreateVector(metadata);
 
    Protocol::TreeInitBuilder builder(*m_builder);
    builder.add_tree_id(treeIdOffset);
    if (!treeName.empty()) {
        builder.add_tree_name(treeNameOffset);
    }
    builder.add_root(rootOffset);
    if (!blackboards.empty()) {
        builder.add_blackboards(blackboardsVector);
    }
    if (!metadata.empty()) {
        builder.add_metadata(metadataVector);
    }
 
    auto init = builder.Finish();
    m_builder->Finish(init);
 
    return MessageFrame(Protocol::MessageType_TreeInit, m_builder->GetBufferPointer(), m_builder->GetSize());
}
 
MessageFrame FlatBufferCodec::BuildTreeInitAck(const std::string &treeId, bool success, int32_t nodeCount,
                                               const std::string &error) {
    Reset();
 
    auto treeIdOffset = m_builder->CreateString(treeId);
    auto errorOffset = error.empty() ? 0 : m_builder->CreateString(error);
 
    Protocol::TreeInitAckBuilder builder(*m_builder);
    builder.add_tree_id(treeIdOffset);
    builder.add_success(success);
    builder.add_node_count(nodeCount);
    if (!error.empty()) {
        builder.add_error(errorOffset);
    }
 
    auto ack = builder.Finish();
    m_builder->Finish(ack);
 
    return MessageFrame(Protocol::MessageType_TreeInitAck, m_builder->GetBufferPointer(), m_builder->GetSize());
}
 
MessageFrame FlatBufferCodec::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) {
    Reset();
 
    auto treeIdOffset = m_builder->CreateString(treeId);
    auto statesVector = m_builder->CreateVector(states);
    auto pathVector = executionPath.empty() ? 0 : m_builder->CreateVector(executionPath);
 
    Protocol::TickUpdateBuilder builder(*m_builder);
    builder.add_tree_id(treeIdOffset);
    builder.add_tick_number(tickNumber);
    builder.add_tick_timestamp_ms(tickTimestampMs);
    builder.add_delta_time_ms(deltaTimeMs);
    builder.add_is_delta(isDelta);
    builder.add_states(statesVector);
    if (!executionPath.empty()) {
        builder.add_execution_path(pathVector);
    }
 
    auto update = builder.Finish();
    m_builder->Finish(update);
 
    return MessageFrame(Protocol::MessageType_TickUpdate, m_builder->GetBufferPointer(), m_builder->GetSize());
}
 
MessageFrame FlatBufferCodec::BuildBlackboardUpdate(
    const std::string &treeId, const std::string &blackboardId, int64_t tickNumber,
    const std::vector<flatbuffers::Offset<Protocol::BlackboardUpdateEntry>> &updates) {
    Reset();
 
    auto treeIdOffset = m_builder->CreateString(treeId);
    auto bbIdOffset = m_builder->CreateString(blackboardId);
    auto updatesVector = updates.empty() ? 0 : m_builder->CreateVector(updates);
 
    Protocol::BlackboardUpdateBuilder builder(*m_builder);
    builder.add_tree_id(treeIdOffset);
    builder.add_blackboard_id(bbIdOffset);
    builder.add_tick_number(tickNumber);
    if (!updates.empty()) {
        builder.add_updates(updatesVector);
    }
 
    auto bbUpdate = builder.Finish();
    m_builder->Finish(bbUpdate);
 
    return MessageFrame(Protocol::MessageType_BlackboardUpdate, m_builder->GetBufferPointer(), m_builder->GetSize());
}
 
MessageFrame FlatBufferCodec::BuildTreeReset(const std::string &treeId, int64_t tickNumber, const std::string &reason) {
    Reset();
 
    auto treeIdOffset = m_builder->CreateString(treeId);
    auto reasonOffset = reason.empty() ? 0 : m_builder->CreateString(reason);
 
    Protocol::TreeResetBuilder builder(*m_builder);
    builder.add_tree_id(treeIdOffset);
    builder.add_tick_number(tickNumber);
    if (!reason.empty()) {
        builder.add_reason(reasonOffset);
    }
 
    auto reset = builder.Finish();
    m_builder->Finish(reset);
 
    return MessageFrame(Protocol::MessageType_TreeReset, m_builder->GetBufferPointer(), m_builder->GetSize());
}
 
MessageFrame FlatBufferCodec::BuildDisconnect(const std::string &reason, const std::string &message) {
    Reset();
 
    auto reasonOffset = reason.empty() ? 0 : m_builder->CreateString(reason);
    auto messageOffset = message.empty() ? 0 : m_builder->CreateString(message);
 
    Protocol::DisconnectBuilder builder(*m_builder);
    if (!reason.empty()) {
        builder.add_reason(reasonOffset);
    }
    if (!message.empty()) {
        builder.add_message(messageOffset);
    }
 
    auto disconnect = builder.Finish();
    m_builder->Finish(disconnect);
 
    return MessageFrame(Protocol::MessageType_Disconnect, m_builder->GetBufferPointer(), m_builder->GetSize());
}
 
MessageFrame FlatBufferCodec::BuildError(Protocol::ErrorCode code, const std::string &message, bool fatal) {
    Reset();
 
    auto messageOffset = message.empty() ? 0 : m_builder->CreateString(message);
 
    Protocol::ErrorBuilder builder(*m_builder);
    builder.add_code(code);
    if (!message.empty()) {
        builder.add_message(messageOffset);
    }
    builder.add_fatal(fatal);
 
    auto error = builder.Finish();
    m_builder->Finish(error);
 
    return MessageFrame(Protocol::MessageType_Error, m_builder->GetBufferPointer(), m_builder->GetSize());
}
 
flatbuffers::Offset<Protocol::NodeDefinition>
FlatBufferCodec::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) {
    auto subtypeOffset = m_builder->CreateString(subtype);
    auto nameOffset = m_builder->CreateString(name);
    auto descOffset = description.empty() ? 0 : m_builder->CreateString(description);
    auto attrsVector = attributes.empty() ? 0 : m_builder->CreateVector(attributes);
    auto childrenVector = children.empty() ? 0 : m_builder->CreateVector(children);
 
    Protocol::NodeDefinitionBuilder builder(*m_builder);
    builder.add_id(id);
    builder.add_node_type(nodeType);
    builder.add_subtype(subtypeOffset);
    builder.add_name(nameOffset);
    if (!description.empty()) {
        builder.add_description(descOffset);
    }
    if (!attributes.empty()) {
        builder.add_attributes(attrsVector);
    }
    if (!children.empty()) {
        builder.add_children(childrenVector);
    }
 
    return builder.Finish();
}
 
flatbuffers::Offset<Protocol::NodeState> FlatBufferCodec::CreateNodeState(int64_t id, Protocol::NodeStatus status,
                                                                          Protocol::NodeStatus lastResult,
                                                                          int64_t tickCount,
                                                                          const std::string &message) {
    auto messageOffset = message.empty() ? 0 : m_builder->CreateString(message);
 
    Protocol::NodeStateBuilder builder(*m_builder);
    builder.add_id(id);
    builder.add_status(status);
    builder.add_last_result(lastResult);
    builder.add_tick_count(tickCount);
    if (!message.empty()) {
        builder.add_message(messageOffset);
    }
 
    return builder.Finish();
}
 
flatbuffers::Offset<Protocol::KeyValue> FlatBufferCodec::CreateKeyValue(const std::string &key,
                                                                        const std::string &value) {
    auto keyOffset = m_builder->CreateString(key);
    auto valueOffset = value.empty() ? 0 : m_builder->CreateString(value);
 
    Protocol::KeyValueBuilder builder(*m_builder);
    builder.add_key(keyOffset);
    if (!value.empty()) {
        builder.add_value(valueOffset);
    }
 
    return builder.Finish();
}
 
flatbuffers::Offset<Protocol::BlackboardEntry> FlatBufferCodec::CreateBlackboardEntry(const std::string &key,
                                                                                      const std::string &valueType,
                                                                                      const std::string &value,
                                                                                      const std::string &description) {
    auto keyOffset = m_builder->CreateString(key);
    auto typeOffset = valueType.empty() ? 0 : m_builder->CreateString(valueType);
    auto valueOffset = value.empty() ? 0 : m_builder->CreateString(value);
    auto descOffset = description.empty() ? 0 : m_builder->CreateString(description);
 
    Protocol::BlackboardEntryBuilder builder(*m_builder);
    builder.add_key(keyOffset);
    if (!valueType.empty()) {
        builder.add_value_type(typeOffset);
    }
    if (!value.empty()) {
        builder.add_value(valueOffset);
    }
    if (!description.empty()) {
        builder.add_description(descOffset);
    }
 
    return builder.Finish();
}
 
flatbuffers::Offset<Protocol::BlackboardDefinition> FlatBufferCodec::CreateBlackboardDefinition(
    const std::string &id, const std::string &name,
    const std::vector<flatbuffers::Offset<Protocol::BlackboardEntry>> &entries) {
    auto idOffset = m_builder->CreateString(id);
    auto nameOffset = name.empty() ? 0 : m_builder->CreateString(name);
    auto entriesVector = entries.empty() ? 0 : m_builder->CreateVector(entries);
 
    Protocol::BlackboardDefinitionBuilder builder(*m_builder);
    builder.add_id(idOffset);
    if (!name.empty()) {
        builder.add_name(nameOffset);
    }
    if (!entries.empty()) {
        builder.add_entries(entriesVector);
    }
 
    return builder.Finish();
}
 
flatbuffers::Offset<Protocol::BlackboardUpdateEntry>
FlatBufferCodec::CreateBlackboardUpdateEntry(const std::string &key, const std::string &value,
                                             const std::string &previousValue) {
    auto keyOffset = m_builder->CreateString(key);
    auto valueOffset = value.empty() ? 0 : m_builder->CreateString(value);
    auto prevOffset = previousValue.empty() ? 0 : m_builder->CreateString(previousValue);
 
    Protocol::BlackboardUpdateEntryBuilder builder(*m_builder);
    builder.add_key(keyOffset);
    if (!value.empty()) {
        builder.add_value(valueOffset);
    }
    if (!previousValue.empty()) {
        builder.add_previous_value(prevOffset);
    }
 
    return builder.Finish();
}
 
} // namespace Network
} // namespace Ember