diff --git a/Build.bat b/Build.bat
new file mode 100644
index 0000000000000000000000000000000000000000..3daa1be4b0944c54640fac98c2b9efa451fcf198
--- /dev/null
+++ b/Build.bat
@@ -0,0 +1,4 @@
+cd %cd%
+flatc.exe -c ModeliProtocol.fbs
+flatc.exe -n ModeliProtocol.fbs
+cmd /k
\ No newline at end of file
diff --git a/ModeliProtocol.fbs b/ModeliProtocol.fbs
new file mode 100644
index 0000000000000000000000000000000000000000..3ba20ddd19785e704d4f46ebce923db48ba9a22f
--- /dev/null
+++ b/ModeliProtocol.fbs
@@ -0,0 +1,101 @@
+// This protocol is used by the ModeliChart backend to transfer data to the frontend
+namespace Network.Protocol;
+
+// The commands
+enum CommandEnum : int {
+ KeepAlive, // Send this command to check if the connection is still alive, do nothing in the backend
+ Play, // Start simulating
+ PlayFast, // Simulate as quick as possible
+ Pause, // Pause simulation
+ Stop, // Stop and reset simulation
+ AddFmu, // Receive the binary
+ RemoveFmu, // Remove a model
+ ValueRefs, // Receive the default ValueRefs used for simulation
+ AddChannelLinks, // Add ChannelLinks
+ RemoveChannelLinks, // Remove ChannelLinks
+ Feedback, // Send a fmi2Status & msg (optional 0 as size) to the frontend
+ IntValues, // Integer values, to backend: set values in fmu, to frontend: latest values from simulation
+ RealValues, // Real values, to backend: set values in fmu, to frontend: latest values from simulation
+ BoolValues, // Boolean values, to backend: set values in fmu, to frontend: latest values from simulation
+ StringValues, // String, to backend: set values in fmu, to frontend: latest values from simulation
+ Log // Send a log message to the frontend
+}
+
+// Contains the information to execute the command
+union DataUnion {
+ Time, FmuFile, ValueRefs, ChannelLink,
+ IntValues, RealValues, BoolValues, StringValues, Feedback, Log
+}
+
+// For message management
+table ModeliMessage {
+ Command:CommandEnum;
+ JobNr:int;
+ Data:DataUnion;
+}
+
+table Time {
+ Value:double;
+}
+
+table FmuFile{
+ InstanceName:string;
+ BinarySize:int;
+}
+
+table ValueRefs {
+ InstanceName:string;
+ IntVrs:[uint];
+ RealVrs:[uint];
+ BoolVrs:[uint];
+ StringVrs:[uint];
+}
+
+table ChannelLink {
+ MasterInstanceName:string;
+ SlaveInstanceName:string;
+ MasterVr:uint;
+ SlaveVr:uint;
+ Factor:double;
+ Shift:double;
+}
+
+table IntValues {
+ InstanceName:string;
+ Timestamp:double;
+ ValueRefs:[uint];
+ Values:[int];
+}
+
+table RealValues {
+ InstanceName:string;
+ Timestamp:double;
+ ValueRefs:[uint];
+ Values:[double];
+}
+
+table BoolValues {
+ InstanceName:string;
+ Timestamp:double;
+ ValueRefs:[uint];
+ Values:[int]; // fmistandard: stored as 1(true) or 0(false) int
+}
+
+table StringValues {
+ InstanceName:string;
+ Timestamp:double;
+ ValueRefs:[uint];
+ Values:[string];
+}
+
+table Feedback {
+ Result:int;
+ Message:string;
+}
+
+table Log {
+ InstanceName:string;
+ Message:string;
+}
+
+root_type ModeliMessage;
\ No newline at end of file
diff --git a/ModeliProtocol_generated.h b/ModeliProtocol_generated.h
new file mode 100644
index 0000000000000000000000000000000000000000..4e81120bc5d845d4504050585bbe0a51cc7c3bfc
--- /dev/null
+++ b/ModeliProtocol_generated.h
@@ -0,0 +1,1212 @@
+// 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_
diff --git a/Network/Protocol/BoolValues.cs b/Network/Protocol/BoolValues.cs
new file mode 100644
index 0000000000000000000000000000000000000000..ee9fb2dc130e9e531e53ce798245957824c9e3c0
--- /dev/null
+++ b/Network/Protocol/BoolValues.cs
@@ -0,0 +1,59 @@
+// <auto-generated>
+// automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Network.Protocol
+{
+
+using global::System;
+using global::FlatBuffers;
+
+public struct BoolValues : IFlatbufferObject
+{
+ private Table __p;
+ public ByteBuffer ByteBuffer { get { return __p.bb; } }
+ public static BoolValues GetRootAsBoolValues(ByteBuffer _bb) { return GetRootAsBoolValues(_bb, new BoolValues()); }
+ public static BoolValues GetRootAsBoolValues(ByteBuffer _bb, BoolValues obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+ public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+ public BoolValues __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+ public string InstanceName { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+ public ArraySegment<byte>? GetInstanceNameBytes() { return __p.__vector_as_arraysegment(4); }
+ public double Timestamp { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetDouble(o + __p.bb_pos) : (double)0.0; } }
+ public uint ValueRefs(int j) { int o = __p.__offset(8); return o != 0 ? __p.bb.GetUint(__p.__vector(o) + j * 4) : (uint)0; }
+ public int ValueRefsLength { get { int o = __p.__offset(8); return o != 0 ? __p.__vector_len(o) : 0; } }
+ public ArraySegment<byte>? GetValueRefsBytes() { return __p.__vector_as_arraysegment(8); }
+ public int Values(int j) { int o = __p.__offset(10); return o != 0 ? __p.bb.GetInt(__p.__vector(o) + j * 4) : (int)0; }
+ public int ValuesLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } }
+ public ArraySegment<byte>? GetValuesBytes() { return __p.__vector_as_arraysegment(10); }
+
+ public static Offset<BoolValues> CreateBoolValues(FlatBufferBuilder builder,
+ StringOffset InstanceNameOffset = default(StringOffset),
+ double Timestamp = 0.0,
+ VectorOffset ValueRefsOffset = default(VectorOffset),
+ VectorOffset ValuesOffset = default(VectorOffset)) {
+ builder.StartObject(4);
+ BoolValues.AddTimestamp(builder, Timestamp);
+ BoolValues.AddValues(builder, ValuesOffset);
+ BoolValues.AddValueRefs(builder, ValueRefsOffset);
+ BoolValues.AddInstanceName(builder, InstanceNameOffset);
+ return BoolValues.EndBoolValues(builder);
+ }
+
+ public static void StartBoolValues(FlatBufferBuilder builder) { builder.StartObject(4); }
+ public static void AddInstanceName(FlatBufferBuilder builder, StringOffset InstanceNameOffset) { builder.AddOffset(0, InstanceNameOffset.Value, 0); }
+ public static void AddTimestamp(FlatBufferBuilder builder, double Timestamp) { builder.AddDouble(1, Timestamp, 0.0); }
+ public static void AddValueRefs(FlatBufferBuilder builder, VectorOffset ValueRefsOffset) { builder.AddOffset(2, ValueRefsOffset.Value, 0); }
+ public static VectorOffset CreateValueRefsVector(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddUint(data[i]); return builder.EndVector(); }
+ public static void StartValueRefsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+ public static void AddValues(FlatBufferBuilder builder, VectorOffset ValuesOffset) { builder.AddOffset(3, ValuesOffset.Value, 0); }
+ public static VectorOffset CreateValuesVector(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt(data[i]); return builder.EndVector(); }
+ public static void StartValuesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+ public static Offset<BoolValues> EndBoolValues(FlatBufferBuilder builder) {
+ int o = builder.EndObject();
+ return new Offset<BoolValues>(o);
+ }
+};
+
+
+}
diff --git a/Network/Protocol/ChannelLink.cs b/Network/Protocol/ChannelLink.cs
new file mode 100644
index 0000000000000000000000000000000000000000..227d238b5383926d600bd7c7c4199528863c5da4
--- /dev/null
+++ b/Network/Protocol/ChannelLink.cs
@@ -0,0 +1,60 @@
+// <auto-generated>
+// automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Network.Protocol
+{
+
+using global::System;
+using global::FlatBuffers;
+
+public struct ChannelLink : IFlatbufferObject
+{
+ private Table __p;
+ public ByteBuffer ByteBuffer { get { return __p.bb; } }
+ public static ChannelLink GetRootAsChannelLink(ByteBuffer _bb) { return GetRootAsChannelLink(_bb, new ChannelLink()); }
+ public static ChannelLink GetRootAsChannelLink(ByteBuffer _bb, ChannelLink obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+ public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+ public ChannelLink __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+ public string MasterInstanceName { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+ public ArraySegment<byte>? GetMasterInstanceNameBytes() { return __p.__vector_as_arraysegment(4); }
+ public string SlaveInstanceName { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+ public ArraySegment<byte>? GetSlaveInstanceNameBytes() { return __p.__vector_as_arraysegment(6); }
+ public uint MasterVr { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+ public uint SlaveVr { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+ public double Factor { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetDouble(o + __p.bb_pos) : (double)0.0; } }
+ public double Shift { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetDouble(o + __p.bb_pos) : (double)0.0; } }
+
+ public static Offset<ChannelLink> CreateChannelLink(FlatBufferBuilder builder,
+ StringOffset MasterInstanceNameOffset = default(StringOffset),
+ StringOffset SlaveInstanceNameOffset = default(StringOffset),
+ uint MasterVr = 0,
+ uint SlaveVr = 0,
+ double Factor = 0.0,
+ double Shift = 0.0) {
+ builder.StartObject(6);
+ ChannelLink.AddShift(builder, Shift);
+ ChannelLink.AddFactor(builder, Factor);
+ ChannelLink.AddSlaveVr(builder, SlaveVr);
+ ChannelLink.AddMasterVr(builder, MasterVr);
+ ChannelLink.AddSlaveInstanceName(builder, SlaveInstanceNameOffset);
+ ChannelLink.AddMasterInstanceName(builder, MasterInstanceNameOffset);
+ return ChannelLink.EndChannelLink(builder);
+ }
+
+ public static void StartChannelLink(FlatBufferBuilder builder) { builder.StartObject(6); }
+ public static void AddMasterInstanceName(FlatBufferBuilder builder, StringOffset MasterInstanceNameOffset) { builder.AddOffset(0, MasterInstanceNameOffset.Value, 0); }
+ public static void AddSlaveInstanceName(FlatBufferBuilder builder, StringOffset SlaveInstanceNameOffset) { builder.AddOffset(1, SlaveInstanceNameOffset.Value, 0); }
+ public static void AddMasterVr(FlatBufferBuilder builder, uint MasterVr) { builder.AddUint(2, MasterVr, 0); }
+ public static void AddSlaveVr(FlatBufferBuilder builder, uint SlaveVr) { builder.AddUint(3, SlaveVr, 0); }
+ public static void AddFactor(FlatBufferBuilder builder, double Factor) { builder.AddDouble(4, Factor, 0.0); }
+ public static void AddShift(FlatBufferBuilder builder, double Shift) { builder.AddDouble(5, Shift, 0.0); }
+ public static Offset<ChannelLink> EndChannelLink(FlatBufferBuilder builder) {
+ int o = builder.EndObject();
+ return new Offset<ChannelLink>(o);
+ }
+};
+
+
+}
diff --git a/Network/Protocol/CommandEnum.cs b/Network/Protocol/CommandEnum.cs
new file mode 100644
index 0000000000000000000000000000000000000000..a54eb841d63ae9786ee0df0fcca7b65123ac7643
--- /dev/null
+++ b/Network/Protocol/CommandEnum.cs
@@ -0,0 +1,29 @@
+// <auto-generated>
+// automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Network.Protocol
+{
+
+public enum CommandEnum : int
+{
+ KeepAlive = 0,
+ Play = 1,
+ PlayFast = 2,
+ Pause = 3,
+ Stop = 4,
+ AddFmu = 5,
+ RemoveFmu = 6,
+ ValueRefs = 7,
+ AddChannelLinks = 8,
+ RemoveChannelLinks = 9,
+ Feedback = 10,
+ IntValues = 11,
+ RealValues = 12,
+ BoolValues = 13,
+ StringValues = 14,
+ Log = 15,
+};
+
+
+}
diff --git a/Network/Protocol/DataUnion.cs b/Network/Protocol/DataUnion.cs
new file mode 100644
index 0000000000000000000000000000000000000000..9b0ecd2dca59f53343c82c698b8408cfb06a1d71
--- /dev/null
+++ b/Network/Protocol/DataUnion.cs
@@ -0,0 +1,24 @@
+// <auto-generated>
+// automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Network.Protocol
+{
+
+public enum DataUnion : byte
+{
+ NONE = 0,
+ Time = 1,
+ FmuFile = 2,
+ ValueRefs = 3,
+ ChannelLink = 4,
+ IntValues = 5,
+ RealValues = 6,
+ BoolValues = 7,
+ StringValues = 8,
+ Feedback = 9,
+ Log = 10,
+};
+
+
+}
diff --git a/Network/Protocol/Feedback.cs b/Network/Protocol/Feedback.cs
new file mode 100644
index 0000000000000000000000000000000000000000..3bd3aeff0c4752b78c00e9bf7290350f4eff4166
--- /dev/null
+++ b/Network/Protocol/Feedback.cs
@@ -0,0 +1,43 @@
+// <auto-generated>
+// automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Network.Protocol
+{
+
+using global::System;
+using global::FlatBuffers;
+
+public struct Feedback : IFlatbufferObject
+{
+ private Table __p;
+ public ByteBuffer ByteBuffer { get { return __p.bb; } }
+ public static Feedback GetRootAsFeedback(ByteBuffer _bb) { return GetRootAsFeedback(_bb, new Feedback()); }
+ public static Feedback GetRootAsFeedback(ByteBuffer _bb, Feedback obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+ public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+ public Feedback __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+ public int Result { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+ public string Message { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+ public ArraySegment<byte>? GetMessageBytes() { return __p.__vector_as_arraysegment(6); }
+
+ public static Offset<Feedback> CreateFeedback(FlatBufferBuilder builder,
+ int Result = 0,
+ StringOffset MessageOffset = default(StringOffset)) {
+ builder.StartObject(2);
+ Feedback.AddMessage(builder, MessageOffset);
+ Feedback.AddResult(builder, Result);
+ return Feedback.EndFeedback(builder);
+ }
+
+ public static void StartFeedback(FlatBufferBuilder builder) { builder.StartObject(2); }
+ public static void AddResult(FlatBufferBuilder builder, int Result) { builder.AddInt(0, Result, 0); }
+ public static void AddMessage(FlatBufferBuilder builder, StringOffset MessageOffset) { builder.AddOffset(1, MessageOffset.Value, 0); }
+ public static Offset<Feedback> EndFeedback(FlatBufferBuilder builder) {
+ int o = builder.EndObject();
+ return new Offset<Feedback>(o);
+ }
+};
+
+
+}
diff --git a/Network/Protocol/FmuFile.cs b/Network/Protocol/FmuFile.cs
new file mode 100644
index 0000000000000000000000000000000000000000..b1db1a3be637e8a30b0954e16b46718a2becb9ae
--- /dev/null
+++ b/Network/Protocol/FmuFile.cs
@@ -0,0 +1,43 @@
+// <auto-generated>
+// automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Network.Protocol
+{
+
+using global::System;
+using global::FlatBuffers;
+
+public struct FmuFile : IFlatbufferObject
+{
+ private Table __p;
+ public ByteBuffer ByteBuffer { get { return __p.bb; } }
+ public static FmuFile GetRootAsFmuFile(ByteBuffer _bb) { return GetRootAsFmuFile(_bb, new FmuFile()); }
+ public static FmuFile GetRootAsFmuFile(ByteBuffer _bb, FmuFile obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+ public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+ public FmuFile __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+ public string InstanceName { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+ public ArraySegment<byte>? GetInstanceNameBytes() { return __p.__vector_as_arraysegment(4); }
+ public int BinarySize { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+
+ public static Offset<FmuFile> CreateFmuFile(FlatBufferBuilder builder,
+ StringOffset InstanceNameOffset = default(StringOffset),
+ int BinarySize = 0) {
+ builder.StartObject(2);
+ FmuFile.AddBinarySize(builder, BinarySize);
+ FmuFile.AddInstanceName(builder, InstanceNameOffset);
+ return FmuFile.EndFmuFile(builder);
+ }
+
+ public static void StartFmuFile(FlatBufferBuilder builder) { builder.StartObject(2); }
+ public static void AddInstanceName(FlatBufferBuilder builder, StringOffset InstanceNameOffset) { builder.AddOffset(0, InstanceNameOffset.Value, 0); }
+ public static void AddBinarySize(FlatBufferBuilder builder, int BinarySize) { builder.AddInt(1, BinarySize, 0); }
+ public static Offset<FmuFile> EndFmuFile(FlatBufferBuilder builder) {
+ int o = builder.EndObject();
+ return new Offset<FmuFile>(o);
+ }
+};
+
+
+}
diff --git a/Network/Protocol/IntValues.cs b/Network/Protocol/IntValues.cs
new file mode 100644
index 0000000000000000000000000000000000000000..c63129c8473c9c1078e72b789f393427e0a0dbb9
--- /dev/null
+++ b/Network/Protocol/IntValues.cs
@@ -0,0 +1,59 @@
+// <auto-generated>
+// automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Network.Protocol
+{
+
+using global::System;
+using global::FlatBuffers;
+
+public struct IntValues : IFlatbufferObject
+{
+ private Table __p;
+ public ByteBuffer ByteBuffer { get { return __p.bb; } }
+ public static IntValues GetRootAsIntValues(ByteBuffer _bb) { return GetRootAsIntValues(_bb, new IntValues()); }
+ public static IntValues GetRootAsIntValues(ByteBuffer _bb, IntValues obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+ public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+ public IntValues __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+ public string InstanceName { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+ public ArraySegment<byte>? GetInstanceNameBytes() { return __p.__vector_as_arraysegment(4); }
+ public double Timestamp { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetDouble(o + __p.bb_pos) : (double)0.0; } }
+ public uint ValueRefs(int j) { int o = __p.__offset(8); return o != 0 ? __p.bb.GetUint(__p.__vector(o) + j * 4) : (uint)0; }
+ public int ValueRefsLength { get { int o = __p.__offset(8); return o != 0 ? __p.__vector_len(o) : 0; } }
+ public ArraySegment<byte>? GetValueRefsBytes() { return __p.__vector_as_arraysegment(8); }
+ public int Values(int j) { int o = __p.__offset(10); return o != 0 ? __p.bb.GetInt(__p.__vector(o) + j * 4) : (int)0; }
+ public int ValuesLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } }
+ public ArraySegment<byte>? GetValuesBytes() { return __p.__vector_as_arraysegment(10); }
+
+ public static Offset<IntValues> CreateIntValues(FlatBufferBuilder builder,
+ StringOffset InstanceNameOffset = default(StringOffset),
+ double Timestamp = 0.0,
+ VectorOffset ValueRefsOffset = default(VectorOffset),
+ VectorOffset ValuesOffset = default(VectorOffset)) {
+ builder.StartObject(4);
+ IntValues.AddTimestamp(builder, Timestamp);
+ IntValues.AddValues(builder, ValuesOffset);
+ IntValues.AddValueRefs(builder, ValueRefsOffset);
+ IntValues.AddInstanceName(builder, InstanceNameOffset);
+ return IntValues.EndIntValues(builder);
+ }
+
+ public static void StartIntValues(FlatBufferBuilder builder) { builder.StartObject(4); }
+ public static void AddInstanceName(FlatBufferBuilder builder, StringOffset InstanceNameOffset) { builder.AddOffset(0, InstanceNameOffset.Value, 0); }
+ public static void AddTimestamp(FlatBufferBuilder builder, double Timestamp) { builder.AddDouble(1, Timestamp, 0.0); }
+ public static void AddValueRefs(FlatBufferBuilder builder, VectorOffset ValueRefsOffset) { builder.AddOffset(2, ValueRefsOffset.Value, 0); }
+ public static VectorOffset CreateValueRefsVector(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddUint(data[i]); return builder.EndVector(); }
+ public static void StartValueRefsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+ public static void AddValues(FlatBufferBuilder builder, VectorOffset ValuesOffset) { builder.AddOffset(3, ValuesOffset.Value, 0); }
+ public static VectorOffset CreateValuesVector(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt(data[i]); return builder.EndVector(); }
+ public static void StartValuesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+ public static Offset<IntValues> EndIntValues(FlatBufferBuilder builder) {
+ int o = builder.EndObject();
+ return new Offset<IntValues>(o);
+ }
+};
+
+
+}
diff --git a/Network/Protocol/Log.cs b/Network/Protocol/Log.cs
new file mode 100644
index 0000000000000000000000000000000000000000..c027f849b56c25d43f4347d13d4d34c9f5d8930a
--- /dev/null
+++ b/Network/Protocol/Log.cs
@@ -0,0 +1,44 @@
+// <auto-generated>
+// automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Network.Protocol
+{
+
+using global::System;
+using global::FlatBuffers;
+
+public struct Log : IFlatbufferObject
+{
+ private Table __p;
+ public ByteBuffer ByteBuffer { get { return __p.bb; } }
+ public static Log GetRootAsLog(ByteBuffer _bb) { return GetRootAsLog(_bb, new Log()); }
+ public static Log GetRootAsLog(ByteBuffer _bb, Log obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+ public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+ public Log __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+ public string InstanceName { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+ public ArraySegment<byte>? GetInstanceNameBytes() { return __p.__vector_as_arraysegment(4); }
+ public string Message { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+ public ArraySegment<byte>? GetMessageBytes() { return __p.__vector_as_arraysegment(6); }
+
+ public static Offset<Log> CreateLog(FlatBufferBuilder builder,
+ StringOffset InstanceNameOffset = default(StringOffset),
+ StringOffset MessageOffset = default(StringOffset)) {
+ builder.StartObject(2);
+ Log.AddMessage(builder, MessageOffset);
+ Log.AddInstanceName(builder, InstanceNameOffset);
+ return Log.EndLog(builder);
+ }
+
+ public static void StartLog(FlatBufferBuilder builder) { builder.StartObject(2); }
+ public static void AddInstanceName(FlatBufferBuilder builder, StringOffset InstanceNameOffset) { builder.AddOffset(0, InstanceNameOffset.Value, 0); }
+ public static void AddMessage(FlatBufferBuilder builder, StringOffset MessageOffset) { builder.AddOffset(1, MessageOffset.Value, 0); }
+ public static Offset<Log> EndLog(FlatBufferBuilder builder) {
+ int o = builder.EndObject();
+ return new Offset<Log>(o);
+ }
+};
+
+
+}
diff --git a/Network/Protocol/ModeliMessage.cs b/Network/Protocol/ModeliMessage.cs
new file mode 100644
index 0000000000000000000000000000000000000000..501d39d3b24983c3a47db14023666c2c88bf03f4
--- /dev/null
+++ b/Network/Protocol/ModeliMessage.cs
@@ -0,0 +1,51 @@
+// <auto-generated>
+// automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Network.Protocol
+{
+
+using global::System;
+using global::FlatBuffers;
+
+public struct ModeliMessage : IFlatbufferObject
+{
+ private Table __p;
+ public ByteBuffer ByteBuffer { get { return __p.bb; } }
+ public static ModeliMessage GetRootAsModeliMessage(ByteBuffer _bb) { return GetRootAsModeliMessage(_bb, new ModeliMessage()); }
+ public static ModeliMessage GetRootAsModeliMessage(ByteBuffer _bb, ModeliMessage obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+ public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+ public ModeliMessage __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+ public CommandEnum Command { get { int o = __p.__offset(4); return o != 0 ? (CommandEnum)__p.bb.GetInt(o + __p.bb_pos) : CommandEnum.KeepAlive; } }
+ public int JobNr { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+ public DataUnion DataType { get { int o = __p.__offset(8); return o != 0 ? (DataUnion)__p.bb.Get(o + __p.bb_pos) : DataUnion.NONE; } }
+ public TTable? Data<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(10); return o != 0 ? (TTable?)__p.__union<TTable>(o) : null; }
+
+ public static Offset<ModeliMessage> CreateModeliMessage(FlatBufferBuilder builder,
+ CommandEnum Command = CommandEnum.KeepAlive,
+ int JobNr = 0,
+ DataUnion Data_type = DataUnion.NONE,
+ int DataOffset = 0) {
+ builder.StartObject(4);
+ ModeliMessage.AddData(builder, DataOffset);
+ ModeliMessage.AddJobNr(builder, JobNr);
+ ModeliMessage.AddCommand(builder, Command);
+ ModeliMessage.AddDataType(builder, Data_type);
+ return ModeliMessage.EndModeliMessage(builder);
+ }
+
+ public static void StartModeliMessage(FlatBufferBuilder builder) { builder.StartObject(4); }
+ public static void AddCommand(FlatBufferBuilder builder, CommandEnum Command) { builder.AddInt(0, (int)Command, 0); }
+ public static void AddJobNr(FlatBufferBuilder builder, int JobNr) { builder.AddInt(1, JobNr, 0); }
+ public static void AddDataType(FlatBufferBuilder builder, DataUnion DataType) { builder.AddByte(2, (byte)DataType, 0); }
+ public static void AddData(FlatBufferBuilder builder, int DataOffset) { builder.AddOffset(3, DataOffset, 0); }
+ public static Offset<ModeliMessage> EndModeliMessage(FlatBufferBuilder builder) {
+ int o = builder.EndObject();
+ return new Offset<ModeliMessage>(o);
+ }
+ public static void FinishModeliMessageBuffer(FlatBufferBuilder builder, Offset<ModeliMessage> offset) { builder.Finish(offset.Value); }
+};
+
+
+}
diff --git a/Network/Protocol/RealValues.cs b/Network/Protocol/RealValues.cs
new file mode 100644
index 0000000000000000000000000000000000000000..d78493f0691c5c7a81c5a41804e56085c1fff657
--- /dev/null
+++ b/Network/Protocol/RealValues.cs
@@ -0,0 +1,59 @@
+// <auto-generated>
+// automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Network.Protocol
+{
+
+using global::System;
+using global::FlatBuffers;
+
+public struct RealValues : IFlatbufferObject
+{
+ private Table __p;
+ public ByteBuffer ByteBuffer { get { return __p.bb; } }
+ public static RealValues GetRootAsRealValues(ByteBuffer _bb) { return GetRootAsRealValues(_bb, new RealValues()); }
+ public static RealValues GetRootAsRealValues(ByteBuffer _bb, RealValues obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+ public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+ public RealValues __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+ public string InstanceName { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+ public ArraySegment<byte>? GetInstanceNameBytes() { return __p.__vector_as_arraysegment(4); }
+ public double Timestamp { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetDouble(o + __p.bb_pos) : (double)0.0; } }
+ public uint ValueRefs(int j) { int o = __p.__offset(8); return o != 0 ? __p.bb.GetUint(__p.__vector(o) + j * 4) : (uint)0; }
+ public int ValueRefsLength { get { int o = __p.__offset(8); return o != 0 ? __p.__vector_len(o) : 0; } }
+ public ArraySegment<byte>? GetValueRefsBytes() { return __p.__vector_as_arraysegment(8); }
+ public double Values(int j) { int o = __p.__offset(10); return o != 0 ? __p.bb.GetDouble(__p.__vector(o) + j * 8) : (double)0; }
+ public int ValuesLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } }
+ public ArraySegment<byte>? GetValuesBytes() { return __p.__vector_as_arraysegment(10); }
+
+ public static Offset<RealValues> CreateRealValues(FlatBufferBuilder builder,
+ StringOffset InstanceNameOffset = default(StringOffset),
+ double Timestamp = 0.0,
+ VectorOffset ValueRefsOffset = default(VectorOffset),
+ VectorOffset ValuesOffset = default(VectorOffset)) {
+ builder.StartObject(4);
+ RealValues.AddTimestamp(builder, Timestamp);
+ RealValues.AddValues(builder, ValuesOffset);
+ RealValues.AddValueRefs(builder, ValueRefsOffset);
+ RealValues.AddInstanceName(builder, InstanceNameOffset);
+ return RealValues.EndRealValues(builder);
+ }
+
+ public static void StartRealValues(FlatBufferBuilder builder) { builder.StartObject(4); }
+ public static void AddInstanceName(FlatBufferBuilder builder, StringOffset InstanceNameOffset) { builder.AddOffset(0, InstanceNameOffset.Value, 0); }
+ public static void AddTimestamp(FlatBufferBuilder builder, double Timestamp) { builder.AddDouble(1, Timestamp, 0.0); }
+ public static void AddValueRefs(FlatBufferBuilder builder, VectorOffset ValueRefsOffset) { builder.AddOffset(2, ValueRefsOffset.Value, 0); }
+ public static VectorOffset CreateValueRefsVector(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddUint(data[i]); return builder.EndVector(); }
+ public static void StartValueRefsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+ public static void AddValues(FlatBufferBuilder builder, VectorOffset ValuesOffset) { builder.AddOffset(3, ValuesOffset.Value, 0); }
+ public static VectorOffset CreateValuesVector(FlatBufferBuilder builder, double[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddDouble(data[i]); return builder.EndVector(); }
+ public static void StartValuesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+ public static Offset<RealValues> EndRealValues(FlatBufferBuilder builder) {
+ int o = builder.EndObject();
+ return new Offset<RealValues>(o);
+ }
+};
+
+
+}
diff --git a/Network/Protocol/StringValues.cs b/Network/Protocol/StringValues.cs
new file mode 100644
index 0000000000000000000000000000000000000000..995df51c5e173a3e8b805fd4231165af2ffb7a9f
--- /dev/null
+++ b/Network/Protocol/StringValues.cs
@@ -0,0 +1,58 @@
+// <auto-generated>
+// automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Network.Protocol
+{
+
+using global::System;
+using global::FlatBuffers;
+
+public struct StringValues : IFlatbufferObject
+{
+ private Table __p;
+ public ByteBuffer ByteBuffer { get { return __p.bb; } }
+ public static StringValues GetRootAsStringValues(ByteBuffer _bb) { return GetRootAsStringValues(_bb, new StringValues()); }
+ public static StringValues GetRootAsStringValues(ByteBuffer _bb, StringValues obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+ public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+ public StringValues __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+ public string InstanceName { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+ public ArraySegment<byte>? GetInstanceNameBytes() { return __p.__vector_as_arraysegment(4); }
+ public double Timestamp { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetDouble(o + __p.bb_pos) : (double)0.0; } }
+ public uint ValueRefs(int j) { int o = __p.__offset(8); return o != 0 ? __p.bb.GetUint(__p.__vector(o) + j * 4) : (uint)0; }
+ public int ValueRefsLength { get { int o = __p.__offset(8); return o != 0 ? __p.__vector_len(o) : 0; } }
+ public ArraySegment<byte>? GetValueRefsBytes() { return __p.__vector_as_arraysegment(8); }
+ public string Values(int j) { int o = __p.__offset(10); return o != 0 ? __p.__string(__p.__vector(o) + j * 4) : null; }
+ public int ValuesLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } }
+
+ public static Offset<StringValues> CreateStringValues(FlatBufferBuilder builder,
+ StringOffset InstanceNameOffset = default(StringOffset),
+ double Timestamp = 0.0,
+ VectorOffset ValueRefsOffset = default(VectorOffset),
+ VectorOffset ValuesOffset = default(VectorOffset)) {
+ builder.StartObject(4);
+ StringValues.AddTimestamp(builder, Timestamp);
+ StringValues.AddValues(builder, ValuesOffset);
+ StringValues.AddValueRefs(builder, ValueRefsOffset);
+ StringValues.AddInstanceName(builder, InstanceNameOffset);
+ return StringValues.EndStringValues(builder);
+ }
+
+ public static void StartStringValues(FlatBufferBuilder builder) { builder.StartObject(4); }
+ public static void AddInstanceName(FlatBufferBuilder builder, StringOffset InstanceNameOffset) { builder.AddOffset(0, InstanceNameOffset.Value, 0); }
+ public static void AddTimestamp(FlatBufferBuilder builder, double Timestamp) { builder.AddDouble(1, Timestamp, 0.0); }
+ public static void AddValueRefs(FlatBufferBuilder builder, VectorOffset ValueRefsOffset) { builder.AddOffset(2, ValueRefsOffset.Value, 0); }
+ public static VectorOffset CreateValueRefsVector(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddUint(data[i]); return builder.EndVector(); }
+ public static void StartValueRefsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+ public static void AddValues(FlatBufferBuilder builder, VectorOffset ValuesOffset) { builder.AddOffset(3, ValuesOffset.Value, 0); }
+ public static VectorOffset CreateValuesVector(FlatBufferBuilder builder, StringOffset[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+ public static void StartValuesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+ public static Offset<StringValues> EndStringValues(FlatBufferBuilder builder) {
+ int o = builder.EndObject();
+ return new Offset<StringValues>(o);
+ }
+};
+
+
+}
diff --git a/Network/Protocol/Time.cs b/Network/Protocol/Time.cs
new file mode 100644
index 0000000000000000000000000000000000000000..78b0a50bf55d48b6fa15821e2cde57cd183f145d
--- /dev/null
+++ b/Network/Protocol/Time.cs
@@ -0,0 +1,38 @@
+// <auto-generated>
+// automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Network.Protocol
+{
+
+using global::System;
+using global::FlatBuffers;
+
+public struct Time : IFlatbufferObject
+{
+ private Table __p;
+ public ByteBuffer ByteBuffer { get { return __p.bb; } }
+ public static Time GetRootAsTime(ByteBuffer _bb) { return GetRootAsTime(_bb, new Time()); }
+ public static Time GetRootAsTime(ByteBuffer _bb, Time obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+ public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+ public Time __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+ public double Value { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetDouble(o + __p.bb_pos) : (double)0.0; } }
+
+ public static Offset<Time> CreateTime(FlatBufferBuilder builder,
+ double Value = 0.0) {
+ builder.StartObject(1);
+ Time.AddValue(builder, Value);
+ return Time.EndTime(builder);
+ }
+
+ public static void StartTime(FlatBufferBuilder builder) { builder.StartObject(1); }
+ public static void AddValue(FlatBufferBuilder builder, double Value) { builder.AddDouble(0, Value, 0.0); }
+ public static Offset<Time> EndTime(FlatBufferBuilder builder) {
+ int o = builder.EndObject();
+ return new Offset<Time>(o);
+ }
+};
+
+
+}
diff --git a/Network/Protocol/ValueRefs.cs b/Network/Protocol/ValueRefs.cs
new file mode 100644
index 0000000000000000000000000000000000000000..3126e62282dd601d8914241833c8bf748c1523d7
--- /dev/null
+++ b/Network/Protocol/ValueRefs.cs
@@ -0,0 +1,71 @@
+// <auto-generated>
+// automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Network.Protocol
+{
+
+using global::System;
+using global::FlatBuffers;
+
+public struct ValueRefs : IFlatbufferObject
+{
+ private Table __p;
+ public ByteBuffer ByteBuffer { get { return __p.bb; } }
+ public static ValueRefs GetRootAsValueRefs(ByteBuffer _bb) { return GetRootAsValueRefs(_bb, new ValueRefs()); }
+ public static ValueRefs GetRootAsValueRefs(ByteBuffer _bb, ValueRefs obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+ public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+ public ValueRefs __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+ public string InstanceName { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+ public ArraySegment<byte>? GetInstanceNameBytes() { return __p.__vector_as_arraysegment(4); }
+ public uint IntVrs(int j) { int o = __p.__offset(6); return o != 0 ? __p.bb.GetUint(__p.__vector(o) + j * 4) : (uint)0; }
+ public int IntVrsLength { get { int o = __p.__offset(6); return o != 0 ? __p.__vector_len(o) : 0; } }
+ public ArraySegment<byte>? GetIntVrsBytes() { return __p.__vector_as_arraysegment(6); }
+ public uint RealVrs(int j) { int o = __p.__offset(8); return o != 0 ? __p.bb.GetUint(__p.__vector(o) + j * 4) : (uint)0; }
+ public int RealVrsLength { get { int o = __p.__offset(8); return o != 0 ? __p.__vector_len(o) : 0; } }
+ public ArraySegment<byte>? GetRealVrsBytes() { return __p.__vector_as_arraysegment(8); }
+ public uint BoolVrs(int j) { int o = __p.__offset(10); return o != 0 ? __p.bb.GetUint(__p.__vector(o) + j * 4) : (uint)0; }
+ public int BoolVrsLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } }
+ public ArraySegment<byte>? GetBoolVrsBytes() { return __p.__vector_as_arraysegment(10); }
+ public uint StringVrs(int j) { int o = __p.__offset(12); return o != 0 ? __p.bb.GetUint(__p.__vector(o) + j * 4) : (uint)0; }
+ public int StringVrsLength { get { int o = __p.__offset(12); return o != 0 ? __p.__vector_len(o) : 0; } }
+ public ArraySegment<byte>? GetStringVrsBytes() { return __p.__vector_as_arraysegment(12); }
+
+ public static Offset<ValueRefs> CreateValueRefs(FlatBufferBuilder builder,
+ StringOffset InstanceNameOffset = default(StringOffset),
+ VectorOffset IntVrsOffset = default(VectorOffset),
+ VectorOffset RealVrsOffset = default(VectorOffset),
+ VectorOffset BoolVrsOffset = default(VectorOffset),
+ VectorOffset StringVrsOffset = default(VectorOffset)) {
+ builder.StartObject(5);
+ ValueRefs.AddStringVrs(builder, StringVrsOffset);
+ ValueRefs.AddBoolVrs(builder, BoolVrsOffset);
+ ValueRefs.AddRealVrs(builder, RealVrsOffset);
+ ValueRefs.AddIntVrs(builder, IntVrsOffset);
+ ValueRefs.AddInstanceName(builder, InstanceNameOffset);
+ return ValueRefs.EndValueRefs(builder);
+ }
+
+ public static void StartValueRefs(FlatBufferBuilder builder) { builder.StartObject(5); }
+ public static void AddInstanceName(FlatBufferBuilder builder, StringOffset InstanceNameOffset) { builder.AddOffset(0, InstanceNameOffset.Value, 0); }
+ public static void AddIntVrs(FlatBufferBuilder builder, VectorOffset IntVrsOffset) { builder.AddOffset(1, IntVrsOffset.Value, 0); }
+ public static VectorOffset CreateIntVrsVector(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddUint(data[i]); return builder.EndVector(); }
+ public static void StartIntVrsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+ public static void AddRealVrs(FlatBufferBuilder builder, VectorOffset RealVrsOffset) { builder.AddOffset(2, RealVrsOffset.Value, 0); }
+ public static VectorOffset CreateRealVrsVector(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddUint(data[i]); return builder.EndVector(); }
+ public static void StartRealVrsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+ public static void AddBoolVrs(FlatBufferBuilder builder, VectorOffset BoolVrsOffset) { builder.AddOffset(3, BoolVrsOffset.Value, 0); }
+ public static VectorOffset CreateBoolVrsVector(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddUint(data[i]); return builder.EndVector(); }
+ public static void StartBoolVrsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+ public static void AddStringVrs(FlatBufferBuilder builder, VectorOffset StringVrsOffset) { builder.AddOffset(4, StringVrsOffset.Value, 0); }
+ public static VectorOffset CreateStringVrsVector(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddUint(data[i]); return builder.EndVector(); }
+ public static void StartStringVrsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+ public static Offset<ValueRefs> EndValueRefs(FlatBufferBuilder builder) {
+ int o = builder.EndObject();
+ return new Offset<ValueRefs>(o);
+ }
+};
+
+
+}
diff --git a/flatc.exe b/flatc.exe
new file mode 100644
index 0000000000000000000000000000000000000000..662cf228d525c3e52b932361d344cdf0f9b058d8
Binary files /dev/null and b/flatc.exe differ