messages_generated.h

// automatically generated by the FlatBuffers compiler, do not modify
 
#ifndef FLATBUFFERS_GENERATED_MESSAGES_SCC_TCP4TLM_H_
#define FLATBUFFERS_GENERATED_MESSAGES_SCC_TCP4TLM_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 == 9 && FLATBUFFERS_VERSION_REVISION == 23,
              "Non-compatible flatbuffers version included");
 
namespace scc {
namespace tcp4tlm {
 
struct NotifyEndpointMsg;
struct NotifyEndpointMsgBuilder;
 
struct NotifyShutdownMsg;
struct NotifyShutdownMsgBuilder;
 
struct SyncMsg;
struct SyncMsgBuilder;
 
struct BusOpMsg;
struct BusOpMsgBuilder;
 
struct ResponseMsg;
struct ResponseMsgBuilder;
 
struct BusDataMsg;
struct BusDataMsgBuilder;
 
struct SigOpMsg;
struct SigOpMsgBuilder;
 
struct LogMsg;
struct LogMsgBuilder;
 
struct RequestEnvelope;
struct RequestEnvelopeBuilder;
 
struct ResponseEnvelope;
struct ResponseEnvelopeBuilder;
 
enum ResponseStatus : uint8_t {
    ResponseStatus_OK = 0,
    ResponseStatus_ACCEPTED = 1,
    ResponseStatus_DELAYED = 2,
    ResponseStatus_DECLINED = 3,
    ResponseStatus_FAILURE = 4,
    ResponseStatus_MIN = ResponseStatus_OK,
    ResponseStatus_MAX = ResponseStatus_FAILURE
};
 
inline const ResponseStatus (&EnumValuesResponseStatus())[5] {
    static const ResponseStatus values[] = {ResponseStatus_OK, ResponseStatus_ACCEPTED, ResponseStatus_DELAYED, ResponseStatus_DECLINED,
                                            ResponseStatus_FAILURE};
    return values;
}
 
inline const char* const* EnumNamesResponseStatus() {
    static const char* const names[6] = {"OK", "ACCEPTED", "DELAYED", "DECLINED", "FAILURE", nullptr};
    return names;
}
 
inline const char* EnumNameResponseStatus(ResponseStatus e) {
    if(::flatbuffers::IsOutRange(e, ResponseStatus_OK, ResponseStatus_FAILURE))
        return "";
    const size_t index = static_cast<size_t>(e);
    return EnumNamesResponseStatus()[index];
}
 
enum BusAccessType : uint8_t {
    BusAccessType_NORMAL_ACC = 0,
    BusAccessType_DEBUG_ACC = 1,
    BusAccessType_MIN = BusAccessType_NORMAL_ACC,
    BusAccessType_MAX = BusAccessType_DEBUG_ACC
};
 
inline const BusAccessType (&EnumValuesBusAccessType())[2] {
    static const BusAccessType values[] = {BusAccessType_NORMAL_ACC, BusAccessType_DEBUG_ACC};
    return values;
}
 
inline const char* const* EnumNamesBusAccessType() {
    static const char* const names[3] = {"NORMAL_ACC", "DEBUG_ACC", nullptr};
    return names;
}
 
inline const char* EnumNameBusAccessType(BusAccessType e) {
    if(::flatbuffers::IsOutRange(e, BusAccessType_NORMAL_ACC, BusAccessType_DEBUG_ACC))
        return "";
    const size_t index = static_cast<size_t>(e);
    return EnumNamesBusAccessType()[index];
}
 
enum RequestPayload : uint8_t {
    RequestPayload_NONE = 0,
    RequestPayload_NotifyEndpointMsg = 1,
    RequestPayload_NotifyShutdownMsg = 2,
    RequestPayload_SyncMsg = 3,
    RequestPayload_BusOpMsg = 4,
    RequestPayload_SigOpMsg = 5,
    RequestPayload_LogMsg = 6,
    RequestPayload_MIN = RequestPayload_NONE,
    RequestPayload_MAX = RequestPayload_LogMsg
};
 
inline const RequestPayload (&EnumValuesRequestPayload())[7] {
    static const RequestPayload values[] = {RequestPayload_NONE,    RequestPayload_NotifyEndpointMsg, RequestPayload_NotifyShutdownMsg,
                                            RequestPayload_SyncMsg, RequestPayload_BusOpMsg,          RequestPayload_SigOpMsg,
                                            RequestPayload_LogMsg};
    return values;
}
 
inline const char* const* EnumNamesRequestPayload() {
    static const char* const names[8] = {"NONE", "NotifyEndpointMsg", "NotifyShutdownMsg", "SyncMsg", "BusOpMsg", "SigOpMsg", "LogMsg",
                                         nullptr};
    return names;
}
 
inline const char* EnumNameRequestPayload(RequestPayload e) {
    if(::flatbuffers::IsOutRange(e, RequestPayload_NONE, RequestPayload_LogMsg))
        return "";
    const size_t index = static_cast<size_t>(e);
    return EnumNamesRequestPayload()[index];
}
 
template <typename T> struct RequestPayloadTraits { static const RequestPayload enum_value = RequestPayload_NONE; };
 
template <> struct RequestPayloadTraits<scc::tcp4tlm::NotifyEndpointMsg> {
    static const RequestPayload enum_value = RequestPayload_NotifyEndpointMsg;
};
 
template <> struct RequestPayloadTraits<scc::tcp4tlm::NotifyShutdownMsg> {
    static const RequestPayload enum_value = RequestPayload_NotifyShutdownMsg;
};
 
template <> struct RequestPayloadTraits<scc::tcp4tlm::SyncMsg> { static const RequestPayload enum_value = RequestPayload_SyncMsg; };
 
template <> struct RequestPayloadTraits<scc::tcp4tlm::BusOpMsg> { static const RequestPayload enum_value = RequestPayload_BusOpMsg; };
 
template <> struct RequestPayloadTraits<scc::tcp4tlm::SigOpMsg> { static const RequestPayload enum_value = RequestPayload_SigOpMsg; };
 
template <> struct RequestPayloadTraits<scc::tcp4tlm::LogMsg> { static const RequestPayload enum_value = RequestPayload_LogMsg; };
 
bool VerifyRequestPayload(::flatbuffers::Verifier& verifier, const void* obj, RequestPayload type);
bool VerifyRequestPayloadVector(::flatbuffers::Verifier& verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>>* values,
                                const ::flatbuffers::Vector<uint8_t>* types);
 
enum ResponsePayload : uint8_t {
    ResponsePayload_NONE = 0,
    ResponsePayload_ResponseMsg = 1,
    ResponsePayload_BusDataMsg = 2,
    ResponsePayload_MIN = ResponsePayload_NONE,
    ResponsePayload_MAX = ResponsePayload_BusDataMsg
};
 
inline const ResponsePayload (&EnumValuesResponsePayload())[3] {
    static const ResponsePayload values[] = {ResponsePayload_NONE, ResponsePayload_ResponseMsg, ResponsePayload_BusDataMsg};
    return values;
}
 
inline const char* const* EnumNamesResponsePayload() {
    static const char* const names[4] = {"NONE", "ResponseMsg", "BusDataMsg", nullptr};
    return names;
}
 
inline const char* EnumNameResponsePayload(ResponsePayload e) {
    if(::flatbuffers::IsOutRange(e, ResponsePayload_NONE, ResponsePayload_BusDataMsg))
        return "";
    const size_t index = static_cast<size_t>(e);
    return EnumNamesResponsePayload()[index];
}
 
template <typename T> struct ResponsePayloadTraits { static const ResponsePayload enum_value = ResponsePayload_NONE; };
 
template <> struct ResponsePayloadTraits<scc::tcp4tlm::ResponseMsg> {
    static const ResponsePayload enum_value = ResponsePayload_ResponseMsg;
};
 
template <> struct ResponsePayloadTraits<scc::tcp4tlm::BusDataMsg> {
    static const ResponsePayload enum_value = ResponsePayload_BusDataMsg;
};
 
bool VerifyResponsePayload(::flatbuffers::Verifier& verifier, const void* obj, ResponsePayload type);
bool VerifyResponsePayloadVector(::flatbuffers::Verifier& verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>>* values,
                                 const ::flatbuffers::Vector<uint8_t>* types);
 
struct NotifyEndpointMsg FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
    typedef NotifyEndpointMsgBuilder Builder;
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_ID = 4, VT_HOSTNAME = 6, VT_PORT = 8 };
    uint32_t id() const { return GetField<uint32_t>(VT_ID, 0); }
    const ::flatbuffers::String* hostname() const { return GetPointer<const ::flatbuffers::String*>(VT_HOSTNAME); }
    uint16_t port() const { return GetField<uint16_t>(VT_PORT, 0); }
    bool Verify(::flatbuffers::Verifier& verifier) const {
        return VerifyTableStart(verifier) && VerifyField<uint32_t>(verifier, VT_ID, 4) && VerifyOffset(verifier, VT_HOSTNAME) &&
               verifier.VerifyString(hostname()) && VerifyField<uint16_t>(verifier, VT_PORT, 2) && verifier.EndTable();
    }
};
 
struct NotifyEndpointMsgBuilder {
    typedef NotifyEndpointMsg Table;
    ::flatbuffers::FlatBufferBuilder& fbb_;
    ::flatbuffers::uoffset_t start_;
    void add_id(uint32_t id) { fbb_.AddElement<uint32_t>(NotifyEndpointMsg::VT_ID, id, 0); }
    void add_hostname(::flatbuffers::Offset<::flatbuffers::String> hostname) { fbb_.AddOffset(NotifyEndpointMsg::VT_HOSTNAME, hostname); }
    void add_port(uint16_t port) { fbb_.AddElement<uint16_t>(NotifyEndpointMsg::VT_PORT, port, 0); }
    explicit NotifyEndpointMsgBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
    : fbb_(_fbb) {
        start_ = fbb_.StartTable();
    }
    ::flatbuffers::Offset<NotifyEndpointMsg> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = ::flatbuffers::Offset<NotifyEndpointMsg>(end);
        return o;
    }
};
 
inline ::flatbuffers::Offset<NotifyEndpointMsg> CreateNotifyEndpointMsg(::flatbuffers::FlatBufferBuilder& _fbb, uint32_t id = 0,
                                                                        ::flatbuffers::Offset<::flatbuffers::String> hostname = 0,
                                                                        uint16_t port = 0) {
    NotifyEndpointMsgBuilder builder_(_fbb);
    builder_.add_hostname(hostname);
    builder_.add_id(id);
    builder_.add_port(port);
    return builder_.Finish();
}
 
inline ::flatbuffers::Offset<NotifyEndpointMsg> CreateNotifyEndpointMsgDirect(::flatbuffers::FlatBufferBuilder& _fbb, uint32_t id = 0,
                                                                              const char* hostname = nullptr, uint16_t port = 0) {
    auto hostname__ = hostname ? _fbb.CreateString(hostname) : 0;
    return scc::tcp4tlm::CreateNotifyEndpointMsg(_fbb, id, hostname__, port);
}
 
struct NotifyShutdownMsg FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
    typedef NotifyShutdownMsgBuilder Builder;
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_ID = 4 };
    uint32_t id() const { return GetField<uint32_t>(VT_ID, 0); }
    bool Verify(::flatbuffers::Verifier& verifier) const {
        return VerifyTableStart(verifier) && VerifyField<uint32_t>(verifier, VT_ID, 4) && verifier.EndTable();
    }
};
 
struct NotifyShutdownMsgBuilder {
    typedef NotifyShutdownMsg Table;
    ::flatbuffers::FlatBufferBuilder& fbb_;
    ::flatbuffers::uoffset_t start_;
    void add_id(uint32_t id) { fbb_.AddElement<uint32_t>(NotifyShutdownMsg::VT_ID, id, 0); }
    explicit NotifyShutdownMsgBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
    : fbb_(_fbb) {
        start_ = fbb_.StartTable();
    }
    ::flatbuffers::Offset<NotifyShutdownMsg> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = ::flatbuffers::Offset<NotifyShutdownMsg>(end);
        return o;
    }
};
 
inline ::flatbuffers::Offset<NotifyShutdownMsg> CreateNotifyShutdownMsg(::flatbuffers::FlatBufferBuilder& _fbb, uint32_t id = 0) {
    NotifyShutdownMsgBuilder builder_(_fbb);
    builder_.add_id(id);
    return builder_.Finish();
}
 
struct SyncMsg FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
    typedef SyncMsgBuilder Builder;
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_ID = 4, VT_TIME_STAMP = 6 };
    uint32_t id() const { return GetField<uint32_t>(VT_ID, 0); }
    uint64_t time_stamp() const { return GetField<uint64_t>(VT_TIME_STAMP, 0); }
    bool Verify(::flatbuffers::Verifier& verifier) const {
        return VerifyTableStart(verifier) && VerifyField<uint32_t>(verifier, VT_ID, 4) &&
               VerifyField<uint64_t>(verifier, VT_TIME_STAMP, 8) && verifier.EndTable();
    }
};
 
struct SyncMsgBuilder {
    typedef SyncMsg Table;
    ::flatbuffers::FlatBufferBuilder& fbb_;
    ::flatbuffers::uoffset_t start_;
    void add_id(uint32_t id) { fbb_.AddElement<uint32_t>(SyncMsg::VT_ID, id, 0); }
    void add_time_stamp(uint64_t time_stamp) { fbb_.AddElement<uint64_t>(SyncMsg::VT_TIME_STAMP, time_stamp, 0); }
    explicit SyncMsgBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
    : fbb_(_fbb) {
        start_ = fbb_.StartTable();
    }
    ::flatbuffers::Offset<SyncMsg> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = ::flatbuffers::Offset<SyncMsg>(end);
        return o;
    }
};
 
inline ::flatbuffers::Offset<SyncMsg> CreateSyncMsg(::flatbuffers::FlatBufferBuilder& _fbb, uint32_t id = 0, uint64_t time_stamp = 0) {
    SyncMsgBuilder builder_(_fbb);
    builder_.add_time_stamp(time_stamp);
    builder_.add_id(id);
    return builder_.Finish();
}
 
struct BusOpMsg FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
    typedef BusOpMsgBuilder Builder;
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
        VT_ID = 4,
        VT_TIME_STAMP = 6,
        VT_TIME_OFFSET = 8,
        VT_TYPE = 10,
        VT_INDEX = 12,
        VT_ADDRESS = 14,
        VT_SIZE = 16,
        VT_NO_RESPONSE = 18,
        VT_DATA = 20,
        VT_BYTE_ENABLE = 22
    };
    uint32_t id() const { return GetField<uint32_t>(VT_ID, 0); }
    uint64_t time_stamp() const { return GetField<uint64_t>(VT_TIME_STAMP, 0); }
    uint64_t time_offset() const { return GetField<uint64_t>(VT_TIME_OFFSET, 0); }
    scc::tcp4tlm::BusAccessType type() const { return static_cast<scc::tcp4tlm::BusAccessType>(GetField<uint8_t>(VT_TYPE, 0)); }
    uint32_t index() const { return GetField<uint32_t>(VT_INDEX, 0); }
    uint64_t address() const { return GetField<uint64_t>(VT_ADDRESS, 0); }
    uint32_t size() const { return GetField<uint32_t>(VT_SIZE, 0); }
    bool no_response() const { return GetField<uint8_t>(VT_NO_RESPONSE, 0) != 0; }
    const ::flatbuffers::Vector<uint8_t>* data() const { return GetPointer<const ::flatbuffers::Vector<uint8_t>*>(VT_DATA); }
    const ::flatbuffers::Vector<uint8_t>* byte_enable() const { return GetPointer<const ::flatbuffers::Vector<uint8_t>*>(VT_BYTE_ENABLE); }
    bool Verify(::flatbuffers::Verifier& verifier) const {
        return VerifyTableStart(verifier) && VerifyField<uint32_t>(verifier, VT_ID, 4) &&
               VerifyField<uint64_t>(verifier, VT_TIME_STAMP, 8) && VerifyField<uint64_t>(verifier, VT_TIME_OFFSET, 8) &&
               VerifyField<uint8_t>(verifier, VT_TYPE, 1) && VerifyField<uint32_t>(verifier, VT_INDEX, 4) &&
               VerifyField<uint64_t>(verifier, VT_ADDRESS, 8) && VerifyField<uint32_t>(verifier, VT_SIZE, 4) &&
               VerifyField<uint8_t>(verifier, VT_NO_RESPONSE, 1) && VerifyOffset(verifier, VT_DATA) && verifier.VerifyVector(data()) &&
               VerifyOffset(verifier, VT_BYTE_ENABLE) && verifier.VerifyVector(byte_enable()) && verifier.EndTable();
    }
};
 
struct BusOpMsgBuilder {
    typedef BusOpMsg Table;
    ::flatbuffers::FlatBufferBuilder& fbb_;
    ::flatbuffers::uoffset_t start_;
    void add_id(uint32_t id) { fbb_.AddElement<uint32_t>(BusOpMsg::VT_ID, id, 0); }
    void add_time_stamp(uint64_t time_stamp) { fbb_.AddElement<uint64_t>(BusOpMsg::VT_TIME_STAMP, time_stamp, 0); }
    void add_time_offset(uint64_t time_offset) { fbb_.AddElement<uint64_t>(BusOpMsg::VT_TIME_OFFSET, time_offset, 0); }
    void add_type(scc::tcp4tlm::BusAccessType type) { fbb_.AddElement<uint8_t>(BusOpMsg::VT_TYPE, static_cast<uint8_t>(type), 0); }
    void add_index(uint32_t index) { fbb_.AddElement<uint32_t>(BusOpMsg::VT_INDEX, index, 0); }
    void add_address(uint64_t address) { fbb_.AddElement<uint64_t>(BusOpMsg::VT_ADDRESS, address, 0); }
    void add_size(uint32_t size) { fbb_.AddElement<uint32_t>(BusOpMsg::VT_SIZE, size, 0); }
    void add_no_response(bool no_response) { fbb_.AddElement<uint8_t>(BusOpMsg::VT_NO_RESPONSE, static_cast<uint8_t>(no_response), 0); }
    void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) { fbb_.AddOffset(BusOpMsg::VT_DATA, data); }
    void add_byte_enable(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> byte_enable) {
        fbb_.AddOffset(BusOpMsg::VT_BYTE_ENABLE, byte_enable);
    }
    explicit BusOpMsgBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
    : fbb_(_fbb) {
        start_ = fbb_.StartTable();
    }
    ::flatbuffers::Offset<BusOpMsg> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = ::flatbuffers::Offset<BusOpMsg>(end);
        return o;
    }
};
 
inline ::flatbuffers::Offset<BusOpMsg> CreateBusOpMsg(::flatbuffers::FlatBufferBuilder& _fbb, uint32_t id = 0, uint64_t time_stamp = 0,
                                                      uint64_t time_offset = 0,
                                                      scc::tcp4tlm::BusAccessType type = scc::tcp4tlm::BusAccessType_NORMAL_ACC,
                                                      uint32_t index = 0, uint64_t address = 0, uint32_t size = 0, bool no_response = false,
                                                      ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0,
                                                      ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> byte_enable = 0) {
    BusOpMsgBuilder builder_(_fbb);
    builder_.add_address(address);
    builder_.add_time_offset(time_offset);
    builder_.add_time_stamp(time_stamp);
    builder_.add_byte_enable(byte_enable);
    builder_.add_data(data);
    builder_.add_size(size);
    builder_.add_index(index);
    builder_.add_id(id);
    builder_.add_no_response(no_response);
    builder_.add_type(type);
    return builder_.Finish();
}
 
inline ::flatbuffers::Offset<BusOpMsg> CreateBusOpMsgDirect(::flatbuffers::FlatBufferBuilder& _fbb, uint32_t id = 0,
                                                            uint64_t time_stamp = 0, uint64_t time_offset = 0,
                                                            scc::tcp4tlm::BusAccessType type = scc::tcp4tlm::BusAccessType_NORMAL_ACC,
                                                            uint32_t index = 0, uint64_t address = 0, uint32_t size = 0,
                                                            bool no_response = false, const std::vector<uint8_t>* data = nullptr,
                                                            const std::vector<uint8_t>* byte_enable = nullptr) {
    auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
    auto byte_enable__ = byte_enable ? _fbb.CreateVector<uint8_t>(*byte_enable) : 0;
    return scc::tcp4tlm::CreateBusOpMsg(_fbb, id, time_stamp, time_offset, type, index, address, size, no_response, data__, byte_enable__);
}
 
struct ResponseMsg FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
    typedef ResponseMsgBuilder Builder;
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_STATUS = 4, VT_REQ_ID = 6 };
    scc::tcp4tlm::ResponseStatus status() const { return static_cast<scc::tcp4tlm::ResponseStatus>(GetField<uint8_t>(VT_STATUS, 0)); }
    uint32_t req_id() const { return GetField<uint32_t>(VT_REQ_ID, 0); }
    bool Verify(::flatbuffers::Verifier& verifier) const {
        return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_STATUS, 1) &&
               VerifyField<uint32_t>(verifier, VT_REQ_ID, 4) && verifier.EndTable();
    }
};
 
struct ResponseMsgBuilder {
    typedef ResponseMsg Table;
    ::flatbuffers::FlatBufferBuilder& fbb_;
    ::flatbuffers::uoffset_t start_;
    void add_status(scc::tcp4tlm::ResponseStatus status) {
        fbb_.AddElement<uint8_t>(ResponseMsg::VT_STATUS, static_cast<uint8_t>(status), 0);
    }
    void add_req_id(uint32_t req_id) { fbb_.AddElement<uint32_t>(ResponseMsg::VT_REQ_ID, req_id, 0); }
    explicit ResponseMsgBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
    : fbb_(_fbb) {
        start_ = fbb_.StartTable();
    }
    ::flatbuffers::Offset<ResponseMsg> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = ::flatbuffers::Offset<ResponseMsg>(end);
        return o;
    }
};
 
inline ::flatbuffers::Offset<ResponseMsg> CreateResponseMsg(::flatbuffers::FlatBufferBuilder& _fbb,
                                                            scc::tcp4tlm::ResponseStatus status = scc::tcp4tlm::ResponseStatus_OK,
                                                            uint32_t req_id = 0) {
    ResponseMsgBuilder builder_(_fbb);
    builder_.add_req_id(req_id);
    builder_.add_status(status);
    return builder_.Finish();
}
 
struct BusDataMsg FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
    typedef BusDataMsgBuilder Builder;
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_STATUS = 4, VT_REQ_ID = 6, VT_DATA = 8 };
    scc::tcp4tlm::ResponseStatus status() const { return static_cast<scc::tcp4tlm::ResponseStatus>(GetField<uint8_t>(VT_STATUS, 0)); }
    uint32_t req_id() const { return GetField<uint32_t>(VT_REQ_ID, 0); }
    const ::flatbuffers::Vector<uint8_t>* data() const { return GetPointer<const ::flatbuffers::Vector<uint8_t>*>(VT_DATA); }
    bool Verify(::flatbuffers::Verifier& verifier) const {
        return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_STATUS, 1) &&
               VerifyField<uint32_t>(verifier, VT_REQ_ID, 4) && VerifyOffset(verifier, VT_DATA) && verifier.VerifyVector(data()) &&
               verifier.EndTable();
    }
};
 
struct BusDataMsgBuilder {
    typedef BusDataMsg Table;
    ::flatbuffers::FlatBufferBuilder& fbb_;
    ::flatbuffers::uoffset_t start_;
    void add_status(scc::tcp4tlm::ResponseStatus status) {
        fbb_.AddElement<uint8_t>(BusDataMsg::VT_STATUS, static_cast<uint8_t>(status), 0);
    }
    void add_req_id(uint32_t req_id) { fbb_.AddElement<uint32_t>(BusDataMsg::VT_REQ_ID, req_id, 0); }
    void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) { fbb_.AddOffset(BusDataMsg::VT_DATA, data); }
    explicit BusDataMsgBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
    : fbb_(_fbb) {
        start_ = fbb_.StartTable();
    }
    ::flatbuffers::Offset<BusDataMsg> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = ::flatbuffers::Offset<BusDataMsg>(end);
        return o;
    }
};
 
inline ::flatbuffers::Offset<BusDataMsg> CreateBusDataMsg(::flatbuffers::FlatBufferBuilder& _fbb,
                                                          scc::tcp4tlm::ResponseStatus status = scc::tcp4tlm::ResponseStatus_OK,
                                                          uint32_t req_id = 0,
                                                          ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
    BusDataMsgBuilder builder_(_fbb);
    builder_.add_data(data);
    builder_.add_req_id(req_id);
    builder_.add_status(status);
    return builder_.Finish();
}
 
inline ::flatbuffers::Offset<BusDataMsg> CreateBusDataMsgDirect(::flatbuffers::FlatBufferBuilder& _fbb,
                                                                scc::tcp4tlm::ResponseStatus status = scc::tcp4tlm::ResponseStatus_OK,
                                                                uint32_t req_id = 0, const std::vector<uint8_t>* data = nullptr) {
    auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
    return scc::tcp4tlm::CreateBusDataMsg(_fbb, status, req_id, data__);
}
 
struct SigOpMsg FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
    typedef SigOpMsgBuilder Builder;
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_ID = 4, VT_TIME_STAMP = 6, VT_INDEX = 8, VT_VALUE = 10 };
    uint32_t id() const { return GetField<uint32_t>(VT_ID, 0); }
    uint64_t time_stamp() const { return GetField<uint64_t>(VT_TIME_STAMP, 0); }
    uint32_t index() const { return GetField<uint32_t>(VT_INDEX, 0); }
    uint8_t value() const { return GetField<uint8_t>(VT_VALUE, 0); }
    bool Verify(::flatbuffers::Verifier& verifier) const {
        return VerifyTableStart(verifier) && VerifyField<uint32_t>(verifier, VT_ID, 4) &&
               VerifyField<uint64_t>(verifier, VT_TIME_STAMP, 8) && VerifyField<uint32_t>(verifier, VT_INDEX, 4) &&
               VerifyField<uint8_t>(verifier, VT_VALUE, 1) && verifier.EndTable();
    }
};
 
struct SigOpMsgBuilder {
    typedef SigOpMsg Table;
    ::flatbuffers::FlatBufferBuilder& fbb_;
    ::flatbuffers::uoffset_t start_;
    void add_id(uint32_t id) { fbb_.AddElement<uint32_t>(SigOpMsg::VT_ID, id, 0); }
    void add_time_stamp(uint64_t time_stamp) { fbb_.AddElement<uint64_t>(SigOpMsg::VT_TIME_STAMP, time_stamp, 0); }
    void add_index(uint32_t index) { fbb_.AddElement<uint32_t>(SigOpMsg::VT_INDEX, index, 0); }
    void add_value(uint8_t value) { fbb_.AddElement<uint8_t>(SigOpMsg::VT_VALUE, value, 0); }
    explicit SigOpMsgBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
    : fbb_(_fbb) {
        start_ = fbb_.StartTable();
    }
    ::flatbuffers::Offset<SigOpMsg> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = ::flatbuffers::Offset<SigOpMsg>(end);
        return o;
    }
};
 
inline ::flatbuffers::Offset<SigOpMsg> CreateSigOpMsg(::flatbuffers::FlatBufferBuilder& _fbb, uint32_t id = 0, uint64_t time_stamp = 0,
                                                      uint32_t index = 0, uint8_t value = 0) {
    SigOpMsgBuilder builder_(_fbb);
    builder_.add_time_stamp(time_stamp);
    builder_.add_index(index);
    builder_.add_id(id);
    builder_.add_value(value);
    return builder_.Finish();
}
 
struct LogMsg FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
    typedef LogMsgBuilder Builder;
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_ID = 4, VT_MSG = 6 };
    uint32_t id() const { return GetField<uint32_t>(VT_ID, 0); }
    const ::flatbuffers::String* msg() const { return GetPointer<const ::flatbuffers::String*>(VT_MSG); }
    bool Verify(::flatbuffers::Verifier& verifier) const {
        return VerifyTableStart(verifier) && VerifyField<uint32_t>(verifier, VT_ID, 4) && VerifyOffset(verifier, VT_MSG) &&
               verifier.VerifyString(msg()) && verifier.EndTable();
    }
};
 
struct LogMsgBuilder {
    typedef LogMsg Table;
    ::flatbuffers::FlatBufferBuilder& fbb_;
    ::flatbuffers::uoffset_t start_;
    void add_id(uint32_t id) { fbb_.AddElement<uint32_t>(LogMsg::VT_ID, id, 0); }
    void add_msg(::flatbuffers::Offset<::flatbuffers::String> msg) { fbb_.AddOffset(LogMsg::VT_MSG, msg); }
    explicit LogMsgBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
    : fbb_(_fbb) {
        start_ = fbb_.StartTable();
    }
    ::flatbuffers::Offset<LogMsg> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = ::flatbuffers::Offset<LogMsg>(end);
        return o;
    }
};
 
inline ::flatbuffers::Offset<LogMsg> CreateLogMsg(::flatbuffers::FlatBufferBuilder& _fbb, uint32_t id = 0,
                                                  ::flatbuffers::Offset<::flatbuffers::String> msg = 0) {
    LogMsgBuilder builder_(_fbb);
    builder_.add_msg(msg);
    builder_.add_id(id);
    return builder_.Finish();
}
 
inline ::flatbuffers::Offset<LogMsg> CreateLogMsgDirect(::flatbuffers::FlatBufferBuilder& _fbb, uint32_t id = 0,
                                                        const char* msg = nullptr) {
    auto msg__ = msg ? _fbb.CreateString(msg) : 0;
    return scc::tcp4tlm::CreateLogMsg(_fbb, id, msg__);
}
 
struct RequestEnvelope FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
    typedef RequestEnvelopeBuilder Builder;
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_PAYLOAD_TYPE = 4, VT_PAYLOAD = 6 };
    scc::tcp4tlm::RequestPayload payload_type() const {
        return static_cast<scc::tcp4tlm::RequestPayload>(GetField<uint8_t>(VT_PAYLOAD_TYPE, 0));
    }
    const void* payload() const { return GetPointer<const void*>(VT_PAYLOAD); }
    template <typename T> const T* payload_as() const;
    const scc::tcp4tlm::NotifyEndpointMsg* payload_as_NotifyEndpointMsg() const {
        return payload_type() == scc::tcp4tlm::RequestPayload_NotifyEndpointMsg
                   ? static_cast<const scc::tcp4tlm::NotifyEndpointMsg*>(payload())
                   : nullptr;
    }
    const scc::tcp4tlm::NotifyShutdownMsg* payload_as_NotifyShutdownMsg() const {
        return payload_type() == scc::tcp4tlm::RequestPayload_NotifyShutdownMsg
                   ? static_cast<const scc::tcp4tlm::NotifyShutdownMsg*>(payload())
                   : nullptr;
    }
    const scc::tcp4tlm::SyncMsg* payload_as_SyncMsg() const {
        return payload_type() == scc::tcp4tlm::RequestPayload_SyncMsg ? static_cast<const scc::tcp4tlm::SyncMsg*>(payload()) : nullptr;
    }
    const scc::tcp4tlm::BusOpMsg* payload_as_BusOpMsg() const {
        return payload_type() == scc::tcp4tlm::RequestPayload_BusOpMsg ? static_cast<const scc::tcp4tlm::BusOpMsg*>(payload()) : nullptr;
    }
    const scc::tcp4tlm::SigOpMsg* payload_as_SigOpMsg() const {
        return payload_type() == scc::tcp4tlm::RequestPayload_SigOpMsg ? static_cast<const scc::tcp4tlm::SigOpMsg*>(payload()) : nullptr;
    }
    const scc::tcp4tlm::LogMsg* payload_as_LogMsg() const {
        return payload_type() == scc::tcp4tlm::RequestPayload_LogMsg ? static_cast<const scc::tcp4tlm::LogMsg*>(payload()) : nullptr;
    }
    bool Verify(::flatbuffers::Verifier& verifier) const {
        return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_PAYLOAD_TYPE, 1) && VerifyOffset(verifier, VT_PAYLOAD) &&
               VerifyRequestPayload(verifier, payload(), payload_type()) && verifier.EndTable();
    }
};
 
template <> inline const scc::tcp4tlm::NotifyEndpointMsg* RequestEnvelope::payload_as<scc::tcp4tlm::NotifyEndpointMsg>() const {
    return payload_as_NotifyEndpointMsg();
}
 
template <> inline const scc::tcp4tlm::NotifyShutdownMsg* RequestEnvelope::payload_as<scc::tcp4tlm::NotifyShutdownMsg>() const {
    return payload_as_NotifyShutdownMsg();
}
 
template <> inline const scc::tcp4tlm::SyncMsg* RequestEnvelope::payload_as<scc::tcp4tlm::SyncMsg>() const { return payload_as_SyncMsg(); }
 
template <> inline const scc::tcp4tlm::BusOpMsg* RequestEnvelope::payload_as<scc::tcp4tlm::BusOpMsg>() const {
    return payload_as_BusOpMsg();
}
 
template <> inline const scc::tcp4tlm::SigOpMsg* RequestEnvelope::payload_as<scc::tcp4tlm::SigOpMsg>() const {
    return payload_as_SigOpMsg();
}
 
template <> inline const scc::tcp4tlm::LogMsg* RequestEnvelope::payload_as<scc::tcp4tlm::LogMsg>() const { return payload_as_LogMsg(); }
 
struct RequestEnvelopeBuilder {
    typedef RequestEnvelope Table;
    ::flatbuffers::FlatBufferBuilder& fbb_;
    ::flatbuffers::uoffset_t start_;
    void add_payload_type(scc::tcp4tlm::RequestPayload payload_type) {
        fbb_.AddElement<uint8_t>(RequestEnvelope::VT_PAYLOAD_TYPE, static_cast<uint8_t>(payload_type), 0);
    }
    void add_payload(::flatbuffers::Offset<void> payload) { fbb_.AddOffset(RequestEnvelope::VT_PAYLOAD, payload); }
    explicit RequestEnvelopeBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
    : fbb_(_fbb) {
        start_ = fbb_.StartTable();
    }
    ::flatbuffers::Offset<RequestEnvelope> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = ::flatbuffers::Offset<RequestEnvelope>(end);
        return o;
    }
};
 
inline ::flatbuffers::Offset<RequestEnvelope>
CreateRequestEnvelope(::flatbuffers::FlatBufferBuilder& _fbb, scc::tcp4tlm::RequestPayload payload_type = scc::tcp4tlm::RequestPayload_NONE,
                      ::flatbuffers::Offset<void> payload = 0) {
    RequestEnvelopeBuilder builder_(_fbb);
    builder_.add_payload(payload);
    builder_.add_payload_type(payload_type);
    return builder_.Finish();
}
 
struct ResponseEnvelope FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
    typedef ResponseEnvelopeBuilder Builder;
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_PAYLOAD_TYPE = 4, VT_PAYLOAD = 6 };
    scc::tcp4tlm::ResponsePayload payload_type() const {
        return static_cast<scc::tcp4tlm::ResponsePayload>(GetField<uint8_t>(VT_PAYLOAD_TYPE, 0));
    }
    const void* payload() const { return GetPointer<const void*>(VT_PAYLOAD); }
    template <typename T> const T* payload_as() const;
    const scc::tcp4tlm::ResponseMsg* payload_as_ResponseMsg() const {
        return payload_type() == scc::tcp4tlm::ResponsePayload_ResponseMsg ? static_cast<const scc::tcp4tlm::ResponseMsg*>(payload())
                                                                           : nullptr;
    }
    const scc::tcp4tlm::BusDataMsg* payload_as_BusDataMsg() const {
        return payload_type() == scc::tcp4tlm::ResponsePayload_BusDataMsg ? static_cast<const scc::tcp4tlm::BusDataMsg*>(payload())
                                                                          : nullptr;
    }
    bool Verify(::flatbuffers::Verifier& verifier) const {
        return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_PAYLOAD_TYPE, 1) && VerifyOffset(verifier, VT_PAYLOAD) &&
               VerifyResponsePayload(verifier, payload(), payload_type()) && verifier.EndTable();
    }
};
 
template <> inline const scc::tcp4tlm::ResponseMsg* ResponseEnvelope::payload_as<scc::tcp4tlm::ResponseMsg>() const {
    return payload_as_ResponseMsg();
}
 
template <> inline const scc::tcp4tlm::BusDataMsg* ResponseEnvelope::payload_as<scc::tcp4tlm::BusDataMsg>() const {
    return payload_as_BusDataMsg();
}
 
struct ResponseEnvelopeBuilder {
    typedef ResponseEnvelope Table;
    ::flatbuffers::FlatBufferBuilder& fbb_;
    ::flatbuffers::uoffset_t start_;
    void add_payload_type(scc::tcp4tlm::ResponsePayload payload_type) {
        fbb_.AddElement<uint8_t>(ResponseEnvelope::VT_PAYLOAD_TYPE, static_cast<uint8_t>(payload_type), 0);
    }
    void add_payload(::flatbuffers::Offset<void> payload) { fbb_.AddOffset(ResponseEnvelope::VT_PAYLOAD, payload); }
    explicit ResponseEnvelopeBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
    : fbb_(_fbb) {
        start_ = fbb_.StartTable();
    }
    ::flatbuffers::Offset<ResponseEnvelope> Finish() {
        const auto end = fbb_.EndTable(start_);
        auto o = ::flatbuffers::Offset<ResponseEnvelope>(end);
        return o;
    }
};
 
inline ::flatbuffers::Offset<ResponseEnvelope>
CreateResponseEnvelope(::flatbuffers::FlatBufferBuilder& _fbb,
                       scc::tcp4tlm::ResponsePayload payload_type = scc::tcp4tlm::ResponsePayload_NONE,
                       ::flatbuffers::Offset<void> payload = 0) {
    ResponseEnvelopeBuilder builder_(_fbb);
    builder_.add_payload(payload);
    builder_.add_payload_type(payload_type);
    return builder_.Finish();
}
 
inline bool VerifyRequestPayload(::flatbuffers::Verifier& verifier, const void* obj, RequestPayload type) {
    switch(type) {
    case RequestPayload_NONE: {
        return true;
    }
    case RequestPayload_NotifyEndpointMsg: {
        auto ptr = reinterpret_cast<const scc::tcp4tlm::NotifyEndpointMsg*>(obj);
        return verifier.VerifyTable(ptr);
    }
    case RequestPayload_NotifyShutdownMsg: {
        auto ptr = reinterpret_cast<const scc::tcp4tlm::NotifyShutdownMsg*>(obj);
        return verifier.VerifyTable(ptr);
    }
    case RequestPayload_SyncMsg: {
        auto ptr = reinterpret_cast<const scc::tcp4tlm::SyncMsg*>(obj);
        return verifier.VerifyTable(ptr);
    }
    case RequestPayload_BusOpMsg: {
        auto ptr = reinterpret_cast<const scc::tcp4tlm::BusOpMsg*>(obj);
        return verifier.VerifyTable(ptr);
    }
    case RequestPayload_SigOpMsg: {
        auto ptr = reinterpret_cast<const scc::tcp4tlm::SigOpMsg*>(obj);
        return verifier.VerifyTable(ptr);
    }
    case RequestPayload_LogMsg: {
        auto ptr = reinterpret_cast<const scc::tcp4tlm::LogMsg*>(obj);
        return verifier.VerifyTable(ptr);
    }
    default:
        return true;
    }
}
 
inline bool VerifyRequestPayloadVector(::flatbuffers::Verifier& verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>>* values,
                                       const ::flatbuffers::Vector<uint8_t>* types) {
    if(!values || !types)
        return !values && !types;
    if(values->size() != types->size())
        return false;
    for(::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
        if(!VerifyRequestPayload(verifier, values->Get(i), types->GetEnum<RequestPayload>(i))) {
            return false;
        }
    }
    return true;
}
 
inline bool VerifyResponsePayload(::flatbuffers::Verifier& verifier, const void* obj, ResponsePayload type) {
    switch(type) {
    case ResponsePayload_NONE: {
        return true;
    }
    case ResponsePayload_ResponseMsg: {
        auto ptr = reinterpret_cast<const scc::tcp4tlm::ResponseMsg*>(obj);
        return verifier.VerifyTable(ptr);
    }
    case ResponsePayload_BusDataMsg: {
        auto ptr = reinterpret_cast<const scc::tcp4tlm::BusDataMsg*>(obj);
        return verifier.VerifyTable(ptr);
    }
    default:
        return true;
    }
}
 
inline bool VerifyResponsePayloadVector(::flatbuffers::Verifier& verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>>* values,
                                        const ::flatbuffers::Vector<uint8_t>* types) {
    if(!values || !types)
        return !values && !types;
    if(values->size() != types->size())
        return false;
    for(::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
        if(!VerifyResponsePayload(verifier, values->Get(i), types->GetEnum<ResponsePayload>(i))) {
            return false;
        }
    }
    return true;
}
 
} // namespace tcp4tlm
} // namespace scc
 
#endif // FLATBUFFERS_GENERATED_MESSAGES_SCC_TCP4TLM_H_