AERA
tcp_data_message.pb.h
1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: tcp_data_message.proto
3 
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_tcp_5fdata_5fmessage_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_tcp_5fdata_5fmessage_2eproto
6 
7 #include <limits>
8 #include <string>
9 
10 #include <google/protobuf/port_def.inc>
11 #if PROTOBUF_VERSION < 3021000
12 #error This file was generated by a newer version of protoc which is
13 #error incompatible with your Protocol Buffer headers. Please update
14 #error your headers.
15 #endif
16 #if 3021008 < PROTOBUF_MIN_PROTOC_VERSION
17 #error This file was generated by an older version of protoc which is
18 #error incompatible with your Protocol Buffer headers. Please
19 #error regenerate this file with a newer version of protoc.
20 #endif
21 
22 #include <google/protobuf/port_undef.inc>
23 #include <google/protobuf/io/coded_stream.h>
24 #include <google/protobuf/arena.h>
25 #include <google/protobuf/arenastring.h>
26 #include <google/protobuf/generated_message_bases.h>
27 #include <google/protobuf/generated_message_util.h>
28 #include <google/protobuf/metadata_lite.h>
29 #include <google/protobuf/generated_message_reflection.h>
30 #include <google/protobuf/message.h>
31 #include <google/protobuf/repeated_field.h> // IWYU pragma: export
32 #include <google/protobuf/extension_set.h> // IWYU pragma: export
33 #include <google/protobuf/map.h> // IWYU pragma: export
34 #include <google/protobuf/map_entry.h>
35 #include <google/protobuf/map_field_inl.h>
36 #include <google/protobuf/generated_enum_reflection.h>
37 #include <google/protobuf/unknown_field_set.h>
38 // @@protoc_insertion_point(includes)
39 #include <google/protobuf/port_def.inc>
40 #define PROTOBUF_INTERNAL_EXPORT_tcp_5fdata_5fmessage_2eproto
41 PROTOBUF_NAMESPACE_OPEN
42 namespace internal {
43 class AnyMetadata;
44 } // namespace internal
45 PROTOBUF_NAMESPACE_CLOSE
46 
47 // Internal implementation detail -- do not use these members.
48 struct TableStruct_tcp_5fdata_5fmessage_2eproto {
49  static const uint32_t offsets[];
50 };
51 extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tcp_5fdata_5fmessage_2eproto;
52 namespace tcp_io_device {
53 class CommandDescription;
54 struct CommandDescriptionDefaultTypeInternal;
55 extern CommandDescriptionDefaultTypeInternal _CommandDescription_default_instance_;
56 class DataMessage;
57 struct DataMessageDefaultTypeInternal;
58 extern DataMessageDefaultTypeInternal _DataMessage_default_instance_;
59 class ProtoVariable;
60 struct ProtoVariableDefaultTypeInternal;
61 extern ProtoVariableDefaultTypeInternal _ProtoVariable_default_instance_;
62 class SetupMessage;
63 struct SetupMessageDefaultTypeInternal;
64 extern SetupMessageDefaultTypeInternal _SetupMessage_default_instance_;
65 class SetupMessage_CommandsEntry_DoNotUse;
66 struct SetupMessage_CommandsEntry_DoNotUseDefaultTypeInternal;
67 extern SetupMessage_CommandsEntry_DoNotUseDefaultTypeInternal _SetupMessage_CommandsEntry_DoNotUse_default_instance_;
68 class SetupMessage_EntitiesEntry_DoNotUse;
69 struct SetupMessage_EntitiesEntry_DoNotUseDefaultTypeInternal;
70 extern SetupMessage_EntitiesEntry_DoNotUseDefaultTypeInternal _SetupMessage_EntitiesEntry_DoNotUse_default_instance_;
71 class SetupMessage_ObjectsEntry_DoNotUse;
72 struct SetupMessage_ObjectsEntry_DoNotUseDefaultTypeInternal;
73 extern SetupMessage_ObjectsEntry_DoNotUseDefaultTypeInternal _SetupMessage_ObjectsEntry_DoNotUse_default_instance_;
74 class StartMessage;
75 struct StartMessageDefaultTypeInternal;
76 extern StartMessageDefaultTypeInternal _StartMessage_default_instance_;
77 class StopMessage;
78 struct StopMessageDefaultTypeInternal;
79 extern StopMessageDefaultTypeInternal _StopMessage_default_instance_;
80 class TCPMessage;
81 struct TCPMessageDefaultTypeInternal;
82 extern TCPMessageDefaultTypeInternal _TCPMessage_default_instance_;
83 class VariableDescription;
84 struct VariableDescriptionDefaultTypeInternal;
85 extern VariableDescriptionDefaultTypeInternal _VariableDescription_default_instance_;
86 } // namespace tcp_io_device
87 PROTOBUF_NAMESPACE_OPEN
88 template<> ::tcp_io_device::CommandDescription* Arena::CreateMaybeMessage<::tcp_io_device::CommandDescription>(Arena*);
89 template<> ::tcp_io_device::DataMessage* Arena::CreateMaybeMessage<::tcp_io_device::DataMessage>(Arena*);
90 template<> ::tcp_io_device::ProtoVariable* Arena::CreateMaybeMessage<::tcp_io_device::ProtoVariable>(Arena*);
91 template<> ::tcp_io_device::SetupMessage* Arena::CreateMaybeMessage<::tcp_io_device::SetupMessage>(Arena*);
92 template<> ::tcp_io_device::SetupMessage_CommandsEntry_DoNotUse* Arena::CreateMaybeMessage<::tcp_io_device::SetupMessage_CommandsEntry_DoNotUse>(Arena*);
93 template<> ::tcp_io_device::SetupMessage_EntitiesEntry_DoNotUse* Arena::CreateMaybeMessage<::tcp_io_device::SetupMessage_EntitiesEntry_DoNotUse>(Arena*);
94 template<> ::tcp_io_device::SetupMessage_ObjectsEntry_DoNotUse* Arena::CreateMaybeMessage<::tcp_io_device::SetupMessage_ObjectsEntry_DoNotUse>(Arena*);
95 template<> ::tcp_io_device::StartMessage* Arena::CreateMaybeMessage<::tcp_io_device::StartMessage>(Arena*);
96 template<> ::tcp_io_device::StopMessage* Arena::CreateMaybeMessage<::tcp_io_device::StopMessage>(Arena*);
97 template<> ::tcp_io_device::TCPMessage* Arena::CreateMaybeMessage<::tcp_io_device::TCPMessage>(Arena*);
98 template<> ::tcp_io_device::VariableDescription* Arena::CreateMaybeMessage<::tcp_io_device::VariableDescription>(Arena*);
99 PROTOBUF_NAMESPACE_CLOSE
100 namespace tcp_io_device {
101 
102 enum TCPMessage_Type : int {
103  TCPMessage_Type_SETUP = 0,
104  TCPMessage_Type_DATA = 1,
105  TCPMessage_Type_START = 2,
106  TCPMessage_Type_STOP = 3,
107  TCPMessage_Type_RECONNECT = 4,
108  TCPMessage_Type_TCPMessage_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
109  TCPMessage_Type_TCPMessage_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
110 };
111 bool TCPMessage_Type_IsValid(int value);
112 constexpr TCPMessage_Type TCPMessage_Type_Type_MIN = TCPMessage_Type_SETUP;
113 constexpr TCPMessage_Type TCPMessage_Type_Type_MAX = TCPMessage_Type_RECONNECT;
114 constexpr int TCPMessage_Type_Type_ARRAYSIZE = TCPMessage_Type_Type_MAX + 1;
115 
116 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TCPMessage_Type_descriptor();
117 template<typename T>
118 inline const std::string& TCPMessage_Type_Name(T enum_t_value) {
119  static_assert(::std::is_same<T, TCPMessage_Type>::value ||
120  ::std::is_integral<T>::value,
121  "Incorrect type passed to function TCPMessage_Type_Name.");
122  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
123  TCPMessage_Type_descriptor(), enum_t_value);
124 }
125 inline bool TCPMessage_Type_Parse(
126  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TCPMessage_Type* value) {
127  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TCPMessage_Type>(
128  TCPMessage_Type_descriptor(), name, value);
129 }
130 enum StartMessage_ReconnectionType : int {
131  StartMessage_ReconnectionType_RE_INIT = 0,
132  StartMessage_ReconnectionType_RE_SETUP = 1,
133  StartMessage_ReconnectionType_NONE = 2,
134  StartMessage_ReconnectionType_StartMessage_ReconnectionType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
135  StartMessage_ReconnectionType_StartMessage_ReconnectionType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
136 };
137 bool StartMessage_ReconnectionType_IsValid(int value);
138 constexpr StartMessage_ReconnectionType StartMessage_ReconnectionType_ReconnectionType_MIN = StartMessage_ReconnectionType_RE_INIT;
139 constexpr StartMessage_ReconnectionType StartMessage_ReconnectionType_ReconnectionType_MAX = StartMessage_ReconnectionType_NONE;
140 constexpr int StartMessage_ReconnectionType_ReconnectionType_ARRAYSIZE = StartMessage_ReconnectionType_ReconnectionType_MAX + 1;
141 
142 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* StartMessage_ReconnectionType_descriptor();
143 template<typename T>
144 inline const std::string& StartMessage_ReconnectionType_Name(T enum_t_value) {
145  static_assert(::std::is_same<T, StartMessage_ReconnectionType>::value ||
146  ::std::is_integral<T>::value,
147  "Incorrect type passed to function StartMessage_ReconnectionType_Name.");
148  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
149  StartMessage_ReconnectionType_descriptor(), enum_t_value);
150 }
151 inline bool StartMessage_ReconnectionType_Parse(
152  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StartMessage_ReconnectionType* value) {
153  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<StartMessage_ReconnectionType>(
154  StartMessage_ReconnectionType_descriptor(), name, value);
155 }
156 enum VariableDescription_DataType : int {
157  VariableDescription_DataType_DOUBLE = 0,
158  VariableDescription_DataType_INT64 = 3,
159  VariableDescription_DataType_BOOL = 12,
160  VariableDescription_DataType_STRING = 13,
161  VariableDescription_DataType_BYTES = 14,
162  VariableDescription_DataType_COMMUNICATION_ID = 15,
163  VariableDescription_DataType_VariableDescription_DataType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
164  VariableDescription_DataType_VariableDescription_DataType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
165 };
166 bool VariableDescription_DataType_IsValid(int value);
167 constexpr VariableDescription_DataType VariableDescription_DataType_DataType_MIN = VariableDescription_DataType_DOUBLE;
168 constexpr VariableDescription_DataType VariableDescription_DataType_DataType_MAX = VariableDescription_DataType_COMMUNICATION_ID;
169 constexpr int VariableDescription_DataType_DataType_ARRAYSIZE = VariableDescription_DataType_DataType_MAX + 1;
170 
171 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* VariableDescription_DataType_descriptor();
172 template<typename T>
173 inline const std::string& VariableDescription_DataType_Name(T enum_t_value) {
174  static_assert(::std::is_same<T, VariableDescription_DataType>::value ||
175  ::std::is_integral<T>::value,
176  "Incorrect type passed to function VariableDescription_DataType_Name.");
177  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
178  VariableDescription_DataType_descriptor(), enum_t_value);
179 }
180 inline bool VariableDescription_DataType_Parse(
181  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VariableDescription_DataType* value) {
182  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<VariableDescription_DataType>(
183  VariableDescription_DataType_descriptor(), name, value);
184 }
185 // ===================================================================
186 
187 class TCPMessage final :
188  public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tcp_io_device.TCPMessage) */ {
189  public:
190  inline TCPMessage() : TCPMessage(nullptr) {}
191  ~TCPMessage() override;
192  explicit PROTOBUF_CONSTEXPR TCPMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
193 
194  TCPMessage(const TCPMessage& from);
195  TCPMessage(TCPMessage&& from) noexcept
196  : TCPMessage() {
197  *this = ::std::move(from);
198  }
199 
200  inline TCPMessage& operator=(const TCPMessage& from) {
201  CopyFrom(from);
202  return *this;
203  }
204  inline TCPMessage& operator=(TCPMessage&& from) noexcept {
205  if (this == &from) return *this;
206  if (GetOwningArena() == from.GetOwningArena()
207  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
208  && GetOwningArena() != nullptr
209  #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
210  ) {
211  InternalSwap(&from);
212  } else {
213  CopyFrom(from);
214  }
215  return *this;
216  }
217 
218  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
219  return GetDescriptor();
220  }
221  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
222  return default_instance().GetMetadata().descriptor;
223  }
224  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
225  return default_instance().GetMetadata().reflection;
226  }
227  static const TCPMessage& default_instance() {
228  return *internal_default_instance();
229  }
230  enum MessageCase {
231  kSetupMessage = 2,
232  kDataMessage = 3,
233  kStartMessage = 4,
234  kStopMessage = 5,
235  MESSAGE_NOT_SET = 0,
236  };
237 
238  static inline const TCPMessage* internal_default_instance() {
239  return reinterpret_cast<const TCPMessage*>(
240  &_TCPMessage_default_instance_);
241  }
242  static constexpr int kIndexInFileMessages =
243  0;
244 
245  friend void swap(TCPMessage& a, TCPMessage& b) {
246  a.Swap(&b);
247  }
248  inline void Swap(TCPMessage* other) {
249  if (other == this) return;
250  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
251  if (GetOwningArena() != nullptr &&
252  GetOwningArena() == other->GetOwningArena()) {
253  #else // PROTOBUF_FORCE_COPY_IN_SWAP
254  if (GetOwningArena() == other->GetOwningArena()) {
255  #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
256  InternalSwap(other);
257  } else {
258  ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
259  }
260  }
261  void UnsafeArenaSwap(TCPMessage* other) {
262  if (other == this) return;
263  GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
264  InternalSwap(other);
265  }
266 
267  // implements Message ----------------------------------------------
268 
269  TCPMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
270  return CreateMaybeMessage<TCPMessage>(arena);
271  }
272  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
273  void CopyFrom(const TCPMessage& from);
274  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
275  void MergeFrom( const TCPMessage& from) {
276  TCPMessage::MergeImpl(*this, from);
277  }
278  private:
279  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
280  public:
281  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
282  bool IsInitialized() const final;
283 
284  size_t ByteSizeLong() const final;
285  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
286  uint8_t* _InternalSerialize(
287  uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
288  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
289 
290  private:
291  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
292  void SharedDtor();
293  void SetCachedSize(int size) const final;
294  void InternalSwap(TCPMessage* other);
295 
296  private:
297  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
298  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
299  return "tcp_io_device.TCPMessage";
300  }
301  protected:
302  explicit TCPMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
303  bool is_message_owned = false);
304  public:
305 
306  static const ClassData _class_data_;
307  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
308 
309  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
310 
311  // nested types ----------------------------------------------------
312 
313  typedef TCPMessage_Type Type;
314  static constexpr Type SETUP =
315  TCPMessage_Type_SETUP;
316  static constexpr Type DATA =
317  TCPMessage_Type_DATA;
318  static constexpr Type START =
319  TCPMessage_Type_START;
320  static constexpr Type STOP =
321  TCPMessage_Type_STOP;
322  static constexpr Type RECONNECT =
323  TCPMessage_Type_RECONNECT;
324  static inline bool Type_IsValid(int value) {
325  return TCPMessage_Type_IsValid(value);
326  }
327  static constexpr Type Type_MIN =
328  TCPMessage_Type_Type_MIN;
329  static constexpr Type Type_MAX =
330  TCPMessage_Type_Type_MAX;
331  static constexpr int Type_ARRAYSIZE =
332  TCPMessage_Type_Type_ARRAYSIZE;
333  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
334  Type_descriptor() {
335  return TCPMessage_Type_descriptor();
336  }
337  template<typename T>
338  static inline const std::string& Type_Name(T enum_t_value) {
339  static_assert(::std::is_same<T, Type>::value ||
340  ::std::is_integral<T>::value,
341  "Incorrect type passed to function Type_Name.");
342  return TCPMessage_Type_Name(enum_t_value);
343  }
344  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
345  Type* value) {
346  return TCPMessage_Type_Parse(name, value);
347  }
348 
349  // accessors -------------------------------------------------------
350 
351  enum : int {
352  kTimestampFieldNumber = 6,
353  kMessageTypeFieldNumber = 1,
354  kSetupMessageFieldNumber = 2,
355  kDataMessageFieldNumber = 3,
356  kStartMessageFieldNumber = 4,
357  kStopMessageFieldNumber = 5,
358  };
359  // uint64 timestamp = 6;
360  void clear_timestamp();
361  uint64_t timestamp() const;
362  void set_timestamp(uint64_t value);
363  private:
364  uint64_t _internal_timestamp() const;
365  void _internal_set_timestamp(uint64_t value);
366  public:
367 
368  // .tcp_io_device.TCPMessage.Type messageType = 1;
369  void clear_messagetype();
370  ::tcp_io_device::TCPMessage_Type messagetype() const;
371  void set_messagetype(::tcp_io_device::TCPMessage_Type value);
372  private:
373  ::tcp_io_device::TCPMessage_Type _internal_messagetype() const;
374  void _internal_set_messagetype(::tcp_io_device::TCPMessage_Type value);
375  public:
376 
377  // .tcp_io_device.SetupMessage setupMessage = 2;
378  bool has_setupmessage() const;
379  private:
380  bool _internal_has_setupmessage() const;
381  public:
382  void clear_setupmessage();
383  const ::tcp_io_device::SetupMessage& setupmessage() const;
384  PROTOBUF_NODISCARD ::tcp_io_device::SetupMessage* release_setupmessage();
385  ::tcp_io_device::SetupMessage* mutable_setupmessage();
386  void set_allocated_setupmessage(::tcp_io_device::SetupMessage* setupmessage);
387  private:
388  const ::tcp_io_device::SetupMessage& _internal_setupmessage() const;
389  ::tcp_io_device::SetupMessage* _internal_mutable_setupmessage();
390  public:
391  void unsafe_arena_set_allocated_setupmessage(
392  ::tcp_io_device::SetupMessage* setupmessage);
393  ::tcp_io_device::SetupMessage* unsafe_arena_release_setupmessage();
394 
395  // .tcp_io_device.DataMessage dataMessage = 3;
396  bool has_datamessage() const;
397  private:
398  bool _internal_has_datamessage() const;
399  public:
400  void clear_datamessage();
401  const ::tcp_io_device::DataMessage& datamessage() const;
402  PROTOBUF_NODISCARD ::tcp_io_device::DataMessage* release_datamessage();
403  ::tcp_io_device::DataMessage* mutable_datamessage();
404  void set_allocated_datamessage(::tcp_io_device::DataMessage* datamessage);
405  private:
406  const ::tcp_io_device::DataMessage& _internal_datamessage() const;
407  ::tcp_io_device::DataMessage* _internal_mutable_datamessage();
408  public:
409  void unsafe_arena_set_allocated_datamessage(
410  ::tcp_io_device::DataMessage* datamessage);
411  ::tcp_io_device::DataMessage* unsafe_arena_release_datamessage();
412 
413  // .tcp_io_device.StartMessage startMessage = 4;
414  bool has_startmessage() const;
415  private:
416  bool _internal_has_startmessage() const;
417  public:
418  void clear_startmessage();
419  const ::tcp_io_device::StartMessage& startmessage() const;
420  PROTOBUF_NODISCARD ::tcp_io_device::StartMessage* release_startmessage();
421  ::tcp_io_device::StartMessage* mutable_startmessage();
422  void set_allocated_startmessage(::tcp_io_device::StartMessage* startmessage);
423  private:
424  const ::tcp_io_device::StartMessage& _internal_startmessage() const;
425  ::tcp_io_device::StartMessage* _internal_mutable_startmessage();
426  public:
427  void unsafe_arena_set_allocated_startmessage(
428  ::tcp_io_device::StartMessage* startmessage);
429  ::tcp_io_device::StartMessage* unsafe_arena_release_startmessage();
430 
431  // .tcp_io_device.StopMessage stopMessage = 5;
432  bool has_stopmessage() const;
433  private:
434  bool _internal_has_stopmessage() const;
435  public:
436  void clear_stopmessage();
437  const ::tcp_io_device::StopMessage& stopmessage() const;
438  PROTOBUF_NODISCARD ::tcp_io_device::StopMessage* release_stopmessage();
439  ::tcp_io_device::StopMessage* mutable_stopmessage();
440  void set_allocated_stopmessage(::tcp_io_device::StopMessage* stopmessage);
441  private:
442  const ::tcp_io_device::StopMessage& _internal_stopmessage() const;
443  ::tcp_io_device::StopMessage* _internal_mutable_stopmessage();
444  public:
445  void unsafe_arena_set_allocated_stopmessage(
446  ::tcp_io_device::StopMessage* stopmessage);
447  ::tcp_io_device::StopMessage* unsafe_arena_release_stopmessage();
448 
449  void clear_message();
450  MessageCase message_case() const;
451  // @@protoc_insertion_point(class_scope:tcp_io_device.TCPMessage)
452  private:
453  class _Internal;
454  void set_has_setupmessage();
455  void set_has_datamessage();
456  void set_has_startmessage();
457  void set_has_stopmessage();
458 
459  inline bool has_message() const;
460  inline void clear_has_message();
461 
462  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
463  typedef void InternalArenaConstructable_;
464  typedef void DestructorSkippable_;
465  struct Impl_ {
466  uint64_t timestamp_;
467  int messagetype_;
468  union MessageUnion {
469  constexpr MessageUnion() : _constinit_{} {}
470  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
471  ::tcp_io_device::SetupMessage* setupmessage_;
472  ::tcp_io_device::DataMessage* datamessage_;
473  ::tcp_io_device::StartMessage* startmessage_;
474  ::tcp_io_device::StopMessage* stopmessage_;
475  } message_;
476  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
477  uint32_t _oneof_case_[1];
478 
479  };
480  union { Impl_ _impl_; };
481  friend struct ::TableStruct_tcp_5fdata_5fmessage_2eproto;
482 };
483 // -------------------------------------------------------------------
484 
485 class StartMessage final :
486  public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tcp_io_device.StartMessage) */ {
487  public:
488  inline StartMessage() : StartMessage(nullptr) {}
489  ~StartMessage() override;
490  explicit PROTOBUF_CONSTEXPR StartMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
491 
492  StartMessage(const StartMessage& from);
493  StartMessage(StartMessage&& from) noexcept
494  : StartMessage() {
495  *this = ::std::move(from);
496  }
497 
498  inline StartMessage& operator=(const StartMessage& from) {
499  CopyFrom(from);
500  return *this;
501  }
502  inline StartMessage& operator=(StartMessage&& from) noexcept {
503  if (this == &from) return *this;
504  if (GetOwningArena() == from.GetOwningArena()
505  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
506  && GetOwningArena() != nullptr
507  #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
508  ) {
509  InternalSwap(&from);
510  } else {
511  CopyFrom(from);
512  }
513  return *this;
514  }
515 
516  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
517  return GetDescriptor();
518  }
519  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
520  return default_instance().GetMetadata().descriptor;
521  }
522  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
523  return default_instance().GetMetadata().reflection;
524  }
525  static const StartMessage& default_instance() {
526  return *internal_default_instance();
527  }
528  static inline const StartMessage* internal_default_instance() {
529  return reinterpret_cast<const StartMessage*>(
530  &_StartMessage_default_instance_);
531  }
532  static constexpr int kIndexInFileMessages =
533  1;
534 
535  friend void swap(StartMessage& a, StartMessage& b) {
536  a.Swap(&b);
537  }
538  inline void Swap(StartMessage* other) {
539  if (other == this) return;
540  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
541  if (GetOwningArena() != nullptr &&
542  GetOwningArena() == other->GetOwningArena()) {
543  #else // PROTOBUF_FORCE_COPY_IN_SWAP
544  if (GetOwningArena() == other->GetOwningArena()) {
545  #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
546  InternalSwap(other);
547  } else {
548  ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
549  }
550  }
551  void UnsafeArenaSwap(StartMessage* other) {
552  if (other == this) return;
553  GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
554  InternalSwap(other);
555  }
556 
557  // implements Message ----------------------------------------------
558 
559  StartMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
560  return CreateMaybeMessage<StartMessage>(arena);
561  }
562  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
563  void CopyFrom(const StartMessage& from);
564  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
565  void MergeFrom( const StartMessage& from) {
566  StartMessage::MergeImpl(*this, from);
567  }
568  private:
569  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
570  public:
571  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
572  bool IsInitialized() const final;
573 
574  size_t ByteSizeLong() const final;
575  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
576  uint8_t* _InternalSerialize(
577  uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
578  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
579 
580  private:
581  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
582  void SharedDtor();
583  void SetCachedSize(int size) const final;
584  void InternalSwap(StartMessage* other);
585 
586  private:
587  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
588  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
589  return "tcp_io_device.StartMessage";
590  }
591  protected:
592  explicit StartMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
593  bool is_message_owned = false);
594  public:
595 
596  static const ClassData _class_data_;
597  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
598 
599  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
600 
601  // nested types ----------------------------------------------------
602 
603  typedef StartMessage_ReconnectionType ReconnectionType;
604  static constexpr ReconnectionType RE_INIT =
605  StartMessage_ReconnectionType_RE_INIT;
606  static constexpr ReconnectionType RE_SETUP =
607  StartMessage_ReconnectionType_RE_SETUP;
608  static constexpr ReconnectionType NONE =
609  StartMessage_ReconnectionType_NONE;
610  static inline bool ReconnectionType_IsValid(int value) {
611  return StartMessage_ReconnectionType_IsValid(value);
612  }
613  static constexpr ReconnectionType ReconnectionType_MIN =
614  StartMessage_ReconnectionType_ReconnectionType_MIN;
615  static constexpr ReconnectionType ReconnectionType_MAX =
616  StartMessage_ReconnectionType_ReconnectionType_MAX;
617  static constexpr int ReconnectionType_ARRAYSIZE =
618  StartMessage_ReconnectionType_ReconnectionType_ARRAYSIZE;
619  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
620  ReconnectionType_descriptor() {
621  return StartMessage_ReconnectionType_descriptor();
622  }
623  template<typename T>
624  static inline const std::string& ReconnectionType_Name(T enum_t_value) {
625  static_assert(::std::is_same<T, ReconnectionType>::value ||
626  ::std::is_integral<T>::value,
627  "Incorrect type passed to function ReconnectionType_Name.");
628  return StartMessage_ReconnectionType_Name(enum_t_value);
629  }
630  static inline bool ReconnectionType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
631  ReconnectionType* value) {
632  return StartMessage_ReconnectionType_Parse(name, value);
633  }
634 
635  // accessors -------------------------------------------------------
636 
637  enum : int {
638  kDiagnosticModeFieldNumber = 1,
639  kReconnectionTypeFieldNumber = 2,
640  };
641  // bool diagnosticMode = 1;
642  void clear_diagnosticmode();
643  bool diagnosticmode() const;
644  void set_diagnosticmode(bool value);
645  private:
646  bool _internal_diagnosticmode() const;
647  void _internal_set_diagnosticmode(bool value);
648  public:
649 
650  // .tcp_io_device.StartMessage.ReconnectionType reconnectionType = 2;
651  void clear_reconnectiontype();
652  ::tcp_io_device::StartMessage_ReconnectionType reconnectiontype() const;
653  void set_reconnectiontype(::tcp_io_device::StartMessage_ReconnectionType value);
654  private:
655  ::tcp_io_device::StartMessage_ReconnectionType _internal_reconnectiontype() const;
656  void _internal_set_reconnectiontype(::tcp_io_device::StartMessage_ReconnectionType value);
657  public:
658 
659  // @@protoc_insertion_point(class_scope:tcp_io_device.StartMessage)
660  private:
661  class _Internal;
662 
663  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
664  typedef void InternalArenaConstructable_;
665  typedef void DestructorSkippable_;
666  struct Impl_ {
667  bool diagnosticmode_;
668  int reconnectiontype_;
669  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
670  };
671  union { Impl_ _impl_; };
672  friend struct ::TableStruct_tcp_5fdata_5fmessage_2eproto;
673 };
674 // -------------------------------------------------------------------
675 
676 class StopMessage final :
677  public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:tcp_io_device.StopMessage) */ {
678  public:
679  inline StopMessage() : StopMessage(nullptr) {}
680  explicit PROTOBUF_CONSTEXPR StopMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
681 
682  StopMessage(const StopMessage& from);
683  StopMessage(StopMessage&& from) noexcept
684  : StopMessage() {
685  *this = ::std::move(from);
686  }
687 
688  inline StopMessage& operator=(const StopMessage& from) {
689  CopyFrom(from);
690  return *this;
691  }
692  inline StopMessage& operator=(StopMessage&& from) noexcept {
693  if (this == &from) return *this;
694  if (GetOwningArena() == from.GetOwningArena()
695  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
696  && GetOwningArena() != nullptr
697  #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
698  ) {
699  InternalSwap(&from);
700  } else {
701  CopyFrom(from);
702  }
703  return *this;
704  }
705 
706  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
707  return GetDescriptor();
708  }
709  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
710  return default_instance().GetMetadata().descriptor;
711  }
712  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
713  return default_instance().GetMetadata().reflection;
714  }
715  static const StopMessage& default_instance() {
716  return *internal_default_instance();
717  }
718  static inline const StopMessage* internal_default_instance() {
719  return reinterpret_cast<const StopMessage*>(
720  &_StopMessage_default_instance_);
721  }
722  static constexpr int kIndexInFileMessages =
723  2;
724 
725  friend void swap(StopMessage& a, StopMessage& b) {
726  a.Swap(&b);
727  }
728  inline void Swap(StopMessage* other) {
729  if (other == this) return;
730  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
731  if (GetOwningArena() != nullptr &&
732  GetOwningArena() == other->GetOwningArena()) {
733  #else // PROTOBUF_FORCE_COPY_IN_SWAP
734  if (GetOwningArena() == other->GetOwningArena()) {
735  #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
736  InternalSwap(other);
737  } else {
738  ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
739  }
740  }
741  void UnsafeArenaSwap(StopMessage* other) {
742  if (other == this) return;
743  GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
744  InternalSwap(other);
745  }
746 
747  // implements Message ----------------------------------------------
748 
749  StopMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
750  return CreateMaybeMessage<StopMessage>(arena);
751  }
752  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
753  inline void CopyFrom(const StopMessage& from) {
754  ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
755  }
756  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
757  void MergeFrom(const StopMessage& from) {
758  ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
759  }
760  public:
761 
762  private:
763  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
764  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
765  return "tcp_io_device.StopMessage";
766  }
767  protected:
768  explicit StopMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
769  bool is_message_owned = false);
770  public:
771 
772  static const ClassData _class_data_;
773  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
774 
775  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
776 
777  // nested types ----------------------------------------------------
778 
779  // accessors -------------------------------------------------------
780 
781  // @@protoc_insertion_point(class_scope:tcp_io_device.StopMessage)
782  private:
783  class _Internal;
784 
785  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
786  typedef void InternalArenaConstructable_;
787  typedef void DestructorSkippable_;
788  struct Impl_ {
789  };
790  friend struct ::TableStruct_tcp_5fdata_5fmessage_2eproto;
791 };
792 // -------------------------------------------------------------------
793 
794 class SetupMessage_EntitiesEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<SetupMessage_EntitiesEntry_DoNotUse,
795  std::string, int32_t,
796  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
797  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32> {
798 public:
799  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<SetupMessage_EntitiesEntry_DoNotUse,
800  std::string, int32_t,
801  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
802  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32> SuperType;
803  SetupMessage_EntitiesEntry_DoNotUse();
804  explicit PROTOBUF_CONSTEXPR SetupMessage_EntitiesEntry_DoNotUse(
805  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
806  explicit SetupMessage_EntitiesEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
807  void MergeFrom(const SetupMessage_EntitiesEntry_DoNotUse& other);
808  static const SetupMessage_EntitiesEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const SetupMessage_EntitiesEntry_DoNotUse*>(&_SetupMessage_EntitiesEntry_DoNotUse_default_instance_); }
809  static bool ValidateKey(std::string* s) {
810  return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tcp_io_device.SetupMessage.EntitiesEntry.key");
811  }
812  static bool ValidateValue(void*) { return true; }
813  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
814  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
815  friend struct ::TableStruct_tcp_5fdata_5fmessage_2eproto;
816 };
817 
818 // -------------------------------------------------------------------
819 
820 class SetupMessage_ObjectsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<SetupMessage_ObjectsEntry_DoNotUse,
821  std::string, int32_t,
822  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
823  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32> {
824 public:
825  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<SetupMessage_ObjectsEntry_DoNotUse,
826  std::string, int32_t,
827  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
828  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32> SuperType;
829  SetupMessage_ObjectsEntry_DoNotUse();
830  explicit PROTOBUF_CONSTEXPR SetupMessage_ObjectsEntry_DoNotUse(
831  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
832  explicit SetupMessage_ObjectsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
833  void MergeFrom(const SetupMessage_ObjectsEntry_DoNotUse& other);
834  static const SetupMessage_ObjectsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const SetupMessage_ObjectsEntry_DoNotUse*>(&_SetupMessage_ObjectsEntry_DoNotUse_default_instance_); }
835  static bool ValidateKey(std::string* s) {
836  return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tcp_io_device.SetupMessage.ObjectsEntry.key");
837  }
838  static bool ValidateValue(void*) { return true; }
839  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
840  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
841  friend struct ::TableStruct_tcp_5fdata_5fmessage_2eproto;
842 };
843 
844 // -------------------------------------------------------------------
845 
846 class SetupMessage_CommandsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<SetupMessage_CommandsEntry_DoNotUse,
847  std::string, int32_t,
848  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
849  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32> {
850 public:
851  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<SetupMessage_CommandsEntry_DoNotUse,
852  std::string, int32_t,
853  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
854  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32> SuperType;
855  SetupMessage_CommandsEntry_DoNotUse();
856  explicit PROTOBUF_CONSTEXPR SetupMessage_CommandsEntry_DoNotUse(
857  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
858  explicit SetupMessage_CommandsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
859  void MergeFrom(const SetupMessage_CommandsEntry_DoNotUse& other);
860  static const SetupMessage_CommandsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const SetupMessage_CommandsEntry_DoNotUse*>(&_SetupMessage_CommandsEntry_DoNotUse_default_instance_); }
861  static bool ValidateKey(std::string* s) {
862  return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tcp_io_device.SetupMessage.CommandsEntry.key");
863  }
864  static bool ValidateValue(void*) { return true; }
865  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
866  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
867  friend struct ::TableStruct_tcp_5fdata_5fmessage_2eproto;
868 };
869 
870 // -------------------------------------------------------------------
871 
872 class SetupMessage final :
873  public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tcp_io_device.SetupMessage) */ {
874  public:
875  inline SetupMessage() : SetupMessage(nullptr) {}
876  ~SetupMessage() override;
877  explicit PROTOBUF_CONSTEXPR SetupMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
878 
879  SetupMessage(const SetupMessage& from);
880  SetupMessage(SetupMessage&& from) noexcept
881  : SetupMessage() {
882  *this = ::std::move(from);
883  }
884 
885  inline SetupMessage& operator=(const SetupMessage& from) {
886  CopyFrom(from);
887  return *this;
888  }
889  inline SetupMessage& operator=(SetupMessage&& from) noexcept {
890  if (this == &from) return *this;
891  if (GetOwningArena() == from.GetOwningArena()
892  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
893  && GetOwningArena() != nullptr
894  #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
895  ) {
896  InternalSwap(&from);
897  } else {
898  CopyFrom(from);
899  }
900  return *this;
901  }
902 
903  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
904  return GetDescriptor();
905  }
906  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
907  return default_instance().GetMetadata().descriptor;
908  }
909  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
910  return default_instance().GetMetadata().reflection;
911  }
912  static const SetupMessage& default_instance() {
913  return *internal_default_instance();
914  }
915  static inline const SetupMessage* internal_default_instance() {
916  return reinterpret_cast<const SetupMessage*>(
917  &_SetupMessage_default_instance_);
918  }
919  static constexpr int kIndexInFileMessages =
920  6;
921 
922  friend void swap(SetupMessage& a, SetupMessage& b) {
923  a.Swap(&b);
924  }
925  inline void Swap(SetupMessage* other) {
926  if (other == this) return;
927  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
928  if (GetOwningArena() != nullptr &&
929  GetOwningArena() == other->GetOwningArena()) {
930  #else // PROTOBUF_FORCE_COPY_IN_SWAP
931  if (GetOwningArena() == other->GetOwningArena()) {
932  #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
933  InternalSwap(other);
934  } else {
935  ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
936  }
937  }
938  void UnsafeArenaSwap(SetupMessage* other) {
939  if (other == this) return;
940  GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
941  InternalSwap(other);
942  }
943 
944  // implements Message ----------------------------------------------
945 
946  SetupMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
947  return CreateMaybeMessage<SetupMessage>(arena);
948  }
949  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
950  void CopyFrom(const SetupMessage& from);
951  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
952  void MergeFrom( const SetupMessage& from) {
953  SetupMessage::MergeImpl(*this, from);
954  }
955  private:
956  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
957  public:
958  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
959  bool IsInitialized() const final;
960 
961  size_t ByteSizeLong() const final;
962  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
963  uint8_t* _InternalSerialize(
964  uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
965  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
966 
967  private:
968  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
969  void SharedDtor();
970  void SetCachedSize(int size) const final;
971  void InternalSwap(SetupMessage* other);
972 
973  private:
974  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
975  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
976  return "tcp_io_device.SetupMessage";
977  }
978  protected:
979  explicit SetupMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
980  bool is_message_owned = false);
981  private:
982  static void ArenaDtor(void* object);
983  public:
984 
985  static const ClassData _class_data_;
986  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
987 
988  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
989 
990  // nested types ----------------------------------------------------
991 
992 
993  // accessors -------------------------------------------------------
994 
995  enum : int {
996  kEntitiesFieldNumber = 1,
997  kObjectsFieldNumber = 2,
998  kCommandsFieldNumber = 3,
999  kCommandDescriptionsFieldNumber = 4,
1000  };
1001  // map<string, int32> entities = 1;
1002  int entities_size() const;
1003  private:
1004  int _internal_entities_size() const;
1005  public:
1006  void clear_entities();
1007  private:
1008  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >&
1009  _internal_entities() const;
1010  ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >*
1011  _internal_mutable_entities();
1012  public:
1013  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >&
1014  entities() const;
1015  ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >*
1016  mutable_entities();
1017 
1018  // map<string, int32> objects = 2;
1019  int objects_size() const;
1020  private:
1021  int _internal_objects_size() const;
1022  public:
1023  void clear_objects();
1024  private:
1025  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >&
1026  _internal_objects() const;
1027  ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >*
1028  _internal_mutable_objects();
1029  public:
1030  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >&
1031  objects() const;
1032  ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >*
1033  mutable_objects();
1034 
1035  // map<string, int32> commands = 3;
1036  int commands_size() const;
1037  private:
1038  int _internal_commands_size() const;
1039  public:
1040  void clear_commands();
1041  private:
1042  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >&
1043  _internal_commands() const;
1044  ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >*
1045  _internal_mutable_commands();
1046  public:
1047  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >&
1048  commands() const;
1049  ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >*
1050  mutable_commands();
1051 
1052  // repeated .tcp_io_device.CommandDescription commandDescriptions = 4;
1053  int commanddescriptions_size() const;
1054  private:
1055  int _internal_commanddescriptions_size() const;
1056  public:
1057  void clear_commanddescriptions();
1058  ::tcp_io_device::CommandDescription* mutable_commanddescriptions(int index);
1059  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tcp_io_device::CommandDescription >*
1060  mutable_commanddescriptions();
1061  private:
1062  const ::tcp_io_device::CommandDescription& _internal_commanddescriptions(int index) const;
1063  ::tcp_io_device::CommandDescription* _internal_add_commanddescriptions();
1064  public:
1065  const ::tcp_io_device::CommandDescription& commanddescriptions(int index) const;
1066  ::tcp_io_device::CommandDescription* add_commanddescriptions();
1067  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tcp_io_device::CommandDescription >&
1068  commanddescriptions() const;
1069 
1070  // @@protoc_insertion_point(class_scope:tcp_io_device.SetupMessage)
1071  private:
1072  class _Internal;
1073 
1074  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1075  typedef void InternalArenaConstructable_;
1076  typedef void DestructorSkippable_;
1077  struct Impl_ {
1078  ::PROTOBUF_NAMESPACE_ID::internal::MapField<
1079  SetupMessage_EntitiesEntry_DoNotUse,
1080  std::string, int32_t,
1081  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
1082  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32> entities_;
1083  ::PROTOBUF_NAMESPACE_ID::internal::MapField<
1084  SetupMessage_ObjectsEntry_DoNotUse,
1085  std::string, int32_t,
1086  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
1087  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32> objects_;
1088  ::PROTOBUF_NAMESPACE_ID::internal::MapField<
1089  SetupMessage_CommandsEntry_DoNotUse,
1090  std::string, int32_t,
1091  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
1092  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32> commands_;
1093  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tcp_io_device::CommandDescription > commanddescriptions_;
1094  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1095  };
1096  union { Impl_ _impl_; };
1097  friend struct ::TableStruct_tcp_5fdata_5fmessage_2eproto;
1098 };
1099 // -------------------------------------------------------------------
1100 
1101 class CommandDescription final :
1102  public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tcp_io_device.CommandDescription) */ {
1103  public:
1104  inline CommandDescription() : CommandDescription(nullptr) {}
1105  ~CommandDescription() override;
1106  explicit PROTOBUF_CONSTEXPR CommandDescription(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1107 
1108  CommandDescription(const CommandDescription& from);
1109  CommandDescription(CommandDescription&& from) noexcept
1110  : CommandDescription() {
1111  *this = ::std::move(from);
1112  }
1113 
1114  inline CommandDescription& operator=(const CommandDescription& from) {
1115  CopyFrom(from);
1116  return *this;
1117  }
1118  inline CommandDescription& operator=(CommandDescription&& from) noexcept {
1119  if (this == &from) return *this;
1120  if (GetOwningArena() == from.GetOwningArena()
1121  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1122  && GetOwningArena() != nullptr
1123  #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1124  ) {
1125  InternalSwap(&from);
1126  } else {
1127  CopyFrom(from);
1128  }
1129  return *this;
1130  }
1131 
1132  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1133  return GetDescriptor();
1134  }
1135  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1136  return default_instance().GetMetadata().descriptor;
1137  }
1138  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1139  return default_instance().GetMetadata().reflection;
1140  }
1141  static const CommandDescription& default_instance() {
1142  return *internal_default_instance();
1143  }
1144  static inline const CommandDescription* internal_default_instance() {
1145  return reinterpret_cast<const CommandDescription*>(
1146  &_CommandDescription_default_instance_);
1147  }
1148  static constexpr int kIndexInFileMessages =
1149  7;
1150 
1151  friend void swap(CommandDescription& a, CommandDescription& b) {
1152  a.Swap(&b);
1153  }
1154  inline void Swap(CommandDescription* other) {
1155  if (other == this) return;
1156  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1157  if (GetOwningArena() != nullptr &&
1158  GetOwningArena() == other->GetOwningArena()) {
1159  #else // PROTOBUF_FORCE_COPY_IN_SWAP
1160  if (GetOwningArena() == other->GetOwningArena()) {
1161  #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1162  InternalSwap(other);
1163  } else {
1164  ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1165  }
1166  }
1167  void UnsafeArenaSwap(CommandDescription* other) {
1168  if (other == this) return;
1169  GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1170  InternalSwap(other);
1171  }
1172 
1173  // implements Message ----------------------------------------------
1174 
1175  CommandDescription* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1176  return CreateMaybeMessage<CommandDescription>(arena);
1177  }
1178  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
1179  void CopyFrom(const CommandDescription& from);
1180  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
1181  void MergeFrom( const CommandDescription& from) {
1182  CommandDescription::MergeImpl(*this, from);
1183  }
1184  private:
1185  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
1186  public:
1187  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1188  bool IsInitialized() const final;
1189 
1190  size_t ByteSizeLong() const final;
1191  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1192  uint8_t* _InternalSerialize(
1193  uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1194  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1195 
1196  private:
1197  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1198  void SharedDtor();
1199  void SetCachedSize(int size) const final;
1200  void InternalSwap(CommandDescription* other);
1201 
1202  private:
1203  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1204  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1205  return "tcp_io_device.CommandDescription";
1206  }
1207  protected:
1208  explicit CommandDescription(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1209  bool is_message_owned = false);
1210  public:
1211 
1212  static const ClassData _class_data_;
1213  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
1214 
1215  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1216 
1217  // nested types ----------------------------------------------------
1218 
1219  // accessors -------------------------------------------------------
1220 
1221  enum : int {
1222  kNameFieldNumber = 2,
1223  kDescriptionFieldNumber = 1,
1224  };
1225  // string name = 2;
1226  void clear_name();
1227  const std::string& name() const;
1228  template <typename ArgT0 = const std::string&, typename... ArgT>
1229  void set_name(ArgT0&& arg0, ArgT... args);
1230  std::string* mutable_name();
1231  PROTOBUF_NODISCARD std::string* release_name();
1232  void set_allocated_name(std::string* name);
1233  private:
1234  const std::string& _internal_name() const;
1235  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
1236  std::string* _internal_mutable_name();
1237  public:
1238 
1239  // .tcp_io_device.VariableDescription description = 1;
1240  bool has_description() const;
1241  private:
1242  bool _internal_has_description() const;
1243  public:
1244  void clear_description();
1245  const ::tcp_io_device::VariableDescription& description() const;
1246  PROTOBUF_NODISCARD ::tcp_io_device::VariableDescription* release_description();
1247  ::tcp_io_device::VariableDescription* mutable_description();
1248  void set_allocated_description(::tcp_io_device::VariableDescription* description);
1249  private:
1250  const ::tcp_io_device::VariableDescription& _internal_description() const;
1251  ::tcp_io_device::VariableDescription* _internal_mutable_description();
1252  public:
1253  void unsafe_arena_set_allocated_description(
1254  ::tcp_io_device::VariableDescription* description);
1255  ::tcp_io_device::VariableDescription* unsafe_arena_release_description();
1256 
1257  // @@protoc_insertion_point(class_scope:tcp_io_device.CommandDescription)
1258  private:
1259  class _Internal;
1260 
1261  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1262  typedef void InternalArenaConstructable_;
1263  typedef void DestructorSkippable_;
1264  struct Impl_ {
1265  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
1266  ::tcp_io_device::VariableDescription* description_;
1267  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1268  };
1269  union { Impl_ _impl_; };
1270  friend struct ::TableStruct_tcp_5fdata_5fmessage_2eproto;
1271 };
1272 // -------------------------------------------------------------------
1273 
1274 class DataMessage final :
1275  public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tcp_io_device.DataMessage) */ {
1276  public:
1277  inline DataMessage() : DataMessage(nullptr) {}
1278  ~DataMessage() override;
1279  explicit PROTOBUF_CONSTEXPR DataMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1280 
1281  DataMessage(const DataMessage& from);
1282  DataMessage(DataMessage&& from) noexcept
1283  : DataMessage() {
1284  *this = ::std::move(from);
1285  }
1286 
1287  inline DataMessage& operator=(const DataMessage& from) {
1288  CopyFrom(from);
1289  return *this;
1290  }
1291  inline DataMessage& operator=(DataMessage&& from) noexcept {
1292  if (this == &from) return *this;
1293  if (GetOwningArena() == from.GetOwningArena()
1294  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1295  && GetOwningArena() != nullptr
1296  #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1297  ) {
1298  InternalSwap(&from);
1299  } else {
1300  CopyFrom(from);
1301  }
1302  return *this;
1303  }
1304 
1305  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1306  return GetDescriptor();
1307  }
1308  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1309  return default_instance().GetMetadata().descriptor;
1310  }
1311  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1312  return default_instance().GetMetadata().reflection;
1313  }
1314  static const DataMessage& default_instance() {
1315  return *internal_default_instance();
1316  }
1317  static inline const DataMessage* internal_default_instance() {
1318  return reinterpret_cast<const DataMessage*>(
1319  &_DataMessage_default_instance_);
1320  }
1321  static constexpr int kIndexInFileMessages =
1322  8;
1323 
1324  friend void swap(DataMessage& a, DataMessage& b) {
1325  a.Swap(&b);
1326  }
1327  inline void Swap(DataMessage* other) {
1328  if (other == this) return;
1329  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1330  if (GetOwningArena() != nullptr &&
1331  GetOwningArena() == other->GetOwningArena()) {
1332  #else // PROTOBUF_FORCE_COPY_IN_SWAP
1333  if (GetOwningArena() == other->GetOwningArena()) {
1334  #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1335  InternalSwap(other);
1336  } else {
1337  ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1338  }
1339  }
1340  void UnsafeArenaSwap(DataMessage* other) {
1341  if (other == this) return;
1342  GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1343  InternalSwap(other);
1344  }
1345 
1346  // implements Message ----------------------------------------------
1347 
1348  DataMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1349  return CreateMaybeMessage<DataMessage>(arena);
1350  }
1351  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
1352  void CopyFrom(const DataMessage& from);
1353  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
1354  void MergeFrom( const DataMessage& from) {
1355  DataMessage::MergeImpl(*this, from);
1356  }
1357  private:
1358  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
1359  public:
1360  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1361  bool IsInitialized() const final;
1362 
1363  size_t ByteSizeLong() const final;
1364  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1365  uint8_t* _InternalSerialize(
1366  uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1367  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1368 
1369  private:
1370  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1371  void SharedDtor();
1372  void SetCachedSize(int size) const final;
1373  void InternalSwap(DataMessage* other);
1374 
1375  private:
1376  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1377  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1378  return "tcp_io_device.DataMessage";
1379  }
1380  protected:
1381  explicit DataMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1382  bool is_message_owned = false);
1383  public:
1384 
1385  static const ClassData _class_data_;
1386  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
1387 
1388  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1389 
1390  // nested types ----------------------------------------------------
1391 
1392  // accessors -------------------------------------------------------
1393 
1394  enum : int {
1395  kVariablesFieldNumber = 1,
1396  kTimeSpanFieldNumber = 2,
1397  };
1398  // repeated .tcp_io_device.ProtoVariable variables = 1;
1399  int variables_size() const;
1400  private:
1401  int _internal_variables_size() const;
1402  public:
1403  void clear_variables();
1404  ::tcp_io_device::ProtoVariable* mutable_variables(int index);
1405  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tcp_io_device::ProtoVariable >*
1406  mutable_variables();
1407  private:
1408  const ::tcp_io_device::ProtoVariable& _internal_variables(int index) const;
1409  ::tcp_io_device::ProtoVariable* _internal_add_variables();
1410  public:
1411  const ::tcp_io_device::ProtoVariable& variables(int index) const;
1412  ::tcp_io_device::ProtoVariable* add_variables();
1413  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tcp_io_device::ProtoVariable >&
1414  variables() const;
1415 
1416  // uint64 timeSpan = 2;
1417  void clear_timespan();
1418  uint64_t timespan() const;
1419  void set_timespan(uint64_t value);
1420  private:
1421  uint64_t _internal_timespan() const;
1422  void _internal_set_timespan(uint64_t value);
1423  public:
1424 
1425  // @@protoc_insertion_point(class_scope:tcp_io_device.DataMessage)
1426  private:
1427  class _Internal;
1428 
1429  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1430  typedef void InternalArenaConstructable_;
1431  typedef void DestructorSkippable_;
1432  struct Impl_ {
1433  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tcp_io_device::ProtoVariable > variables_;
1434  uint64_t timespan_;
1435  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1436  };
1437  union { Impl_ _impl_; };
1438  friend struct ::TableStruct_tcp_5fdata_5fmessage_2eproto;
1439 };
1440 // -------------------------------------------------------------------
1441 
1442 class VariableDescription final :
1443  public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tcp_io_device.VariableDescription) */ {
1444  public:
1445  inline VariableDescription() : VariableDescription(nullptr) {}
1446  ~VariableDescription() override;
1447  explicit PROTOBUF_CONSTEXPR VariableDescription(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1448 
1449  VariableDescription(const VariableDescription& from);
1450  VariableDescription(VariableDescription&& from) noexcept
1451  : VariableDescription() {
1452  *this = ::std::move(from);
1453  }
1454 
1455  inline VariableDescription& operator=(const VariableDescription& from) {
1456  CopyFrom(from);
1457  return *this;
1458  }
1459  inline VariableDescription& operator=(VariableDescription&& from) noexcept {
1460  if (this == &from) return *this;
1461  if (GetOwningArena() == from.GetOwningArena()
1462  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1463  && GetOwningArena() != nullptr
1464  #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1465  ) {
1466  InternalSwap(&from);
1467  } else {
1468  CopyFrom(from);
1469  }
1470  return *this;
1471  }
1472 
1473  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1474  return GetDescriptor();
1475  }
1476  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1477  return default_instance().GetMetadata().descriptor;
1478  }
1479  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1480  return default_instance().GetMetadata().reflection;
1481  }
1482  static const VariableDescription& default_instance() {
1483  return *internal_default_instance();
1484  }
1485  static inline const VariableDescription* internal_default_instance() {
1486  return reinterpret_cast<const VariableDescription*>(
1487  &_VariableDescription_default_instance_);
1488  }
1489  static constexpr int kIndexInFileMessages =
1490  9;
1491 
1492  friend void swap(VariableDescription& a, VariableDescription& b) {
1493  a.Swap(&b);
1494  }
1495  inline void Swap(VariableDescription* other) {
1496  if (other == this) return;
1497  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1498  if (GetOwningArena() != nullptr &&
1499  GetOwningArena() == other->GetOwningArena()) {
1500  #else // PROTOBUF_FORCE_COPY_IN_SWAP
1501  if (GetOwningArena() == other->GetOwningArena()) {
1502  #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1503  InternalSwap(other);
1504  } else {
1505  ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1506  }
1507  }
1508  void UnsafeArenaSwap(VariableDescription* other) {
1509  if (other == this) return;
1510  GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1511  InternalSwap(other);
1512  }
1513 
1514  // implements Message ----------------------------------------------
1515 
1516  VariableDescription* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1517  return CreateMaybeMessage<VariableDescription>(arena);
1518  }
1519  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
1520  void CopyFrom(const VariableDescription& from);
1521  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
1522  void MergeFrom( const VariableDescription& from) {
1523  VariableDescription::MergeImpl(*this, from);
1524  }
1525  private:
1526  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
1527  public:
1528  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1529  bool IsInitialized() const final;
1530 
1531  size_t ByteSizeLong() const final;
1532  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1533  uint8_t* _InternalSerialize(
1534  uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1535  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1536 
1537  private:
1538  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1539  void SharedDtor();
1540  void SetCachedSize(int size) const final;
1541  void InternalSwap(VariableDescription* other);
1542 
1543  private:
1544  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1545  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1546  return "tcp_io_device.VariableDescription";
1547  }
1548  protected:
1549  explicit VariableDescription(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1550  bool is_message_owned = false);
1551  public:
1552 
1553  static const ClassData _class_data_;
1554  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
1555 
1556  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1557 
1558  // nested types ----------------------------------------------------
1559 
1560  typedef VariableDescription_DataType DataType;
1561  static constexpr DataType DOUBLE =
1562  VariableDescription_DataType_DOUBLE;
1563  static constexpr DataType INT64 =
1564  VariableDescription_DataType_INT64;
1565  static constexpr DataType BOOL =
1566  VariableDescription_DataType_BOOL;
1567  static constexpr DataType STRING =
1568  VariableDescription_DataType_STRING;
1569  static constexpr DataType BYTES =
1570  VariableDescription_DataType_BYTES;
1571  static constexpr DataType COMMUNICATION_ID =
1572  VariableDescription_DataType_COMMUNICATION_ID;
1573  static inline bool DataType_IsValid(int value) {
1574  return VariableDescription_DataType_IsValid(value);
1575  }
1576  static constexpr DataType DataType_MIN =
1577  VariableDescription_DataType_DataType_MIN;
1578  static constexpr DataType DataType_MAX =
1579  VariableDescription_DataType_DataType_MAX;
1580  static constexpr int DataType_ARRAYSIZE =
1581  VariableDescription_DataType_DataType_ARRAYSIZE;
1582  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
1583  DataType_descriptor() {
1584  return VariableDescription_DataType_descriptor();
1585  }
1586  template<typename T>
1587  static inline const std::string& DataType_Name(T enum_t_value) {
1588  static_assert(::std::is_same<T, DataType>::value ||
1589  ::std::is_integral<T>::value,
1590  "Incorrect type passed to function DataType_Name.");
1591  return VariableDescription_DataType_Name(enum_t_value);
1592  }
1593  static inline bool DataType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
1594  DataType* value) {
1595  return VariableDescription_DataType_Parse(name, value);
1596  }
1597 
1598  // accessors -------------------------------------------------------
1599 
1600  enum : int {
1601  kDimensionsFieldNumber = 4,
1602  kOpcodeStringHandleFieldNumber = 5,
1603  kEntityIDFieldNumber = 1,
1604  kIDFieldNumber = 2,
1605  kDataTypeFieldNumber = 3,
1606  };
1607  // repeated uint64 dimensions = 4;
1608  int dimensions_size() const;
1609  private:
1610  int _internal_dimensions_size() const;
1611  public:
1612  void clear_dimensions();
1613  private:
1614  uint64_t _internal_dimensions(int index) const;
1615  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
1616  _internal_dimensions() const;
1617  void _internal_add_dimensions(uint64_t value);
1618  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
1619  _internal_mutable_dimensions();
1620  public:
1621  uint64_t dimensions(int index) const;
1622  void set_dimensions(int index, uint64_t value);
1623  void add_dimensions(uint64_t value);
1624  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
1625  dimensions() const;
1626  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
1627  mutable_dimensions();
1628 
1629  // string opcode_string_handle = 5;
1630  void clear_opcode_string_handle();
1631  const std::string& opcode_string_handle() const;
1632  template <typename ArgT0 = const std::string&, typename... ArgT>
1633  void set_opcode_string_handle(ArgT0&& arg0, ArgT... args);
1634  std::string* mutable_opcode_string_handle();
1635  PROTOBUF_NODISCARD std::string* release_opcode_string_handle();
1636  void set_allocated_opcode_string_handle(std::string* opcode_string_handle);
1637  private:
1638  const std::string& _internal_opcode_string_handle() const;
1639  inline PROTOBUF_ALWAYS_INLINE void _internal_set_opcode_string_handle(const std::string& value);
1640  std::string* _internal_mutable_opcode_string_handle();
1641  public:
1642 
1643  // int32 entityID = 1;
1644  void clear_entityid();
1645  int32_t entityid() const;
1646  void set_entityid(int32_t value);
1647  private:
1648  int32_t _internal_entityid() const;
1649  void _internal_set_entityid(int32_t value);
1650  public:
1651 
1652  // int32 ID = 2;
1653  void clear_id();
1654  int32_t id() const;
1655  void set_id(int32_t value);
1656  private:
1657  int32_t _internal_id() const;
1658  void _internal_set_id(int32_t value);
1659  public:
1660 
1661  // .tcp_io_device.VariableDescription.DataType dataType = 3;
1662  void clear_datatype();
1663  ::tcp_io_device::VariableDescription_DataType datatype() const;
1664  void set_datatype(::tcp_io_device::VariableDescription_DataType value);
1665  private:
1666  ::tcp_io_device::VariableDescription_DataType _internal_datatype() const;
1667  void _internal_set_datatype(::tcp_io_device::VariableDescription_DataType value);
1668  public:
1669 
1670  // @@protoc_insertion_point(class_scope:tcp_io_device.VariableDescription)
1671  private:
1672  class _Internal;
1673 
1674  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1675  typedef void InternalArenaConstructable_;
1676  typedef void DestructorSkippable_;
1677  struct Impl_ {
1678  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > dimensions_;
1679  mutable std::atomic<int> _dimensions_cached_byte_size_;
1680  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr opcode_string_handle_;
1681  int32_t entityid_;
1682  int32_t id_;
1683  int datatype_;
1684  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1685  };
1686  union { Impl_ _impl_; };
1687  friend struct ::TableStruct_tcp_5fdata_5fmessage_2eproto;
1688 };
1689 // -------------------------------------------------------------------
1690 
1691 class ProtoVariable final :
1692  public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tcp_io_device.ProtoVariable) */ {
1693  public:
1694  inline ProtoVariable() : ProtoVariable(nullptr) {}
1695  ~ProtoVariable() override;
1696  explicit PROTOBUF_CONSTEXPR ProtoVariable(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1697 
1698  ProtoVariable(const ProtoVariable& from);
1699  ProtoVariable(ProtoVariable&& from) noexcept
1700  : ProtoVariable() {
1701  *this = ::std::move(from);
1702  }
1703 
1704  inline ProtoVariable& operator=(const ProtoVariable& from) {
1705  CopyFrom(from);
1706  return *this;
1707  }
1708  inline ProtoVariable& operator=(ProtoVariable&& from) noexcept {
1709  if (this == &from) return *this;
1710  if (GetOwningArena() == from.GetOwningArena()
1711  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1712  && GetOwningArena() != nullptr
1713  #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1714  ) {
1715  InternalSwap(&from);
1716  } else {
1717  CopyFrom(from);
1718  }
1719  return *this;
1720  }
1721 
1722  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1723  return GetDescriptor();
1724  }
1725  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1726  return default_instance().GetMetadata().descriptor;
1727  }
1728  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1729  return default_instance().GetMetadata().reflection;
1730  }
1731  static const ProtoVariable& default_instance() {
1732  return *internal_default_instance();
1733  }
1734  static inline const ProtoVariable* internal_default_instance() {
1735  return reinterpret_cast<const ProtoVariable*>(
1736  &_ProtoVariable_default_instance_);
1737  }
1738  static constexpr int kIndexInFileMessages =
1739  10;
1740 
1741  friend void swap(ProtoVariable& a, ProtoVariable& b) {
1742  a.Swap(&b);
1743  }
1744  inline void Swap(ProtoVariable* other) {
1745  if (other == this) return;
1746  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1747  if (GetOwningArena() != nullptr &&
1748  GetOwningArena() == other->GetOwningArena()) {
1749  #else // PROTOBUF_FORCE_COPY_IN_SWAP
1750  if (GetOwningArena() == other->GetOwningArena()) {
1751  #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1752  InternalSwap(other);
1753  } else {
1754  ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1755  }
1756  }
1757  void UnsafeArenaSwap(ProtoVariable* other) {
1758  if (other == this) return;
1759  GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1760  InternalSwap(other);
1761  }
1762 
1763  // implements Message ----------------------------------------------
1764 
1765  ProtoVariable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1766  return CreateMaybeMessage<ProtoVariable>(arena);
1767  }
1768  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
1769  void CopyFrom(const ProtoVariable& from);
1770  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
1771  void MergeFrom( const ProtoVariable& from) {
1772  ProtoVariable::MergeImpl(*this, from);
1773  }
1774  private:
1775  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
1776  public:
1777  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1778  bool IsInitialized() const final;
1779 
1780  size_t ByteSizeLong() const final;
1781  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1782  uint8_t* _InternalSerialize(
1783  uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1784  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1785 
1786  private:
1787  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1788  void SharedDtor();
1789  void SetCachedSize(int size) const final;
1790  void InternalSwap(ProtoVariable* other);
1791 
1792  private:
1793  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1794  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1795  return "tcp_io_device.ProtoVariable";
1796  }
1797  protected:
1798  explicit ProtoVariable(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1799  bool is_message_owned = false);
1800  public:
1801 
1802  static const ClassData _class_data_;
1803  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
1804 
1805  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1806 
1807  // nested types ----------------------------------------------------
1808 
1809  // accessors -------------------------------------------------------
1810 
1811  enum : int {
1812  kDataFieldNumber = 2,
1813  kMetaDataFieldNumber = 1,
1814  };
1815  // bytes data = 2;
1816  void clear_data();
1817  const std::string& data() const;
1818  template <typename ArgT0 = const std::string&, typename... ArgT>
1819  void set_data(ArgT0&& arg0, ArgT... args);
1820  std::string* mutable_data();
1821  PROTOBUF_NODISCARD std::string* release_data();
1822  void set_allocated_data(std::string* data);
1823  private:
1824  const std::string& _internal_data() const;
1825  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
1826  std::string* _internal_mutable_data();
1827  public:
1828 
1829  // .tcp_io_device.VariableDescription metaData = 1;
1830  bool has_metadata() const;
1831  private:
1832  bool _internal_has_metadata() const;
1833  public:
1834  void clear_metadata();
1835  const ::tcp_io_device::VariableDescription& metadata() const;
1836  PROTOBUF_NODISCARD ::tcp_io_device::VariableDescription* release_metadata();
1837  ::tcp_io_device::VariableDescription* mutable_metadata();
1838  void set_allocated_metadata(::tcp_io_device::VariableDescription* metadata);
1839  private:
1840  const ::tcp_io_device::VariableDescription& _internal_metadata() const;
1841  ::tcp_io_device::VariableDescription* _internal_mutable_metadata();
1842  public:
1843  void unsafe_arena_set_allocated_metadata(
1844  ::tcp_io_device::VariableDescription* metadata);
1845  ::tcp_io_device::VariableDescription* unsafe_arena_release_metadata();
1846 
1847  // @@protoc_insertion_point(class_scope:tcp_io_device.ProtoVariable)
1848  private:
1849  class _Internal;
1850 
1851  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1852  typedef void InternalArenaConstructable_;
1853  typedef void DestructorSkippable_;
1854  struct Impl_ {
1855  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
1856  ::tcp_io_device::VariableDescription* metadata_;
1857  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1858  };
1859  union { Impl_ _impl_; };
1860  friend struct ::TableStruct_tcp_5fdata_5fmessage_2eproto;
1861 };
1862 // ===================================================================
1863 
1864 
1865 // ===================================================================
1866 
1867 #ifdef __GNUC__
1868  #pragma GCC diagnostic push
1869  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1870 #endif // __GNUC__
1871 // TCPMessage
1872 
1873 // .tcp_io_device.TCPMessage.Type messageType = 1;
1874 inline void TCPMessage::clear_messagetype() {
1875  _impl_.messagetype_ = 0;
1876 }
1877 inline ::tcp_io_device::TCPMessage_Type TCPMessage::_internal_messagetype() const {
1878  return static_cast< ::tcp_io_device::TCPMessage_Type >(_impl_.messagetype_);
1879 }
1880 inline ::tcp_io_device::TCPMessage_Type TCPMessage::messagetype() const {
1881  // @@protoc_insertion_point(field_get:tcp_io_device.TCPMessage.messageType)
1882  return _internal_messagetype();
1883 }
1884 inline void TCPMessage::_internal_set_messagetype(::tcp_io_device::TCPMessage_Type value) {
1885 
1886  _impl_.messagetype_ = value;
1887 }
1888 inline void TCPMessage::set_messagetype(::tcp_io_device::TCPMessage_Type value) {
1889  _internal_set_messagetype(value);
1890  // @@protoc_insertion_point(field_set:tcp_io_device.TCPMessage.messageType)
1891 }
1892 
1893 // .tcp_io_device.SetupMessage setupMessage = 2;
1894 inline bool TCPMessage::_internal_has_setupmessage() const {
1895  return message_case() == kSetupMessage;
1896 }
1897 inline bool TCPMessage::has_setupmessage() const {
1898  return _internal_has_setupmessage();
1899 }
1900 inline void TCPMessage::set_has_setupmessage() {
1901  _impl_._oneof_case_[0] = kSetupMessage;
1902 }
1903 inline void TCPMessage::clear_setupmessage() {
1904  if (_internal_has_setupmessage()) {
1905  if (GetArenaForAllocation() == nullptr) {
1906  delete _impl_.message_.setupmessage_;
1907  }
1908  clear_has_message();
1909  }
1910 }
1911 inline ::tcp_io_device::SetupMessage* TCPMessage::release_setupmessage() {
1912  // @@protoc_insertion_point(field_release:tcp_io_device.TCPMessage.setupMessage)
1913  if (_internal_has_setupmessage()) {
1914  clear_has_message();
1915  ::tcp_io_device::SetupMessage* temp = _impl_.message_.setupmessage_;
1916  if (GetArenaForAllocation() != nullptr) {
1917  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1918  }
1919  _impl_.message_.setupmessage_ = nullptr;
1920  return temp;
1921  } else {
1922  return nullptr;
1923  }
1924 }
1925 inline const ::tcp_io_device::SetupMessage& TCPMessage::_internal_setupmessage() const {
1926  return _internal_has_setupmessage()
1927  ? *_impl_.message_.setupmessage_
1928  : reinterpret_cast< ::tcp_io_device::SetupMessage&>(::tcp_io_device::_SetupMessage_default_instance_);
1929 }
1930 inline const ::tcp_io_device::SetupMessage& TCPMessage::setupmessage() const {
1931  // @@protoc_insertion_point(field_get:tcp_io_device.TCPMessage.setupMessage)
1932  return _internal_setupmessage();
1933 }
1934 inline ::tcp_io_device::SetupMessage* TCPMessage::unsafe_arena_release_setupmessage() {
1935  // @@protoc_insertion_point(field_unsafe_arena_release:tcp_io_device.TCPMessage.setupMessage)
1936  if (_internal_has_setupmessage()) {
1937  clear_has_message();
1938  ::tcp_io_device::SetupMessage* temp = _impl_.message_.setupmessage_;
1939  _impl_.message_.setupmessage_ = nullptr;
1940  return temp;
1941  } else {
1942  return nullptr;
1943  }
1944 }
1945 inline void TCPMessage::unsafe_arena_set_allocated_setupmessage(::tcp_io_device::SetupMessage* setupmessage) {
1946  clear_message();
1947  if (setupmessage) {
1948  set_has_setupmessage();
1949  _impl_.message_.setupmessage_ = setupmessage;
1950  }
1951  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tcp_io_device.TCPMessage.setupMessage)
1952 }
1953 inline ::tcp_io_device::SetupMessage* TCPMessage::_internal_mutable_setupmessage() {
1954  if (!_internal_has_setupmessage()) {
1955  clear_message();
1956  set_has_setupmessage();
1957  _impl_.message_.setupmessage_ = CreateMaybeMessage< ::tcp_io_device::SetupMessage >(GetArenaForAllocation());
1958  }
1959  return _impl_.message_.setupmessage_;
1960 }
1961 inline ::tcp_io_device::SetupMessage* TCPMessage::mutable_setupmessage() {
1962  ::tcp_io_device::SetupMessage* _msg = _internal_mutable_setupmessage();
1963  // @@protoc_insertion_point(field_mutable:tcp_io_device.TCPMessage.setupMessage)
1964  return _msg;
1965 }
1966 
1967 // .tcp_io_device.DataMessage dataMessage = 3;
1968 inline bool TCPMessage::_internal_has_datamessage() const {
1969  return message_case() == kDataMessage;
1970 }
1971 inline bool TCPMessage::has_datamessage() const {
1972  return _internal_has_datamessage();
1973 }
1974 inline void TCPMessage::set_has_datamessage() {
1975  _impl_._oneof_case_[0] = kDataMessage;
1976 }
1977 inline void TCPMessage::clear_datamessage() {
1978  if (_internal_has_datamessage()) {
1979  if (GetArenaForAllocation() == nullptr) {
1980  delete _impl_.message_.datamessage_;
1981  }
1982  clear_has_message();
1983  }
1984 }
1985 inline ::tcp_io_device::DataMessage* TCPMessage::release_datamessage() {
1986  // @@protoc_insertion_point(field_release:tcp_io_device.TCPMessage.dataMessage)
1987  if (_internal_has_datamessage()) {
1988  clear_has_message();
1989  ::tcp_io_device::DataMessage* temp = _impl_.message_.datamessage_;
1990  if (GetArenaForAllocation() != nullptr) {
1991  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1992  }
1993  _impl_.message_.datamessage_ = nullptr;
1994  return temp;
1995  } else {
1996  return nullptr;
1997  }
1998 }
1999 inline const ::tcp_io_device::DataMessage& TCPMessage::_internal_datamessage() const {
2000  return _internal_has_datamessage()
2001  ? *_impl_.message_.datamessage_
2002  : reinterpret_cast< ::tcp_io_device::DataMessage&>(::tcp_io_device::_DataMessage_default_instance_);
2003 }
2004 inline const ::tcp_io_device::DataMessage& TCPMessage::datamessage() const {
2005  // @@protoc_insertion_point(field_get:tcp_io_device.TCPMessage.dataMessage)
2006  return _internal_datamessage();
2007 }
2008 inline ::tcp_io_device::DataMessage* TCPMessage::unsafe_arena_release_datamessage() {
2009  // @@protoc_insertion_point(field_unsafe_arena_release:tcp_io_device.TCPMessage.dataMessage)
2010  if (_internal_has_datamessage()) {
2011  clear_has_message();
2012  ::tcp_io_device::DataMessage* temp = _impl_.message_.datamessage_;
2013  _impl_.message_.datamessage_ = nullptr;
2014  return temp;
2015  } else {
2016  return nullptr;
2017  }
2018 }
2019 inline void TCPMessage::unsafe_arena_set_allocated_datamessage(::tcp_io_device::DataMessage* datamessage) {
2020  clear_message();
2021  if (datamessage) {
2022  set_has_datamessage();
2023  _impl_.message_.datamessage_ = datamessage;
2024  }
2025  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tcp_io_device.TCPMessage.dataMessage)
2026 }
2027 inline ::tcp_io_device::DataMessage* TCPMessage::_internal_mutable_datamessage() {
2028  if (!_internal_has_datamessage()) {
2029  clear_message();
2030  set_has_datamessage();
2031  _impl_.message_.datamessage_ = CreateMaybeMessage< ::tcp_io_device::DataMessage >(GetArenaForAllocation());
2032  }
2033  return _impl_.message_.datamessage_;
2034 }
2035 inline ::tcp_io_device::DataMessage* TCPMessage::mutable_datamessage() {
2036  ::tcp_io_device::DataMessage* _msg = _internal_mutable_datamessage();
2037  // @@protoc_insertion_point(field_mutable:tcp_io_device.TCPMessage.dataMessage)
2038  return _msg;
2039 }
2040 
2041 // .tcp_io_device.StartMessage startMessage = 4;
2042 inline bool TCPMessage::_internal_has_startmessage() const {
2043  return message_case() == kStartMessage;
2044 }
2045 inline bool TCPMessage::has_startmessage() const {
2046  return _internal_has_startmessage();
2047 }
2048 inline void TCPMessage::set_has_startmessage() {
2049  _impl_._oneof_case_[0] = kStartMessage;
2050 }
2051 inline void TCPMessage::clear_startmessage() {
2052  if (_internal_has_startmessage()) {
2053  if (GetArenaForAllocation() == nullptr) {
2054  delete _impl_.message_.startmessage_;
2055  }
2056  clear_has_message();
2057  }
2058 }
2059 inline ::tcp_io_device::StartMessage* TCPMessage::release_startmessage() {
2060  // @@protoc_insertion_point(field_release:tcp_io_device.TCPMessage.startMessage)
2061  if (_internal_has_startmessage()) {
2062  clear_has_message();
2063  ::tcp_io_device::StartMessage* temp = _impl_.message_.startmessage_;
2064  if (GetArenaForAllocation() != nullptr) {
2065  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2066  }
2067  _impl_.message_.startmessage_ = nullptr;
2068  return temp;
2069  } else {
2070  return nullptr;
2071  }
2072 }
2073 inline const ::tcp_io_device::StartMessage& TCPMessage::_internal_startmessage() const {
2074  return _internal_has_startmessage()
2075  ? *_impl_.message_.startmessage_
2076  : reinterpret_cast< ::tcp_io_device::StartMessage&>(::tcp_io_device::_StartMessage_default_instance_);
2077 }
2078 inline const ::tcp_io_device::StartMessage& TCPMessage::startmessage() const {
2079  // @@protoc_insertion_point(field_get:tcp_io_device.TCPMessage.startMessage)
2080  return _internal_startmessage();
2081 }
2082 inline ::tcp_io_device::StartMessage* TCPMessage::unsafe_arena_release_startmessage() {
2083  // @@protoc_insertion_point(field_unsafe_arena_release:tcp_io_device.TCPMessage.startMessage)
2084  if (_internal_has_startmessage()) {
2085  clear_has_message();
2086  ::tcp_io_device::StartMessage* temp = _impl_.message_.startmessage_;
2087  _impl_.message_.startmessage_ = nullptr;
2088  return temp;
2089  } else {
2090  return nullptr;
2091  }
2092 }
2093 inline void TCPMessage::unsafe_arena_set_allocated_startmessage(::tcp_io_device::StartMessage* startmessage) {
2094  clear_message();
2095  if (startmessage) {
2096  set_has_startmessage();
2097  _impl_.message_.startmessage_ = startmessage;
2098  }
2099  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tcp_io_device.TCPMessage.startMessage)
2100 }
2101 inline ::tcp_io_device::StartMessage* TCPMessage::_internal_mutable_startmessage() {
2102  if (!_internal_has_startmessage()) {
2103  clear_message();
2104  set_has_startmessage();
2105  _impl_.message_.startmessage_ = CreateMaybeMessage< ::tcp_io_device::StartMessage >(GetArenaForAllocation());
2106  }
2107  return _impl_.message_.startmessage_;
2108 }
2109 inline ::tcp_io_device::StartMessage* TCPMessage::mutable_startmessage() {
2110  ::tcp_io_device::StartMessage* _msg = _internal_mutable_startmessage();
2111  // @@protoc_insertion_point(field_mutable:tcp_io_device.TCPMessage.startMessage)
2112  return _msg;
2113 }
2114 
2115 // .tcp_io_device.StopMessage stopMessage = 5;
2116 inline bool TCPMessage::_internal_has_stopmessage() const {
2117  return message_case() == kStopMessage;
2118 }
2119 inline bool TCPMessage::has_stopmessage() const {
2120  return _internal_has_stopmessage();
2121 }
2122 inline void TCPMessage::set_has_stopmessage() {
2123  _impl_._oneof_case_[0] = kStopMessage;
2124 }
2125 inline void TCPMessage::clear_stopmessage() {
2126  if (_internal_has_stopmessage()) {
2127  if (GetArenaForAllocation() == nullptr) {
2128  delete _impl_.message_.stopmessage_;
2129  }
2130  clear_has_message();
2131  }
2132 }
2133 inline ::tcp_io_device::StopMessage* TCPMessage::release_stopmessage() {
2134  // @@protoc_insertion_point(field_release:tcp_io_device.TCPMessage.stopMessage)
2135  if (_internal_has_stopmessage()) {
2136  clear_has_message();
2137  ::tcp_io_device::StopMessage* temp = _impl_.message_.stopmessage_;
2138  if (GetArenaForAllocation() != nullptr) {
2139  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2140  }
2141  _impl_.message_.stopmessage_ = nullptr;
2142  return temp;
2143  } else {
2144  return nullptr;
2145  }
2146 }
2147 inline const ::tcp_io_device::StopMessage& TCPMessage::_internal_stopmessage() const {
2148  return _internal_has_stopmessage()
2149  ? *_impl_.message_.stopmessage_
2150  : reinterpret_cast< ::tcp_io_device::StopMessage&>(::tcp_io_device::_StopMessage_default_instance_);
2151 }
2152 inline const ::tcp_io_device::StopMessage& TCPMessage::stopmessage() const {
2153  // @@protoc_insertion_point(field_get:tcp_io_device.TCPMessage.stopMessage)
2154  return _internal_stopmessage();
2155 }
2156 inline ::tcp_io_device::StopMessage* TCPMessage::unsafe_arena_release_stopmessage() {
2157  // @@protoc_insertion_point(field_unsafe_arena_release:tcp_io_device.TCPMessage.stopMessage)
2158  if (_internal_has_stopmessage()) {
2159  clear_has_message();
2160  ::tcp_io_device::StopMessage* temp = _impl_.message_.stopmessage_;
2161  _impl_.message_.stopmessage_ = nullptr;
2162  return temp;
2163  } else {
2164  return nullptr;
2165  }
2166 }
2167 inline void TCPMessage::unsafe_arena_set_allocated_stopmessage(::tcp_io_device::StopMessage* stopmessage) {
2168  clear_message();
2169  if (stopmessage) {
2170  set_has_stopmessage();
2171  _impl_.message_.stopmessage_ = stopmessage;
2172  }
2173  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tcp_io_device.TCPMessage.stopMessage)
2174 }
2175 inline ::tcp_io_device::StopMessage* TCPMessage::_internal_mutable_stopmessage() {
2176  if (!_internal_has_stopmessage()) {
2177  clear_message();
2178  set_has_stopmessage();
2179  _impl_.message_.stopmessage_ = CreateMaybeMessage< ::tcp_io_device::StopMessage >(GetArenaForAllocation());
2180  }
2181  return _impl_.message_.stopmessage_;
2182 }
2183 inline ::tcp_io_device::StopMessage* TCPMessage::mutable_stopmessage() {
2184  ::tcp_io_device::StopMessage* _msg = _internal_mutable_stopmessage();
2185  // @@protoc_insertion_point(field_mutable:tcp_io_device.TCPMessage.stopMessage)
2186  return _msg;
2187 }
2188 
2189 // uint64 timestamp = 6;
2190 inline void TCPMessage::clear_timestamp() {
2191  _impl_.timestamp_ = uint64_t{0u};
2192 }
2193 inline uint64_t TCPMessage::_internal_timestamp() const {
2194  return _impl_.timestamp_;
2195 }
2196 inline uint64_t TCPMessage::timestamp() const {
2197  // @@protoc_insertion_point(field_get:tcp_io_device.TCPMessage.timestamp)
2198  return _internal_timestamp();
2199 }
2200 inline void TCPMessage::_internal_set_timestamp(uint64_t value) {
2201 
2202  _impl_.timestamp_ = value;
2203 }
2204 inline void TCPMessage::set_timestamp(uint64_t value) {
2205  _internal_set_timestamp(value);
2206  // @@protoc_insertion_point(field_set:tcp_io_device.TCPMessage.timestamp)
2207 }
2208 
2209 inline bool TCPMessage::has_message() const {
2210  return message_case() != MESSAGE_NOT_SET;
2211 }
2212 inline void TCPMessage::clear_has_message() {
2213  _impl_._oneof_case_[0] = MESSAGE_NOT_SET;
2214 }
2215 inline TCPMessage::MessageCase TCPMessage::message_case() const {
2216  return TCPMessage::MessageCase(_impl_._oneof_case_[0]);
2217 }
2218 // -------------------------------------------------------------------
2219 
2220 // StartMessage
2221 
2222 // bool diagnosticMode = 1;
2223 inline void StartMessage::clear_diagnosticmode() {
2224  _impl_.diagnosticmode_ = false;
2225 }
2226 inline bool StartMessage::_internal_diagnosticmode() const {
2227  return _impl_.diagnosticmode_;
2228 }
2229 inline bool StartMessage::diagnosticmode() const {
2230  // @@protoc_insertion_point(field_get:tcp_io_device.StartMessage.diagnosticMode)
2231  return _internal_diagnosticmode();
2232 }
2233 inline void StartMessage::_internal_set_diagnosticmode(bool value) {
2234 
2235  _impl_.diagnosticmode_ = value;
2236 }
2237 inline void StartMessage::set_diagnosticmode(bool value) {
2238  _internal_set_diagnosticmode(value);
2239  // @@protoc_insertion_point(field_set:tcp_io_device.StartMessage.diagnosticMode)
2240 }
2241 
2242 // .tcp_io_device.StartMessage.ReconnectionType reconnectionType = 2;
2243 inline void StartMessage::clear_reconnectiontype() {
2244  _impl_.reconnectiontype_ = 0;
2245 }
2246 inline ::tcp_io_device::StartMessage_ReconnectionType StartMessage::_internal_reconnectiontype() const {
2247  return static_cast< ::tcp_io_device::StartMessage_ReconnectionType >(_impl_.reconnectiontype_);
2248 }
2249 inline ::tcp_io_device::StartMessage_ReconnectionType StartMessage::reconnectiontype() const {
2250  // @@protoc_insertion_point(field_get:tcp_io_device.StartMessage.reconnectionType)
2251  return _internal_reconnectiontype();
2252 }
2253 inline void StartMessage::_internal_set_reconnectiontype(::tcp_io_device::StartMessage_ReconnectionType value) {
2254 
2255  _impl_.reconnectiontype_ = value;
2256 }
2257 inline void StartMessage::set_reconnectiontype(::tcp_io_device::StartMessage_ReconnectionType value) {
2258  _internal_set_reconnectiontype(value);
2259  // @@protoc_insertion_point(field_set:tcp_io_device.StartMessage.reconnectionType)
2260 }
2261 
2262 // -------------------------------------------------------------------
2263 
2264 // StopMessage
2265 
2266 // -------------------------------------------------------------------
2267 
2268 // -------------------------------------------------------------------
2269 
2270 // -------------------------------------------------------------------
2271 
2272 // -------------------------------------------------------------------
2273 
2274 // SetupMessage
2275 
2276 // map<string, int32> entities = 1;
2277 inline int SetupMessage::_internal_entities_size() const {
2278  return _impl_.entities_.size();
2279 }
2280 inline int SetupMessage::entities_size() const {
2281  return _internal_entities_size();
2282 }
2283 inline void SetupMessage::clear_entities() {
2284  _impl_.entities_.Clear();
2285 }
2286 inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >&
2287 SetupMessage::_internal_entities() const {
2288  return _impl_.entities_.GetMap();
2289 }
2290 inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >&
2291 SetupMessage::entities() const {
2292  // @@protoc_insertion_point(field_map:tcp_io_device.SetupMessage.entities)
2293  return _internal_entities();
2294 }
2295 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >*
2296 SetupMessage::_internal_mutable_entities() {
2297  return _impl_.entities_.MutableMap();
2298 }
2299 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >*
2300 SetupMessage::mutable_entities() {
2301  // @@protoc_insertion_point(field_mutable_map:tcp_io_device.SetupMessage.entities)
2302  return _internal_mutable_entities();
2303 }
2304 
2305 // map<string, int32> objects = 2;
2306 inline int SetupMessage::_internal_objects_size() const {
2307  return _impl_.objects_.size();
2308 }
2309 inline int SetupMessage::objects_size() const {
2310  return _internal_objects_size();
2311 }
2312 inline void SetupMessage::clear_objects() {
2313  _impl_.objects_.Clear();
2314 }
2315 inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >&
2316 SetupMessage::_internal_objects() const {
2317  return _impl_.objects_.GetMap();
2318 }
2319 inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >&
2320 SetupMessage::objects() const {
2321  // @@protoc_insertion_point(field_map:tcp_io_device.SetupMessage.objects)
2322  return _internal_objects();
2323 }
2324 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >*
2325 SetupMessage::_internal_mutable_objects() {
2326  return _impl_.objects_.MutableMap();
2327 }
2328 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >*
2329 SetupMessage::mutable_objects() {
2330  // @@protoc_insertion_point(field_mutable_map:tcp_io_device.SetupMessage.objects)
2331  return _internal_mutable_objects();
2332 }
2333 
2334 // map<string, int32> commands = 3;
2335 inline int SetupMessage::_internal_commands_size() const {
2336  return _impl_.commands_.size();
2337 }
2338 inline int SetupMessage::commands_size() const {
2339  return _internal_commands_size();
2340 }
2341 inline void SetupMessage::clear_commands() {
2342  _impl_.commands_.Clear();
2343 }
2344 inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >&
2345 SetupMessage::_internal_commands() const {
2346  return _impl_.commands_.GetMap();
2347 }
2348 inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >&
2349 SetupMessage::commands() const {
2350  // @@protoc_insertion_point(field_map:tcp_io_device.SetupMessage.commands)
2351  return _internal_commands();
2352 }
2353 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >*
2354 SetupMessage::_internal_mutable_commands() {
2355  return _impl_.commands_.MutableMap();
2356 }
2357 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, int32_t >*
2358 SetupMessage::mutable_commands() {
2359  // @@protoc_insertion_point(field_mutable_map:tcp_io_device.SetupMessage.commands)
2360  return _internal_mutable_commands();
2361 }
2362 
2363 // repeated .tcp_io_device.CommandDescription commandDescriptions = 4;
2364 inline int SetupMessage::_internal_commanddescriptions_size() const {
2365  return _impl_.commanddescriptions_.size();
2366 }
2367 inline int SetupMessage::commanddescriptions_size() const {
2368  return _internal_commanddescriptions_size();
2369 }
2370 inline void SetupMessage::clear_commanddescriptions() {
2371  _impl_.commanddescriptions_.Clear();
2372 }
2373 inline ::tcp_io_device::CommandDescription* SetupMessage::mutable_commanddescriptions(int index) {
2374  // @@protoc_insertion_point(field_mutable:tcp_io_device.SetupMessage.commandDescriptions)
2375  return _impl_.commanddescriptions_.Mutable(index);
2376 }
2377 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tcp_io_device::CommandDescription >*
2378 SetupMessage::mutable_commanddescriptions() {
2379  // @@protoc_insertion_point(field_mutable_list:tcp_io_device.SetupMessage.commandDescriptions)
2380  return &_impl_.commanddescriptions_;
2381 }
2382 inline const ::tcp_io_device::CommandDescription& SetupMessage::_internal_commanddescriptions(int index) const {
2383  return _impl_.commanddescriptions_.Get(index);
2384 }
2385 inline const ::tcp_io_device::CommandDescription& SetupMessage::commanddescriptions(int index) const {
2386  // @@protoc_insertion_point(field_get:tcp_io_device.SetupMessage.commandDescriptions)
2387  return _internal_commanddescriptions(index);
2388 }
2389 inline ::tcp_io_device::CommandDescription* SetupMessage::_internal_add_commanddescriptions() {
2390  return _impl_.commanddescriptions_.Add();
2391 }
2392 inline ::tcp_io_device::CommandDescription* SetupMessage::add_commanddescriptions() {
2393  ::tcp_io_device::CommandDescription* _add = _internal_add_commanddescriptions();
2394  // @@protoc_insertion_point(field_add:tcp_io_device.SetupMessage.commandDescriptions)
2395  return _add;
2396 }
2397 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tcp_io_device::CommandDescription >&
2398 SetupMessage::commanddescriptions() const {
2399  // @@protoc_insertion_point(field_list:tcp_io_device.SetupMessage.commandDescriptions)
2400  return _impl_.commanddescriptions_;
2401 }
2402 
2403 // -------------------------------------------------------------------
2404 
2405 // CommandDescription
2406 
2407 // .tcp_io_device.VariableDescription description = 1;
2408 inline bool CommandDescription::_internal_has_description() const {
2409  return this != internal_default_instance() && _impl_.description_ != nullptr;
2410 }
2411 inline bool CommandDescription::has_description() const {
2412  return _internal_has_description();
2413 }
2414 inline void CommandDescription::clear_description() {
2415  if (GetArenaForAllocation() == nullptr && _impl_.description_ != nullptr) {
2416  delete _impl_.description_;
2417  }
2418  _impl_.description_ = nullptr;
2419 }
2420 inline const ::tcp_io_device::VariableDescription& CommandDescription::_internal_description() const {
2421  const ::tcp_io_device::VariableDescription* p = _impl_.description_;
2422  return p != nullptr ? *p : reinterpret_cast<const ::tcp_io_device::VariableDescription&>(
2423  ::tcp_io_device::_VariableDescription_default_instance_);
2424 }
2425 inline const ::tcp_io_device::VariableDescription& CommandDescription::description() const {
2426  // @@protoc_insertion_point(field_get:tcp_io_device.CommandDescription.description)
2427  return _internal_description();
2428 }
2429 inline void CommandDescription::unsafe_arena_set_allocated_description(
2430  ::tcp_io_device::VariableDescription* description) {
2431  if (GetArenaForAllocation() == nullptr) {
2432  delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.description_);
2433  }
2434  _impl_.description_ = description;
2435  if (description) {
2436 
2437  } else {
2438 
2439  }
2440  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tcp_io_device.CommandDescription.description)
2441 }
2442 inline ::tcp_io_device::VariableDescription* CommandDescription::release_description() {
2443 
2444  ::tcp_io_device::VariableDescription* temp = _impl_.description_;
2445  _impl_.description_ = nullptr;
2446 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2447  auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2448  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2449  if (GetArenaForAllocation() == nullptr) { delete old; }
2450 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2451  if (GetArenaForAllocation() != nullptr) {
2452  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2453  }
2454 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2455  return temp;
2456 }
2457 inline ::tcp_io_device::VariableDescription* CommandDescription::unsafe_arena_release_description() {
2458  // @@protoc_insertion_point(field_release:tcp_io_device.CommandDescription.description)
2459 
2460  ::tcp_io_device::VariableDescription* temp = _impl_.description_;
2461  _impl_.description_ = nullptr;
2462  return temp;
2463 }
2464 inline ::tcp_io_device::VariableDescription* CommandDescription::_internal_mutable_description() {
2465 
2466  if (_impl_.description_ == nullptr) {
2467  auto* p = CreateMaybeMessage<::tcp_io_device::VariableDescription>(GetArenaForAllocation());
2468  _impl_.description_ = p;
2469  }
2470  return _impl_.description_;
2471 }
2472 inline ::tcp_io_device::VariableDescription* CommandDescription::mutable_description() {
2473  ::tcp_io_device::VariableDescription* _msg = _internal_mutable_description();
2474  // @@protoc_insertion_point(field_mutable:tcp_io_device.CommandDescription.description)
2475  return _msg;
2476 }
2477 inline void CommandDescription::set_allocated_description(::tcp_io_device::VariableDescription* description) {
2478  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2479  if (message_arena == nullptr) {
2480  delete _impl_.description_;
2481  }
2482  if (description) {
2483  ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2484  ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(description);
2485  if (message_arena != submessage_arena) {
2486  description = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2487  message_arena, description, submessage_arena);
2488  }
2489 
2490  } else {
2491 
2492  }
2493  _impl_.description_ = description;
2494  // @@protoc_insertion_point(field_set_allocated:tcp_io_device.CommandDescription.description)
2495 }
2496 
2497 // string name = 2;
2498 inline void CommandDescription::clear_name() {
2499  _impl_.name_.ClearToEmpty();
2500 }
2501 inline const std::string& CommandDescription::name() const {
2502  // @@protoc_insertion_point(field_get:tcp_io_device.CommandDescription.name)
2503  return _internal_name();
2504 }
2505 template <typename ArgT0, typename... ArgT>
2506 inline PROTOBUF_ALWAYS_INLINE
2507 void CommandDescription::set_name(ArgT0&& arg0, ArgT... args) {
2508 
2509  _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2510  // @@protoc_insertion_point(field_set:tcp_io_device.CommandDescription.name)
2511 }
2512 inline std::string* CommandDescription::mutable_name() {
2513  std::string* _s = _internal_mutable_name();
2514  // @@protoc_insertion_point(field_mutable:tcp_io_device.CommandDescription.name)
2515  return _s;
2516 }
2517 inline const std::string& CommandDescription::_internal_name() const {
2518  return _impl_.name_.Get();
2519 }
2520 inline void CommandDescription::_internal_set_name(const std::string& value) {
2521 
2522  _impl_.name_.Set(value, GetArenaForAllocation());
2523 }
2524 inline std::string* CommandDescription::_internal_mutable_name() {
2525 
2526  return _impl_.name_.Mutable(GetArenaForAllocation());
2527 }
2528 inline std::string* CommandDescription::release_name() {
2529  // @@protoc_insertion_point(field_release:tcp_io_device.CommandDescription.name)
2530  return _impl_.name_.Release();
2531 }
2532 inline void CommandDescription::set_allocated_name(std::string* name) {
2533  if (name != nullptr) {
2534 
2535  } else {
2536 
2537  }
2538  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
2539 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2540  if (_impl_.name_.IsDefault()) {
2541  _impl_.name_.Set("", GetArenaForAllocation());
2542  }
2543 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2544  // @@protoc_insertion_point(field_set_allocated:tcp_io_device.CommandDescription.name)
2545 }
2546 
2547 // -------------------------------------------------------------------
2548 
2549 // DataMessage
2550 
2551 // repeated .tcp_io_device.ProtoVariable variables = 1;
2552 inline int DataMessage::_internal_variables_size() const {
2553  return _impl_.variables_.size();
2554 }
2555 inline int DataMessage::variables_size() const {
2556  return _internal_variables_size();
2557 }
2558 inline void DataMessage::clear_variables() {
2559  _impl_.variables_.Clear();
2560 }
2561 inline ::tcp_io_device::ProtoVariable* DataMessage::mutable_variables(int index) {
2562  // @@protoc_insertion_point(field_mutable:tcp_io_device.DataMessage.variables)
2563  return _impl_.variables_.Mutable(index);
2564 }
2565 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tcp_io_device::ProtoVariable >*
2566 DataMessage::mutable_variables() {
2567  // @@protoc_insertion_point(field_mutable_list:tcp_io_device.DataMessage.variables)
2568  return &_impl_.variables_;
2569 }
2570 inline const ::tcp_io_device::ProtoVariable& DataMessage::_internal_variables(int index) const {
2571  return _impl_.variables_.Get(index);
2572 }
2573 inline const ::tcp_io_device::ProtoVariable& DataMessage::variables(int index) const {
2574  // @@protoc_insertion_point(field_get:tcp_io_device.DataMessage.variables)
2575  return _internal_variables(index);
2576 }
2577 inline ::tcp_io_device::ProtoVariable* DataMessage::_internal_add_variables() {
2578  return _impl_.variables_.Add();
2579 }
2580 inline ::tcp_io_device::ProtoVariable* DataMessage::add_variables() {
2581  ::tcp_io_device::ProtoVariable* _add = _internal_add_variables();
2582  // @@protoc_insertion_point(field_add:tcp_io_device.DataMessage.variables)
2583  return _add;
2584 }
2585 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tcp_io_device::ProtoVariable >&
2586 DataMessage::variables() const {
2587  // @@protoc_insertion_point(field_list:tcp_io_device.DataMessage.variables)
2588  return _impl_.variables_;
2589 }
2590 
2591 // uint64 timeSpan = 2;
2592 inline void DataMessage::clear_timespan() {
2593  _impl_.timespan_ = uint64_t{0u};
2594 }
2595 inline uint64_t DataMessage::_internal_timespan() const {
2596  return _impl_.timespan_;
2597 }
2598 inline uint64_t DataMessage::timespan() const {
2599  // @@protoc_insertion_point(field_get:tcp_io_device.DataMessage.timeSpan)
2600  return _internal_timespan();
2601 }
2602 inline void DataMessage::_internal_set_timespan(uint64_t value) {
2603 
2604  _impl_.timespan_ = value;
2605 }
2606 inline void DataMessage::set_timespan(uint64_t value) {
2607  _internal_set_timespan(value);
2608  // @@protoc_insertion_point(field_set:tcp_io_device.DataMessage.timeSpan)
2609 }
2610 
2611 // -------------------------------------------------------------------
2612 
2613 // VariableDescription
2614 
2615 // int32 entityID = 1;
2616 inline void VariableDescription::clear_entityid() {
2617  _impl_.entityid_ = 0;
2618 }
2619 inline int32_t VariableDescription::_internal_entityid() const {
2620  return _impl_.entityid_;
2621 }
2622 inline int32_t VariableDescription::entityid() const {
2623  // @@protoc_insertion_point(field_get:tcp_io_device.VariableDescription.entityID)
2624  return _internal_entityid();
2625 }
2626 inline void VariableDescription::_internal_set_entityid(int32_t value) {
2627 
2628  _impl_.entityid_ = value;
2629 }
2630 inline void VariableDescription::set_entityid(int32_t value) {
2631  _internal_set_entityid(value);
2632  // @@protoc_insertion_point(field_set:tcp_io_device.VariableDescription.entityID)
2633 }
2634 
2635 // int32 ID = 2;
2636 inline void VariableDescription::clear_id() {
2637  _impl_.id_ = 0;
2638 }
2639 inline int32_t VariableDescription::_internal_id() const {
2640  return _impl_.id_;
2641 }
2642 inline int32_t VariableDescription::id() const {
2643  // @@protoc_insertion_point(field_get:tcp_io_device.VariableDescription.ID)
2644  return _internal_id();
2645 }
2646 inline void VariableDescription::_internal_set_id(int32_t value) {
2647 
2648  _impl_.id_ = value;
2649 }
2650 inline void VariableDescription::set_id(int32_t value) {
2651  _internal_set_id(value);
2652  // @@protoc_insertion_point(field_set:tcp_io_device.VariableDescription.ID)
2653 }
2654 
2655 // .tcp_io_device.VariableDescription.DataType dataType = 3;
2656 inline void VariableDescription::clear_datatype() {
2657  _impl_.datatype_ = 0;
2658 }
2659 inline ::tcp_io_device::VariableDescription_DataType VariableDescription::_internal_datatype() const {
2660  return static_cast< ::tcp_io_device::VariableDescription_DataType >(_impl_.datatype_);
2661 }
2662 inline ::tcp_io_device::VariableDescription_DataType VariableDescription::datatype() const {
2663  // @@protoc_insertion_point(field_get:tcp_io_device.VariableDescription.dataType)
2664  return _internal_datatype();
2665 }
2666 inline void VariableDescription::_internal_set_datatype(::tcp_io_device::VariableDescription_DataType value) {
2667 
2668  _impl_.datatype_ = value;
2669 }
2670 inline void VariableDescription::set_datatype(::tcp_io_device::VariableDescription_DataType value) {
2671  _internal_set_datatype(value);
2672  // @@protoc_insertion_point(field_set:tcp_io_device.VariableDescription.dataType)
2673 }
2674 
2675 // repeated uint64 dimensions = 4;
2676 inline int VariableDescription::_internal_dimensions_size() const {
2677  return _impl_.dimensions_.size();
2678 }
2679 inline int VariableDescription::dimensions_size() const {
2680  return _internal_dimensions_size();
2681 }
2682 inline void VariableDescription::clear_dimensions() {
2683  _impl_.dimensions_.Clear();
2684 }
2685 inline uint64_t VariableDescription::_internal_dimensions(int index) const {
2686  return _impl_.dimensions_.Get(index);
2687 }
2688 inline uint64_t VariableDescription::dimensions(int index) const {
2689  // @@protoc_insertion_point(field_get:tcp_io_device.VariableDescription.dimensions)
2690  return _internal_dimensions(index);
2691 }
2692 inline void VariableDescription::set_dimensions(int index, uint64_t value) {
2693  _impl_.dimensions_.Set(index, value);
2694  // @@protoc_insertion_point(field_set:tcp_io_device.VariableDescription.dimensions)
2695 }
2696 inline void VariableDescription::_internal_add_dimensions(uint64_t value) {
2697  _impl_.dimensions_.Add(value);
2698 }
2699 inline void VariableDescription::add_dimensions(uint64_t value) {
2700  _internal_add_dimensions(value);
2701  // @@protoc_insertion_point(field_add:tcp_io_device.VariableDescription.dimensions)
2702 }
2703 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
2704 VariableDescription::_internal_dimensions() const {
2705  return _impl_.dimensions_;
2706 }
2707 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
2708 VariableDescription::dimensions() const {
2709  // @@protoc_insertion_point(field_list:tcp_io_device.VariableDescription.dimensions)
2710  return _internal_dimensions();
2711 }
2712 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
2713 VariableDescription::_internal_mutable_dimensions() {
2714  return &_impl_.dimensions_;
2715 }
2716 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
2717 VariableDescription::mutable_dimensions() {
2718  // @@protoc_insertion_point(field_mutable_list:tcp_io_device.VariableDescription.dimensions)
2719  return _internal_mutable_dimensions();
2720 }
2721 
2722 // string opcode_string_handle = 5;
2723 inline void VariableDescription::clear_opcode_string_handle() {
2724  _impl_.opcode_string_handle_.ClearToEmpty();
2725 }
2726 inline const std::string& VariableDescription::opcode_string_handle() const {
2727  // @@protoc_insertion_point(field_get:tcp_io_device.VariableDescription.opcode_string_handle)
2728  return _internal_opcode_string_handle();
2729 }
2730 template <typename ArgT0, typename... ArgT>
2731 inline PROTOBUF_ALWAYS_INLINE
2732 void VariableDescription::set_opcode_string_handle(ArgT0&& arg0, ArgT... args) {
2733 
2734  _impl_.opcode_string_handle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2735  // @@protoc_insertion_point(field_set:tcp_io_device.VariableDescription.opcode_string_handle)
2736 }
2737 inline std::string* VariableDescription::mutable_opcode_string_handle() {
2738  std::string* _s = _internal_mutable_opcode_string_handle();
2739  // @@protoc_insertion_point(field_mutable:tcp_io_device.VariableDescription.opcode_string_handle)
2740  return _s;
2741 }
2742 inline const std::string& VariableDescription::_internal_opcode_string_handle() const {
2743  return _impl_.opcode_string_handle_.Get();
2744 }
2745 inline void VariableDescription::_internal_set_opcode_string_handle(const std::string& value) {
2746 
2747  _impl_.opcode_string_handle_.Set(value, GetArenaForAllocation());
2748 }
2749 inline std::string* VariableDescription::_internal_mutable_opcode_string_handle() {
2750 
2751  return _impl_.opcode_string_handle_.Mutable(GetArenaForAllocation());
2752 }
2753 inline std::string* VariableDescription::release_opcode_string_handle() {
2754  // @@protoc_insertion_point(field_release:tcp_io_device.VariableDescription.opcode_string_handle)
2755  return _impl_.opcode_string_handle_.Release();
2756 }
2757 inline void VariableDescription::set_allocated_opcode_string_handle(std::string* opcode_string_handle) {
2758  if (opcode_string_handle != nullptr) {
2759 
2760  } else {
2761 
2762  }
2763  _impl_.opcode_string_handle_.SetAllocated(opcode_string_handle, GetArenaForAllocation());
2764 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2765  if (_impl_.opcode_string_handle_.IsDefault()) {
2766  _impl_.opcode_string_handle_.Set("", GetArenaForAllocation());
2767  }
2768 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2769  // @@protoc_insertion_point(field_set_allocated:tcp_io_device.VariableDescription.opcode_string_handle)
2770 }
2771 
2772 // -------------------------------------------------------------------
2773 
2774 // ProtoVariable
2775 
2776 // .tcp_io_device.VariableDescription metaData = 1;
2777 inline bool ProtoVariable::_internal_has_metadata() const {
2778  return this != internal_default_instance() && _impl_.metadata_ != nullptr;
2779 }
2780 inline bool ProtoVariable::has_metadata() const {
2781  return _internal_has_metadata();
2782 }
2783 inline void ProtoVariable::clear_metadata() {
2784  if (GetArenaForAllocation() == nullptr && _impl_.metadata_ != nullptr) {
2785  delete _impl_.metadata_;
2786  }
2787  _impl_.metadata_ = nullptr;
2788 }
2789 inline const ::tcp_io_device::VariableDescription& ProtoVariable::_internal_metadata() const {
2790  const ::tcp_io_device::VariableDescription* p = _impl_.metadata_;
2791  return p != nullptr ? *p : reinterpret_cast<const ::tcp_io_device::VariableDescription&>(
2792  ::tcp_io_device::_VariableDescription_default_instance_);
2793 }
2794 inline const ::tcp_io_device::VariableDescription& ProtoVariable::metadata() const {
2795  // @@protoc_insertion_point(field_get:tcp_io_device.ProtoVariable.metaData)
2796  return _internal_metadata();
2797 }
2798 inline void ProtoVariable::unsafe_arena_set_allocated_metadata(
2799  ::tcp_io_device::VariableDescription* metadata) {
2800  if (GetArenaForAllocation() == nullptr) {
2801  delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.metadata_);
2802  }
2803  _impl_.metadata_ = metadata;
2804  if (metadata) {
2805 
2806  } else {
2807 
2808  }
2809  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tcp_io_device.ProtoVariable.metaData)
2810 }
2811 inline ::tcp_io_device::VariableDescription* ProtoVariable::release_metadata() {
2812 
2813  ::tcp_io_device::VariableDescription* temp = _impl_.metadata_;
2814  _impl_.metadata_ = nullptr;
2815 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2816  auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2817  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2818  if (GetArenaForAllocation() == nullptr) { delete old; }
2819 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2820  if (GetArenaForAllocation() != nullptr) {
2821  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2822  }
2823 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2824  return temp;
2825 }
2826 inline ::tcp_io_device::VariableDescription* ProtoVariable::unsafe_arena_release_metadata() {
2827  // @@protoc_insertion_point(field_release:tcp_io_device.ProtoVariable.metaData)
2828 
2829  ::tcp_io_device::VariableDescription* temp = _impl_.metadata_;
2830  _impl_.metadata_ = nullptr;
2831  return temp;
2832 }
2833 inline ::tcp_io_device::VariableDescription* ProtoVariable::_internal_mutable_metadata() {
2834 
2835  if (_impl_.metadata_ == nullptr) {
2836  auto* p = CreateMaybeMessage<::tcp_io_device::VariableDescription>(GetArenaForAllocation());
2837  _impl_.metadata_ = p;
2838  }
2839  return _impl_.metadata_;
2840 }
2841 inline ::tcp_io_device::VariableDescription* ProtoVariable::mutable_metadata() {
2842  ::tcp_io_device::VariableDescription* _msg = _internal_mutable_metadata();
2843  // @@protoc_insertion_point(field_mutable:tcp_io_device.ProtoVariable.metaData)
2844  return _msg;
2845 }
2846 inline void ProtoVariable::set_allocated_metadata(::tcp_io_device::VariableDescription* metadata) {
2847  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2848  if (message_arena == nullptr) {
2849  delete _impl_.metadata_;
2850  }
2851  if (metadata) {
2852  ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2853  ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(metadata);
2854  if (message_arena != submessage_arena) {
2855  metadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2856  message_arena, metadata, submessage_arena);
2857  }
2858 
2859  } else {
2860 
2861  }
2862  _impl_.metadata_ = metadata;
2863  // @@protoc_insertion_point(field_set_allocated:tcp_io_device.ProtoVariable.metaData)
2864 }
2865 
2866 // bytes data = 2;
2867 inline void ProtoVariable::clear_data() {
2868  _impl_.data_.ClearToEmpty();
2869 }
2870 inline const std::string& ProtoVariable::data() const {
2871  // @@protoc_insertion_point(field_get:tcp_io_device.ProtoVariable.data)
2872  return _internal_data();
2873 }
2874 template <typename ArgT0, typename... ArgT>
2875 inline PROTOBUF_ALWAYS_INLINE
2876 void ProtoVariable::set_data(ArgT0&& arg0, ArgT... args) {
2877 
2878  _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2879  // @@protoc_insertion_point(field_set:tcp_io_device.ProtoVariable.data)
2880 }
2881 inline std::string* ProtoVariable::mutable_data() {
2882  std::string* _s = _internal_mutable_data();
2883  // @@protoc_insertion_point(field_mutable:tcp_io_device.ProtoVariable.data)
2884  return _s;
2885 }
2886 inline const std::string& ProtoVariable::_internal_data() const {
2887  return _impl_.data_.Get();
2888 }
2889 inline void ProtoVariable::_internal_set_data(const std::string& value) {
2890 
2891  _impl_.data_.Set(value, GetArenaForAllocation());
2892 }
2893 inline std::string* ProtoVariable::_internal_mutable_data() {
2894 
2895  return _impl_.data_.Mutable(GetArenaForAllocation());
2896 }
2897 inline std::string* ProtoVariable::release_data() {
2898  // @@protoc_insertion_point(field_release:tcp_io_device.ProtoVariable.data)
2899  return _impl_.data_.Release();
2900 }
2901 inline void ProtoVariable::set_allocated_data(std::string* data) {
2902  if (data != nullptr) {
2903 
2904  } else {
2905 
2906  }
2907  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
2908 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2909  if (_impl_.data_.IsDefault()) {
2910  _impl_.data_.Set("", GetArenaForAllocation());
2911  }
2912 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2913  // @@protoc_insertion_point(field_set_allocated:tcp_io_device.ProtoVariable.data)
2914 }
2915 
2916 #ifdef __GNUC__
2917  #pragma GCC diagnostic pop
2918 #endif // __GNUC__
2919 // -------------------------------------------------------------------
2920 
2921 // -------------------------------------------------------------------
2922 
2923 // -------------------------------------------------------------------
2924 
2925 // -------------------------------------------------------------------
2926 
2927 // -------------------------------------------------------------------
2928 
2929 // -------------------------------------------------------------------
2930 
2931 // -------------------------------------------------------------------
2932 
2933 // -------------------------------------------------------------------
2934 
2935 // -------------------------------------------------------------------
2936 
2937 // -------------------------------------------------------------------
2938 
2939 
2940 // @@protoc_insertion_point(namespace_scope)
2941 
2942 } // namespace tcp_io_device
2943 
2944 PROTOBUF_NAMESPACE_OPEN
2945 
2946 template <> struct is_proto_enum< ::tcp_io_device::TCPMessage_Type> : ::std::true_type {};
2947 template <>
2948 inline const EnumDescriptor* GetEnumDescriptor< ::tcp_io_device::TCPMessage_Type>() {
2949  return ::tcp_io_device::TCPMessage_Type_descriptor();
2950 }
2951 template <> struct is_proto_enum< ::tcp_io_device::StartMessage_ReconnectionType> : ::std::true_type {};
2952 template <>
2953 inline const EnumDescriptor* GetEnumDescriptor< ::tcp_io_device::StartMessage_ReconnectionType>() {
2954  return ::tcp_io_device::StartMessage_ReconnectionType_descriptor();
2955 }
2956 template <> struct is_proto_enum< ::tcp_io_device::VariableDescription_DataType> : ::std::true_type {};
2957 template <>
2958 inline const EnumDescriptor* GetEnumDescriptor< ::tcp_io_device::VariableDescription_DataType>() {
2959  return ::tcp_io_device::VariableDescription_DataType_descriptor();
2960 }
2961 
2962 PROTOBUF_NAMESPACE_CLOSE
2963 
2964 // @@protoc_insertion_point(global_scope)
2965 
2966 #include <google/protobuf/port_undef.inc>
2967 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tcp_5fdata_5fmessage_2eproto
tcp_io_device::TCPMessage::Impl_::MessageUnion
Definition: tcp_data_message.pb.h:468
tcp_io_device::StartMessage
Definition: tcp_data_message.pb.h:486
tcp_io_device::CommandDescription
Definition: tcp_data_message.pb.h:1102
tcp_io_device::SetupMessage_ObjectsEntry_DoNotUse
Definition: tcp_data_message.pb.h:823
tcp_io_device::SetupMessage
Definition: tcp_data_message.pb.h:873
tcp_io_device::ProtoVariable
Definition: tcp_data_message.pb.h:1692
TableStruct_tcp_5fdata_5fmessage_2eproto
Definition: tcp_data_message.pb.h:48
tcp_io_device::DataMessage
Definition: tcp_data_message.pb.h:1275
tcp_io_device::VariableDescription
Definition: tcp_data_message.pb.h:1443
tcp_io_device::SetupMessage_EntitiesEntry_DoNotUse
Definition: tcp_data_message.pb.h:797
tcp_io_device::SetupMessage_CommandsEntry_DoNotUse
Definition: tcp_data_message.pb.h:849
tcp_io_device::StopMessage
Definition: tcp_data_message.pb.h:677
tcp_io_device::TCPMessage
Definition: tcp_data_message.pb.h:188
Generated by   doxygen 1.8.18