ember_protocol_generated.h

Go to the documentation of this file.

// automatically generated by the FlatBuffers compiler, do not modify
 
#ifndef FLATBUFFERS_GENERATED_EMBERPROTOCOL_EMBER_PROTOCOL_H_
#define FLATBUFFERS_GENERATED_EMBERPROTOCOL_EMBER_PROTOCOL_H_
 
#include "flatbuffers/flatbuffers.h"
 
namespace Ember {
namespace Protocol {
 
struct KeyValue;
 
struct Handshake;
 
struct HandshakeAck;
 
struct NodeDefinition;
 
struct BlackboardEntry;
 
struct BlackboardDefinition;
 
struct TreeInit;
 
struct TreeInitAck;
 
struct NodeState;
 
struct TickUpdate;
 
struct TickUpdateBatch;
 
struct BlackboardUpdateEntry;
 
struct BlackboardUpdate;
 
struct TreeReset;
 
struct Disconnect;
 
struct Error;
 
enum MessageType {
    MessageType_Handshake = 1,
    MessageType_HandshakeAck = 2,
    MessageType_TreeInit = 16,
    MessageType_TreeInitAck = 17,
    MessageType_TickUpdate = 32,
    MessageType_TickUpdateBatch = 33,
    MessageType_BlackboardUpdate = 48,
    MessageType_TreeReset = 64,
    MessageType_Disconnect = 240,
    MessageType_Error = 255,
    MessageType_MIN = MessageType_Handshake,
    MessageType_MAX = MessageType_Error
};
 
inline const MessageType (&EnumValuesMessageType())[10] {
    static const MessageType values[] = {MessageType_Handshake,        MessageType_HandshakeAck,
                                         MessageType_TreeInit,         MessageType_TreeInitAck,
                                         MessageType_TickUpdate,       MessageType_TickUpdateBatch,
                                         MessageType_BlackboardUpdate, MessageType_TreeReset,
                                         MessageType_Disconnect,       MessageType_Error};
    return values;
}
 
inline const char *EnumNameMessageType(MessageType e) {
    switch (e) {
    case MessageType_Handshake:
        return "Handshake";
    case MessageType_HandshakeAck:
        return "HandshakeAck";
    case MessageType_TreeInit:
        return "TreeInit";
    case MessageType_TreeInitAck:
        return "TreeInitAck";
    case MessageType_TickUpdate:
        return "TickUpdate";
    case MessageType_TickUpdateBatch:
        return "TickUpdateBatch";
    case MessageType_BlackboardUpdate:
        return "BlackboardUpdate";
    case MessageType_TreeReset:
        return "TreeReset";
    case MessageType_Disconnect:
        return "Disconnect";
    case MessageType_Error:
        return "Error";
    default:
        return "";
    }
}
 
enum NodeStatus {
    NodeStatus_Idle = 0,
    NodeStatus_Running = 1,
    NodeStatus_Success = 2,
    NodeStatus_Failure = 3,
    NodeStatus_Halted = 4,
    NodeStatus_MIN = NodeStatus_Idle,
    NodeStatus_MAX = NodeStatus_Halted
};
 
inline const NodeStatus (&EnumValuesNodeStatus())[5] {
    static const NodeStatus values[] = {NodeStatus_Idle, NodeStatus_Running, NodeStatus_Success, NodeStatus_Failure,
                                        NodeStatus_Halted};
    return values;
}
 
inline const char *const *EnumNamesNodeStatus() {
    static const char *const names[] = {"Idle", "Running", "Success", "Failure", "Halted", nullptr};
    return names;
}
 
inline const char *EnumNameNodeStatus(NodeStatus e) {
    if (e < NodeStatus_Idle || e > NodeStatus_Halted)
        return "";
    const size_t index = static_cast<size_t>(e);
    return EnumNamesNodeStatus()[index];
}
 
enum NodeType {
    NodeType_Action = 0,
    NodeType_Control = 1,
    NodeType_Condition = 2,
    NodeType_Decorator = 3,
    NodeType_SubTree = 4,
    NodeType_MIN = NodeType_Action,
    NodeType_MAX = NodeType_SubTree
};
 
inline const NodeType (&EnumValuesNodeType())[5] {
    static const NodeType values[] = {NodeType_Action, NodeType_Control, NodeType_Condition, NodeType_Decorator,
                                      NodeType_SubTree};
    return values;
}
 
inline const char *const *EnumNamesNodeType() {
    static const char *const names[] = {"Action", "Control", "Condition", "Decorator", "SubTree", nullptr};
    return names;
}
 
inline const char *EnumNameNodeType(NodeType e) {
    if (e < NodeType_Action || e > NodeType_SubTree)
        return "";
    const size_t index = static_cast<size_t>(e);
    return EnumNamesNodeType()[index];
}
 
enum ErrorCode {
    ErrorCode_None = 0,
    ErrorCode_ProtocolMismatch = 1,
    ErrorCode_InvalidMessage = 2,
    ErrorCode_UnknownTree = 3,
    ErrorCode_UnknownNode = 4,
    ErrorCode_InternalError = 500,
    ErrorCode_MIN = ErrorCode_None,
    ErrorCode_MAX = ErrorCode_InternalError
};
 
inline const ErrorCode (&EnumValuesErrorCode())[6] {
    static const ErrorCode values[] = {ErrorCode_None,        ErrorCode_ProtocolMismatch, ErrorCode_InvalidMessage,
                                       ErrorCode_UnknownTree, ErrorCode_UnknownNode,      ErrorCode_InternalError};
    return values;
}
 
inline const char *EnumNameErrorCode(ErrorCode e) {
    switch (e) {
    case ErrorCode_None:
        return "None";
    case ErrorCode_ProtocolMismatch:
        return "ProtocolMismatch";
    case ErrorCode_InvalidMessage:
        return "InvalidMessage";
    case ErrorCode_UnknownTree:
        return "UnknownTree";
    case ErrorCode_UnknownNode:
        return "UnknownNode";
    case ErrorCode_InternalError:
        return "InternalError";
    default:
        return "";
    }
}
 
struct KeyValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_KEY = 4, VT_VALUE = 6 };
    const flatbuffers::String *key() const { return GetPointer<const flatbuffers::String *>(VT_KEY); }
    const flatbuffers::String *value() const { return GetPointer<const flatbuffers::String *>(VT_VALUE); }
    bool Verify(flatbuffers::Verifier &verifier) const {
        return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_KEY) && verifier.VerifyString(key()) &&
               VerifyOffset(verifier, VT_VALUE) && verifier.VerifyString(value()) && verifier.EndTable();
    }
};
 
struct KeyValueBuilder {
    flatbuffers::FlatBufferBuilder &fbb_;
    flatbuffers::uoffset_t start_;
    void add_key(flatbuffers::Offset<flatbuffers::String> key) { fbb_.AddOffset(KeyValue::VT_KEY, key); }
    void add_value(flatbuffers::Offset<flatbuffers::String> value) { fbb_.AddOffset(KeyValue::VT_VALUE, value); }
    explicit KeyValueBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    KeyValueBuilder &operator=(const KeyValueBuilder &);
    flatbuffers::Offset<KeyValue> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = flatbuffers::Offset<KeyValue>(end);
        fbb_.Required(o, KeyValue::VT_KEY);
        return o;
    }
};
 
inline flatbuffers::Offset<KeyValue> CreateKeyValue(flatbuffers::FlatBufferBuilder &_fbb,
                                                    flatbuffers::Offset<flatbuffers::String> key = 0,
                                                    flatbuffers::Offset<flatbuffers::String> value = 0) {
    KeyValueBuilder builder_(_fbb);
    builder_.add_value(value);
    builder_.add_key(key);
    return builder_.Finish();
}
 
inline flatbuffers::Offset<KeyValue> CreateKeyValueDirect(flatbuffers::FlatBufferBuilder &_fbb,
                                                          const char *key = nullptr, const char *value = nullptr) {
    auto key__ = key ? _fbb.CreateString(key) : 0;
    auto value__ = value ? _fbb.CreateString(value) : 0;
    return Ember::Protocol::CreateKeyValue(_fbb, key__, value__);
}
 
struct Handshake FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
        VT_VERSION = 4,
        VT_CLIENT_ID = 6,
        VT_CLIENT_NAME = 8,
        VT_CAPABILITIES = 10
    };
    const flatbuffers::String *version() const { return GetPointer<const flatbuffers::String *>(VT_VERSION); }
    const flatbuffers::String *client_id() const { return GetPointer<const flatbuffers::String *>(VT_CLIENT_ID); }
    const flatbuffers::String *client_name() const { return GetPointer<const flatbuffers::String *>(VT_CLIENT_NAME); }
    const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *capabilities() const {
        return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_CAPABILITIES);
    }
    bool Verify(flatbuffers::Verifier &verifier) const {
        return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_VERSION) &&
               verifier.VerifyString(version()) && VerifyOffsetRequired(verifier, VT_CLIENT_ID) &&
               verifier.VerifyString(client_id()) && VerifyOffset(verifier, VT_CLIENT_NAME) &&
               verifier.VerifyString(client_name()) && VerifyOffset(verifier, VT_CAPABILITIES) &&
               verifier.VerifyVector(capabilities()) && verifier.VerifyVectorOfStrings(capabilities()) &&
               verifier.EndTable();
    }
};
 
struct HandshakeBuilder {
    flatbuffers::FlatBufferBuilder &fbb_;
    flatbuffers::uoffset_t start_;
    void add_version(flatbuffers::Offset<flatbuffers::String> version) {
        fbb_.AddOffset(Handshake::VT_VERSION, version);
    }
    void add_client_id(flatbuffers::Offset<flatbuffers::String> client_id) {
        fbb_.AddOffset(Handshake::VT_CLIENT_ID, client_id);
    }
    void add_client_name(flatbuffers::Offset<flatbuffers::String> client_name) {
        fbb_.AddOffset(Handshake::VT_CLIENT_NAME, client_name);
    }
    void
    add_capabilities(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> capabilities) {
        fbb_.AddOffset(Handshake::VT_CAPABILITIES, capabilities);
    }
    explicit HandshakeBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    HandshakeBuilder &operator=(const HandshakeBuilder &);
    flatbuffers::Offset<Handshake> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = flatbuffers::Offset<Handshake>(end);
        fbb_.Required(o, Handshake::VT_VERSION);
        fbb_.Required(o, Handshake::VT_CLIENT_ID);
        return o;
    }
};
 
inline flatbuffers::Offset<Handshake>
CreateHandshake(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset<flatbuffers::String> version = 0,
                flatbuffers::Offset<flatbuffers::String> client_id = 0,
                flatbuffers::Offset<flatbuffers::String> client_name = 0,
                flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> capabilities = 0) {
    HandshakeBuilder builder_(_fbb);
    builder_.add_capabilities(capabilities);
    builder_.add_client_name(client_name);
    builder_.add_client_id(client_id);
    builder_.add_version(version);
    return builder_.Finish();
}
 
inline flatbuffers::Offset<Handshake>
CreateHandshakeDirect(flatbuffers::FlatBufferBuilder &_fbb, const char *version = nullptr,
                      const char *client_id = nullptr, const char *client_name = nullptr,
                      const std::vector<flatbuffers::Offset<flatbuffers::String>> *capabilities = nullptr) {
    auto version__ = version ? _fbb.CreateString(version) : 0;
    auto client_id__ = client_id ? _fbb.CreateString(client_id) : 0;
    auto client_name__ = client_name ? _fbb.CreateString(client_name) : 0;
    auto capabilities__ = capabilities ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*capabilities) : 0;
    return Ember::Protocol::CreateHandshake(_fbb, version__, client_id__, client_name__, capabilities__);
}
 
struct HandshakeAck FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
        VT_VERSION = 4,
        VT_SESSION_ID = 6,
        VT_ACCEPTED = 8,
        VT_ERROR = 10
    };
    const flatbuffers::String *version() const { return GetPointer<const flatbuffers::String *>(VT_VERSION); }
    const flatbuffers::String *session_id() const { return GetPointer<const flatbuffers::String *>(VT_SESSION_ID); }
    bool accepted() const { return GetField<uint8_t>(VT_ACCEPTED, 1) != 0; }
    const flatbuffers::String *error() const { return GetPointer<const flatbuffers::String *>(VT_ERROR); }
    bool Verify(flatbuffers::Verifier &verifier) const {
        return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_VERSION) &&
               verifier.VerifyString(version()) && VerifyOffsetRequired(verifier, VT_SESSION_ID) &&
               verifier.VerifyString(session_id()) && VerifyField<uint8_t>(verifier, VT_ACCEPTED) &&
               VerifyOffset(verifier, VT_ERROR) && verifier.VerifyString(error()) && verifier.EndTable();
    }
};
 
struct HandshakeAckBuilder {
    flatbuffers::FlatBufferBuilder &fbb_;
    flatbuffers::uoffset_t start_;
    void add_version(flatbuffers::Offset<flatbuffers::String> version) {
        fbb_.AddOffset(HandshakeAck::VT_VERSION, version);
    }
    void add_session_id(flatbuffers::Offset<flatbuffers::String> session_id) {
        fbb_.AddOffset(HandshakeAck::VT_SESSION_ID, session_id);
    }
    void add_accepted(bool accepted) {
        fbb_.AddElement<uint8_t>(HandshakeAck::VT_ACCEPTED, static_cast<uint8_t>(accepted), 1);
    }
    void add_error(flatbuffers::Offset<flatbuffers::String> error) { fbb_.AddOffset(HandshakeAck::VT_ERROR, error); }
    explicit HandshakeAckBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    HandshakeAckBuilder &operator=(const HandshakeAckBuilder &);
    flatbuffers::Offset<HandshakeAck> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = flatbuffers::Offset<HandshakeAck>(end);
        fbb_.Required(o, HandshakeAck::VT_VERSION);
        fbb_.Required(o, HandshakeAck::VT_SESSION_ID);
        return o;
    }
};
 
inline flatbuffers::Offset<HandshakeAck> CreateHandshakeAck(flatbuffers::FlatBufferBuilder &_fbb,
                                                            flatbuffers::Offset<flatbuffers::String> version = 0,
                                                            flatbuffers::Offset<flatbuffers::String> session_id = 0,
                                                            bool accepted = true,
                                                            flatbuffers::Offset<flatbuffers::String> error = 0) {
    HandshakeAckBuilder builder_(_fbb);
    builder_.add_error(error);
    builder_.add_session_id(session_id);
    builder_.add_version(version);
    builder_.add_accepted(accepted);
    return builder_.Finish();
}
 
inline flatbuffers::Offset<HandshakeAck> CreateHandshakeAckDirect(flatbuffers::FlatBufferBuilder &_fbb,
                                                                  const char *version = nullptr,
                                                                  const char *session_id = nullptr,
                                                                  bool accepted = true, const char *error = nullptr) {
    auto version__ = version ? _fbb.CreateString(version) : 0;
    auto session_id__ = session_id ? _fbb.CreateString(session_id) : 0;
    auto error__ = error ? _fbb.CreateString(error) : 0;
    return Ember::Protocol::CreateHandshakeAck(_fbb, version__, session_id__, accepted, error__);
}
 
struct NodeDefinition FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
        VT_ID = 4,
        VT_NODE_TYPE = 6,
        VT_SUBTYPE = 8,
        VT_NAME = 10,
        VT_DESCRIPTION = 12,
        VT_ATTRIBUTES = 14,
        VT_CHILDREN = 16
    };
    int64_t id() const { return GetField<int64_t>(VT_ID, 0); }
    NodeType node_type() const { return static_cast<NodeType>(GetField<uint8_t>(VT_NODE_TYPE, 0)); }
    const flatbuffers::String *subtype() const { return GetPointer<const flatbuffers::String *>(VT_SUBTYPE); }
    const flatbuffers::String *name() const { return GetPointer<const flatbuffers::String *>(VT_NAME); }
    const flatbuffers::String *description() const { return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION); }
    const flatbuffers::Vector<flatbuffers::Offset<KeyValue>> *attributes() const {
        return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<KeyValue>> *>(VT_ATTRIBUTES);
    }
    const flatbuffers::Vector<flatbuffers::Offset<NodeDefinition>> *children() const {
        return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<NodeDefinition>> *>(VT_CHILDREN);
    }
    bool Verify(flatbuffers::Verifier &verifier) const {
        return VerifyTableStart(verifier) && VerifyField<int64_t>(verifier, VT_ID) &&
               VerifyField<uint8_t>(verifier, VT_NODE_TYPE) && VerifyOffsetRequired(verifier, VT_SUBTYPE) &&
               verifier.VerifyString(subtype()) && VerifyOffsetRequired(verifier, VT_NAME) &&
               verifier.VerifyString(name()) && VerifyOffset(verifier, VT_DESCRIPTION) &&
               verifier.VerifyString(description()) && VerifyOffset(verifier, VT_ATTRIBUTES) &&
               verifier.VerifyVector(attributes()) && verifier.VerifyVectorOfTables(attributes()) &&
               VerifyOffset(verifier, VT_CHILDREN) && verifier.VerifyVector(children()) &&
               verifier.VerifyVectorOfTables(children()) && verifier.EndTable();
    }
};
 
struct NodeDefinitionBuilder {
    flatbuffers::FlatBufferBuilder &fbb_;
    flatbuffers::uoffset_t start_;
    void add_id(int64_t id) { fbb_.AddElement<int64_t>(NodeDefinition::VT_ID, id, 0); }
    void add_node_type(NodeType node_type) {
        fbb_.AddElement<uint8_t>(NodeDefinition::VT_NODE_TYPE, static_cast<uint8_t>(node_type), 0);
    }
    void add_subtype(flatbuffers::Offset<flatbuffers::String> subtype) {
        fbb_.AddOffset(NodeDefinition::VT_SUBTYPE, subtype);
    }
    void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(NodeDefinition::VT_NAME, name); }
    void add_description(flatbuffers::Offset<flatbuffers::String> description) {
        fbb_.AddOffset(NodeDefinition::VT_DESCRIPTION, description);
    }
    void add_attributes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> attributes) {
        fbb_.AddOffset(NodeDefinition::VT_ATTRIBUTES, attributes);
    }
    void add_children(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NodeDefinition>>> children) {
        fbb_.AddOffset(NodeDefinition::VT_CHILDREN, children);
    }
    explicit NodeDefinitionBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    NodeDefinitionBuilder &operator=(const NodeDefinitionBuilder &);
    flatbuffers::Offset<NodeDefinition> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = flatbuffers::Offset<NodeDefinition>(end);
        fbb_.Required(o, NodeDefinition::VT_SUBTYPE);
        fbb_.Required(o, NodeDefinition::VT_NAME);
        return o;
    }
};
 
inline flatbuffers::Offset<NodeDefinition>
CreateNodeDefinition(flatbuffers::FlatBufferBuilder &_fbb, int64_t id = 0, NodeType node_type = NodeType_Action,
                     flatbuffers::Offset<flatbuffers::String> subtype = 0,
                     flatbuffers::Offset<flatbuffers::String> name = 0,
                     flatbuffers::Offset<flatbuffers::String> description = 0,
                     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> attributes = 0,
                     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NodeDefinition>>> children = 0) {
    NodeDefinitionBuilder builder_(_fbb);
    builder_.add_id(id);
    builder_.add_children(children);
    builder_.add_attributes(attributes);
    builder_.add_description(description);
    builder_.add_name(name);
    builder_.add_subtype(subtype);
    builder_.add_node_type(node_type);
    return builder_.Finish();
}
 
inline flatbuffers::Offset<NodeDefinition>
CreateNodeDefinitionDirect(flatbuffers::FlatBufferBuilder &_fbb, int64_t id = 0, NodeType node_type = NodeType_Action,
                           const char *subtype = nullptr, const char *name = nullptr, const char *description = nullptr,
                           const std::vector<flatbuffers::Offset<KeyValue>> *attributes = nullptr,
                           const std::vector<flatbuffers::Offset<NodeDefinition>> *children = nullptr) {
    auto subtype__ = subtype ? _fbb.CreateString(subtype) : 0;
    auto name__ = name ? _fbb.CreateString(name) : 0;
    auto description__ = description ? _fbb.CreateString(description) : 0;
    auto attributes__ = attributes ? _fbb.CreateVector<flatbuffers::Offset<KeyValue>>(*attributes) : 0;
    auto children__ = children ? _fbb.CreateVector<flatbuffers::Offset<NodeDefinition>>(*children) : 0;
    return Ember::Protocol::CreateNodeDefinition(_fbb, id, node_type, subtype__, name__, description__, attributes__,
                                                 children__);
}
 
struct BlackboardEntry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
        VT_KEY = 4,
        VT_VALUE_TYPE = 6,
        VT_VALUE = 8,
        VT_DESCRIPTION = 10
    };
    const flatbuffers::String *key() const { return GetPointer<const flatbuffers::String *>(VT_KEY); }
    const flatbuffers::String *value_type() const { return GetPointer<const flatbuffers::String *>(VT_VALUE_TYPE); }
    const flatbuffers::String *value() const { return GetPointer<const flatbuffers::String *>(VT_VALUE); }
    const flatbuffers::String *description() const { return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION); }
    bool Verify(flatbuffers::Verifier &verifier) const {
        return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_KEY) && verifier.VerifyString(key()) &&
               VerifyOffset(verifier, VT_VALUE_TYPE) && verifier.VerifyString(value_type()) &&
               VerifyOffset(verifier, VT_VALUE) && verifier.VerifyString(value()) &&
               VerifyOffset(verifier, VT_DESCRIPTION) && verifier.VerifyString(description()) && verifier.EndTable();
    }
};
 
struct BlackboardEntryBuilder {
    flatbuffers::FlatBufferBuilder &fbb_;
    flatbuffers::uoffset_t start_;
    void add_key(flatbuffers::Offset<flatbuffers::String> key) { fbb_.AddOffset(BlackboardEntry::VT_KEY, key); }
    void add_value_type(flatbuffers::Offset<flatbuffers::String> value_type) {
        fbb_.AddOffset(BlackboardEntry::VT_VALUE_TYPE, value_type);
    }
    void add_value(flatbuffers::Offset<flatbuffers::String> value) { fbb_.AddOffset(BlackboardEntry::VT_VALUE, value); }
    void add_description(flatbuffers::Offset<flatbuffers::String> description) {
        fbb_.AddOffset(BlackboardEntry::VT_DESCRIPTION, description);
    }
    explicit BlackboardEntryBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    BlackboardEntryBuilder &operator=(const BlackboardEntryBuilder &);
    flatbuffers::Offset<BlackboardEntry> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = flatbuffers::Offset<BlackboardEntry>(end);
        fbb_.Required(o, BlackboardEntry::VT_KEY);
        return o;
    }
};
 
inline flatbuffers::Offset<BlackboardEntry>
CreateBlackboardEntry(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset<flatbuffers::String> key = 0,
                      flatbuffers::Offset<flatbuffers::String> value_type = 0,
                      flatbuffers::Offset<flatbuffers::String> value = 0,
                      flatbuffers::Offset<flatbuffers::String> description = 0) {
    BlackboardEntryBuilder builder_(_fbb);
    builder_.add_description(description);
    builder_.add_value(value);
    builder_.add_value_type(value_type);
    builder_.add_key(key);
    return builder_.Finish();
}
 
inline flatbuffers::Offset<BlackboardEntry> CreateBlackboardEntryDirect(flatbuffers::FlatBufferBuilder &_fbb,
                                                                        const char *key = nullptr,
                                                                        const char *value_type = nullptr,
                                                                        const char *value = nullptr,
                                                                        const char *description = nullptr) {
    auto key__ = key ? _fbb.CreateString(key) : 0;
    auto value_type__ = value_type ? _fbb.CreateString(value_type) : 0;
    auto value__ = value ? _fbb.CreateString(value) : 0;
    auto description__ = description ? _fbb.CreateString(description) : 0;
    return Ember::Protocol::CreateBlackboardEntry(_fbb, key__, value_type__, value__, description__);
}
 
struct BlackboardDefinition FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_ID = 4, VT_NAME = 6, VT_ENTRIES = 8 };
    const flatbuffers::String *id() const { return GetPointer<const flatbuffers::String *>(VT_ID); }
    const flatbuffers::String *name() const { return GetPointer<const flatbuffers::String *>(VT_NAME); }
    const flatbuffers::Vector<flatbuffers::Offset<BlackboardEntry>> *entries() const {
        return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<BlackboardEntry>> *>(VT_ENTRIES);
    }
    bool Verify(flatbuffers::Verifier &verifier) const {
        return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_ID) && verifier.VerifyString(id()) &&
               VerifyOffset(verifier, VT_NAME) && verifier.VerifyString(name()) && VerifyOffset(verifier, VT_ENTRIES) &&
               verifier.VerifyVector(entries()) && verifier.VerifyVectorOfTables(entries()) && verifier.EndTable();
    }
};
 
struct BlackboardDefinitionBuilder {
    flatbuffers::FlatBufferBuilder &fbb_;
    flatbuffers::uoffset_t start_;
    void add_id(flatbuffers::Offset<flatbuffers::String> id) { fbb_.AddOffset(BlackboardDefinition::VT_ID, id); }
    void add_name(flatbuffers::Offset<flatbuffers::String> name) {
        fbb_.AddOffset(BlackboardDefinition::VT_NAME, name);
    }
    void add_entries(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BlackboardEntry>>> entries) {
        fbb_.AddOffset(BlackboardDefinition::VT_ENTRIES, entries);
    }
    explicit BlackboardDefinitionBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
        start_ = fbb_.StartTable();
    }
    BlackboardDefinitionBuilder &operator=(const BlackboardDefinitionBuilder &);
    flatbuffers::Offset<BlackboardDefinition> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = flatbuffers::Offset<BlackboardDefinition>(end);
        fbb_.Required(o, BlackboardDefinition::VT_ID);
        return o;
    }
};
 
inline flatbuffers::Offset<BlackboardDefinition>
CreateBlackboardDefinition(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset<flatbuffers::String> id = 0,
                           flatbuffers::Offset<flatbuffers::String> name = 0,
                           flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BlackboardEntry>>> entries = 0) {
    BlackboardDefinitionBuilder builder_(_fbb);
    builder_.add_entries(entries);
    builder_.add_name(name);
    builder_.add_id(id);
    return builder_.Finish();
}
 
inline flatbuffers::Offset<BlackboardDefinition>
CreateBlackboardDefinitionDirect(flatbuffers::FlatBufferBuilder &_fbb, const char *id = nullptr,
                                 const char *name = nullptr,
                                 const std::vector<flatbuffers::Offset<BlackboardEntry>> *entries = nullptr) {
    auto id__ = id ? _fbb.CreateString(id) : 0;
    auto name__ = name ? _fbb.CreateString(name) : 0;
    auto entries__ = entries ? _fbb.CreateVector<flatbuffers::Offset<BlackboardEntry>>(*entries) : 0;
    return Ember::Protocol::CreateBlackboardDefinition(_fbb, id__, name__, entries__);
}
 
struct TreeInit FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
        VT_TREE_ID = 4,
        VT_TREE_NAME = 6,
        VT_ROOT = 8,
        VT_BLACKBOARDS = 10,
        VT_METADATA = 12
    };
    const flatbuffers::String *tree_id() const { return GetPointer<const flatbuffers::String *>(VT_TREE_ID); }
    const flatbuffers::String *tree_name() const { return GetPointer<const flatbuffers::String *>(VT_TREE_NAME); }
    const NodeDefinition *root() const { return GetPointer<const NodeDefinition *>(VT_ROOT); }
    const flatbuffers::Vector<flatbuffers::Offset<BlackboardDefinition>> *blackboards() const {
        return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<BlackboardDefinition>> *>(VT_BLACKBOARDS);
    }
    const flatbuffers::Vector<flatbuffers::Offset<KeyValue>> *metadata() const {
        return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<KeyValue>> *>(VT_METADATA);
    }
    bool Verify(flatbuffers::Verifier &verifier) const {
        return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_TREE_ID) &&
               verifier.VerifyString(tree_id()) && VerifyOffset(verifier, VT_TREE_NAME) &&
               verifier.VerifyString(tree_name()) && VerifyOffsetRequired(verifier, VT_ROOT) &&
               verifier.VerifyTable(root()) && VerifyOffset(verifier, VT_BLACKBOARDS) &&
               verifier.VerifyVector(blackboards()) && verifier.VerifyVectorOfTables(blackboards()) &&
               VerifyOffset(verifier, VT_METADATA) && verifier.VerifyVector(metadata()) &&
               verifier.VerifyVectorOfTables(metadata()) && verifier.EndTable();
    }
};
 
struct TreeInitBuilder {
    flatbuffers::FlatBufferBuilder &fbb_;
    flatbuffers::uoffset_t start_;
    void add_tree_id(flatbuffers::Offset<flatbuffers::String> tree_id) {
        fbb_.AddOffset(TreeInit::VT_TREE_ID, tree_id);
    }
    void add_tree_name(flatbuffers::Offset<flatbuffers::String> tree_name) {
        fbb_.AddOffset(TreeInit::VT_TREE_NAME, tree_name);
    }
    void add_root(flatbuffers::Offset<NodeDefinition> root) { fbb_.AddOffset(TreeInit::VT_ROOT, root); }
    void
    add_blackboards(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BlackboardDefinition>>> blackboards) {
        fbb_.AddOffset(TreeInit::VT_BLACKBOARDS, blackboards);
    }
    void add_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> metadata) {
        fbb_.AddOffset(TreeInit::VT_METADATA, metadata);
    }
    explicit TreeInitBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    TreeInitBuilder &operator=(const TreeInitBuilder &);
    flatbuffers::Offset<TreeInit> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = flatbuffers::Offset<TreeInit>(end);
        fbb_.Required(o, TreeInit::VT_TREE_ID);
        fbb_.Required(o, TreeInit::VT_ROOT);
        return o;
    }
};
 
inline flatbuffers::Offset<TreeInit>
CreateTreeInit(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset<flatbuffers::String> tree_id = 0,
               flatbuffers::Offset<flatbuffers::String> tree_name = 0, flatbuffers::Offset<NodeDefinition> root = 0,
               flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BlackboardDefinition>>> blackboards = 0,
               flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> metadata = 0) {
    TreeInitBuilder builder_(_fbb);
    builder_.add_metadata(metadata);
    builder_.add_blackboards(blackboards);
    builder_.add_root(root);
    builder_.add_tree_name(tree_name);
    builder_.add_tree_id(tree_id);
    return builder_.Finish();
}
 
inline flatbuffers::Offset<TreeInit>
CreateTreeInitDirect(flatbuffers::FlatBufferBuilder &_fbb, const char *tree_id = nullptr,
                     const char *tree_name = nullptr, flatbuffers::Offset<NodeDefinition> root = 0,
                     const std::vector<flatbuffers::Offset<BlackboardDefinition>> *blackboards = nullptr,
                     const std::vector<flatbuffers::Offset<KeyValue>> *metadata = nullptr) {
    auto tree_id__ = tree_id ? _fbb.CreateString(tree_id) : 0;
    auto tree_name__ = tree_name ? _fbb.CreateString(tree_name) : 0;
    auto blackboards__ = blackboards ? _fbb.CreateVector<flatbuffers::Offset<BlackboardDefinition>>(*blackboards) : 0;
    auto metadata__ = metadata ? _fbb.CreateVector<flatbuffers::Offset<KeyValue>>(*metadata) : 0;
    return Ember::Protocol::CreateTreeInit(_fbb, tree_id__, tree_name__, root, blackboards__, metadata__);
}
 
struct TreeInitAck FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
        VT_TREE_ID = 4,
        VT_SUCCESS = 6,
        VT_NODE_COUNT = 8,
        VT_ERROR = 10
    };
    const flatbuffers::String *tree_id() const { return GetPointer<const flatbuffers::String *>(VT_TREE_ID); }
    bool success() const { return GetField<uint8_t>(VT_SUCCESS, 1) != 0; }
    int32_t node_count() const { return GetField<int32_t>(VT_NODE_COUNT, 0); }
    const flatbuffers::String *error() const { return GetPointer<const flatbuffers::String *>(VT_ERROR); }
    bool Verify(flatbuffers::Verifier &verifier) const {
        return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_TREE_ID) &&
               verifier.VerifyString(tree_id()) && VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
               VerifyField<int32_t>(verifier, VT_NODE_COUNT) && VerifyOffset(verifier, VT_ERROR) &&
               verifier.VerifyString(error()) && verifier.EndTable();
    }
};
 
struct TreeInitAckBuilder {
    flatbuffers::FlatBufferBuilder &fbb_;
    flatbuffers::uoffset_t start_;
    void add_tree_id(flatbuffers::Offset<flatbuffers::String> tree_id) {
        fbb_.AddOffset(TreeInitAck::VT_TREE_ID, tree_id);
    }
    void add_success(bool success) {
        fbb_.AddElement<uint8_t>(TreeInitAck::VT_SUCCESS, static_cast<uint8_t>(success), 1);
    }
    void add_node_count(int32_t node_count) { fbb_.AddElement<int32_t>(TreeInitAck::VT_NODE_COUNT, node_count, 0); }
    void add_error(flatbuffers::Offset<flatbuffers::String> error) { fbb_.AddOffset(TreeInitAck::VT_ERROR, error); }
    explicit TreeInitAckBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    TreeInitAckBuilder &operator=(const TreeInitAckBuilder &);
    flatbuffers::Offset<TreeInitAck> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = flatbuffers::Offset<TreeInitAck>(end);
        fbb_.Required(o, TreeInitAck::VT_TREE_ID);
        return o;
    }
};
 
inline flatbuffers::Offset<TreeInitAck> CreateTreeInitAck(flatbuffers::FlatBufferBuilder &_fbb,
                                                          flatbuffers::Offset<flatbuffers::String> tree_id = 0,
                                                          bool success = true, int32_t node_count = 0,
                                                          flatbuffers::Offset<flatbuffers::String> error = 0) {
    TreeInitAckBuilder builder_(_fbb);
    builder_.add_error(error);
    builder_.add_node_count(node_count);
    builder_.add_tree_id(tree_id);
    builder_.add_success(success);
    return builder_.Finish();
}
 
inline flatbuffers::Offset<TreeInitAck> CreateTreeInitAckDirect(flatbuffers::FlatBufferBuilder &_fbb,
                                                                const char *tree_id = nullptr, bool success = true,
                                                                int32_t node_count = 0, const char *error = nullptr) {
    auto tree_id__ = tree_id ? _fbb.CreateString(tree_id) : 0;
    auto error__ = error ? _fbb.CreateString(error) : 0;
    return Ember::Protocol::CreateTreeInitAck(_fbb, tree_id__, success, node_count, error__);
}
 
struct NodeState FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
        VT_ID = 4,
        VT_STATUS = 6,
        VT_LAST_RESULT = 8,
        VT_TICK_COUNT = 10,
        VT_MESSAGE = 12
    };
    int64_t id() const { return GetField<int64_t>(VT_ID, 0); }
    NodeStatus status() const { return static_cast<NodeStatus>(GetField<uint8_t>(VT_STATUS, 0)); }
    NodeStatus last_result() const { return static_cast<NodeStatus>(GetField<uint8_t>(VT_LAST_RESULT, 0)); }
    int64_t tick_count() const { return GetField<int64_t>(VT_TICK_COUNT, 0); }
    const flatbuffers::String *message() const { return GetPointer<const flatbuffers::String *>(VT_MESSAGE); }
    bool Verify(flatbuffers::Verifier &verifier) const {
        return VerifyTableStart(verifier) && VerifyField<int64_t>(verifier, VT_ID) &&
               VerifyField<uint8_t>(verifier, VT_STATUS) && VerifyField<uint8_t>(verifier, VT_LAST_RESULT) &&
               VerifyField<int64_t>(verifier, VT_TICK_COUNT) && VerifyOffset(verifier, VT_MESSAGE) &&
               verifier.VerifyString(message()) && verifier.EndTable();
    }
};
 
struct NodeStateBuilder {
    flatbuffers::FlatBufferBuilder &fbb_;
    flatbuffers::uoffset_t start_;
    void add_id(int64_t id) { fbb_.AddElement<int64_t>(NodeState::VT_ID, id, 0); }
    void add_status(NodeStatus status) {
        fbb_.AddElement<uint8_t>(NodeState::VT_STATUS, static_cast<uint8_t>(status), 0);
    }
    void add_last_result(NodeStatus last_result) {
        fbb_.AddElement<uint8_t>(NodeState::VT_LAST_RESULT, static_cast<uint8_t>(last_result), 0);
    }
    void add_tick_count(int64_t tick_count) { fbb_.AddElement<int64_t>(NodeState::VT_TICK_COUNT, tick_count, 0); }
    void add_message(flatbuffers::Offset<flatbuffers::String> message) {
        fbb_.AddOffset(NodeState::VT_MESSAGE, message);
    }
    explicit NodeStateBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    NodeStateBuilder &operator=(const NodeStateBuilder &);
    flatbuffers::Offset<NodeState> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = flatbuffers::Offset<NodeState>(end);
        return o;
    }
};
 
inline flatbuffers::Offset<NodeState> CreateNodeState(flatbuffers::FlatBufferBuilder &_fbb, int64_t id = 0,
                                                      NodeStatus status = NodeStatus_Idle,
                                                      NodeStatus last_result = NodeStatus_Idle, int64_t tick_count = 0,
                                                      flatbuffers::Offset<flatbuffers::String> message = 0) {
    NodeStateBuilder builder_(_fbb);
    builder_.add_tick_count(tick_count);
    builder_.add_id(id);
    builder_.add_message(message);
    builder_.add_last_result(last_result);
    builder_.add_status(status);
    return builder_.Finish();
}
 
inline flatbuffers::Offset<NodeState> CreateNodeStateDirect(flatbuffers::FlatBufferBuilder &_fbb, int64_t id = 0,
                                                            NodeStatus status = NodeStatus_Idle,
                                                            NodeStatus last_result = NodeStatus_Idle,
                                                            int64_t tick_count = 0, const char *message = nullptr) {
    auto message__ = message ? _fbb.CreateString(message) : 0;
    return Ember::Protocol::CreateNodeState(_fbb, id, status, last_result, tick_count, message__);
}
 
struct TickUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
        VT_TREE_ID = 4,
        VT_TICK_NUMBER = 6,
        VT_TICK_TIMESTAMP_MS = 8,
        VT_DELTA_TIME_MS = 10,
        VT_IS_DELTA = 12,
        VT_STATES = 14,
        VT_EXECUTION_PATH = 16
    };
    const flatbuffers::String *tree_id() const { return GetPointer<const flatbuffers::String *>(VT_TREE_ID); }
    int64_t tick_number() const { return GetField<int64_t>(VT_TICK_NUMBER, 0); }
    int64_t tick_timestamp_ms() const { return GetField<int64_t>(VT_TICK_TIMESTAMP_MS, 0); }
    float delta_time_ms() const { return GetField<float>(VT_DELTA_TIME_MS, 0.0f); }
    bool is_delta() const { return GetField<uint8_t>(VT_IS_DELTA, 0) != 0; }
    const flatbuffers::Vector<flatbuffers::Offset<NodeState>> *states() const {
        return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<NodeState>> *>(VT_STATES);
    }
    const flatbuffers::Vector<int64_t> *execution_path() const {
        return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_EXECUTION_PATH);
    }
    bool Verify(flatbuffers::Verifier &verifier) const {
        return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_TREE_ID) &&
               verifier.VerifyString(tree_id()) && VerifyField<int64_t>(verifier, VT_TICK_NUMBER) &&
               VerifyField<int64_t>(verifier, VT_TICK_TIMESTAMP_MS) && VerifyField<float>(verifier, VT_DELTA_TIME_MS) &&
               VerifyField<uint8_t>(verifier, VT_IS_DELTA) && VerifyOffsetRequired(verifier, VT_STATES) &&
               verifier.VerifyVector(states()) && verifier.VerifyVectorOfTables(states()) &&
               VerifyOffset(verifier, VT_EXECUTION_PATH) && verifier.VerifyVector(execution_path()) &&
               verifier.EndTable();
    }
};
 
struct TickUpdateBuilder {
    flatbuffers::FlatBufferBuilder &fbb_;
    flatbuffers::uoffset_t start_;
    void add_tree_id(flatbuffers::Offset<flatbuffers::String> tree_id) {
        fbb_.AddOffset(TickUpdate::VT_TREE_ID, tree_id);
    }
    void add_tick_number(int64_t tick_number) { fbb_.AddElement<int64_t>(TickUpdate::VT_TICK_NUMBER, tick_number, 0); }
    void add_tick_timestamp_ms(int64_t tick_timestamp_ms) {
        fbb_.AddElement<int64_t>(TickUpdate::VT_TICK_TIMESTAMP_MS, tick_timestamp_ms, 0);
    }
    void add_delta_time_ms(float delta_time_ms) {
        fbb_.AddElement<float>(TickUpdate::VT_DELTA_TIME_MS, delta_time_ms, 0.0f);
    }
    void add_is_delta(bool is_delta) {
        fbb_.AddElement<uint8_t>(TickUpdate::VT_IS_DELTA, static_cast<uint8_t>(is_delta), 0);
    }
    void add_states(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NodeState>>> states) {
        fbb_.AddOffset(TickUpdate::VT_STATES, states);
    }
    void add_execution_path(flatbuffers::Offset<flatbuffers::Vector<int64_t>> execution_path) {
        fbb_.AddOffset(TickUpdate::VT_EXECUTION_PATH, execution_path);
    }
    explicit TickUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    TickUpdateBuilder &operator=(const TickUpdateBuilder &);
    flatbuffers::Offset<TickUpdate> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = flatbuffers::Offset<TickUpdate>(end);
        fbb_.Required(o, TickUpdate::VT_TREE_ID);
        fbb_.Required(o, TickUpdate::VT_STATES);
        return o;
    }
};
 
inline flatbuffers::Offset<TickUpdate>
CreateTickUpdate(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset<flatbuffers::String> tree_id = 0,
                 int64_t tick_number = 0, int64_t tick_timestamp_ms = 0, float delta_time_ms = 0.0f,
                 bool is_delta = false,
                 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NodeState>>> states = 0,
                 flatbuffers::Offset<flatbuffers::Vector<int64_t>> execution_path = 0) {
    TickUpdateBuilder builder_(_fbb);
    builder_.add_tick_timestamp_ms(tick_timestamp_ms);
    builder_.add_tick_number(tick_number);
    builder_.add_execution_path(execution_path);
    builder_.add_states(states);
    builder_.add_delta_time_ms(delta_time_ms);
    builder_.add_tree_id(tree_id);
    builder_.add_is_delta(is_delta);
    return builder_.Finish();
}
 
inline flatbuffers::Offset<TickUpdate>
CreateTickUpdateDirect(flatbuffers::FlatBufferBuilder &_fbb, const char *tree_id = nullptr, int64_t tick_number = 0,
                       int64_t tick_timestamp_ms = 0, float delta_time_ms = 0.0f, bool is_delta = false,
                       const std::vector<flatbuffers::Offset<NodeState>> *states = nullptr,
                       const std::vector<int64_t> *execution_path = nullptr) {
    auto tree_id__ = tree_id ? _fbb.CreateString(tree_id) : 0;
    auto states__ = states ? _fbb.CreateVector<flatbuffers::Offset<NodeState>>(*states) : 0;
    auto execution_path__ = execution_path ? _fbb.CreateVector<int64_t>(*execution_path) : 0;
    return Ember::Protocol::CreateTickUpdate(_fbb, tree_id__, tick_number, tick_timestamp_ms, delta_time_ms, is_delta,
                                             states__, execution_path__);
}
 
struct TickUpdateBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_TREE_ID = 4, VT_TICKS = 6 };
    const flatbuffers::String *tree_id() const { return GetPointer<const flatbuffers::String *>(VT_TREE_ID); }
    const flatbuffers::Vector<flatbuffers::Offset<TickUpdate>> *ticks() const {
        return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<TickUpdate>> *>(VT_TICKS);
    }
    bool Verify(flatbuffers::Verifier &verifier) const {
        return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_TREE_ID) &&
               verifier.VerifyString(tree_id()) && VerifyOffsetRequired(verifier, VT_TICKS) &&
               verifier.VerifyVector(ticks()) && verifier.VerifyVectorOfTables(ticks()) && verifier.EndTable();
    }
};
 
struct TickUpdateBatchBuilder {
    flatbuffers::FlatBufferBuilder &fbb_;
    flatbuffers::uoffset_t start_;
    void add_tree_id(flatbuffers::Offset<flatbuffers::String> tree_id) {
        fbb_.AddOffset(TickUpdateBatch::VT_TREE_ID, tree_id);
    }
    void add_ticks(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TickUpdate>>> ticks) {
        fbb_.AddOffset(TickUpdateBatch::VT_TICKS, ticks);
    }
    explicit TickUpdateBatchBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    TickUpdateBatchBuilder &operator=(const TickUpdateBatchBuilder &);
    flatbuffers::Offset<TickUpdateBatch> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = flatbuffers::Offset<TickUpdateBatch>(end);
        fbb_.Required(o, TickUpdateBatch::VT_TREE_ID);
        fbb_.Required(o, TickUpdateBatch::VT_TICKS);
        return o;
    }
};
 
inline flatbuffers::Offset<TickUpdateBatch>
CreateTickUpdateBatch(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset<flatbuffers::String> tree_id = 0,
                      flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TickUpdate>>> ticks = 0) {
    TickUpdateBatchBuilder builder_(_fbb);
    builder_.add_ticks(ticks);
    builder_.add_tree_id(tree_id);
    return builder_.Finish();
}
 
inline flatbuffers::Offset<TickUpdateBatch>
CreateTickUpdateBatchDirect(flatbuffers::FlatBufferBuilder &_fbb, const char *tree_id = nullptr,
                            const std::vector<flatbuffers::Offset<TickUpdate>> *ticks = nullptr) {
    auto tree_id__ = tree_id ? _fbb.CreateString(tree_id) : 0;
    auto ticks__ = ticks ? _fbb.CreateVector<flatbuffers::Offset<TickUpdate>>(*ticks) : 0;
    return Ember::Protocol::CreateTickUpdateBatch(_fbb, tree_id__, ticks__);
}
 
struct BlackboardUpdateEntry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_KEY = 4, VT_VALUE = 6, VT_PREVIOUS_VALUE = 8 };
    const flatbuffers::String *key() const { return GetPointer<const flatbuffers::String *>(VT_KEY); }
    const flatbuffers::String *value() const { return GetPointer<const flatbuffers::String *>(VT_VALUE); }
    const flatbuffers::String *previous_value() const {
        return GetPointer<const flatbuffers::String *>(VT_PREVIOUS_VALUE);
    }
    bool Verify(flatbuffers::Verifier &verifier) const {
        return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_KEY) && verifier.VerifyString(key()) &&
               VerifyOffset(verifier, VT_VALUE) && verifier.VerifyString(value()) &&
               VerifyOffset(verifier, VT_PREVIOUS_VALUE) && verifier.VerifyString(previous_value()) &&
               verifier.EndTable();
    }
};
 
struct BlackboardUpdateEntryBuilder {
    flatbuffers::FlatBufferBuilder &fbb_;
    flatbuffers::uoffset_t start_;
    void add_key(flatbuffers::Offset<flatbuffers::String> key) { fbb_.AddOffset(BlackboardUpdateEntry::VT_KEY, key); }
    void add_value(flatbuffers::Offset<flatbuffers::String> value) {
        fbb_.AddOffset(BlackboardUpdateEntry::VT_VALUE, value);
    }
    void add_previous_value(flatbuffers::Offset<flatbuffers::String> previous_value) {
        fbb_.AddOffset(BlackboardUpdateEntry::VT_PREVIOUS_VALUE, previous_value);
    }
    explicit BlackboardUpdateEntryBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
        start_ = fbb_.StartTable();
    }
    BlackboardUpdateEntryBuilder &operator=(const BlackboardUpdateEntryBuilder &);
    flatbuffers::Offset<BlackboardUpdateEntry> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = flatbuffers::Offset<BlackboardUpdateEntry>(end);
        fbb_.Required(o, BlackboardUpdateEntry::VT_KEY);
        return o;
    }
};
 
inline flatbuffers::Offset<BlackboardUpdateEntry>
CreateBlackboardUpdateEntry(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset<flatbuffers::String> key = 0,
                            flatbuffers::Offset<flatbuffers::String> value = 0,
                            flatbuffers::Offset<flatbuffers::String> previous_value = 0) {
    BlackboardUpdateEntryBuilder builder_(_fbb);
    builder_.add_previous_value(previous_value);
    builder_.add_value(value);
    builder_.add_key(key);
    return builder_.Finish();
}
 
inline flatbuffers::Offset<BlackboardUpdateEntry>
CreateBlackboardUpdateEntryDirect(flatbuffers::FlatBufferBuilder &_fbb, const char *key = nullptr,
                                  const char *value = nullptr, const char *previous_value = nullptr) {
    auto key__ = key ? _fbb.CreateString(key) : 0;
    auto value__ = value ? _fbb.CreateString(value) : 0;
    auto previous_value__ = previous_value ? _fbb.CreateString(previous_value) : 0;
    return Ember::Protocol::CreateBlackboardUpdateEntry(_fbb, key__, value__, previous_value__);
}
 
struct BlackboardUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
        VT_TREE_ID = 4,
        VT_BLACKBOARD_ID = 6,
        VT_TICK_NUMBER = 8,
        VT_UPDATES = 10
    };
    const flatbuffers::String *tree_id() const { return GetPointer<const flatbuffers::String *>(VT_TREE_ID); }
    const flatbuffers::String *blackboard_id() const {
        return GetPointer<const flatbuffers::String *>(VT_BLACKBOARD_ID);
    }
    int64_t tick_number() const { return GetField<int64_t>(VT_TICK_NUMBER, 0); }
    const flatbuffers::Vector<flatbuffers::Offset<BlackboardUpdateEntry>> *updates() const {
        return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<BlackboardUpdateEntry>> *>(VT_UPDATES);
    }
    bool Verify(flatbuffers::Verifier &verifier) const {
        return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_TREE_ID) &&
               verifier.VerifyString(tree_id()) && VerifyOffsetRequired(verifier, VT_BLACKBOARD_ID) &&
               verifier.VerifyString(blackboard_id()) && VerifyField<int64_t>(verifier, VT_TICK_NUMBER) &&
               VerifyOffset(verifier, VT_UPDATES) && verifier.VerifyVector(updates()) &&
               verifier.VerifyVectorOfTables(updates()) && verifier.EndTable();
    }
};
 
struct BlackboardUpdateBuilder {
    flatbuffers::FlatBufferBuilder &fbb_;
    flatbuffers::uoffset_t start_;
    void add_tree_id(flatbuffers::Offset<flatbuffers::String> tree_id) {
        fbb_.AddOffset(BlackboardUpdate::VT_TREE_ID, tree_id);
    }
    void add_blackboard_id(flatbuffers::Offset<flatbuffers::String> blackboard_id) {
        fbb_.AddOffset(BlackboardUpdate::VT_BLACKBOARD_ID, blackboard_id);
    }
    void add_tick_number(int64_t tick_number) {
        fbb_.AddElement<int64_t>(BlackboardUpdate::VT_TICK_NUMBER, tick_number, 0);
    }
    void add_updates(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BlackboardUpdateEntry>>> updates) {
        fbb_.AddOffset(BlackboardUpdate::VT_UPDATES, updates);
    }
    explicit BlackboardUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    BlackboardUpdateBuilder &operator=(const BlackboardUpdateBuilder &);
    flatbuffers::Offset<BlackboardUpdate> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = flatbuffers::Offset<BlackboardUpdate>(end);
        fbb_.Required(o, BlackboardUpdate::VT_TREE_ID);
        fbb_.Required(o, BlackboardUpdate::VT_BLACKBOARD_ID);
        return o;
    }
};
 
inline flatbuffers::Offset<BlackboardUpdate> CreateBlackboardUpdate(
    flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset<flatbuffers::String> tree_id = 0,
    flatbuffers::Offset<flatbuffers::String> blackboard_id = 0, int64_t tick_number = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BlackboardUpdateEntry>>> updates = 0) {
    BlackboardUpdateBuilder builder_(_fbb);
    builder_.add_tick_number(tick_number);
    builder_.add_updates(updates);
    builder_.add_blackboard_id(blackboard_id);
    builder_.add_tree_id(tree_id);
    return builder_.Finish();
}
 
inline flatbuffers::Offset<BlackboardUpdate>
CreateBlackboardUpdateDirect(flatbuffers::FlatBufferBuilder &_fbb, const char *tree_id = nullptr,
                             const char *blackboard_id = nullptr, int64_t tick_number = 0,
                             const std::vector<flatbuffers::Offset<BlackboardUpdateEntry>> *updates = nullptr) {
    auto tree_id__ = tree_id ? _fbb.CreateString(tree_id) : 0;
    auto blackboard_id__ = blackboard_id ? _fbb.CreateString(blackboard_id) : 0;
    auto updates__ = updates ? _fbb.CreateVector<flatbuffers::Offset<BlackboardUpdateEntry>>(*updates) : 0;
    return Ember::Protocol::CreateBlackboardUpdate(_fbb, tree_id__, blackboard_id__, tick_number, updates__);
}
 
struct TreeReset FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
        VT_TREE_ID = 4,
        VT_TICK_NUMBER = 6,
        VT_REASON = 8
    };
    const flatbuffers::String *tree_id() const { return GetPointer<const flatbuffers::String *>(VT_TREE_ID); }
    int64_t tick_number() const { return GetField<int64_t>(VT_TICK_NUMBER, 0); }
    const flatbuffers::String *reason() const { return GetPointer<const flatbuffers::String *>(VT_REASON); }
    bool Verify(flatbuffers::Verifier &verifier) const {
        return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_TREE_ID) &&
               verifier.VerifyString(tree_id()) && VerifyField<int64_t>(verifier, VT_TICK_NUMBER) &&
               VerifyOffset(verifier, VT_REASON) && verifier.VerifyString(reason()) && verifier.EndTable();
    }
};
 
struct TreeResetBuilder {
    flatbuffers::FlatBufferBuilder &fbb_;
    flatbuffers::uoffset_t start_;
    void add_tree_id(flatbuffers::Offset<flatbuffers::String> tree_id) {
        fbb_.AddOffset(TreeReset::VT_TREE_ID, tree_id);
    }
    void add_tick_number(int64_t tick_number) { fbb_.AddElement<int64_t>(TreeReset::VT_TICK_NUMBER, tick_number, 0); }
    void add_reason(flatbuffers::Offset<flatbuffers::String> reason) { fbb_.AddOffset(TreeReset::VT_REASON, reason); }
    explicit TreeResetBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    TreeResetBuilder &operator=(const TreeResetBuilder &);
    flatbuffers::Offset<TreeReset> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = flatbuffers::Offset<TreeReset>(end);
        fbb_.Required(o, TreeReset::VT_TREE_ID);
        return o;
    }
};
 
inline flatbuffers::Offset<TreeReset> CreateTreeReset(flatbuffers::FlatBufferBuilder &_fbb,
                                                      flatbuffers::Offset<flatbuffers::String> tree_id = 0,
                                                      int64_t tick_number = 0,
                                                      flatbuffers::Offset<flatbuffers::String> reason = 0) {
    TreeResetBuilder builder_(_fbb);
    builder_.add_tick_number(tick_number);
    builder_.add_reason(reason);
    builder_.add_tree_id(tree_id);
    return builder_.Finish();
}
 
inline flatbuffers::Offset<TreeReset> CreateTreeResetDirect(flatbuffers::FlatBufferBuilder &_fbb,
                                                            const char *tree_id = nullptr, int64_t tick_number = 0,
                                                            const char *reason = nullptr) {
    auto tree_id__ = tree_id ? _fbb.CreateString(tree_id) : 0;
    auto reason__ = reason ? _fbb.CreateString(reason) : 0;
    return Ember::Protocol::CreateTreeReset(_fbb, tree_id__, tick_number, reason__);
}
 
struct Disconnect FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_REASON = 4, VT_MESSAGE = 6 };
    const flatbuffers::String *reason() const { return GetPointer<const flatbuffers::String *>(VT_REASON); }
    const flatbuffers::String *message() const { return GetPointer<const flatbuffers::String *>(VT_MESSAGE); }
    bool Verify(flatbuffers::Verifier &verifier) const {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_REASON) && verifier.VerifyString(reason()) &&
               VerifyOffset(verifier, VT_MESSAGE) && verifier.VerifyString(message()) && verifier.EndTable();
    }
};
 
struct DisconnectBuilder {
    flatbuffers::FlatBufferBuilder &fbb_;
    flatbuffers::uoffset_t start_;
    void add_reason(flatbuffers::Offset<flatbuffers::String> reason) { fbb_.AddOffset(Disconnect::VT_REASON, reason); }
    void add_message(flatbuffers::Offset<flatbuffers::String> message) {
        fbb_.AddOffset(Disconnect::VT_MESSAGE, message);
    }
    explicit DisconnectBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    DisconnectBuilder &operator=(const DisconnectBuilder &);
    flatbuffers::Offset<Disconnect> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = flatbuffers::Offset<Disconnect>(end);
        return o;
    }
};
 
inline flatbuffers::Offset<Disconnect> CreateDisconnect(flatbuffers::FlatBufferBuilder &_fbb,
                                                        flatbuffers::Offset<flatbuffers::String> reason = 0,
                                                        flatbuffers::Offset<flatbuffers::String> message = 0) {
    DisconnectBuilder builder_(_fbb);
    builder_.add_message(message);
    builder_.add_reason(reason);
    return builder_.Finish();
}
 
inline flatbuffers::Offset<Disconnect> CreateDisconnectDirect(flatbuffers::FlatBufferBuilder &_fbb,
                                                              const char *reason = nullptr,
                                                              const char *message = nullptr) {
    auto reason__ = reason ? _fbb.CreateString(reason) : 0;
    auto message__ = message ? _fbb.CreateString(message) : 0;
    return Ember::Protocol::CreateDisconnect(_fbb, reason__, message__);
}
 
struct Error FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_CODE = 4, VT_MESSAGE = 6, VT_FATAL = 8 };
    ErrorCode code() const { return static_cast<ErrorCode>(GetField<uint16_t>(VT_CODE, 0)); }
    const flatbuffers::String *message() const { return GetPointer<const flatbuffers::String *>(VT_MESSAGE); }
    bool fatal() const { return GetField<uint8_t>(VT_FATAL, 0) != 0; }
    bool Verify(flatbuffers::Verifier &verifier) const {
        return VerifyTableStart(verifier) && VerifyField<uint16_t>(verifier, VT_CODE) &&
               VerifyOffset(verifier, VT_MESSAGE) && verifier.VerifyString(message()) &&
               VerifyField<uint8_t>(verifier, VT_FATAL) && verifier.EndTable();
    }
};
 
struct ErrorBuilder {
    flatbuffers::FlatBufferBuilder &fbb_;
    flatbuffers::uoffset_t start_;
    void add_code(ErrorCode code) { fbb_.AddElement<uint16_t>(Error::VT_CODE, static_cast<uint16_t>(code), 0); }
    void add_message(flatbuffers::Offset<flatbuffers::String> message) { fbb_.AddOffset(Error::VT_MESSAGE, message); }
    void add_fatal(bool fatal) { fbb_.AddElement<uint8_t>(Error::VT_FATAL, static_cast<uint8_t>(fatal), 0); }
    explicit ErrorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    ErrorBuilder &operator=(const ErrorBuilder &);
    flatbuffers::Offset<Error> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = flatbuffers::Offset<Error>(end);
        return o;
    }
};
 
inline flatbuffers::Offset<Error> CreateError(flatbuffers::FlatBufferBuilder &_fbb, ErrorCode code = ErrorCode_None,
                                              flatbuffers::Offset<flatbuffers::String> message = 0,
                                              bool fatal = false) {
    ErrorBuilder builder_(_fbb);
    builder_.add_message(message);
    builder_.add_code(code);
    builder_.add_fatal(fatal);
    return builder_.Finish();
}
 
inline flatbuffers::Offset<Error> CreateErrorDirect(flatbuffers::FlatBufferBuilder &_fbb,
                                                    ErrorCode code = ErrorCode_None, const char *message = nullptr,
                                                    bool fatal = false) {
    auto message__ = message ? _fbb.CreateString(message) : 0;
    return Ember::Protocol::CreateError(_fbb, code, message__, fatal);
}
 
inline const Ember::Protocol::TickUpdate *GetTickUpdate(const void *buf) {
    return flatbuffers::GetRoot<Ember::Protocol::TickUpdate>(buf);
}
 
inline const Ember::Protocol::TickUpdate *GetSizePrefixedTickUpdate(const void *buf) {
    return flatbuffers::GetSizePrefixedRoot<Ember::Protocol::TickUpdate>(buf);
}
 
inline bool VerifyTickUpdateBuffer(flatbuffers::Verifier &verifier) {
    return verifier.VerifyBuffer<Ember::Protocol::TickUpdate>(nullptr);
}
 
inline bool VerifySizePrefixedTickUpdateBuffer(flatbuffers::Verifier &verifier) {
    return verifier.VerifySizePrefixedBuffer<Ember::Protocol::TickUpdate>(nullptr);
}
 
inline void FinishTickUpdateBuffer(flatbuffers::FlatBufferBuilder &fbb,
                                   flatbuffers::Offset<Ember::Protocol::TickUpdate> root) {
    fbb.Finish(root);
}
 
inline void FinishSizePrefixedTickUpdateBuffer(flatbuffers::FlatBufferBuilder &fbb,
                                               flatbuffers::Offset<Ember::Protocol::TickUpdate> root) {
    fbb.FinishSizePrefixed(root);
}
 
} // namespace Protocol
} // namespace Ember
 
#endif // FLATBUFFERS_GENERATED_EMBERPROTOCOL_EMBER_PROTOCOL_H_