firmware/components/flatbuffers/include/flatbuffers_generated/RobotModule_generated.h

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


#ifndef FLATBUFFERS_GENERATED_ROBOTMODULE_H_
#define FLATBUFFERS_GENERATED_ROBOTMODULE_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");

struct RobotModule;
struct RobotModuleBuilder;

enum ModuleType : int8_t {
  ModuleType_SPLITTER = 0,
  ModuleType_SERVO_1 = 1,
  ModuleType_DC_MOTOR = 2,
  ModuleType_BATTERY = 3,
  ModuleType_MIN = ModuleType_SPLITTER,
  ModuleType_MAX = ModuleType_BATTERY
};

inline const ModuleType (&EnumValuesModuleType())[4] {
  static const ModuleType values[] = {
    ModuleType_SPLITTER,
    ModuleType_SERVO_1,
    ModuleType_DC_MOTOR,
    ModuleType_BATTERY
  };
  return values;
}

inline const char * const *EnumNamesModuleType() {
  static const char * const names[5] = {
    "SPLITTER",
    "SERVO_1",
    "DC_MOTOR",
    "BATTERY",
    nullptr
  };
  return names;
}

inline const char *EnumNameModuleType(ModuleType e) {
  if (::flatbuffers::IsOutRange(e, ModuleType_SPLITTER, ModuleType_BATTERY)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesModuleType()[index];
}

struct RobotModule FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef RobotModuleBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_IP = 6,
    VT_HOSTNAME = 8,
    VT_MODULE_TYPE = 10,
    VT_CONNECTED_MODULE_IDS = 12
  };
  int32_t id() const {
    return GetField<int32_t>(VT_ID, 0);
  }
  const ::flatbuffers::String *ip() const {
    return GetPointer<const ::flatbuffers::String *>(VT_IP);
  }
  const ::flatbuffers::String *hostname() const {
    return GetPointer<const ::flatbuffers::String *>(VT_HOSTNAME);
  }
  ModuleType module_type() const {
    return static_cast<ModuleType>(GetField<int8_t>(VT_MODULE_TYPE, 0));
  }
  const ::flatbuffers::Vector<int32_t> *connected_module_ids() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_CONNECTED_MODULE_IDS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_ID, 4) &&
           VerifyOffset(verifier, VT_IP) &&
           verifier.VerifyString(ip()) &&
           VerifyOffset(verifier, VT_HOSTNAME) &&
           verifier.VerifyString(hostname()) &&
           VerifyField<int8_t>(verifier, VT_MODULE_TYPE, 1) &&
           VerifyOffset(verifier, VT_CONNECTED_MODULE_IDS) &&
           verifier.VerifyVector(connected_module_ids()) &&
           verifier.EndTable();
  }
};

struct RobotModuleBuilder {
  typedef RobotModule Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_id(int32_t id) {
    fbb_.AddElement<int32_t>(RobotModule::VT_ID, id, 0);
  }
  void add_ip(::flatbuffers::Offset<::flatbuffers::String> ip) {
    fbb_.AddOffset(RobotModule::VT_IP, ip);
  }
  void add_hostname(::flatbuffers::Offset<::flatbuffers::String> hostname) {
    fbb_.AddOffset(RobotModule::VT_HOSTNAME, hostname);
  }
  void add_module_type(ModuleType module_type) {
    fbb_.AddElement<int8_t>(RobotModule::VT_MODULE_TYPE, static_cast<int8_t>(module_type), 0);
  }
  void add_connected_module_ids(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> connected_module_ids) {
    fbb_.AddOffset(RobotModule::VT_CONNECTED_MODULE_IDS, connected_module_ids);
  }
  explicit RobotModuleBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<RobotModule> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<RobotModule>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<RobotModule> CreateRobotModule(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t id = 0,
    ::flatbuffers::Offset<::flatbuffers::String> ip = 0,
    ::flatbuffers::Offset<::flatbuffers::String> hostname = 0,
    ModuleType module_type = ModuleType_SPLITTER,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> connected_module_ids = 0) {
  RobotModuleBuilder builder_(_fbb);
  builder_.add_connected_module_ids(connected_module_ids);
  builder_.add_hostname(hostname);
  builder_.add_ip(ip);
  builder_.add_id(id);
  builder_.add_module_type(module_type);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<RobotModule> CreateRobotModuleDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t id = 0,
    const char *ip = nullptr,
    const char *hostname = nullptr,
    ModuleType module_type = ModuleType_SPLITTER,
    const std::vector<int32_t> *connected_module_ids = nullptr) {
  auto ip__ = ip ? _fbb.CreateString(ip) : 0;
  auto hostname__ = hostname ? _fbb.CreateString(hostname) : 0;
  auto connected_module_ids__ = connected_module_ids ? _fbb.CreateVector<int32_t>(*connected_module_ids) : 0;
  return CreateRobotModule(
      _fbb,
      id,
      ip__,
      hostname__,
      module_type,
      connected_module_ids__);
}

inline const RobotModule *GetRobotModule(const void *buf) {
  return ::flatbuffers::GetRoot<RobotModule>(buf);
}

inline const RobotModule *GetSizePrefixedRobotModule(const void *buf) {
  return ::flatbuffers::GetSizePrefixedRoot<RobotModule>(buf);
}

inline bool VerifyRobotModuleBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifyBuffer<RobotModule>(nullptr);
}

inline bool VerifySizePrefixedRobotModuleBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifySizePrefixedBuffer<RobotModule>(nullptr);
}

inline void FinishRobotModuleBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<RobotModule> root) {
  fbb.Finish(root);
}

inline void FinishSizePrefixedRobotModuleBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<RobotModule> root) {
  fbb.FinishSizePrefixed(root);
}

#endif  // FLATBUFFERS_GENERATED_ROBOTMODULE_H_