Skip to content
Snippets Groups Projects
Select Git revision
  • a500a7b6dd577016ed103c083000e19f193bf21a
  • master default protected
  • Rpc
3 results

ModeliProtocol_generated.h

Blame
    • user avatar
    Added files
    Tim Übelhör authored
    a59e26e0
    History
    user avatar a59e26e0
    History
    Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    ModeliProtocol_generated.h 39.05 KiB 
    // automatically generated by the FlatBuffers compiler, do not modify


#ifndef FLATBUFFERS_GENERATED_MODELIPROTOCOL_NETWORK_PROTOCOL_H_
#define FLATBUFFERS_GENERATED_MODELIPROTOCOL_NETWORK_PROTOCOL_H_

#include "flatbuffers/flatbuffers.h"

namespace Network {
namespace Protocol {

struct ModeliMessage;

struct Time;

struct FmuFile;

struct ValueRefs;

struct ChannelLink;

struct IntValues;

struct RealValues;

struct BoolValues;

struct StringValues;

struct Feedback;

struct Log;

enum CommandEnum {
  CommandEnum_KeepAlive = 0,
  CommandEnum_Play = 1,
  CommandEnum_PlayFast = 2,
  CommandEnum_Pause = 3,
  CommandEnum_Stop = 4,
  CommandEnum_AddFmu = 5,
  CommandEnum_RemoveFmu = 6,
  CommandEnum_ValueRefs = 7,
  CommandEnum_AddChannelLinks = 8,
  CommandEnum_RemoveChannelLinks = 9,
  CommandEnum_Feedback = 10,
  CommandEnum_IntValues = 11,
  CommandEnum_RealValues = 12,
  CommandEnum_BoolValues = 13,
  CommandEnum_StringValues = 14,
  CommandEnum_Log = 15,
  CommandEnum_MIN = CommandEnum_KeepAlive,
  CommandEnum_MAX = CommandEnum_Log
};

inline CommandEnum (&EnumValuesCommandEnum())[16] {
  static CommandEnum values[] = {
    CommandEnum_KeepAlive,
    CommandEnum_Play,
    CommandEnum_PlayFast,
    CommandEnum_Pause,
    CommandEnum_Stop,
    CommandEnum_AddFmu,
    CommandEnum_RemoveFmu,
    CommandEnum_ValueRefs,
    CommandEnum_AddChannelLinks,
    CommandEnum_RemoveChannelLinks,
    CommandEnum_Feedback,
    CommandEnum_IntValues,
    CommandEnum_RealValues,
    CommandEnum_BoolValues,
        CommandEnum_StringValues,
    CommandEnum_Log
  };
  return values;
}

inline const char **EnumNamesCommandEnum() {
  static const char *names[] = {
    "KeepAlive",
    "Play",
    "PlayFast",
    "Pause",
    "Stop",
    "AddFmu",
    "RemoveFmu",
    "ValueRefs",
    "AddChannelLinks",
    "RemoveChannelLinks",
    "Feedback",
    "IntValues",
    "RealValues",
    "BoolValues",
    "StringValues",
    "Log",
    nullptr
  };
  return names;
}

inline const char *EnumNameCommandEnum(CommandEnum e) {
  const size_t index = static_cast<int>(e);
  return EnumNamesCommandEnum()[index];
}

enum DataUnion {
  DataUnion_NONE = 0,
  DataUnion_Time = 1,
  DataUnion_FmuFile = 2,
  DataUnion_ValueRefs = 3,
  DataUnion_ChannelLink = 4,
  DataUnion_IntValues = 5,
  DataUnion_RealValues = 6,
  DataUnion_BoolValues = 7,
  DataUnion_StringValues = 8,
  DataUnion_Feedback = 9,
  DataUnion_Log = 10,
  DataUnion_MIN = DataUnion_NONE,
  DataUnion_MAX = DataUnion_Log
};

inline DataUnion (&EnumValuesDataUnion())[11] {
  static DataUnion values[] = {
    DataUnion_NONE,
    DataUnion_Time,
    DataUnion_FmuFile,
    DataUnion_ValueRefs,
    DataUnion_ChannelLink,
    DataUnion_IntValues,
    DataUnion_RealValues,
    DataUnion_BoolValues,
    DataUnion_StringValues,
    DataUnion_Feedback,
    DataUnion_Log
  };
  return values;
}

inline const char **EnumNamesDataUnion() {
  static const char *names[] = {
    "NONE",
        "Time",
    "FmuFile",
    "ValueRefs",
    "ChannelLink",
    "IntValues",
    "RealValues",
    "BoolValues",
    "StringValues",
    "Feedback",
    "Log",
    nullptr
  };
  return names;
}

inline const char *EnumNameDataUnion(DataUnion e) {
  const size_t index = static_cast<int>(e);
  return EnumNamesDataUnion()[index];
}

template<typename T> struct DataUnionTraits {
  static const DataUnion enum_value = DataUnion_NONE;
};

template<> struct DataUnionTraits<Time> {
  static const DataUnion enum_value = DataUnion_Time;
};

template<> struct DataUnionTraits<FmuFile> {
  static const DataUnion enum_value = DataUnion_FmuFile;
};

template<> struct DataUnionTraits<ValueRefs> {
  static const DataUnion enum_value = DataUnion_ValueRefs;
};

template<> struct DataUnionTraits<ChannelLink> {
  static const DataUnion enum_value = DataUnion_ChannelLink;
};

template<> struct DataUnionTraits<IntValues> {
  static const DataUnion enum_value = DataUnion_IntValues;
};

template<> struct DataUnionTraits<RealValues> {
  static const DataUnion enum_value = DataUnion_RealValues;
};

template<> struct DataUnionTraits<BoolValues> {
  static const DataUnion enum_value = DataUnion_BoolValues;
};

template<> struct DataUnionTraits<StringValues> {
  static const DataUnion enum_value = DataUnion_StringValues;
};

template<> struct DataUnionTraits<Feedback> {
  static const DataUnion enum_value = DataUnion_Feedback;
};

template<> struct DataUnionTraits<Log> {
  static const DataUnion enum_value = DataUnion_Log;
};

bool VerifyDataUnion(flatbuffers::Verifier &verifier, const void *obj, DataUnion type);
bool VerifyDataUnionVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);

struct ModeliMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum {
    VT_COMMAND = 4,
        VT_JOBNR = 6,
    VT_DATA_TYPE = 8,
    VT_DATA = 10
  };
  CommandEnum Command() const {
    return static_cast<CommandEnum>(GetField<int32_t>(VT_COMMAND, 0));
  }
  int32_t JobNr() const {
    return GetField<int32_t>(VT_JOBNR, 0);
  }
  DataUnion Data_type() const {
    return static_cast<DataUnion>(GetField<uint8_t>(VT_DATA_TYPE, 0));
  }
  const void *Data() const {
    return GetPointer<const void *>(VT_DATA);
  }
  template<typename T> const T *Data_as() const;
  const Time *Data_as_Time() const {
    return Data_type() == DataUnion_Time ? static_cast<const Time *>(Data()) : nullptr;
  }
  const FmuFile *Data_as_FmuFile() const {
    return Data_type() == DataUnion_FmuFile ? static_cast<const FmuFile *>(Data()) : nullptr;
  }
  const ValueRefs *Data_as_ValueRefs() const {
    return Data_type() == DataUnion_ValueRefs ? static_cast<const ValueRefs *>(Data()) : nullptr;
  }
  const ChannelLink *Data_as_ChannelLink() const {
    return Data_type() == DataUnion_ChannelLink ? static_cast<const ChannelLink *>(Data()) : nullptr;
  }
  const IntValues *Data_as_IntValues() const {
    return Data_type() == DataUnion_IntValues ? static_cast<const IntValues *>(Data()) : nullptr;
  }
  const RealValues *Data_as_RealValues() const {
    return Data_type() == DataUnion_RealValues ? static_cast<const RealValues *>(Data()) : nullptr;
  }
  const BoolValues *Data_as_BoolValues() const {
    return Data_type() == DataUnion_BoolValues ? static_cast<const BoolValues *>(Data()) : nullptr;
  }
  const StringValues *Data_as_StringValues() const {
    return Data_type() == DataUnion_StringValues ? static_cast<const StringValues *>(Data()) : nullptr;
  }
  const Feedback *Data_as_Feedback() const {
    return Data_type() == DataUnion_Feedback ? static_cast<const Feedback *>(Data()) : nullptr;
  }
  const Log *Data_as_Log() const {
    return Data_type() == DataUnion_Log ? static_cast<const Log *>(Data()) : nullptr;
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_COMMAND) &&
           VerifyField<int32_t>(verifier, VT_JOBNR) &&
           VerifyField<uint8_t>(verifier, VT_DATA_TYPE) &&
           VerifyOffset(verifier, VT_DATA) &&
           VerifyDataUnion(verifier, Data(), Data_type()) &&
           verifier.EndTable();
  }
};

template<> inline const Time *ModeliMessage::Data_as<Time>() const {
  return Data_as_Time();
}

template<> inline const FmuFile *ModeliMessage::Data_as<FmuFile>() const {
  return Data_as_FmuFile();
}

template<> inline const ValueRefs *ModeliMessage::Data_as<ValueRefs>() const {
  return Data_as_ValueRefs();
}

    template<> inline const ChannelLink *ModeliMessage::Data_as<ChannelLink>() const {
  return Data_as_ChannelLink();
}

template<> inline const IntValues *ModeliMessage::Data_as<IntValues>() const {
  return Data_as_IntValues();
}

template<> inline const RealValues *ModeliMessage::Data_as<RealValues>() const {
  return Data_as_RealValues();
}

template<> inline const BoolValues *ModeliMessage::Data_as<BoolValues>() const {
  return Data_as_BoolValues();
}

template<> inline const StringValues *ModeliMessage::Data_as<StringValues>() const {
  return Data_as_StringValues();
}

template<> inline const Feedback *ModeliMessage::Data_as<Feedback>() const {
  return Data_as_Feedback();
}

template<> inline const Log *ModeliMessage::Data_as<Log>() const {
  return Data_as_Log();
}

struct ModeliMessageBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_Command(CommandEnum Command) {
    fbb_.AddElement<int32_t>(ModeliMessage::VT_COMMAND, static_cast<int32_t>(Command), 0);
  }
  void add_JobNr(int32_t JobNr) {
    fbb_.AddElement<int32_t>(ModeliMessage::VT_JOBNR, JobNr, 0);
  }
  void add_Data_type(DataUnion Data_type) {
    fbb_.AddElement<uint8_t>(ModeliMessage::VT_DATA_TYPE, static_cast<uint8_t>(Data_type), 0);
  }
  void add_Data(flatbuffers::Offset<void> Data) {
    fbb_.AddOffset(ModeliMessage::VT_DATA, Data);
  }
  ModeliMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ModeliMessageBuilder &operator=(const ModeliMessageBuilder &);
  flatbuffers::Offset<ModeliMessage> Finish() {
    const auto end = fbb_.EndTable(start_, 4);
    auto o = flatbuffers::Offset<ModeliMessage>(end);
    return o;
  }
};

inline flatbuffers::Offset<ModeliMessage> CreateModeliMessage(
    flatbuffers::FlatBufferBuilder &_fbb,
    CommandEnum Command = CommandEnum_KeepAlive,
    int32_t JobNr = 0,
    DataUnion Data_type = DataUnion_NONE,
    flatbuffers::Offset<void> Data = 0) {
  ModeliMessageBuilder builder_(_fbb);
  builder_.add_Data(Data);
  builder_.add_JobNr(JobNr);
  builder_.add_Command(Command);
  builder_.add_Data_type(Data_type);
  return builder_.Finish();
}

struct Time FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
      enum {
    VT_VALUE = 4
  };
  double Value() const {
    return GetField<double>(VT_VALUE, 0.0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<double>(verifier, VT_VALUE) &&
           verifier.EndTable();
  }
};

struct TimeBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_Value(double Value) {
    fbb_.AddElement<double>(Time::VT_VALUE, Value, 0.0);
  }
  TimeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  TimeBuilder &operator=(const TimeBuilder &);
  flatbuffers::Offset<Time> Finish() {
    const auto end = fbb_.EndTable(start_, 1);
    auto o = flatbuffers::Offset<Time>(end);
    return o;
  }
};

inline flatbuffers::Offset<Time> CreateTime(
    flatbuffers::FlatBufferBuilder &_fbb,
    double Value = 0.0) {
  TimeBuilder builder_(_fbb);
  builder_.add_Value(Value);
  return builder_.Finish();
}

struct FmuFile FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum {
    VT_INSTANCENAME = 4,
    VT_BINARYSIZE = 6
  };
  const flatbuffers::String *InstanceName() const {
    return GetPointer<const flatbuffers::String *>(VT_INSTANCENAME);
  }
  int32_t BinarySize() const {
    return GetField<int32_t>(VT_BINARYSIZE, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_INSTANCENAME) &&
           verifier.Verify(InstanceName()) &&
           VerifyField<int32_t>(verifier, VT_BINARYSIZE) &&
           verifier.EndTable();
  }
};

struct FmuFileBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_InstanceName(flatbuffers::Offset<flatbuffers::String> InstanceName) {
    fbb_.AddOffset(FmuFile::VT_INSTANCENAME, InstanceName);
  }
  void add_BinarySize(int32_t BinarySize) {
    fbb_.AddElement<int32_t>(FmuFile::VT_BINARYSIZE, BinarySize, 0);
  }
  FmuFileBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
        start_ = fbb_.StartTable();
  }
  FmuFileBuilder &operator=(const FmuFileBuilder &);
  flatbuffers::Offset<FmuFile> Finish() {
    const auto end = fbb_.EndTable(start_, 2);
    auto o = flatbuffers::Offset<FmuFile>(end);
    return o;
  }
};

inline flatbuffers::Offset<FmuFile> CreateFmuFile(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> InstanceName = 0,
    int32_t BinarySize = 0) {
  FmuFileBuilder builder_(_fbb);
  builder_.add_BinarySize(BinarySize);
  builder_.add_InstanceName(InstanceName);
  return builder_.Finish();
}

inline flatbuffers::Offset<FmuFile> CreateFmuFileDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *InstanceName = nullptr,
    int32_t BinarySize = 0) {
  return Network::Protocol::CreateFmuFile(
      _fbb,
      InstanceName ? _fbb.CreateString(InstanceName) : 0,
      BinarySize);
}

struct ValueRefs FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum {
    VT_INSTANCENAME = 4,
    VT_INTVRS = 6,
    VT_REALVRS = 8,
    VT_BOOLVRS = 10,
    VT_STRINGVRS = 12
  };
  const flatbuffers::String *InstanceName() const {
    return GetPointer<const flatbuffers::String *>(VT_INSTANCENAME);
  }
  const flatbuffers::Vector<uint32_t> *IntVrs() const {
    return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_INTVRS);
  }
  const flatbuffers::Vector<uint32_t> *RealVrs() const {
    return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_REALVRS);
  }
  const flatbuffers::Vector<uint32_t> *BoolVrs() const {
    return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_BOOLVRS);
  }
  const flatbuffers::Vector<uint32_t> *StringVrs() const {
    return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_STRINGVRS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_INSTANCENAME) &&
           verifier.Verify(InstanceName()) &&
           VerifyOffset(verifier, VT_INTVRS) &&
           verifier.Verify(IntVrs()) &&
           VerifyOffset(verifier, VT_REALVRS) &&
           verifier.Verify(RealVrs()) &&
           VerifyOffset(verifier, VT_BOOLVRS) &&
           verifier.Verify(BoolVrs()) &&
           VerifyOffset(verifier, VT_STRINGVRS) &&
           verifier.Verify(StringVrs()) &&
           verifier.EndTable();
  }
};

struct ValueRefsBuilder {
      flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_InstanceName(flatbuffers::Offset<flatbuffers::String> InstanceName) {
    fbb_.AddOffset(ValueRefs::VT_INSTANCENAME, InstanceName);
  }
  void add_IntVrs(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> IntVrs) {
    fbb_.AddOffset(ValueRefs::VT_INTVRS, IntVrs);
  }
  void add_RealVrs(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> RealVrs) {
    fbb_.AddOffset(ValueRefs::VT_REALVRS, RealVrs);
  }
  void add_BoolVrs(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> BoolVrs) {
    fbb_.AddOffset(ValueRefs::VT_BOOLVRS, BoolVrs);
  }
  void add_StringVrs(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> StringVrs) {
    fbb_.AddOffset(ValueRefs::VT_STRINGVRS, StringVrs);
  }
  ValueRefsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ValueRefsBuilder &operator=(const ValueRefsBuilder &);
  flatbuffers::Offset<ValueRefs> Finish() {
    const auto end = fbb_.EndTable(start_, 5);
    auto o = flatbuffers::Offset<ValueRefs>(end);
    return o;
  }
};

inline flatbuffers::Offset<ValueRefs> CreateValueRefs(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> InstanceName = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint32_t>> IntVrs = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint32_t>> RealVrs = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint32_t>> BoolVrs = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint32_t>> StringVrs = 0) {
  ValueRefsBuilder builder_(_fbb);
  builder_.add_StringVrs(StringVrs);
  builder_.add_BoolVrs(BoolVrs);
  builder_.add_RealVrs(RealVrs);
  builder_.add_IntVrs(IntVrs);
  builder_.add_InstanceName(InstanceName);
  return builder_.Finish();
}

inline flatbuffers::Offset<ValueRefs> CreateValueRefsDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *InstanceName = nullptr,
    const std::vector<uint32_t> *IntVrs = nullptr,
    const std::vector<uint32_t> *RealVrs = nullptr,
    const std::vector<uint32_t> *BoolVrs = nullptr,
    const std::vector<uint32_t> *StringVrs = nullptr) {
  return Network::Protocol::CreateValueRefs(
      _fbb,
      InstanceName ? _fbb.CreateString(InstanceName) : 0,
      IntVrs ? _fbb.CreateVector<uint32_t>(*IntVrs) : 0,
      RealVrs ? _fbb.CreateVector<uint32_t>(*RealVrs) : 0,
      BoolVrs ? _fbb.CreateVector<uint32_t>(*BoolVrs) : 0,
      StringVrs ? _fbb.CreateVector<uint32_t>(*StringVrs) : 0);
}

struct ChannelLink FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum {
    VT_MASTERINSTANCENAME = 4,
    VT_SLAVEINSTANCENAME = 6,
    VT_MASTERVR = 8,
    VT_SLAVEVR = 10,
    VT_FACTOR = 12,
    VT_SHIFT = 14
  };
      const flatbuffers::String *MasterInstanceName() const {
    return GetPointer<const flatbuffers::String *>(VT_MASTERINSTANCENAME);
  }
  const flatbuffers::String *SlaveInstanceName() const {
    return GetPointer<const flatbuffers::String *>(VT_SLAVEINSTANCENAME);
  }
  uint32_t MasterVr() const {
    return GetField<uint32_t>(VT_MASTERVR, 0);
  }
  uint32_t SlaveVr() const {
    return GetField<uint32_t>(VT_SLAVEVR, 0);
  }
  double Factor() const {
    return GetField<double>(VT_FACTOR, 0.0);
  }
  double Shift() const {
    return GetField<double>(VT_SHIFT, 0.0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_MASTERINSTANCENAME) &&
           verifier.Verify(MasterInstanceName()) &&
           VerifyOffset(verifier, VT_SLAVEINSTANCENAME) &&
           verifier.Verify(SlaveInstanceName()) &&
           VerifyField<uint32_t>(verifier, VT_MASTERVR) &&
           VerifyField<uint32_t>(verifier, VT_SLAVEVR) &&
           VerifyField<double>(verifier, VT_FACTOR) &&
           VerifyField<double>(verifier, VT_SHIFT) &&
           verifier.EndTable();
  }
};

struct ChannelLinkBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_MasterInstanceName(flatbuffers::Offset<flatbuffers::String> MasterInstanceName) {
    fbb_.AddOffset(ChannelLink::VT_MASTERINSTANCENAME, MasterInstanceName);
  }
  void add_SlaveInstanceName(flatbuffers::Offset<flatbuffers::String> SlaveInstanceName) {
    fbb_.AddOffset(ChannelLink::VT_SLAVEINSTANCENAME, SlaveInstanceName);
  }
  void add_MasterVr(uint32_t MasterVr) {
    fbb_.AddElement<uint32_t>(ChannelLink::VT_MASTERVR, MasterVr, 0);
  }
  void add_SlaveVr(uint32_t SlaveVr) {
    fbb_.AddElement<uint32_t>(ChannelLink::VT_SLAVEVR, SlaveVr, 0);
  }
  void add_Factor(double Factor) {
    fbb_.AddElement<double>(ChannelLink::VT_FACTOR, Factor, 0.0);
  }
  void add_Shift(double Shift) {
    fbb_.AddElement<double>(ChannelLink::VT_SHIFT, Shift, 0.0);
  }
  ChannelLinkBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ChannelLinkBuilder &operator=(const ChannelLinkBuilder &);
  flatbuffers::Offset<ChannelLink> Finish() {
    const auto end = fbb_.EndTable(start_, 6);
    auto o = flatbuffers::Offset<ChannelLink>(end);
    return o;
  }
};

inline flatbuffers::Offset<ChannelLink> CreateChannelLink(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> MasterInstanceName = 0,
    flatbuffers::Offset<flatbuffers::String> SlaveInstanceName = 0,
    uint32_t MasterVr = 0,
        uint32_t SlaveVr = 0,
    double Factor = 0.0,
    double Shift = 0.0) {
  ChannelLinkBuilder builder_(_fbb);
  builder_.add_Shift(Shift);
  builder_.add_Factor(Factor);
  builder_.add_SlaveVr(SlaveVr);
  builder_.add_MasterVr(MasterVr);
  builder_.add_SlaveInstanceName(SlaveInstanceName);
  builder_.add_MasterInstanceName(MasterInstanceName);
  return builder_.Finish();
}

inline flatbuffers::Offset<ChannelLink> CreateChannelLinkDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *MasterInstanceName = nullptr,
    const char *SlaveInstanceName = nullptr,
    uint32_t MasterVr = 0,
    uint32_t SlaveVr = 0,
    double Factor = 0.0,
    double Shift = 0.0) {
  return Network::Protocol::CreateChannelLink(
      _fbb,
      MasterInstanceName ? _fbb.CreateString(MasterInstanceName) : 0,
      SlaveInstanceName ? _fbb.CreateString(SlaveInstanceName) : 0,
      MasterVr,
      SlaveVr,
      Factor,
      Shift);
}

struct IntValues FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum {
    VT_INSTANCENAME = 4,
    VT_TIMESTAMP = 6,
    VT_VALUEREFS = 8,
    VT_VALUES = 10
  };
  const flatbuffers::String *InstanceName() const {
    return GetPointer<const flatbuffers::String *>(VT_INSTANCENAME);
  }
  double Timestamp() const {
    return GetField<double>(VT_TIMESTAMP, 0.0);
  }
  const flatbuffers::Vector<uint32_t> *ValueRefs() const {
    return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_VALUEREFS);
  }
  const flatbuffers::Vector<int32_t> *Values() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_VALUES);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_INSTANCENAME) &&
           verifier.Verify(InstanceName()) &&
           VerifyField<double>(verifier, VT_TIMESTAMP) &&
           VerifyOffset(verifier, VT_VALUEREFS) &&
           verifier.Verify(ValueRefs()) &&
           VerifyOffset(verifier, VT_VALUES) &&
           verifier.Verify(Values()) &&
           verifier.EndTable();
  }
};

struct IntValuesBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_InstanceName(flatbuffers::Offset<flatbuffers::String> InstanceName) {
    fbb_.AddOffset(IntValues::VT_INSTANCENAME, InstanceName);
  }
  void add_Timestamp(double Timestamp) {
        fbb_.AddElement<double>(IntValues::VT_TIMESTAMP, Timestamp, 0.0);
  }
  void add_ValueRefs(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> ValueRefs) {
    fbb_.AddOffset(IntValues::VT_VALUEREFS, ValueRefs);
  }
  void add_Values(flatbuffers::Offset<flatbuffers::Vector<int32_t>> Values) {
    fbb_.AddOffset(IntValues::VT_VALUES, Values);
  }
  IntValuesBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  IntValuesBuilder &operator=(const IntValuesBuilder &);
  flatbuffers::Offset<IntValues> Finish() {
    const auto end = fbb_.EndTable(start_, 4);
    auto o = flatbuffers::Offset<IntValues>(end);
    return o;
  }
};

inline flatbuffers::Offset<IntValues> CreateIntValues(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> InstanceName = 0,
    double Timestamp = 0.0,
    flatbuffers::Offset<flatbuffers::Vector<uint32_t>> ValueRefs = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> Values = 0) {
  IntValuesBuilder builder_(_fbb);
  builder_.add_Timestamp(Timestamp);
  builder_.add_Values(Values);
  builder_.add_ValueRefs(ValueRefs);
  builder_.add_InstanceName(InstanceName);
  return builder_.Finish();
}

inline flatbuffers::Offset<IntValues> CreateIntValuesDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *InstanceName = nullptr,
    double Timestamp = 0.0,
    const std::vector<uint32_t> *ValueRefs = nullptr,
    const std::vector<int32_t> *Values = nullptr) {
  return Network::Protocol::CreateIntValues(
      _fbb,
      InstanceName ? _fbb.CreateString(InstanceName) : 0,
      Timestamp,
      ValueRefs ? _fbb.CreateVector<uint32_t>(*ValueRefs) : 0,
      Values ? _fbb.CreateVector<int32_t>(*Values) : 0);
}

struct RealValues FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum {
    VT_INSTANCENAME = 4,
    VT_TIMESTAMP = 6,
    VT_VALUEREFS = 8,
    VT_VALUES = 10
  };
  const flatbuffers::String *InstanceName() const {
    return GetPointer<const flatbuffers::String *>(VT_INSTANCENAME);
  }
  double Timestamp() const {
    return GetField<double>(VT_TIMESTAMP, 0.0);
  }
  const flatbuffers::Vector<uint32_t> *ValueRefs() const {
    return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_VALUEREFS);
  }
  const flatbuffers::Vector<double> *Values() const {
    return GetPointer<const flatbuffers::Vector<double> *>(VT_VALUES);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_INSTANCENAME) &&
               verifier.Verify(InstanceName()) &&
           VerifyField<double>(verifier, VT_TIMESTAMP) &&
           VerifyOffset(verifier, VT_VALUEREFS) &&
           verifier.Verify(ValueRefs()) &&
           VerifyOffset(verifier, VT_VALUES) &&
           verifier.Verify(Values()) &&
           verifier.EndTable();
  }
};

struct RealValuesBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_InstanceName(flatbuffers::Offset<flatbuffers::String> InstanceName) {
    fbb_.AddOffset(RealValues::VT_INSTANCENAME, InstanceName);
  }
  void add_Timestamp(double Timestamp) {
    fbb_.AddElement<double>(RealValues::VT_TIMESTAMP, Timestamp, 0.0);
  }
  void add_ValueRefs(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> ValueRefs) {
    fbb_.AddOffset(RealValues::VT_VALUEREFS, ValueRefs);
  }
  void add_Values(flatbuffers::Offset<flatbuffers::Vector<double>> Values) {
    fbb_.AddOffset(RealValues::VT_VALUES, Values);
  }
  RealValuesBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  RealValuesBuilder &operator=(const RealValuesBuilder &);
  flatbuffers::Offset<RealValues> Finish() {
    const auto end = fbb_.EndTable(start_, 4);
    auto o = flatbuffers::Offset<RealValues>(end);
    return o;
  }
};

inline flatbuffers::Offset<RealValues> CreateRealValues(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> InstanceName = 0,
    double Timestamp = 0.0,
    flatbuffers::Offset<flatbuffers::Vector<uint32_t>> ValueRefs = 0,
    flatbuffers::Offset<flatbuffers::Vector<double>> Values = 0) {
  RealValuesBuilder builder_(_fbb);
  builder_.add_Timestamp(Timestamp);
  builder_.add_Values(Values);
  builder_.add_ValueRefs(ValueRefs);
  builder_.add_InstanceName(InstanceName);
  return builder_.Finish();
}

inline flatbuffers::Offset<RealValues> CreateRealValuesDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *InstanceName = nullptr,
    double Timestamp = 0.0,
    const std::vector<uint32_t> *ValueRefs = nullptr,
    const std::vector<double> *Values = nullptr) {
  return Network::Protocol::CreateRealValues(
      _fbb,
      InstanceName ? _fbb.CreateString(InstanceName) : 0,
      Timestamp,
      ValueRefs ? _fbb.CreateVector<uint32_t>(*ValueRefs) : 0,
      Values ? _fbb.CreateVector<double>(*Values) : 0);
}

struct BoolValues FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum {
    VT_INSTANCENAME = 4,
    VT_TIMESTAMP = 6,
    VT_VALUEREFS = 8,
        VT_VALUES = 10
  };
  const flatbuffers::String *InstanceName() const {
    return GetPointer<const flatbuffers::String *>(VT_INSTANCENAME);
  }
  double Timestamp() const {
    return GetField<double>(VT_TIMESTAMP, 0.0);
  }
  const flatbuffers::Vector<uint32_t> *ValueRefs() const {
    return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_VALUEREFS);
  }
  const flatbuffers::Vector<int32_t> *Values() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_VALUES);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_INSTANCENAME) &&
           verifier.Verify(InstanceName()) &&
           VerifyField<double>(verifier, VT_TIMESTAMP) &&
           VerifyOffset(verifier, VT_VALUEREFS) &&
           verifier.Verify(ValueRefs()) &&
           VerifyOffset(verifier, VT_VALUES) &&
           verifier.Verify(Values()) &&
           verifier.EndTable();
  }
};

struct BoolValuesBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_InstanceName(flatbuffers::Offset<flatbuffers::String> InstanceName) {
    fbb_.AddOffset(BoolValues::VT_INSTANCENAME, InstanceName);
  }
  void add_Timestamp(double Timestamp) {
    fbb_.AddElement<double>(BoolValues::VT_TIMESTAMP, Timestamp, 0.0);
  }
  void add_ValueRefs(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> ValueRefs) {
    fbb_.AddOffset(BoolValues::VT_VALUEREFS, ValueRefs);
  }
  void add_Values(flatbuffers::Offset<flatbuffers::Vector<int32_t>> Values) {
    fbb_.AddOffset(BoolValues::VT_VALUES, Values);
  }
  BoolValuesBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  BoolValuesBuilder &operator=(const BoolValuesBuilder &);
  flatbuffers::Offset<BoolValues> Finish() {
    const auto end = fbb_.EndTable(start_, 4);
    auto o = flatbuffers::Offset<BoolValues>(end);
    return o;
  }
};

inline flatbuffers::Offset<BoolValues> CreateBoolValues(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> InstanceName = 0,
    double Timestamp = 0.0,
    flatbuffers::Offset<flatbuffers::Vector<uint32_t>> ValueRefs = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> Values = 0) {
  BoolValuesBuilder builder_(_fbb);
  builder_.add_Timestamp(Timestamp);
  builder_.add_Values(Values);
  builder_.add_ValueRefs(ValueRefs);
  builder_.add_InstanceName(InstanceName);
  return builder_.Finish();
}

inline flatbuffers::Offset<BoolValues> CreateBoolValuesDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
        const char *InstanceName = nullptr,
    double Timestamp = 0.0,
    const std::vector<uint32_t> *ValueRefs = nullptr,
    const std::vector<int32_t> *Values = nullptr) {
  return Network::Protocol::CreateBoolValues(
      _fbb,
      InstanceName ? _fbb.CreateString(InstanceName) : 0,
      Timestamp,
      ValueRefs ? _fbb.CreateVector<uint32_t>(*ValueRefs) : 0,
      Values ? _fbb.CreateVector<int32_t>(*Values) : 0);
}

struct StringValues FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum {
    VT_INSTANCENAME = 4,
    VT_TIMESTAMP = 6,
    VT_VALUEREFS = 8,
    VT_VALUES = 10
  };
  const flatbuffers::String *InstanceName() const {
    return GetPointer<const flatbuffers::String *>(VT_INSTANCENAME);
  }
  double Timestamp() const {
    return GetField<double>(VT_TIMESTAMP, 0.0);
  }
  const flatbuffers::Vector<uint32_t> *ValueRefs() const {
    return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_VALUEREFS);
  }
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *Values() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_VALUES);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_INSTANCENAME) &&
           verifier.Verify(InstanceName()) &&
           VerifyField<double>(verifier, VT_TIMESTAMP) &&
           VerifyOffset(verifier, VT_VALUEREFS) &&
           verifier.Verify(ValueRefs()) &&
           VerifyOffset(verifier, VT_VALUES) &&
           verifier.Verify(Values()) &&
           verifier.VerifyVectorOfStrings(Values()) &&
           verifier.EndTable();
  }
};

struct StringValuesBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_InstanceName(flatbuffers::Offset<flatbuffers::String> InstanceName) {
    fbb_.AddOffset(StringValues::VT_INSTANCENAME, InstanceName);
  }
  void add_Timestamp(double Timestamp) {
    fbb_.AddElement<double>(StringValues::VT_TIMESTAMP, Timestamp, 0.0);
  }
  void add_ValueRefs(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> ValueRefs) {
    fbb_.AddOffset(StringValues::VT_VALUEREFS, ValueRefs);
  }
  void add_Values(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> Values) {
    fbb_.AddOffset(StringValues::VT_VALUES, Values);
  }
  StringValuesBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  StringValuesBuilder &operator=(const StringValuesBuilder &);
  flatbuffers::Offset<StringValues> Finish() {
    const auto end = fbb_.EndTable(start_, 4);
    auto o = flatbuffers::Offset<StringValues>(end);
    return o;
  }
    };

inline flatbuffers::Offset<StringValues> CreateStringValues(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> InstanceName = 0,
    double Timestamp = 0.0,
    flatbuffers::Offset<flatbuffers::Vector<uint32_t>> ValueRefs = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> Values = 0) {
  StringValuesBuilder builder_(_fbb);
  builder_.add_Timestamp(Timestamp);
  builder_.add_Values(Values);
  builder_.add_ValueRefs(ValueRefs);
  builder_.add_InstanceName(InstanceName);
  return builder_.Finish();
}

inline flatbuffers::Offset<StringValues> CreateStringValuesDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *InstanceName = nullptr,
    double Timestamp = 0.0,
    const std::vector<uint32_t> *ValueRefs = nullptr,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *Values = nullptr) {
  return Network::Protocol::CreateStringValues(
      _fbb,
      InstanceName ? _fbb.CreateString(InstanceName) : 0,
      Timestamp,
      ValueRefs ? _fbb.CreateVector<uint32_t>(*ValueRefs) : 0,
      Values ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*Values) : 0);
}

struct Feedback FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum {
    VT_RESULT = 4,
    VT_MESSAGE = 6
  };
  int32_t Result() const {
    return GetField<int32_t>(VT_RESULT, 0);
  }
  const flatbuffers::String *Message() const {
    return GetPointer<const flatbuffers::String *>(VT_MESSAGE);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_RESULT) &&
           VerifyOffset(verifier, VT_MESSAGE) &&
           verifier.Verify(Message()) &&
           verifier.EndTable();
  }
};

struct FeedbackBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_Result(int32_t Result) {
    fbb_.AddElement<int32_t>(Feedback::VT_RESULT, Result, 0);
  }
  void add_Message(flatbuffers::Offset<flatbuffers::String> Message) {
    fbb_.AddOffset(Feedback::VT_MESSAGE, Message);
  }
  FeedbackBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  FeedbackBuilder &operator=(const FeedbackBuilder &);
  flatbuffers::Offset<Feedback> Finish() {
    const auto end = fbb_.EndTable(start_, 2);
    auto o = flatbuffers::Offset<Feedback>(end);
    return o;
  }
};
    
inline flatbuffers::Offset<Feedback> CreateFeedback(
    flatbuffers::FlatBufferBuilder &_fbb,
    int32_t Result = 0,
    flatbuffers::Offset<flatbuffers::String> Message = 0) {
  FeedbackBuilder builder_(_fbb);
  builder_.add_Message(Message);
  builder_.add_Result(Result);
  return builder_.Finish();
}

inline flatbuffers::Offset<Feedback> CreateFeedbackDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    int32_t Result = 0,
    const char *Message = nullptr) {
  return Network::Protocol::CreateFeedback(
      _fbb,
      Result,
      Message ? _fbb.CreateString(Message) : 0);
}

struct Log FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum {
    VT_INSTANCENAME = 4,
    VT_MESSAGE = 6
  };
  const flatbuffers::String *InstanceName() const {
    return GetPointer<const flatbuffers::String *>(VT_INSTANCENAME);
  }
  const flatbuffers::String *Message() const {
    return GetPointer<const flatbuffers::String *>(VT_MESSAGE);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_INSTANCENAME) &&
           verifier.Verify(InstanceName()) &&
           VerifyOffset(verifier, VT_MESSAGE) &&
           verifier.Verify(Message()) &&
           verifier.EndTable();
  }
};

struct LogBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_InstanceName(flatbuffers::Offset<flatbuffers::String> InstanceName) {
    fbb_.AddOffset(Log::VT_INSTANCENAME, InstanceName);
  }
  void add_Message(flatbuffers::Offset<flatbuffers::String> Message) {
    fbb_.AddOffset(Log::VT_MESSAGE, Message);
  }
  LogBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  LogBuilder &operator=(const LogBuilder &);
  flatbuffers::Offset<Log> Finish() {
    const auto end = fbb_.EndTable(start_, 2);
    auto o = flatbuffers::Offset<Log>(end);
    return o;
  }
};

inline flatbuffers::Offset<Log> CreateLog(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> InstanceName = 0,
    flatbuffers::Offset<flatbuffers::String> Message = 0) {
  LogBuilder builder_(_fbb);
  builder_.add_Message(Message);
  builder_.add_InstanceName(InstanceName);
      return builder_.Finish();
}

inline flatbuffers::Offset<Log> CreateLogDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *InstanceName = nullptr,
    const char *Message = nullptr) {
  return Network::Protocol::CreateLog(
      _fbb,
      InstanceName ? _fbb.CreateString(InstanceName) : 0,
      Message ? _fbb.CreateString(Message) : 0);
}

inline bool VerifyDataUnion(flatbuffers::Verifier &verifier, const void *obj, DataUnion type) {
  switch (type) {
    case DataUnion_NONE: {
      return true;
    }
    case DataUnion_Time: {
      auto ptr = reinterpret_cast<const Time *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case DataUnion_FmuFile: {
      auto ptr = reinterpret_cast<const FmuFile *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case DataUnion_ValueRefs: {
      auto ptr = reinterpret_cast<const ValueRefs *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case DataUnion_ChannelLink: {
      auto ptr = reinterpret_cast<const ChannelLink *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case DataUnion_IntValues: {
      auto ptr = reinterpret_cast<const IntValues *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case DataUnion_RealValues: {
      auto ptr = reinterpret_cast<const RealValues *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case DataUnion_BoolValues: {
      auto ptr = reinterpret_cast<const BoolValues *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case DataUnion_StringValues: {
      auto ptr = reinterpret_cast<const StringValues *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case DataUnion_Feedback: {
      auto ptr = reinterpret_cast<const Feedback *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case DataUnion_Log: {
      auto ptr = reinterpret_cast<const Log *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return false;
  }
}

inline bool VerifyDataUnionVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
  if (values->size() != types->size()) return false;
  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
    if (!VerifyDataUnion(
        verifier,  values->Get(i), types->GetEnum<DataUnion>(i))) {
      return false;
    }
  }
      return true;
}

inline const Network::Protocol::ModeliMessage *GetModeliMessage(const void *buf) {
  return flatbuffers::GetRoot<Network::Protocol::ModeliMessage>(buf);
}

inline bool VerifyModeliMessageBuffer(
    flatbuffers::Verifier &verifier) {
  return verifier.VerifyBuffer<Network::Protocol::ModeliMessage>(nullptr);
}

inline void FinishModeliMessageBuffer(
    flatbuffers::FlatBufferBuilder &fbb,
    flatbuffers::Offset<Network::Protocol::ModeliMessage> root) {
  fbb.Finish(root);
}

}  // namespace Protocol
}  // namespace Network

#endif  // FLATBUFFERS_GENERATED_MODELIPROTOCOL_NETWORK_PROTOCOL_H_