00001
00002
00003
00004 #ifndef FLATBUFFERS_GENERATED_BTLOGGER_SERIALIZATION_H_
00005 #define FLATBUFFERS_GENERATED_BTLOGGER_SERIALIZATION_H_
00006
00007 #include "behaviortree_cpp/flatbuffers/flatbuffers.h"
00008
00009 namespace Serialization {
00010
00011 struct PortModel;
00012
00013 struct PortConfig;
00014
00015 struct TreeNode;
00016
00017 struct NodeModel;
00018
00019 struct BehaviorTree;
00020
00021 struct Timestamp;
00022
00023 struct StatusChange;
00024
00025 struct StatusChangeLog;
00026
00027 enum class NodeStatus : int8_t {
00028 IDLE = 0,
00029 RUNNING = 1,
00030 SUCCESS = 2,
00031 FAILURE = 3,
00032 MIN = IDLE,
00033 MAX = FAILURE
00034 };
00035
00036 inline const NodeStatus (&EnumValuesNodeStatus())[4] {
00037 static const NodeStatus values[] = {
00038 NodeStatus::IDLE,
00039 NodeStatus::RUNNING,
00040 NodeStatus::SUCCESS,
00041 NodeStatus::FAILURE
00042 };
00043 return values;
00044 }
00045
00046 inline const char * const *EnumNamesNodeStatus() {
00047 static const char * const names[] = {
00048 "IDLE",
00049 "RUNNING",
00050 "SUCCESS",
00051 "FAILURE",
00052 nullptr
00053 };
00054 return names;
00055 }
00056
00057 inline const char *EnumNameNodeStatus(NodeStatus e) {
00058 if (e < NodeStatus::IDLE || e > NodeStatus::FAILURE) return "";
00059 const size_t index = static_cast<int>(e);
00060 return EnumNamesNodeStatus()[index];
00061 }
00062
00063 enum class NodeType : int8_t {
00064 UNDEFINED = 0,
00065 ACTION = 1,
00066 CONDITION = 2,
00067 CONTROL = 3,
00068 DECORATOR = 4,
00069 SUBTREE = 5,
00070 MIN = UNDEFINED,
00071 MAX = SUBTREE
00072 };
00073
00074 inline const NodeType (&EnumValuesNodeType())[6] {
00075 static const NodeType values[] = {
00076 NodeType::UNDEFINED,
00077 NodeType::ACTION,
00078 NodeType::CONDITION,
00079 NodeType::CONTROL,
00080 NodeType::DECORATOR,
00081 NodeType::SUBTREE
00082 };
00083 return values;
00084 }
00085
00086 inline const char * const *EnumNamesNodeType() {
00087 static const char * const names[] = {
00088 "UNDEFINED",
00089 "ACTION",
00090 "CONDITION",
00091 "CONTROL",
00092 "DECORATOR",
00093 "SUBTREE",
00094 nullptr
00095 };
00096 return names;
00097 }
00098
00099 inline const char *EnumNameNodeType(NodeType e) {
00100 if (e < NodeType::UNDEFINED || e > NodeType::SUBTREE) return "";
00101 const size_t index = static_cast<int>(e);
00102 return EnumNamesNodeType()[index];
00103 }
00104
00105 enum class PortDirection : int8_t {
00106 INPUT = 0,
00107 OUTPUT = 1,
00108 INOUT = 2,
00109 MIN = INPUT,
00110 MAX = INOUT
00111 };
00112
00113 inline const PortDirection (&EnumValuesPortDirection())[3] {
00114 static const PortDirection values[] = {
00115 PortDirection::INPUT,
00116 PortDirection::OUTPUT,
00117 PortDirection::INOUT
00118 };
00119 return values;
00120 }
00121
00122 inline const char * const *EnumNamesPortDirection() {
00123 static const char * const names[] = {
00124 "INPUT",
00125 "OUTPUT",
00126 "INOUT",
00127 nullptr
00128 };
00129 return names;
00130 }
00131
00132 inline const char *EnumNamePortDirection(PortDirection e) {
00133 if (e < PortDirection::INPUT || e > PortDirection::INOUT) return "";
00134 const size_t index = static_cast<int>(e);
00135 return EnumNamesPortDirection()[index];
00136 }
00137
00138 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Timestamp FLATBUFFERS_FINAL_CLASS {
00139 private:
00140 uint64_t usec_since_epoch_;
00141
00142 public:
00143 Timestamp() {
00144 memset(this, 0, sizeof(Timestamp));
00145 }
00146 Timestamp(uint64_t _usec_since_epoch)
00147 : usec_since_epoch_(flatbuffers::EndianScalar(_usec_since_epoch)) {
00148 }
00149 uint64_t usec_since_epoch() const {
00150 return flatbuffers::EndianScalar(usec_since_epoch_);
00151 }
00152 };
00153 FLATBUFFERS_STRUCT_END(Timestamp, 8);
00154
00155 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) StatusChange FLATBUFFERS_FINAL_CLASS {
00156 private:
00157 uint16_t uid_;
00158 int8_t prev_status_;
00159 int8_t status_;
00160 int32_t padding0__;
00161 Timestamp timestamp_;
00162
00163 public:
00164 StatusChange() {
00165 memset(this, 0, sizeof(StatusChange));
00166 }
00167 StatusChange(uint16_t _uid, NodeStatus _prev_status, NodeStatus _status, const Timestamp &_timestamp)
00168 : uid_(flatbuffers::EndianScalar(_uid)),
00169 prev_status_(flatbuffers::EndianScalar(static_cast<int8_t>(_prev_status))),
00170 status_(flatbuffers::EndianScalar(static_cast<int8_t>(_status))),
00171 padding0__(0),
00172 timestamp_(_timestamp) {
00173 (void)padding0__;
00174 }
00175 uint16_t uid() const {
00176 return flatbuffers::EndianScalar(uid_);
00177 }
00178 NodeStatus prev_status() const {
00179 return static_cast<NodeStatus>(flatbuffers::EndianScalar(prev_status_));
00180 }
00181 NodeStatus status() const {
00182 return static_cast<NodeStatus>(flatbuffers::EndianScalar(status_));
00183 }
00184 const Timestamp ×tamp() const {
00185 return timestamp_;
00186 }
00187 };
00188 FLATBUFFERS_STRUCT_END(StatusChange, 16);
00189
00190 struct PortModel FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
00191 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
00192 VT_PORT_NAME = 4,
00193 VT_DIRECTION = 6,
00194 VT_TYPE_INFO = 8,
00195 VT_DESCRIPTION = 10
00196 };
00197 const flatbuffers::String *port_name() const {
00198 return GetPointer<const flatbuffers::String *>(VT_PORT_NAME);
00199 }
00200 PortDirection direction() const {
00201 return static_cast<PortDirection>(GetField<int8_t>(VT_DIRECTION, 0));
00202 }
00203 const flatbuffers::String *type_info() const {
00204 return GetPointer<const flatbuffers::String *>(VT_TYPE_INFO);
00205 }
00206 const flatbuffers::String *description() const {
00207 return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
00208 }
00209 bool Verify(flatbuffers::Verifier &verifier) const {
00210 return VerifyTableStart(verifier) &&
00211 VerifyOffset(verifier, VT_PORT_NAME) &&
00212 verifier.VerifyString(port_name()) &&
00213 VerifyField<int8_t>(verifier, VT_DIRECTION) &&
00214 VerifyOffset(verifier, VT_TYPE_INFO) &&
00215 verifier.VerifyString(type_info()) &&
00216 VerifyOffset(verifier, VT_DESCRIPTION) &&
00217 verifier.VerifyString(description()) &&
00218 verifier.EndTable();
00219 }
00220 };
00221
00222 struct PortModelBuilder {
00223 flatbuffers::FlatBufferBuilder &fbb_;
00224 flatbuffers::uoffset_t start_;
00225 void add_port_name(flatbuffers::Offset<flatbuffers::String> port_name) {
00226 fbb_.AddOffset(PortModel::VT_PORT_NAME, port_name);
00227 }
00228 void add_direction(PortDirection direction) {
00229 fbb_.AddElement<int8_t>(PortModel::VT_DIRECTION, static_cast<int8_t>(direction), 0);
00230 }
00231 void add_type_info(flatbuffers::Offset<flatbuffers::String> type_info) {
00232 fbb_.AddOffset(PortModel::VT_TYPE_INFO, type_info);
00233 }
00234 void add_description(flatbuffers::Offset<flatbuffers::String> description) {
00235 fbb_.AddOffset(PortModel::VT_DESCRIPTION, description);
00236 }
00237 explicit PortModelBuilder(flatbuffers::FlatBufferBuilder &_fbb)
00238 : fbb_(_fbb) {
00239 start_ = fbb_.StartTable();
00240 }
00241 PortModelBuilder &operator=(const PortModelBuilder &);
00242 flatbuffers::Offset<PortModel> Finish() {
00243 const auto end = fbb_.EndTable(start_);
00244 auto o = flatbuffers::Offset<PortModel>(end);
00245 return o;
00246 }
00247 };
00248
00249 inline flatbuffers::Offset<PortModel> CreatePortModel(
00250 flatbuffers::FlatBufferBuilder &_fbb,
00251 flatbuffers::Offset<flatbuffers::String> port_name = 0,
00252 PortDirection direction = PortDirection::INPUT,
00253 flatbuffers::Offset<flatbuffers::String> type_info = 0,
00254 flatbuffers::Offset<flatbuffers::String> description = 0) {
00255 PortModelBuilder builder_(_fbb);
00256 builder_.add_description(description);
00257 builder_.add_type_info(type_info);
00258 builder_.add_port_name(port_name);
00259 builder_.add_direction(direction);
00260 return builder_.Finish();
00261 }
00262
00263 inline flatbuffers::Offset<PortModel> CreatePortModelDirect(
00264 flatbuffers::FlatBufferBuilder &_fbb,
00265 const char *port_name = nullptr,
00266 PortDirection direction = PortDirection::INPUT,
00267 const char *type_info = nullptr,
00268 const char *description = nullptr) {
00269 auto port_name__ = port_name ? _fbb.CreateString(port_name) : 0;
00270 auto type_info__ = type_info ? _fbb.CreateString(type_info) : 0;
00271 auto description__ = description ? _fbb.CreateString(description) : 0;
00272 return Serialization::CreatePortModel(
00273 _fbb,
00274 port_name__,
00275 direction,
00276 type_info__,
00277 description__);
00278 }
00279
00280 struct PortConfig FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
00281 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
00282 VT_PORT_NAME = 4,
00283 VT_REMAP = 6
00284 };
00285 const flatbuffers::String *port_name() const {
00286 return GetPointer<const flatbuffers::String *>(VT_PORT_NAME);
00287 }
00288 const flatbuffers::String *remap() const {
00289 return GetPointer<const flatbuffers::String *>(VT_REMAP);
00290 }
00291 bool Verify(flatbuffers::Verifier &verifier) const {
00292 return VerifyTableStart(verifier) &&
00293 VerifyOffset(verifier, VT_PORT_NAME) &&
00294 verifier.VerifyString(port_name()) &&
00295 VerifyOffset(verifier, VT_REMAP) &&
00296 verifier.VerifyString(remap()) &&
00297 verifier.EndTable();
00298 }
00299 };
00300
00301 struct PortConfigBuilder {
00302 flatbuffers::FlatBufferBuilder &fbb_;
00303 flatbuffers::uoffset_t start_;
00304 void add_port_name(flatbuffers::Offset<flatbuffers::String> port_name) {
00305 fbb_.AddOffset(PortConfig::VT_PORT_NAME, port_name);
00306 }
00307 void add_remap(flatbuffers::Offset<flatbuffers::String> remap) {
00308 fbb_.AddOffset(PortConfig::VT_REMAP, remap);
00309 }
00310 explicit PortConfigBuilder(flatbuffers::FlatBufferBuilder &_fbb)
00311 : fbb_(_fbb) {
00312 start_ = fbb_.StartTable();
00313 }
00314 PortConfigBuilder &operator=(const PortConfigBuilder &);
00315 flatbuffers::Offset<PortConfig> Finish() {
00316 const auto end = fbb_.EndTable(start_);
00317 auto o = flatbuffers::Offset<PortConfig>(end);
00318 return o;
00319 }
00320 };
00321
00322 inline flatbuffers::Offset<PortConfig> CreatePortConfig(
00323 flatbuffers::FlatBufferBuilder &_fbb,
00324 flatbuffers::Offset<flatbuffers::String> port_name = 0,
00325 flatbuffers::Offset<flatbuffers::String> remap = 0) {
00326 PortConfigBuilder builder_(_fbb);
00327 builder_.add_remap(remap);
00328 builder_.add_port_name(port_name);
00329 return builder_.Finish();
00330 }
00331
00332 inline flatbuffers::Offset<PortConfig> CreatePortConfigDirect(
00333 flatbuffers::FlatBufferBuilder &_fbb,
00334 const char *port_name = nullptr,
00335 const char *remap = nullptr) {
00336 auto port_name__ = port_name ? _fbb.CreateString(port_name) : 0;
00337 auto remap__ = remap ? _fbb.CreateString(remap) : 0;
00338 return Serialization::CreatePortConfig(
00339 _fbb,
00340 port_name__,
00341 remap__);
00342 }
00343
00344 struct TreeNode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
00345 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
00346 VT_UID = 4,
00347 VT_CHILDREN_UID = 6,
00348 VT_STATUS = 8,
00349 VT_INSTANCE_NAME = 10,
00350 VT_REGISTRATION_NAME = 12,
00351 VT_PORT_REMAPS = 14
00352 };
00353 uint16_t uid() const {
00354 return GetField<uint16_t>(VT_UID, 0);
00355 }
00356 const flatbuffers::Vector<uint16_t> *children_uid() const {
00357 return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_CHILDREN_UID);
00358 }
00359 NodeStatus status() const {
00360 return static_cast<NodeStatus>(GetField<int8_t>(VT_STATUS, 0));
00361 }
00362 const flatbuffers::String *instance_name() const {
00363 return GetPointer<const flatbuffers::String *>(VT_INSTANCE_NAME);
00364 }
00365 const flatbuffers::String *registration_name() const {
00366 return GetPointer<const flatbuffers::String *>(VT_REGISTRATION_NAME);
00367 }
00368 const flatbuffers::Vector<flatbuffers::Offset<PortConfig>> *port_remaps() const {
00369 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<PortConfig>> *>(VT_PORT_REMAPS);
00370 }
00371 bool Verify(flatbuffers::Verifier &verifier) const {
00372 return VerifyTableStart(verifier) &&
00373 VerifyField<uint16_t>(verifier, VT_UID) &&
00374 VerifyOffset(verifier, VT_CHILDREN_UID) &&
00375 verifier.VerifyVector(children_uid()) &&
00376 VerifyField<int8_t>(verifier, VT_STATUS) &&
00377 VerifyOffsetRequired(verifier, VT_INSTANCE_NAME) &&
00378 verifier.VerifyString(instance_name()) &&
00379 VerifyOffsetRequired(verifier, VT_REGISTRATION_NAME) &&
00380 verifier.VerifyString(registration_name()) &&
00381 VerifyOffset(verifier, VT_PORT_REMAPS) &&
00382 verifier.VerifyVector(port_remaps()) &&
00383 verifier.VerifyVectorOfTables(port_remaps()) &&
00384 verifier.EndTable();
00385 }
00386 };
00387
00388 struct TreeNodeBuilder {
00389 flatbuffers::FlatBufferBuilder &fbb_;
00390 flatbuffers::uoffset_t start_;
00391 void add_uid(uint16_t uid) {
00392 fbb_.AddElement<uint16_t>(TreeNode::VT_UID, uid, 0);
00393 }
00394 void add_children_uid(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> children_uid) {
00395 fbb_.AddOffset(TreeNode::VT_CHILDREN_UID, children_uid);
00396 }
00397 void add_status(NodeStatus status) {
00398 fbb_.AddElement<int8_t>(TreeNode::VT_STATUS, static_cast<int8_t>(status), 0);
00399 }
00400 void add_instance_name(flatbuffers::Offset<flatbuffers::String> instance_name) {
00401 fbb_.AddOffset(TreeNode::VT_INSTANCE_NAME, instance_name);
00402 }
00403 void add_registration_name(flatbuffers::Offset<flatbuffers::String> registration_name) {
00404 fbb_.AddOffset(TreeNode::VT_REGISTRATION_NAME, registration_name);
00405 }
00406 void add_port_remaps(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<PortConfig>>> port_remaps) {
00407 fbb_.AddOffset(TreeNode::VT_PORT_REMAPS, port_remaps);
00408 }
00409 explicit TreeNodeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
00410 : fbb_(_fbb) {
00411 start_ = fbb_.StartTable();
00412 }
00413 TreeNodeBuilder &operator=(const TreeNodeBuilder &);
00414 flatbuffers::Offset<TreeNode> Finish() {
00415 const auto end = fbb_.EndTable(start_);
00416 auto o = flatbuffers::Offset<TreeNode>(end);
00417 fbb_.Required(o, TreeNode::VT_INSTANCE_NAME);
00418 fbb_.Required(o, TreeNode::VT_REGISTRATION_NAME);
00419 return o;
00420 }
00421 };
00422
00423 inline flatbuffers::Offset<TreeNode> CreateTreeNode(
00424 flatbuffers::FlatBufferBuilder &_fbb,
00425 uint16_t uid = 0,
00426 flatbuffers::Offset<flatbuffers::Vector<uint16_t>> children_uid = 0,
00427 NodeStatus status = NodeStatus::IDLE,
00428 flatbuffers::Offset<flatbuffers::String> instance_name = 0,
00429 flatbuffers::Offset<flatbuffers::String> registration_name = 0,
00430 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<PortConfig>>> port_remaps = 0) {
00431 TreeNodeBuilder builder_(_fbb);
00432 builder_.add_port_remaps(port_remaps);
00433 builder_.add_registration_name(registration_name);
00434 builder_.add_instance_name(instance_name);
00435 builder_.add_children_uid(children_uid);
00436 builder_.add_uid(uid);
00437 builder_.add_status(status);
00438 return builder_.Finish();
00439 }
00440
00441 inline flatbuffers::Offset<TreeNode> CreateTreeNodeDirect(
00442 flatbuffers::FlatBufferBuilder &_fbb,
00443 uint16_t uid = 0,
00444 const std::vector<uint16_t> *children_uid = nullptr,
00445 NodeStatus status = NodeStatus::IDLE,
00446 const char *instance_name = nullptr,
00447 const char *registration_name = nullptr,
00448 const std::vector<flatbuffers::Offset<PortConfig>> *port_remaps = nullptr) {
00449 auto children_uid__ = children_uid ? _fbb.CreateVector<uint16_t>(*children_uid) : 0;
00450 auto instance_name__ = instance_name ? _fbb.CreateString(instance_name) : 0;
00451 auto registration_name__ = registration_name ? _fbb.CreateString(registration_name) : 0;
00452 auto port_remaps__ = port_remaps ? _fbb.CreateVector<flatbuffers::Offset<PortConfig>>(*port_remaps) : 0;
00453 return Serialization::CreateTreeNode(
00454 _fbb,
00455 uid,
00456 children_uid__,
00457 status,
00458 instance_name__,
00459 registration_name__,
00460 port_remaps__);
00461 }
00462
00463 struct NodeModel FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
00464 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
00465 VT_REGISTRATION_NAME = 4,
00466 VT_TYPE = 6,
00467 VT_PORTS = 8
00468 };
00469 const flatbuffers::String *registration_name() const {
00470 return GetPointer<const flatbuffers::String *>(VT_REGISTRATION_NAME);
00471 }
00472 NodeType type() const {
00473 return static_cast<NodeType>(GetField<int8_t>(VT_TYPE, 0));
00474 }
00475 const flatbuffers::Vector<flatbuffers::Offset<PortModel>> *ports() const {
00476 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<PortModel>> *>(VT_PORTS);
00477 }
00478 bool Verify(flatbuffers::Verifier &verifier) const {
00479 return VerifyTableStart(verifier) &&
00480 VerifyOffsetRequired(verifier, VT_REGISTRATION_NAME) &&
00481 verifier.VerifyString(registration_name()) &&
00482 VerifyField<int8_t>(verifier, VT_TYPE) &&
00483 VerifyOffset(verifier, VT_PORTS) &&
00484 verifier.VerifyVector(ports()) &&
00485 verifier.VerifyVectorOfTables(ports()) &&
00486 verifier.EndTable();
00487 }
00488 };
00489
00490 struct NodeModelBuilder {
00491 flatbuffers::FlatBufferBuilder &fbb_;
00492 flatbuffers::uoffset_t start_;
00493 void add_registration_name(flatbuffers::Offset<flatbuffers::String> registration_name) {
00494 fbb_.AddOffset(NodeModel::VT_REGISTRATION_NAME, registration_name);
00495 }
00496 void add_type(NodeType type) {
00497 fbb_.AddElement<int8_t>(NodeModel::VT_TYPE, static_cast<int8_t>(type), 0);
00498 }
00499 void add_ports(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<PortModel>>> ports) {
00500 fbb_.AddOffset(NodeModel::VT_PORTS, ports);
00501 }
00502 explicit NodeModelBuilder(flatbuffers::FlatBufferBuilder &_fbb)
00503 : fbb_(_fbb) {
00504 start_ = fbb_.StartTable();
00505 }
00506 NodeModelBuilder &operator=(const NodeModelBuilder &);
00507 flatbuffers::Offset<NodeModel> Finish() {
00508 const auto end = fbb_.EndTable(start_);
00509 auto o = flatbuffers::Offset<NodeModel>(end);
00510 fbb_.Required(o, NodeModel::VT_REGISTRATION_NAME);
00511 return o;
00512 }
00513 };
00514
00515 inline flatbuffers::Offset<NodeModel> CreateNodeModel(
00516 flatbuffers::FlatBufferBuilder &_fbb,
00517 flatbuffers::Offset<flatbuffers::String> registration_name = 0,
00518 NodeType type = NodeType::UNDEFINED,
00519 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<PortModel>>> ports = 0) {
00520 NodeModelBuilder builder_(_fbb);
00521 builder_.add_ports(ports);
00522 builder_.add_registration_name(registration_name);
00523 builder_.add_type(type);
00524 return builder_.Finish();
00525 }
00526
00527 inline flatbuffers::Offset<NodeModel> CreateNodeModelDirect(
00528 flatbuffers::FlatBufferBuilder &_fbb,
00529 const char *registration_name = nullptr,
00530 NodeType type = NodeType::UNDEFINED,
00531 const std::vector<flatbuffers::Offset<PortModel>> *ports = nullptr) {
00532 auto registration_name__ = registration_name ? _fbb.CreateString(registration_name) : 0;
00533 auto ports__ = ports ? _fbb.CreateVector<flatbuffers::Offset<PortModel>>(*ports) : 0;
00534 return Serialization::CreateNodeModel(
00535 _fbb,
00536 registration_name__,
00537 type,
00538 ports__);
00539 }
00540
00541 struct BehaviorTree FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
00542 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
00543 VT_ROOT_UID = 4,
00544 VT_NODES = 6,
00545 VT_NODE_MODELS = 8
00546 };
00547 uint16_t root_uid() const {
00548 return GetField<uint16_t>(VT_ROOT_UID, 0);
00549 }
00550 const flatbuffers::Vector<flatbuffers::Offset<TreeNode>> *nodes() const {
00551 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<TreeNode>> *>(VT_NODES);
00552 }
00553 const flatbuffers::Vector<flatbuffers::Offset<NodeModel>> *node_models() const {
00554 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<NodeModel>> *>(VT_NODE_MODELS);
00555 }
00556 bool Verify(flatbuffers::Verifier &verifier) const {
00557 return VerifyTableStart(verifier) &&
00558 VerifyField<uint16_t>(verifier, VT_ROOT_UID) &&
00559 VerifyOffset(verifier, VT_NODES) &&
00560 verifier.VerifyVector(nodes()) &&
00561 verifier.VerifyVectorOfTables(nodes()) &&
00562 VerifyOffset(verifier, VT_NODE_MODELS) &&
00563 verifier.VerifyVector(node_models()) &&
00564 verifier.VerifyVectorOfTables(node_models()) &&
00565 verifier.EndTable();
00566 }
00567 };
00568
00569 struct BehaviorTreeBuilder {
00570 flatbuffers::FlatBufferBuilder &fbb_;
00571 flatbuffers::uoffset_t start_;
00572 void add_root_uid(uint16_t root_uid) {
00573 fbb_.AddElement<uint16_t>(BehaviorTree::VT_ROOT_UID, root_uid, 0);
00574 }
00575 void add_nodes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TreeNode>>> nodes) {
00576 fbb_.AddOffset(BehaviorTree::VT_NODES, nodes);
00577 }
00578 void add_node_models(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NodeModel>>> node_models) {
00579 fbb_.AddOffset(BehaviorTree::VT_NODE_MODELS, node_models);
00580 }
00581 explicit BehaviorTreeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
00582 : fbb_(_fbb) {
00583 start_ = fbb_.StartTable();
00584 }
00585 BehaviorTreeBuilder &operator=(const BehaviorTreeBuilder &);
00586 flatbuffers::Offset<BehaviorTree> Finish() {
00587 const auto end = fbb_.EndTable(start_);
00588 auto o = flatbuffers::Offset<BehaviorTree>(end);
00589 return o;
00590 }
00591 };
00592
00593 inline flatbuffers::Offset<BehaviorTree> CreateBehaviorTree(
00594 flatbuffers::FlatBufferBuilder &_fbb,
00595 uint16_t root_uid = 0,
00596 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TreeNode>>> nodes = 0,
00597 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NodeModel>>> node_models = 0) {
00598 BehaviorTreeBuilder builder_(_fbb);
00599 builder_.add_node_models(node_models);
00600 builder_.add_nodes(nodes);
00601 builder_.add_root_uid(root_uid);
00602 return builder_.Finish();
00603 }
00604
00605 inline flatbuffers::Offset<BehaviorTree> CreateBehaviorTreeDirect(
00606 flatbuffers::FlatBufferBuilder &_fbb,
00607 uint16_t root_uid = 0,
00608 const std::vector<flatbuffers::Offset<TreeNode>> *nodes = nullptr,
00609 const std::vector<flatbuffers::Offset<NodeModel>> *node_models = nullptr) {
00610 auto nodes__ = nodes ? _fbb.CreateVector<flatbuffers::Offset<TreeNode>>(*nodes) : 0;
00611 auto node_models__ = node_models ? _fbb.CreateVector<flatbuffers::Offset<NodeModel>>(*node_models) : 0;
00612 return Serialization::CreateBehaviorTree(
00613 _fbb,
00614 root_uid,
00615 nodes__,
00616 node_models__);
00617 }
00618
00619 struct StatusChangeLog FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
00620 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
00621 VT_BEHAVIOR_TREE = 4,
00622 VT_STATE_CHANGES = 6
00623 };
00624 const BehaviorTree *behavior_tree() const {
00625 return GetPointer<const BehaviorTree *>(VT_BEHAVIOR_TREE);
00626 }
00627 const flatbuffers::Vector<const StatusChange *> *state_changes() const {
00628 return GetPointer<const flatbuffers::Vector<const StatusChange *> *>(VT_STATE_CHANGES);
00629 }
00630 bool Verify(flatbuffers::Verifier &verifier) const {
00631 return VerifyTableStart(verifier) &&
00632 VerifyOffset(verifier, VT_BEHAVIOR_TREE) &&
00633 verifier.VerifyTable(behavior_tree()) &&
00634 VerifyOffset(verifier, VT_STATE_CHANGES) &&
00635 verifier.VerifyVector(state_changes()) &&
00636 verifier.EndTable();
00637 }
00638 };
00639
00640 struct StatusChangeLogBuilder {
00641 flatbuffers::FlatBufferBuilder &fbb_;
00642 flatbuffers::uoffset_t start_;
00643 void add_behavior_tree(flatbuffers::Offset<BehaviorTree> behavior_tree) {
00644 fbb_.AddOffset(StatusChangeLog::VT_BEHAVIOR_TREE, behavior_tree);
00645 }
00646 void add_state_changes(flatbuffers::Offset<flatbuffers::Vector<const StatusChange *>> state_changes) {
00647 fbb_.AddOffset(StatusChangeLog::VT_STATE_CHANGES, state_changes);
00648 }
00649 explicit StatusChangeLogBuilder(flatbuffers::FlatBufferBuilder &_fbb)
00650 : fbb_(_fbb) {
00651 start_ = fbb_.StartTable();
00652 }
00653 StatusChangeLogBuilder &operator=(const StatusChangeLogBuilder &);
00654 flatbuffers::Offset<StatusChangeLog> Finish() {
00655 const auto end = fbb_.EndTable(start_);
00656 auto o = flatbuffers::Offset<StatusChangeLog>(end);
00657 return o;
00658 }
00659 };
00660
00661 inline flatbuffers::Offset<StatusChangeLog> CreateStatusChangeLog(
00662 flatbuffers::FlatBufferBuilder &_fbb,
00663 flatbuffers::Offset<BehaviorTree> behavior_tree = 0,
00664 flatbuffers::Offset<flatbuffers::Vector<const StatusChange *>> state_changes = 0) {
00665 StatusChangeLogBuilder builder_(_fbb);
00666 builder_.add_state_changes(state_changes);
00667 builder_.add_behavior_tree(behavior_tree);
00668 return builder_.Finish();
00669 }
00670
00671 inline flatbuffers::Offset<StatusChangeLog> CreateStatusChangeLogDirect(
00672 flatbuffers::FlatBufferBuilder &_fbb,
00673 flatbuffers::Offset<BehaviorTree> behavior_tree = 0,
00674 const std::vector<StatusChange> *state_changes = nullptr) {
00675 auto state_changes__ = state_changes ? _fbb.CreateVectorOfStructs<StatusChange>(*state_changes) : 0;
00676 return Serialization::CreateStatusChangeLog(
00677 _fbb,
00678 behavior_tree,
00679 state_changes__);
00680 }
00681
00682 inline const Serialization::BehaviorTree *GetBehaviorTree(const void *buf) {
00683 return flatbuffers::GetRoot<Serialization::BehaviorTree>(buf);
00684 }
00685
00686 inline const Serialization::BehaviorTree *GetSizePrefixedBehaviorTree(const void *buf) {
00687 return flatbuffers::GetSizePrefixedRoot<Serialization::BehaviorTree>(buf);
00688 }
00689
00690 inline bool VerifyBehaviorTreeBuffer(
00691 flatbuffers::Verifier &verifier) {
00692 return verifier.VerifyBuffer<Serialization::BehaviorTree>(nullptr);
00693 }
00694
00695 inline bool VerifySizePrefixedBehaviorTreeBuffer(
00696 flatbuffers::Verifier &verifier) {
00697 return verifier.VerifySizePrefixedBuffer<Serialization::BehaviorTree>(nullptr);
00698 }
00699
00700 inline void FinishBehaviorTreeBuffer(
00701 flatbuffers::FlatBufferBuilder &fbb,
00702 flatbuffers::Offset<Serialization::BehaviorTree> root) {
00703 fbb.Finish(root);
00704 }
00705
00706 inline void FinishSizePrefixedBehaviorTreeBuffer(
00707 flatbuffers::FlatBufferBuilder &fbb,
00708 flatbuffers::Offset<Serialization::BehaviorTree> root) {
00709 fbb.FinishSizePrefixed(root);
00710 }
00711
00712 }
00713
00714 #endif // FLATBUFFERS_GENERATED_BTLOGGER_SERIALIZATION_H_