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_