control/include/flatbuffers_generated/RobotConfiguration_generated.h

// automatically generated by the FlatBuffers compiler, do not modify

#ifndef FLATBUFFERS_GENERATED_ROBOTCONFIGURATION_FRONTEND_H_
#define FLATBUFFERS_GENERATED_ROBOTCONFIGURATION_FRONTEND_H_

#include "flatbuffers/flatbuffers.h"

// Ensure the included flatbuffers.h is the same version as when this file was
// generated, otherwise it may not be compatible.
// static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
//               FLATBUFFERS_VERSION_MINOR == 2 &&
//               FLATBUFFERS_VERSION_REVISION == 10,
//              "Non-compatible flatbuffers version included");

#include "RobotModule_generated.h"

namespace Frontend {

struct ModuleConnection;
struct ModuleConnectionBuilder;

struct RobotConfiguration;
struct RobotConfigurationBuilder;

struct ModuleConnection FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ModuleConnectionBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_FROM_MODULE_ID = 4,
    VT_TO_MODULE_ID = 6,
    VT_FROM_SOCKET = 8,
    VT_TO_SOCKET = 10,
    VT_ORIENTATION = 12
  };
  uint8_t from_module_id() const {
    return GetField<uint8_t>(VT_FROM_MODULE_ID, 0);
  }
  uint8_t to_module_id() const { return GetField<uint8_t>(VT_TO_MODULE_ID, 0); }
  uint8_t from_socket() const { return GetField<uint8_t>(VT_FROM_SOCKET, 0); }
  uint8_t to_socket() const { return GetField<uint8_t>(VT_TO_SOCKET, 0); }
  Orientation orientation() const {
    return static_cast<Orientation>(GetField<int8_t>(VT_ORIENTATION, 0));
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_FROM_MODULE_ID, 1) &&
           VerifyField<uint8_t>(verifier, VT_TO_MODULE_ID, 1) &&
           VerifyField<uint8_t>(verifier, VT_FROM_SOCKET, 1) &&
           VerifyField<uint8_t>(verifier, VT_TO_SOCKET, 1) &&
           VerifyField<int8_t>(verifier, VT_ORIENTATION, 1) &&
           verifier.EndTable();
  }
};

struct ModuleConnectionBuilder {
  typedef ModuleConnection Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_from_module_id(uint8_t from_module_id) {
    fbb_.AddElement<uint8_t>(ModuleConnection::VT_FROM_MODULE_ID,
                             from_module_id, 0);
  }
  void add_to_module_id(uint8_t to_module_id) {
    fbb_.AddElement<uint8_t>(ModuleConnection::VT_TO_MODULE_ID, to_module_id,
                             0);
  }
  void add_from_socket(uint8_t from_socket) {
    fbb_.AddElement<uint8_t>(ModuleConnection::VT_FROM_SOCKET, from_socket, 0);
  }
  void add_to_socket(uint8_t to_socket) {
    fbb_.AddElement<uint8_t>(ModuleConnection::VT_TO_SOCKET, to_socket, 0);
  }
  void add_orientation(Orientation orientation) {
    fbb_.AddElement<int8_t>(ModuleConnection::VT_ORIENTATION,
                            static_cast<int8_t>(orientation), 0);
  }
  explicit ModuleConnectionBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
      : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ModuleConnection> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ModuleConnection>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ModuleConnection>
CreateModuleConnection(::flatbuffers::FlatBufferBuilder &_fbb,
                       uint8_t from_module_id = 0, uint8_t to_module_id = 0,
                       uint8_t from_socket = 0, uint8_t to_socket = 0,
                       Orientation orientation = Orientation_Deg0) {
  ModuleConnectionBuilder builder_(_fbb);
  builder_.add_orientation(orientation);
  builder_.add_to_socket(to_socket);
  builder_.add_from_socket(from_socket);
  builder_.add_to_module_id(to_module_id);
  builder_.add_from_module_id(from_module_id);
  return builder_.Finish();
}

struct RobotConfiguration FLATBUFFERS_FINAL_CLASS
    : private ::flatbuffers::Table {
  typedef RobotConfigurationBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_MODULES = 4,
    VT_CONNECTIONS = 6
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<RobotModule>> *
  modules() const {
    return GetPointer<
        const ::flatbuffers::Vector<::flatbuffers::Offset<RobotModule>> *>(
        VT_MODULES);
  }
  const ::flatbuffers::Vector<
      ::flatbuffers::Offset<Frontend::ModuleConnection>> *
  connections() const {
    return GetPointer<const ::flatbuffers::Vector<
        ::flatbuffers::Offset<Frontend::ModuleConnection>> *>(VT_CONNECTIONS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_MODULES) &&
           verifier.VerifyVector(modules()) &&
           verifier.VerifyVectorOfTables(modules()) &&
           VerifyOffset(verifier, VT_CONNECTIONS) &&
           verifier.VerifyVector(connections()) &&
           verifier.VerifyVectorOfTables(connections()) && verifier.EndTable();
  }
};

struct RobotConfigurationBuilder {
  typedef RobotConfiguration Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_modules(::flatbuffers::Offset<
                   ::flatbuffers::Vector<::flatbuffers::Offset<RobotModule>>>
                       modules) {
    fbb_.AddOffset(RobotConfiguration::VT_MODULES, modules);
  }
  void add_connections(::flatbuffers::Offset<::flatbuffers::Vector<
                           ::flatbuffers::Offset<Frontend::ModuleConnection>>>
                           connections) {
    fbb_.AddOffset(RobotConfiguration::VT_CONNECTIONS, connections);
  }
  explicit RobotConfigurationBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
      : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<RobotConfiguration> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<RobotConfiguration>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<RobotConfiguration> CreateRobotConfiguration(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<
        ::flatbuffers::Vector<::flatbuffers::Offset<RobotModule>>>
        modules = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<
        ::flatbuffers::Offset<Frontend::ModuleConnection>>>
        connections = 0) {
  RobotConfigurationBuilder builder_(_fbb);
  builder_.add_connections(connections);
  builder_.add_modules(modules);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<RobotConfiguration> CreateRobotConfigurationDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<RobotModule>> *modules = nullptr,
    const std::vector<::flatbuffers::Offset<Frontend::ModuleConnection>>
        *connections = nullptr) {
  auto modules__ =
      modules ? _fbb.CreateVector<::flatbuffers::Offset<RobotModule>>(*modules)
              : 0;
  auto connections__ =
      connections
          ? _fbb.CreateVector<
                ::flatbuffers::Offset<Frontend::ModuleConnection>>(*connections)
          : 0;
  return Frontend::CreateRobotConfiguration(_fbb, modules__, connections__);
}

inline const Frontend::RobotConfiguration *
GetRobotConfiguration(const void *buf) {
  return ::flatbuffers::GetRoot<Frontend::RobotConfiguration>(buf);
}

inline const Frontend::RobotConfiguration *
GetSizePrefixedRobotConfiguration(const void *buf) {
  return ::flatbuffers::GetSizePrefixedRoot<Frontend::RobotConfiguration>(buf);
}

inline bool VerifyRobotConfigurationBuffer(::flatbuffers::Verifier &verifier) {
  return verifier.VerifyBuffer<Frontend::RobotConfiguration>(nullptr);
}

inline bool
VerifySizePrefixedRobotConfigurationBuffer(::flatbuffers::Verifier &verifier) {
  return verifier.VerifySizePrefixedBuffer<Frontend::RobotConfiguration>(
      nullptr);
}

inline void FinishRobotConfigurationBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<Frontend::RobotConfiguration> root) {
  fbb.Finish(root);
}

inline void FinishSizePrefixedRobotConfigurationBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<Frontend::RobotConfiguration> root) {
  fbb.FinishSizePrefixed(root);
}

} // namespace Frontend

#endif // FLATBUFFERS_GENERATED_ROBOTCONFIGURATION_FRONTEND_H_