Ignition Msgs

API Reference

5.8.1
discovery.pb.h
Go to the documentation of this file.
1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: ignition/msgs/discovery.proto
3 
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_ignition_2fmsgs_2fdiscovery_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_ignition_2fmsgs_2fdiscovery_2eproto
6 
7 #include <limits>
8 #include <string>
9 
10 #include <google/protobuf/port_def.inc>
11 #if PROTOBUF_VERSION < 3014000
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 3014000 < 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_table_driven.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/generated_enum_reflection.h>
34 #include <google/protobuf/unknown_field_set.h>
36 #ifndef _MSC_VER
37 #pragma GCC system_header
38 #else
39 #pragma warning(push)
40 #pragma warning(disable: 4244 4267 4100 4244 4512 4127 4068 4275 4251)
41 #endif
42 #ifdef __linux__
43 #include <sys/sysmacros.h>
44 #endif
45 #include <memory>
46 #include <ignition/msgs/Export.hh>
47 // @@protoc_insertion_point(includes)
48 #include <google/protobuf/port_def.inc>
49 #define PROTOBUF_INTERNAL_EXPORT_ignition_2fmsgs_2fdiscovery_2eproto IGNITION_MSGS_VISIBLE
50 PROTOBUF_NAMESPACE_OPEN
51 namespace internal {
52 class AnyMetadata;
53 } // namespace internal
54 PROTOBUF_NAMESPACE_CLOSE
55 
56 // Internal implementation detail -- do not use these members.
58  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
59  PROTOBUF_SECTION_VARIABLE(protodesc_cold);
60  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
61  PROTOBUF_SECTION_VARIABLE(protodesc_cold);
62  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[6]
63  PROTOBUF_SECTION_VARIABLE(protodesc_cold);
64  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
65  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
66  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
67 };
68 extern IGNITION_MSGS_VISIBLE const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_ignition_2fmsgs_2fdiscovery_2eproto;
69 namespace ignition {
70 namespace msgs {
71 class Discovery;
72 class DiscoveryDefaultTypeInternal;
73 IGNITION_MSGS_VISIBLE extern DiscoveryDefaultTypeInternal _Discovery_default_instance_;
74 class Discovery_Flags;
75 class Discovery_FlagsDefaultTypeInternal;
76 IGNITION_MSGS_VISIBLE extern Discovery_FlagsDefaultTypeInternal _Discovery_Flags_default_instance_;
77 class Discovery_Publisher;
78 class Discovery_PublisherDefaultTypeInternal;
79 IGNITION_MSGS_VISIBLE extern Discovery_PublisherDefaultTypeInternal _Discovery_Publisher_default_instance_;
80 class Discovery_Publisher_MessagePublisher;
81 class Discovery_Publisher_MessagePublisherDefaultTypeInternal;
82 IGNITION_MSGS_VISIBLE extern Discovery_Publisher_MessagePublisherDefaultTypeInternal _Discovery_Publisher_MessagePublisher_default_instance_;
83 class Discovery_Publisher_ServicePublisher;
84 class Discovery_Publisher_ServicePublisherDefaultTypeInternal;
85 IGNITION_MSGS_VISIBLE extern Discovery_Publisher_ServicePublisherDefaultTypeInternal _Discovery_Publisher_ServicePublisher_default_instance_;
86 class Discovery_Subscriber;
87 class Discovery_SubscriberDefaultTypeInternal;
88 IGNITION_MSGS_VISIBLE extern Discovery_SubscriberDefaultTypeInternal _Discovery_Subscriber_default_instance_;
89 } // namespace msgs
90 } // namespace ignition
91 PROTOBUF_NAMESPACE_OPEN
92 template<> IGNITION_MSGS_VISIBLE ::ignition::msgs::Discovery* Arena::CreateMaybeMessage<::ignition::msgs::Discovery>(Arena*);
93 template<> IGNITION_MSGS_VISIBLE ::ignition::msgs::Discovery_Flags* Arena::CreateMaybeMessage<::ignition::msgs::Discovery_Flags>(Arena*);
94 template<> IGNITION_MSGS_VISIBLE ::ignition::msgs::Discovery_Publisher* Arena::CreateMaybeMessage<::ignition::msgs::Discovery_Publisher>(Arena*);
95 template<> IGNITION_MSGS_VISIBLE ::ignition::msgs::Discovery_Publisher_MessagePublisher* Arena::CreateMaybeMessage<::ignition::msgs::Discovery_Publisher_MessagePublisher>(Arena*);
96 template<> IGNITION_MSGS_VISIBLE ::ignition::msgs::Discovery_Publisher_ServicePublisher* Arena::CreateMaybeMessage<::ignition::msgs::Discovery_Publisher_ServicePublisher>(Arena*);
97 template<> IGNITION_MSGS_VISIBLE ::ignition::msgs::Discovery_Subscriber* Arena::CreateMaybeMessage<::ignition::msgs::Discovery_Subscriber>(Arena*);
98 PROTOBUF_NAMESPACE_CLOSE
99 namespace ignition {
100 namespace msgs {
101 
108 };
109 IGNITION_MSGS_VISIBLE bool Discovery_Publisher_Scope_IsValid(int value);
113 
114 IGNITION_MSGS_VISIBLE const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Discovery_Publisher_Scope_descriptor();
115 template<typename T>
116 inline const std::string& Discovery_Publisher_Scope_Name(T enum_t_value) {
119  "Incorrect type passed to function Discovery_Publisher_Scope_Name.");
120  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
121  Discovery_Publisher_Scope_descriptor(), enum_t_value);
122 }
124  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Discovery_Publisher_Scope* value) {
125  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Discovery_Publisher_Scope>(
126  Discovery_Publisher_Scope_descriptor(), name, value);
127 }
128 enum Discovery_Type : int {
139 };
140 IGNITION_MSGS_VISIBLE bool Discovery_Type_IsValid(int value);
144 
145 IGNITION_MSGS_VISIBLE const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Discovery_Type_descriptor();
146 template<typename T>
147 inline const std::string& Discovery_Type_Name(T enum_t_value) {
148  static_assert(::std::is_same<T, Discovery_Type>::value ||
150  "Incorrect type passed to function Discovery_Type_Name.");
151  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
152  Discovery_Type_descriptor(), enum_t_value);
153 }
155  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Discovery_Type* value) {
156  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Discovery_Type>(
157  Discovery_Type_descriptor(), name, value);
158 }
159 // ===================================================================
160 
161 class IGNITION_MSGS_VISIBLE Discovery_Flags PROTOBUF_FINAL :
162  public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ignition.msgs.Discovery.Flags) */ {
163  public:
164  inline Discovery_Flags() : Discovery_Flags(nullptr) {}
165  virtual ~Discovery_Flags();
166 
167  Discovery_Flags(const Discovery_Flags& from);
168  Discovery_Flags(Discovery_Flags&& from) noexcept
169  : Discovery_Flags() {
170  *this = ::std::move(from);
171  }
172 
173  inline Discovery_Flags& operator=(const Discovery_Flags& from) {
174  CopyFrom(from);
175  return *this;
176  }
177  inline Discovery_Flags& operator=(Discovery_Flags&& from) noexcept {
178  if (GetArena() == from.GetArena()) {
179  if (this != &from) InternalSwap(&from);
180  } else {
181  CopyFrom(from);
182  }
183  return *this;
184  }
185 
186  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
187  return GetDescriptor();
188  }
189  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
190  return GetMetadataStatic().descriptor;
191  }
192  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
193  return GetMetadataStatic().reflection;
194  }
195  static const Discovery_Flags& default_instance();
196 
197  static inline const Discovery_Flags* internal_default_instance() {
198  return reinterpret_cast<const Discovery_Flags*>(
200  }
201  static constexpr int kIndexInFileMessages =
202  0;
203 
204  friend void swap(Discovery_Flags& a, Discovery_Flags& b) {
205  a.Swap(&b);
206  }
207  inline void Swap(Discovery_Flags* other) {
208  if (other == this) return;
209  if (GetArena() == other->GetArena()) {
210  InternalSwap(other);
211  } else {
212  ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
213  }
214  }
215  void UnsafeArenaSwap(Discovery_Flags* other) {
216  if (other == this) return;
217  GOOGLE_DCHECK(GetArena() == other->GetArena());
218  InternalSwap(other);
219  }
220 
221  // implements Message ----------------------------------------------
222 
223  inline Discovery_Flags* New() const final {
224  return CreateMaybeMessage<Discovery_Flags>(nullptr);
225  }
226 
227  Discovery_Flags* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
228  return CreateMaybeMessage<Discovery_Flags>(arena);
229  }
230  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
231  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
232  void CopyFrom(const Discovery_Flags& from);
233  void MergeFrom(const Discovery_Flags& from);
234  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
235  bool IsInitialized() const final;
236 
237  size_t ByteSizeLong() const final;
238  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
239  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
240  ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
241  int GetCachedSize() const final { return _cached_size_.Get(); }
242 
243  private:
244  inline void SharedCtor();
245  inline void SharedDtor();
246  void SetCachedSize(int size) const final;
247  void InternalSwap(Discovery_Flags* other);
248  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
249  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
250  return "ignition.msgs.Discovery.Flags";
251  }
252  protected:
253  explicit Discovery_Flags(::PROTOBUF_NAMESPACE_ID::Arena* arena);
254  private:
255  static void ArenaDtor(void* object);
256  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
257  public:
258 
259  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
260  private:
261  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
262  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_ignition_2fmsgs_2fdiscovery_2eproto);
263  return ::descriptor_table_ignition_2fmsgs_2fdiscovery_2eproto.file_level_metadata[kIndexInFileMessages];
264  }
265 
266  public:
267 
268  // nested types ----------------------------------------------------
269 
270  // accessors -------------------------------------------------------
271 
272  enum : int {
273  kRelayFieldNumber = 1,
274  kNoRelayFieldNumber = 2,
275  };
276  // bool relay = 1;
277  void clear_relay();
278  bool relay() const;
279  void set_relay(bool value);
280  private:
281  bool _internal_relay() const;
282  void _internal_set_relay(bool value);
283  public:
284 
285  // bool no_relay = 2;
287  bool no_relay() const;
288  void set_no_relay(bool value);
289  private:
290  bool _internal_no_relay() const;
291  void _internal_set_no_relay(bool value);
292  public:
293 
294  // @@protoc_insertion_point(class_scope:ignition.msgs.Discovery.Flags)
295  private:
296  class _Internal;
297 
298  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
299  typedef void InternalArenaConstructable_;
300  typedef void DestructorSkippable_;
301  bool relay_;
302  bool no_relay_;
303  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
304  friend struct ::TableStruct_ignition_2fmsgs_2fdiscovery_2eproto;
305 };
306 // -------------------------------------------------------------------
307 
308 class IGNITION_MSGS_VISIBLE Discovery_Subscriber PROTOBUF_FINAL :
309  public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ignition.msgs.Discovery.Subscriber) */ {
310  public:
311  inline Discovery_Subscriber() : Discovery_Subscriber(nullptr) {}
313 
314  Discovery_Subscriber(const Discovery_Subscriber& from);
315  Discovery_Subscriber(Discovery_Subscriber&& from) noexcept
316  : Discovery_Subscriber() {
317  *this = ::std::move(from);
318  }
319 
320  inline Discovery_Subscriber& operator=(const Discovery_Subscriber& from) {
321  CopyFrom(from);
322  return *this;
323  }
324  inline Discovery_Subscriber& operator=(Discovery_Subscriber&& from) noexcept {
325  if (GetArena() == from.GetArena()) {
326  if (this != &from) InternalSwap(&from);
327  } else {
328  CopyFrom(from);
329  }
330  return *this;
331  }
332 
333  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
334  return GetDescriptor();
335  }
336  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
337  return GetMetadataStatic().descriptor;
338  }
339  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
340  return GetMetadataStatic().reflection;
341  }
342  static const Discovery_Subscriber& default_instance();
343 
344  static inline const Discovery_Subscriber* internal_default_instance() {
345  return reinterpret_cast<const Discovery_Subscriber*>(
347  }
348  static constexpr int kIndexInFileMessages =
349  1;
350 
351  friend void swap(Discovery_Subscriber& a, Discovery_Subscriber& b) {
352  a.Swap(&b);
353  }
354  inline void Swap(Discovery_Subscriber* other) {
355  if (other == this) return;
356  if (GetArena() == other->GetArena()) {
357  InternalSwap(other);
358  } else {
359  ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
360  }
361  }
362  void UnsafeArenaSwap(Discovery_Subscriber* other) {
363  if (other == this) return;
364  GOOGLE_DCHECK(GetArena() == other->GetArena());
365  InternalSwap(other);
366  }
367 
368  // implements Message ----------------------------------------------
369 
370  inline Discovery_Subscriber* New() const final {
371  return CreateMaybeMessage<Discovery_Subscriber>(nullptr);
372  }
373 
374  Discovery_Subscriber* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
375  return CreateMaybeMessage<Discovery_Subscriber>(arena);
376  }
377  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
378  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
379  void CopyFrom(const Discovery_Subscriber& from);
380  void MergeFrom(const Discovery_Subscriber& from);
381  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
382  bool IsInitialized() const final;
383 
384  size_t ByteSizeLong() const final;
385  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
386  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
387  ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
388  int GetCachedSize() const final { return _cached_size_.Get(); }
389 
390  private:
391  inline void SharedCtor();
392  inline void SharedDtor();
393  void SetCachedSize(int size) const final;
394  void InternalSwap(Discovery_Subscriber* other);
395  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
396  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
397  return "ignition.msgs.Discovery.Subscriber";
398  }
399  protected:
400  explicit Discovery_Subscriber(::PROTOBUF_NAMESPACE_ID::Arena* arena);
401  private:
402  static void ArenaDtor(void* object);
403  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
404  public:
405 
406  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
407  private:
408  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
409  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_ignition_2fmsgs_2fdiscovery_2eproto);
410  return ::descriptor_table_ignition_2fmsgs_2fdiscovery_2eproto.file_level_metadata[kIndexInFileMessages];
411  }
412 
413  public:
414 
415  // nested types ----------------------------------------------------
416 
417  // accessors -------------------------------------------------------
418 
419  enum : int {
420  kTopicFieldNumber = 1,
421  };
422  // string topic = 1;
423  void clear_topic();
424  const std::string& topic() const;
425  void set_topic(const std::string& value);
426  void set_topic(std::string&& value);
427  void set_topic(const char* value);
428  void set_topic(const char* value, size_t size);
432  private:
433  const std::string& _internal_topic() const;
434  void _internal_set_topic(const std::string& value);
435  std::string* _internal_mutable_topic();
436  public:
437 
438  // @@protoc_insertion_point(class_scope:ignition.msgs.Discovery.Subscriber)
439  private:
440  class _Internal;
441 
442  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
443  typedef void InternalArenaConstructable_;
444  typedef void DestructorSkippable_;
445  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr topic_;
446  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
447  friend struct ::TableStruct_ignition_2fmsgs_2fdiscovery_2eproto;
448 };
449 // -------------------------------------------------------------------
450 
451 class IGNITION_MSGS_VISIBLE Discovery_Publisher_MessagePublisher PROTOBUF_FINAL :
452  public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ignition.msgs.Discovery.Publisher.MessagePublisher) */ {
453  public:
454  inline Discovery_Publisher_MessagePublisher() : Discovery_Publisher_MessagePublisher(nullptr) {}
456 
457  Discovery_Publisher_MessagePublisher(const Discovery_Publisher_MessagePublisher& from);
458  Discovery_Publisher_MessagePublisher(Discovery_Publisher_MessagePublisher&& from) noexcept
459  : Discovery_Publisher_MessagePublisher() {
460  *this = ::std::move(from);
461  }
462 
463  inline Discovery_Publisher_MessagePublisher& operator=(const Discovery_Publisher_MessagePublisher& from) {
464  CopyFrom(from);
465  return *this;
466  }
467  inline Discovery_Publisher_MessagePublisher& operator=(Discovery_Publisher_MessagePublisher&& from) noexcept {
468  if (GetArena() == from.GetArena()) {
469  if (this != &from) InternalSwap(&from);
470  } else {
471  CopyFrom(from);
472  }
473  return *this;
474  }
475 
476  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
477  return GetDescriptor();
478  }
479  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
480  return GetMetadataStatic().descriptor;
481  }
482  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
483  return GetMetadataStatic().reflection;
484  }
485  static const Discovery_Publisher_MessagePublisher& default_instance();
486 
487  static inline const Discovery_Publisher_MessagePublisher* internal_default_instance() {
488  return reinterpret_cast<const Discovery_Publisher_MessagePublisher*>(
490  }
491  static constexpr int kIndexInFileMessages =
492  2;
493 
494  friend void swap(Discovery_Publisher_MessagePublisher& a, Discovery_Publisher_MessagePublisher& b) {
495  a.Swap(&b);
496  }
497  inline void Swap(Discovery_Publisher_MessagePublisher* other) {
498  if (other == this) return;
499  if (GetArena() == other->GetArena()) {
500  InternalSwap(other);
501  } else {
502  ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
503  }
504  }
505  void UnsafeArenaSwap(Discovery_Publisher_MessagePublisher* other) {
506  if (other == this) return;
507  GOOGLE_DCHECK(GetArena() == other->GetArena());
508  InternalSwap(other);
509  }
510 
511  // implements Message ----------------------------------------------
512 
513  inline Discovery_Publisher_MessagePublisher* New() const final {
514  return CreateMaybeMessage<Discovery_Publisher_MessagePublisher>(nullptr);
515  }
516 
517  Discovery_Publisher_MessagePublisher* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
518  return CreateMaybeMessage<Discovery_Publisher_MessagePublisher>(arena);
519  }
520  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
521  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
522  void CopyFrom(const Discovery_Publisher_MessagePublisher& from);
523  void MergeFrom(const Discovery_Publisher_MessagePublisher& from);
524  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
525  bool IsInitialized() const final;
526 
527  size_t ByteSizeLong() const final;
528  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
529  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
530  ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
531  int GetCachedSize() const final { return _cached_size_.Get(); }
532 
533  private:
534  inline void SharedCtor();
535  inline void SharedDtor();
536  void SetCachedSize(int size) const final;
537  void InternalSwap(Discovery_Publisher_MessagePublisher* other);
538  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
539  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
540  return "ignition.msgs.Discovery.Publisher.MessagePublisher";
541  }
542  protected:
543  explicit Discovery_Publisher_MessagePublisher(::PROTOBUF_NAMESPACE_ID::Arena* arena);
544  private:
545  static void ArenaDtor(void* object);
546  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
547  public:
548 
549  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
550  private:
551  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
552  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_ignition_2fmsgs_2fdiscovery_2eproto);
553  return ::descriptor_table_ignition_2fmsgs_2fdiscovery_2eproto.file_level_metadata[kIndexInFileMessages];
554  }
555 
556  public:
557 
558  // nested types ----------------------------------------------------
559 
560  // accessors -------------------------------------------------------
561 
562  enum : int {
563  kCtrlFieldNumber = 1,
564  kMsgTypeFieldNumber = 2,
565  kMsgsPerSecFieldNumber = 4,
566  kThrottledFieldNumber = 3,
567  };
568  // string ctrl = 1;
569  void clear_ctrl();
570  const std::string& ctrl() const;
571  void set_ctrl(const std::string& value);
572  void set_ctrl(std::string&& value);
573  void set_ctrl(const char* value);
574  void set_ctrl(const char* value, size_t size);
578  private:
579  const std::string& _internal_ctrl() const;
580  void _internal_set_ctrl(const std::string& value);
581  std::string* _internal_mutable_ctrl();
582  public:
583 
584  // string msg_type = 2;
586  const std::string& msg_type() const;
587  void set_msg_type(const std::string& value);
588  void set_msg_type(std::string&& value);
589  void set_msg_type(const char* value);
590  void set_msg_type(const char* value, size_t size);
594  private:
595  const std::string& _internal_msg_type() const;
596  void _internal_set_msg_type(const std::string& value);
597  std::string* _internal_mutable_msg_type();
598  public:
599 
600  // uint64 msgs_per_sec = 4;
602  ::PROTOBUF_NAMESPACE_ID::uint64 msgs_per_sec() const;
603  void set_msgs_per_sec(::PROTOBUF_NAMESPACE_ID::uint64 value);
604  private:
605  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_msgs_per_sec() const;
606  void _internal_set_msgs_per_sec(::PROTOBUF_NAMESPACE_ID::uint64 value);
607  public:
608 
609  // bool throttled = 3;
611  bool throttled() const;
612  void set_throttled(bool value);
613  private:
614  bool _internal_throttled() const;
615  void _internal_set_throttled(bool value);
616  public:
617 
618  // @@protoc_insertion_point(class_scope:ignition.msgs.Discovery.Publisher.MessagePublisher)
619  private:
620  class _Internal;
621 
622  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
623  typedef void InternalArenaConstructable_;
624  typedef void DestructorSkippable_;
625  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ctrl_;
626  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr msg_type_;
627  ::PROTOBUF_NAMESPACE_ID::uint64 msgs_per_sec_;
628  bool throttled_;
629  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
630  friend struct ::TableStruct_ignition_2fmsgs_2fdiscovery_2eproto;
631 };
632 // -------------------------------------------------------------------
633 
634 class IGNITION_MSGS_VISIBLE Discovery_Publisher_ServicePublisher PROTOBUF_FINAL :
635  public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ignition.msgs.Discovery.Publisher.ServicePublisher) */ {
636  public:
637  inline Discovery_Publisher_ServicePublisher() : Discovery_Publisher_ServicePublisher(nullptr) {}
639 
640  Discovery_Publisher_ServicePublisher(const Discovery_Publisher_ServicePublisher& from);
641  Discovery_Publisher_ServicePublisher(Discovery_Publisher_ServicePublisher&& from) noexcept
642  : Discovery_Publisher_ServicePublisher() {
643  *this = ::std::move(from);
644  }
645 
646  inline Discovery_Publisher_ServicePublisher& operator=(const Discovery_Publisher_ServicePublisher& from) {
647  CopyFrom(from);
648  return *this;
649  }
650  inline Discovery_Publisher_ServicePublisher& operator=(Discovery_Publisher_ServicePublisher&& from) noexcept {
651  if (GetArena() == from.GetArena()) {
652  if (this != &from) InternalSwap(&from);
653  } else {
654  CopyFrom(from);
655  }
656  return *this;
657  }
658 
659  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
660  return GetDescriptor();
661  }
662  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
663  return GetMetadataStatic().descriptor;
664  }
665  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
666  return GetMetadataStatic().reflection;
667  }
668  static const Discovery_Publisher_ServicePublisher& default_instance();
669 
670  static inline const Discovery_Publisher_ServicePublisher* internal_default_instance() {
671  return reinterpret_cast<const Discovery_Publisher_ServicePublisher*>(
673  }
674  static constexpr int kIndexInFileMessages =
675  3;
676 
677  friend void swap(Discovery_Publisher_ServicePublisher& a, Discovery_Publisher_ServicePublisher& b) {
678  a.Swap(&b);
679  }
680  inline void Swap(Discovery_Publisher_ServicePublisher* other) {
681  if (other == this) return;
682  if (GetArena() == other->GetArena()) {
683  InternalSwap(other);
684  } else {
685  ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
686  }
687  }
688  void UnsafeArenaSwap(Discovery_Publisher_ServicePublisher* other) {
689  if (other == this) return;
690  GOOGLE_DCHECK(GetArena() == other->GetArena());
691  InternalSwap(other);
692  }
693 
694  // implements Message ----------------------------------------------
695 
696  inline Discovery_Publisher_ServicePublisher* New() const final {
697  return CreateMaybeMessage<Discovery_Publisher_ServicePublisher>(nullptr);
698  }
699 
700  Discovery_Publisher_ServicePublisher* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
701  return CreateMaybeMessage<Discovery_Publisher_ServicePublisher>(arena);
702  }
703  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
704  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
705  void CopyFrom(const Discovery_Publisher_ServicePublisher& from);
706  void MergeFrom(const Discovery_Publisher_ServicePublisher& from);
707  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
708  bool IsInitialized() const final;
709 
710  size_t ByteSizeLong() const final;
711  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
712  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
713  ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
714  int GetCachedSize() const final { return _cached_size_.Get(); }
715 
716  private:
717  inline void SharedCtor();
718  inline void SharedDtor();
719  void SetCachedSize(int size) const final;
720  void InternalSwap(Discovery_Publisher_ServicePublisher* other);
721  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
722  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
723  return "ignition.msgs.Discovery.Publisher.ServicePublisher";
724  }
725  protected:
726  explicit Discovery_Publisher_ServicePublisher(::PROTOBUF_NAMESPACE_ID::Arena* arena);
727  private:
728  static void ArenaDtor(void* object);
729  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
730  public:
731 
732  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
733  private:
734  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
735  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_ignition_2fmsgs_2fdiscovery_2eproto);
736  return ::descriptor_table_ignition_2fmsgs_2fdiscovery_2eproto.file_level_metadata[kIndexInFileMessages];
737  }
738 
739  public:
740 
741  // nested types ----------------------------------------------------
742 
743  // accessors -------------------------------------------------------
744 
745  enum : int {
746  kSocketIdFieldNumber = 1,
747  kRequestTypeFieldNumber = 2,
748  kResponseTypeFieldNumber = 3,
749  };
750  // string socket_id = 1;
752  const std::string& socket_id() const;
753  void set_socket_id(const std::string& value);
754  void set_socket_id(std::string&& value);
755  void set_socket_id(const char* value);
756  void set_socket_id(const char* value, size_t size);
760  private:
761  const std::string& _internal_socket_id() const;
762  void _internal_set_socket_id(const std::string& value);
763  std::string* _internal_mutable_socket_id();
764  public:
765 
766  // string request_type = 2;
768  const std::string& request_type() const;
769  void set_request_type(const std::string& value);
771  void set_request_type(const char* value);
772  void set_request_type(const char* value, size_t size);
776  private:
777  const std::string& _internal_request_type() const;
778  void _internal_set_request_type(const std::string& value);
779  std::string* _internal_mutable_request_type();
780  public:
781 
782  // string response_type = 3;
784  const std::string& response_type() const;
785  void set_response_type(const std::string& value);
787  void set_response_type(const char* value);
788  void set_response_type(const char* value, size_t size);
792  private:
793  const std::string& _internal_response_type() const;
794  void _internal_set_response_type(const std::string& value);
795  std::string* _internal_mutable_response_type();
796  public:
797 
798  // @@protoc_insertion_point(class_scope:ignition.msgs.Discovery.Publisher.ServicePublisher)
799  private:
800  class _Internal;
801 
802  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
803  typedef void InternalArenaConstructable_;
804  typedef void DestructorSkippable_;
805  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr socket_id_;
806  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_type_;
807  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr response_type_;
808  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
809  friend struct ::TableStruct_ignition_2fmsgs_2fdiscovery_2eproto;
810 };
811 // -------------------------------------------------------------------
812 
813 class IGNITION_MSGS_VISIBLE Discovery_Publisher PROTOBUF_FINAL :
814  public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ignition.msgs.Discovery.Publisher) */ {
815  public:
816  inline Discovery_Publisher() : Discovery_Publisher(nullptr) {}
818 
819  Discovery_Publisher(const Discovery_Publisher& from);
820  Discovery_Publisher(Discovery_Publisher&& from) noexcept
821  : Discovery_Publisher() {
822  *this = ::std::move(from);
823  }
824 
825  inline Discovery_Publisher& operator=(const Discovery_Publisher& from) {
826  CopyFrom(from);
827  return *this;
828  }
829  inline Discovery_Publisher& operator=(Discovery_Publisher&& from) noexcept {
830  if (GetArena() == from.GetArena()) {
831  if (this != &from) InternalSwap(&from);
832  } else {
833  CopyFrom(from);
834  }
835  return *this;
836  }
837 
838  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
839  return GetDescriptor();
840  }
841  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
842  return GetMetadataStatic().descriptor;
843  }
844  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
845  return GetMetadataStatic().reflection;
846  }
847  static const Discovery_Publisher& default_instance();
848 
849  enum PubTypeCase {
850  kMsgPub = 6,
851  kSrvPub = 7,
852  PUB_TYPE_NOT_SET = 0,
853  };
854 
855  static inline const Discovery_Publisher* internal_default_instance() {
856  return reinterpret_cast<const Discovery_Publisher*>(
858  }
859  static constexpr int kIndexInFileMessages =
860  4;
861 
862  friend void swap(Discovery_Publisher& a, Discovery_Publisher& b) {
863  a.Swap(&b);
864  }
865  inline void Swap(Discovery_Publisher* other) {
866  if (other == this) return;
867  if (GetArena() == other->GetArena()) {
868  InternalSwap(other);
869  } else {
870  ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
871  }
872  }
873  void UnsafeArenaSwap(Discovery_Publisher* other) {
874  if (other == this) return;
875  GOOGLE_DCHECK(GetArena() == other->GetArena());
876  InternalSwap(other);
877  }
878 
879  // implements Message ----------------------------------------------
880 
881  inline Discovery_Publisher* New() const final {
882  return CreateMaybeMessage<Discovery_Publisher>(nullptr);
883  }
884 
885  Discovery_Publisher* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
886  return CreateMaybeMessage<Discovery_Publisher>(arena);
887  }
888  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
889  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
890  void CopyFrom(const Discovery_Publisher& from);
891  void MergeFrom(const Discovery_Publisher& from);
892  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
893  bool IsInitialized() const final;
894 
895  size_t ByteSizeLong() const final;
896  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
897  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
898  ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
899  int GetCachedSize() const final { return _cached_size_.Get(); }
900 
901  private:
902  inline void SharedCtor();
903  inline void SharedDtor();
904  void SetCachedSize(int size) const final;
905  void InternalSwap(Discovery_Publisher* other);
906  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
907  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
908  return "ignition.msgs.Discovery.Publisher";
909  }
910  protected:
911  explicit Discovery_Publisher(::PROTOBUF_NAMESPACE_ID::Arena* arena);
912  private:
913  static void ArenaDtor(void* object);
914  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
915  public:
916 
917  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
918  private:
919  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
920  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_ignition_2fmsgs_2fdiscovery_2eproto);
921  return ::descriptor_table_ignition_2fmsgs_2fdiscovery_2eproto.file_level_metadata[kIndexInFileMessages];
922  }
923 
924  public:
925 
926  // nested types ----------------------------------------------------
927 
928  typedef Discovery_Publisher_MessagePublisher MessagePublisher;
929  typedef Discovery_Publisher_ServicePublisher ServicePublisher;
930 
932  static constexpr Scope PROCESS =
934  static constexpr Scope HOST =
936  static constexpr Scope ALL =
938  static inline bool Scope_IsValid(int value) {
939  return Discovery_Publisher_Scope_IsValid(value);
940  }
941  static constexpr Scope Scope_MIN =
943  static constexpr Scope Scope_MAX =
945  static constexpr int Scope_ARRAYSIZE =
947  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
950  }
951  template<typename T>
952  static inline const std::string& Scope_Name(T enum_t_value) {
953  static_assert(::std::is_same<T, Scope>::value ||
955  "Incorrect type passed to function Scope_Name.");
956  return Discovery_Publisher_Scope_Name(enum_t_value);
957  }
958  static inline bool Scope_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
959  Scope* value) {
960  return Discovery_Publisher_Scope_Parse(name, value);
961  }
962 
963  // accessors -------------------------------------------------------
964 
965  enum : int {
966  kTopicFieldNumber = 1,
967  kAddressFieldNumber = 2,
968  kProcessUuidFieldNumber = 3,
969  kNodeUuidFieldNumber = 4,
970  kScopeFieldNumber = 5,
971  kMsgPubFieldNumber = 6,
972  kSrvPubFieldNumber = 7,
973  };
974  // string topic = 1;
975  void clear_topic();
976  const std::string& topic() const;
977  void set_topic(const std::string& value);
978  void set_topic(std::string&& value);
979  void set_topic(const char* value);
980  void set_topic(const char* value, size_t size);
984  private:
985  const std::string& _internal_topic() const;
986  void _internal_set_topic(const std::string& value);
987  std::string* _internal_mutable_topic();
988  public:
989 
990  // string address = 2;
992  const std::string& address() const;
993  void set_address(const std::string& value);
994  void set_address(std::string&& value);
995  void set_address(const char* value);
996  void set_address(const char* value, size_t size);
1000  private:
1001  const std::string& _internal_address() const;
1002  void _internal_set_address(const std::string& value);
1003  std::string* _internal_mutable_address();
1004  public:
1005 
1006  // string process_uuid = 3;
1008  const std::string& process_uuid() const;
1009  void set_process_uuid(const std::string& value);
1011  void set_process_uuid(const char* value);
1012  void set_process_uuid(const char* value, size_t size);
1016  private:
1017  const std::string& _internal_process_uuid() const;
1018  void _internal_set_process_uuid(const std::string& value);
1019  std::string* _internal_mutable_process_uuid();
1020  public:
1021 
1022  // string node_uuid = 4;
1024  const std::string& node_uuid() const;
1025  void set_node_uuid(const std::string& value);
1027  void set_node_uuid(const char* value);
1028  void set_node_uuid(const char* value, size_t size);
1032  private:
1033  const std::string& _internal_node_uuid() const;
1034  void _internal_set_node_uuid(const std::string& value);
1035  std::string* _internal_mutable_node_uuid();
1036  public:
1037 
1038  // .ignition.msgs.Discovery.Publisher.Scope scope = 5;
1039  void clear_scope();
1042  private:
1043  ::ignition::msgs::Discovery_Publisher_Scope _internal_scope() const;
1044  void _internal_set_scope(::ignition::msgs::Discovery_Publisher_Scope value);
1045  public:
1046 
1047  // .ignition.msgs.Discovery.Publisher.MessagePublisher msg_pub = 6;
1048  bool has_msg_pub() const;
1049  private:
1050  bool _internal_has_msg_pub() const;
1051  public:
1053  const ::ignition::msgs::Discovery_Publisher_MessagePublisher& msg_pub() const;
1054  ::ignition::msgs::Discovery_Publisher_MessagePublisher* release_msg_pub();
1055  ::ignition::msgs::Discovery_Publisher_MessagePublisher* mutable_msg_pub();
1056  void set_allocated_msg_pub(::ignition::msgs::Discovery_Publisher_MessagePublisher* msg_pub);
1057  private:
1058  const ::ignition::msgs::Discovery_Publisher_MessagePublisher& _internal_msg_pub() const;
1059  ::ignition::msgs::Discovery_Publisher_MessagePublisher* _internal_mutable_msg_pub();
1060  public:
1062  ::ignition::msgs::Discovery_Publisher_MessagePublisher* msg_pub);
1063  ::ignition::msgs::Discovery_Publisher_MessagePublisher* unsafe_arena_release_msg_pub();
1064 
1065  // .ignition.msgs.Discovery.Publisher.ServicePublisher srv_pub = 7;
1066  bool has_srv_pub() const;
1067  private:
1068  bool _internal_has_srv_pub() const;
1069  public:
1071  const ::ignition::msgs::Discovery_Publisher_ServicePublisher& srv_pub() const;
1072  ::ignition::msgs::Discovery_Publisher_ServicePublisher* release_srv_pub();
1073  ::ignition::msgs::Discovery_Publisher_ServicePublisher* mutable_srv_pub();
1074  void set_allocated_srv_pub(::ignition::msgs::Discovery_Publisher_ServicePublisher* srv_pub);
1075  private:
1076  const ::ignition::msgs::Discovery_Publisher_ServicePublisher& _internal_srv_pub() const;
1077  ::ignition::msgs::Discovery_Publisher_ServicePublisher* _internal_mutable_srv_pub();
1078  public:
1080  ::ignition::msgs::Discovery_Publisher_ServicePublisher* srv_pub);
1081  ::ignition::msgs::Discovery_Publisher_ServicePublisher* unsafe_arena_release_srv_pub();
1082 
1085  // @@protoc_insertion_point(class_scope:ignition.msgs.Discovery.Publisher)
1086  private:
1087  class _Internal;
1088  void set_has_msg_pub();
1089  void set_has_srv_pub();
1090 
1091  inline bool has_pub_type() const;
1092  inline void clear_has_pub_type();
1093 
1094  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1095  typedef void InternalArenaConstructable_;
1096  typedef void DestructorSkippable_;
1097  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr topic_;
1098  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr address_;
1099  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr process_uuid_;
1100  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr node_uuid_;
1101  int scope_;
1102  union PubTypeUnion {
1103  PubTypeUnion() {}
1104  ::ignition::msgs::Discovery_Publisher_MessagePublisher* msg_pub_;
1105  ::ignition::msgs::Discovery_Publisher_ServicePublisher* srv_pub_;
1106  } pub_type_;
1107  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1108  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
1109 
1110  friend struct ::TableStruct_ignition_2fmsgs_2fdiscovery_2eproto;
1111 };
1112 // -------------------------------------------------------------------
1113 
1114 class IGNITION_MSGS_VISIBLE Discovery PROTOBUF_FINAL :
1115  public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ignition.msgs.Discovery) */ {
1116  public:
1117  inline Discovery() : Discovery(nullptr) {}
1118  virtual ~Discovery();
1119 
1120  Discovery(const Discovery& from);
1121  Discovery(Discovery&& from) noexcept
1122  : Discovery() {
1123  *this = ::std::move(from);
1124  }
1125 
1126  inline Discovery& operator=(const Discovery& from) {
1127  CopyFrom(from);
1128  return *this;
1129  }
1130  inline Discovery& operator=(Discovery&& from) noexcept {
1131  if (GetArena() == from.GetArena()) {
1132  if (this != &from) InternalSwap(&from);
1133  } else {
1134  CopyFrom(from);
1135  }
1136  return *this;
1137  }
1138 
1139  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1140  return GetDescriptor();
1141  }
1142  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1143  return GetMetadataStatic().descriptor;
1144  }
1145  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1146  return GetMetadataStatic().reflection;
1147  }
1148  static const Discovery& default_instance();
1149 
1151  kSub = 6,
1152  kPub = 7,
1153  DISC_CONTENTS_NOT_SET = 0,
1154  };
1155 
1156  static inline const Discovery* internal_default_instance() {
1157  return reinterpret_cast<const Discovery*>(
1159  }
1160  static constexpr int kIndexInFileMessages =
1161  5;
1162 
1163  friend void swap(Discovery& a, Discovery& b) {
1164  a.Swap(&b);
1165  }
1166  inline void Swap(Discovery* other) {
1167  if (other == this) return;
1168  if (GetArena() == other->GetArena()) {
1169  InternalSwap(other);
1170  } else {
1171  ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1172  }
1173  }
1174  void UnsafeArenaSwap(Discovery* other) {
1175  if (other == this) return;
1176  GOOGLE_DCHECK(GetArena() == other->GetArena());
1177  InternalSwap(other);
1178  }
1179 
1180  // implements Message ----------------------------------------------
1181 
1182  inline Discovery* New() const final {
1183  return CreateMaybeMessage<Discovery>(nullptr);
1184  }
1185 
1186  Discovery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1187  return CreateMaybeMessage<Discovery>(arena);
1188  }
1189  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1190  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1191  void CopyFrom(const Discovery& from);
1192  void MergeFrom(const Discovery& from);
1193  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1194  bool IsInitialized() const final;
1195 
1196  size_t ByteSizeLong() const final;
1197  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1198  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
1199  ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1200  int GetCachedSize() const final { return _cached_size_.Get(); }
1201 
1202  private:
1203  inline void SharedCtor();
1204  inline void SharedDtor();
1205  void SetCachedSize(int size) const final;
1206  void InternalSwap(Discovery* other);
1207  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1208  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1209  return "ignition.msgs.Discovery";
1210  }
1211  protected:
1212  explicit Discovery(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1213  private:
1214  static void ArenaDtor(void* object);
1215  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1216  public:
1217 
1218  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1219  private:
1220  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1221  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_ignition_2fmsgs_2fdiscovery_2eproto);
1222  return ::descriptor_table_ignition_2fmsgs_2fdiscovery_2eproto.file_level_metadata[kIndexInFileMessages];
1223  }
1224 
1225  public:
1226 
1227  // nested types ----------------------------------------------------
1228 
1229  typedef Discovery_Flags Flags;
1230  typedef Discovery_Subscriber Subscriber;
1231  typedef Discovery_Publisher Publisher;
1232 
1234  static constexpr Type UNINITIALIZED =
1236  static constexpr Type ADVERTISE =
1238  static constexpr Type SUBSCRIBE =
1240  static constexpr Type UNADVERTISE =
1242  static constexpr Type HEARTBEAT =
1244  static constexpr Type BYE =
1246  static constexpr Type NEW_CONNECTION =
1248  static constexpr Type END_CONNECTION =
1250  static inline bool Type_IsValid(int value) {
1251  return Discovery_Type_IsValid(value);
1252  }
1253  static constexpr Type Type_MIN =
1255  static constexpr Type Type_MAX =
1257  static constexpr int Type_ARRAYSIZE =
1259  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
1261  return Discovery_Type_descriptor();
1262  }
1263  template<typename T>
1264  static inline const std::string& Type_Name(T enum_t_value) {
1265  static_assert(::std::is_same<T, Type>::value ||
1267  "Incorrect type passed to function Type_Name.");
1268  return Discovery_Type_Name(enum_t_value);
1269  }
1270  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
1271  Type* value) {
1272  return Discovery_Type_Parse(name, value);
1273  }
1274 
1275  // accessors -------------------------------------------------------
1276 
1277  enum : int {
1278  kProcessUuidFieldNumber = 3,
1279  kHeaderFieldNumber = 1,
1280  kFlagsFieldNumber = 5,
1281  kVersionFieldNumber = 2,
1282  kTypeFieldNumber = 4,
1283  kSubFieldNumber = 6,
1284  kPubFieldNumber = 7,
1285  };
1286  // string process_uuid = 3;
1288  const std::string& process_uuid() const;
1289  void set_process_uuid(const std::string& value);
1291  void set_process_uuid(const char* value);
1292  void set_process_uuid(const char* value, size_t size);
1296  private:
1297  const std::string& _internal_process_uuid() const;
1298  void _internal_set_process_uuid(const std::string& value);
1299  std::string* _internal_mutable_process_uuid();
1300  public:
1301 
1302  // .ignition.msgs.Header header = 1;
1303  bool has_header() const;
1304  private:
1305  bool _internal_has_header() const;
1306  public:
1308  const ::ignition::msgs::Header& header() const;
1309  ::ignition::msgs::Header* release_header();
1310  ::ignition::msgs::Header* mutable_header();
1311  void set_allocated_header(::ignition::msgs::Header* header);
1312  private:
1313  const ::ignition::msgs::Header& _internal_header() const;
1314  ::ignition::msgs::Header* _internal_mutable_header();
1315  public:
1317  ::ignition::msgs::Header* header);
1318  ::ignition::msgs::Header* unsafe_arena_release_header();
1319 
1320  // .ignition.msgs.Discovery.Flags flags = 5;
1321  bool has_flags() const;
1322  private:
1323  bool _internal_has_flags() const;
1324  public:
1325  void clear_flags();
1326  const ::ignition::msgs::Discovery_Flags& flags() const;
1327  ::ignition::msgs::Discovery_Flags* release_flags();
1328  ::ignition::msgs::Discovery_Flags* mutable_flags();
1329  void set_allocated_flags(::ignition::msgs::Discovery_Flags* flags);
1330  private:
1331  const ::ignition::msgs::Discovery_Flags& _internal_flags() const;
1332  ::ignition::msgs::Discovery_Flags* _internal_mutable_flags();
1333  public:
1335  ::ignition::msgs::Discovery_Flags* flags);
1336  ::ignition::msgs::Discovery_Flags* unsafe_arena_release_flags();
1337 
1338  // uint32 version = 2;
1340  ::PROTOBUF_NAMESPACE_ID::uint32 version() const;
1341  void set_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
1342  private:
1343  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_version() const;
1344  void _internal_set_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
1345  public:
1346 
1347  // .ignition.msgs.Discovery.Type type = 4;
1348  void clear_type();
1351  private:
1352  ::ignition::msgs::Discovery_Type _internal_type() const;
1353  void _internal_set_type(::ignition::msgs::Discovery_Type value);
1354  public:
1355 
1356  // .ignition.msgs.Discovery.Subscriber sub = 6;
1357  bool has_sub() const;
1358  private:
1359  bool _internal_has_sub() const;
1360  public:
1361  void clear_sub();
1362  const ::ignition::msgs::Discovery_Subscriber& sub() const;
1363  ::ignition::msgs::Discovery_Subscriber* release_sub();
1364  ::ignition::msgs::Discovery_Subscriber* mutable_sub();
1365  void set_allocated_sub(::ignition::msgs::Discovery_Subscriber* sub);
1366  private:
1367  const ::ignition::msgs::Discovery_Subscriber& _internal_sub() const;
1368  ::ignition::msgs::Discovery_Subscriber* _internal_mutable_sub();
1369  public:
1371  ::ignition::msgs::Discovery_Subscriber* sub);
1372  ::ignition::msgs::Discovery_Subscriber* unsafe_arena_release_sub();
1373 
1374  // .ignition.msgs.Discovery.Publisher pub = 7;
1375  bool has_pub() const;
1376  private:
1377  bool _internal_has_pub() const;
1378  public:
1379  void clear_pub();
1380  const ::ignition::msgs::Discovery_Publisher& pub() const;
1381  ::ignition::msgs::Discovery_Publisher* release_pub();
1382  ::ignition::msgs::Discovery_Publisher* mutable_pub();
1383  void set_allocated_pub(::ignition::msgs::Discovery_Publisher* pub);
1384  private:
1385  const ::ignition::msgs::Discovery_Publisher& _internal_pub() const;
1386  ::ignition::msgs::Discovery_Publisher* _internal_mutable_pub();
1387  public:
1389  ::ignition::msgs::Discovery_Publisher* pub);
1390  ::ignition::msgs::Discovery_Publisher* unsafe_arena_release_pub();
1391 
1394  // @@protoc_insertion_point(class_scope:ignition.msgs.Discovery)
1395  private:
1396  class _Internal;
1397  void set_has_sub();
1398  void set_has_pub();
1399 
1400  inline bool has_disc_contents() const;
1401  inline void clear_has_disc_contents();
1402 
1403  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1404  typedef void InternalArenaConstructable_;
1405  typedef void DestructorSkippable_;
1406  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr process_uuid_;
1407  ::ignition::msgs::Header* header_;
1408  ::ignition::msgs::Discovery_Flags* flags_;
1409  ::PROTOBUF_NAMESPACE_ID::uint32 version_;
1410  int type_;
1411  union DiscContentsUnion {
1412  DiscContentsUnion() {}
1413  ::ignition::msgs::Discovery_Subscriber* sub_;
1414  ::ignition::msgs::Discovery_Publisher* pub_;
1415  } disc_contents_;
1416  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1417  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
1418 
1419  friend struct ::TableStruct_ignition_2fmsgs_2fdiscovery_2eproto;
1420 };
1421 // ===================================================================
1422 
1423 
1424 // ===================================================================
1425 
1426 #ifdef __GNUC__
1427  #pragma GCC diagnostic push
1428  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1429 #endif // __GNUC__
1430 // Discovery_Flags
1431 
1432 // bool relay = 1;
1433 inline void Discovery_Flags::clear_relay() {
1434  relay_ = false;
1435 }
1436 inline bool Discovery_Flags::_internal_relay() const {
1437  return relay_;
1438 }
1439 inline bool Discovery_Flags::relay() const {
1440  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Flags.relay)
1441  return _internal_relay();
1442 }
1443 inline void Discovery_Flags::_internal_set_relay(bool value) {
1444 
1445  relay_ = value;
1446 }
1447 inline void Discovery_Flags::set_relay(bool value) {
1448  _internal_set_relay(value);
1449  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Flags.relay)
1450 }
1451 
1452 // bool no_relay = 2;
1453 inline void Discovery_Flags::clear_no_relay() {
1454  no_relay_ = false;
1455 }
1456 inline bool Discovery_Flags::_internal_no_relay() const {
1457  return no_relay_;
1458 }
1459 inline bool Discovery_Flags::no_relay() const {
1460  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Flags.no_relay)
1461  return _internal_no_relay();
1462 }
1463 inline void Discovery_Flags::_internal_set_no_relay(bool value) {
1464 
1465  no_relay_ = value;
1466 }
1467 inline void Discovery_Flags::set_no_relay(bool value) {
1468  _internal_set_no_relay(value);
1469  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Flags.no_relay)
1470 }
1471 
1472 // -------------------------------------------------------------------
1473 
1474 // Discovery_Subscriber
1475 
1476 // string topic = 1;
1477 inline void Discovery_Subscriber::clear_topic() {
1478  topic_.ClearToEmpty();
1479 }
1480 inline const std::string& Discovery_Subscriber::topic() const {
1481  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Subscriber.topic)
1482  return _internal_topic();
1483 }
1484 inline void Discovery_Subscriber::set_topic(const std::string& value) {
1485  _internal_set_topic(value);
1486  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Subscriber.topic)
1487 }
1488 inline std::string* Discovery_Subscriber::mutable_topic() {
1489  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Subscriber.topic)
1490  return _internal_mutable_topic();
1491 }
1492 inline const std::string& Discovery_Subscriber::_internal_topic() const {
1493  return topic_.Get();
1494 }
1495 inline void Discovery_Subscriber::_internal_set_topic(const std::string& value) {
1496 
1497  topic_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
1498 }
1499 inline void Discovery_Subscriber::set_topic(std::string&& value) {
1500 
1501  topic_.Set(
1502  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
1503  // @@protoc_insertion_point(field_set_rvalue:ignition.msgs.Discovery.Subscriber.topic)
1504 }
1505 inline void Discovery_Subscriber::set_topic(const char* value) {
1506  GOOGLE_DCHECK(value != nullptr);
1507 
1508  topic_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
1509  // @@protoc_insertion_point(field_set_char:ignition.msgs.Discovery.Subscriber.topic)
1510 }
1511 inline void Discovery_Subscriber::set_topic(const char* value,
1512  size_t size) {
1513 
1514  topic_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
1515  reinterpret_cast<const char*>(value), size), GetArena());
1516  // @@protoc_insertion_point(field_set_pointer:ignition.msgs.Discovery.Subscriber.topic)
1517 }
1518 inline std::string* Discovery_Subscriber::_internal_mutable_topic() {
1519 
1520  return topic_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
1521 }
1522 inline std::string* Discovery_Subscriber::release_topic() {
1523  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Subscriber.topic)
1524  return topic_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
1525 }
1526 inline void Discovery_Subscriber::set_allocated_topic(std::string* topic) {
1527  if (topic != nullptr) {
1528 
1529  } else {
1530 
1531  }
1532  topic_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), topic,
1533  GetArena());
1534  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.Subscriber.topic)
1535 }
1536 
1537 // -------------------------------------------------------------------
1538 
1539 // Discovery_Publisher_MessagePublisher
1540 
1541 // string ctrl = 1;
1542 inline void Discovery_Publisher_MessagePublisher::clear_ctrl() {
1543  ctrl_.ClearToEmpty();
1544 }
1545 inline const std::string& Discovery_Publisher_MessagePublisher::ctrl() const {
1546  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.MessagePublisher.ctrl)
1547  return _internal_ctrl();
1548 }
1549 inline void Discovery_Publisher_MessagePublisher::set_ctrl(const std::string& value) {
1550  _internal_set_ctrl(value);
1551  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.MessagePublisher.ctrl)
1552 }
1553 inline std::string* Discovery_Publisher_MessagePublisher::mutable_ctrl() {
1554  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.MessagePublisher.ctrl)
1555  return _internal_mutable_ctrl();
1556 }
1557 inline const std::string& Discovery_Publisher_MessagePublisher::_internal_ctrl() const {
1558  return ctrl_.Get();
1559 }
1560 inline void Discovery_Publisher_MessagePublisher::_internal_set_ctrl(const std::string& value) {
1561 
1562  ctrl_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
1563 }
1564 inline void Discovery_Publisher_MessagePublisher::set_ctrl(std::string&& value) {
1565 
1566  ctrl_.Set(
1567  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
1568  // @@protoc_insertion_point(field_set_rvalue:ignition.msgs.Discovery.Publisher.MessagePublisher.ctrl)
1569 }
1570 inline void Discovery_Publisher_MessagePublisher::set_ctrl(const char* value) {
1571  GOOGLE_DCHECK(value != nullptr);
1572 
1573  ctrl_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
1574  // @@protoc_insertion_point(field_set_char:ignition.msgs.Discovery.Publisher.MessagePublisher.ctrl)
1575 }
1576 inline void Discovery_Publisher_MessagePublisher::set_ctrl(const char* value,
1577  size_t size) {
1578 
1579  ctrl_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
1580  reinterpret_cast<const char*>(value), size), GetArena());
1581  // @@protoc_insertion_point(field_set_pointer:ignition.msgs.Discovery.Publisher.MessagePublisher.ctrl)
1582 }
1583 inline std::string* Discovery_Publisher_MessagePublisher::_internal_mutable_ctrl() {
1584 
1585  return ctrl_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
1586 }
1587 inline std::string* Discovery_Publisher_MessagePublisher::release_ctrl() {
1588  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.MessagePublisher.ctrl)
1589  return ctrl_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
1590 }
1591 inline void Discovery_Publisher_MessagePublisher::set_allocated_ctrl(std::string* ctrl) {
1592  if (ctrl != nullptr) {
1593 
1594  } else {
1595 
1596  }
1597  ctrl_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ctrl,
1598  GetArena());
1599  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.Publisher.MessagePublisher.ctrl)
1600 }
1601 
1602 // string msg_type = 2;
1603 inline void Discovery_Publisher_MessagePublisher::clear_msg_type() {
1604  msg_type_.ClearToEmpty();
1605 }
1606 inline const std::string& Discovery_Publisher_MessagePublisher::msg_type() const {
1607  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.MessagePublisher.msg_type)
1608  return _internal_msg_type();
1609 }
1610 inline void Discovery_Publisher_MessagePublisher::set_msg_type(const std::string& value) {
1611  _internal_set_msg_type(value);
1612  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.MessagePublisher.msg_type)
1613 }
1614 inline std::string* Discovery_Publisher_MessagePublisher::mutable_msg_type() {
1615  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.MessagePublisher.msg_type)
1616  return _internal_mutable_msg_type();
1617 }
1618 inline const std::string& Discovery_Publisher_MessagePublisher::_internal_msg_type() const {
1619  return msg_type_.Get();
1620 }
1621 inline void Discovery_Publisher_MessagePublisher::_internal_set_msg_type(const std::string& value) {
1622 
1623  msg_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
1624 }
1625 inline void Discovery_Publisher_MessagePublisher::set_msg_type(std::string&& value) {
1626 
1627  msg_type_.Set(
1628  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
1629  // @@protoc_insertion_point(field_set_rvalue:ignition.msgs.Discovery.Publisher.MessagePublisher.msg_type)
1630 }
1631 inline void Discovery_Publisher_MessagePublisher::set_msg_type(const char* value) {
1632  GOOGLE_DCHECK(value != nullptr);
1633 
1634  msg_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
1635  // @@protoc_insertion_point(field_set_char:ignition.msgs.Discovery.Publisher.MessagePublisher.msg_type)
1636 }
1637 inline void Discovery_Publisher_MessagePublisher::set_msg_type(const char* value,
1638  size_t size) {
1639 
1640  msg_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
1641  reinterpret_cast<const char*>(value), size), GetArena());
1642  // @@protoc_insertion_point(field_set_pointer:ignition.msgs.Discovery.Publisher.MessagePublisher.msg_type)
1643 }
1644 inline std::string* Discovery_Publisher_MessagePublisher::_internal_mutable_msg_type() {
1645 
1646  return msg_type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
1647 }
1648 inline std::string* Discovery_Publisher_MessagePublisher::release_msg_type() {
1649  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.MessagePublisher.msg_type)
1650  return msg_type_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
1651 }
1652 inline void Discovery_Publisher_MessagePublisher::set_allocated_msg_type(std::string* msg_type) {
1653  if (msg_type != nullptr) {
1654 
1655  } else {
1656 
1657  }
1658  msg_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), msg_type,
1659  GetArena());
1660  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.Publisher.MessagePublisher.msg_type)
1661 }
1662 
1663 // bool throttled = 3;
1664 inline void Discovery_Publisher_MessagePublisher::clear_throttled() {
1665  throttled_ = false;
1666 }
1667 inline bool Discovery_Publisher_MessagePublisher::_internal_throttled() const {
1668  return throttled_;
1669 }
1670 inline bool Discovery_Publisher_MessagePublisher::throttled() const {
1671  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.MessagePublisher.throttled)
1672  return _internal_throttled();
1673 }
1674 inline void Discovery_Publisher_MessagePublisher::_internal_set_throttled(bool value) {
1675 
1676  throttled_ = value;
1677 }
1678 inline void Discovery_Publisher_MessagePublisher::set_throttled(bool value) {
1679  _internal_set_throttled(value);
1680  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.MessagePublisher.throttled)
1681 }
1682 
1683 // uint64 msgs_per_sec = 4;
1684 inline void Discovery_Publisher_MessagePublisher::clear_msgs_per_sec() {
1685  msgs_per_sec_ = PROTOBUF_ULONGLONG(0);
1686 }
1687 inline ::PROTOBUF_NAMESPACE_ID::uint64 Discovery_Publisher_MessagePublisher::_internal_msgs_per_sec() const {
1688  return msgs_per_sec_;
1689 }
1690 inline ::PROTOBUF_NAMESPACE_ID::uint64 Discovery_Publisher_MessagePublisher::msgs_per_sec() const {
1691  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.MessagePublisher.msgs_per_sec)
1692  return _internal_msgs_per_sec();
1693 }
1694 inline void Discovery_Publisher_MessagePublisher::_internal_set_msgs_per_sec(::PROTOBUF_NAMESPACE_ID::uint64 value) {
1695 
1696  msgs_per_sec_ = value;
1697 }
1698 inline void Discovery_Publisher_MessagePublisher::set_msgs_per_sec(::PROTOBUF_NAMESPACE_ID::uint64 value) {
1699  _internal_set_msgs_per_sec(value);
1700  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.MessagePublisher.msgs_per_sec)
1701 }
1702 
1703 // -------------------------------------------------------------------
1704 
1705 // Discovery_Publisher_ServicePublisher
1706 
1707 // string socket_id = 1;
1708 inline void Discovery_Publisher_ServicePublisher::clear_socket_id() {
1709  socket_id_.ClearToEmpty();
1710 }
1711 inline const std::string& Discovery_Publisher_ServicePublisher::socket_id() const {
1712  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.ServicePublisher.socket_id)
1713  return _internal_socket_id();
1714 }
1715 inline void Discovery_Publisher_ServicePublisher::set_socket_id(const std::string& value) {
1716  _internal_set_socket_id(value);
1717  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.ServicePublisher.socket_id)
1718 }
1719 inline std::string* Discovery_Publisher_ServicePublisher::mutable_socket_id() {
1720  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.ServicePublisher.socket_id)
1721  return _internal_mutable_socket_id();
1722 }
1723 inline const std::string& Discovery_Publisher_ServicePublisher::_internal_socket_id() const {
1724  return socket_id_.Get();
1725 }
1726 inline void Discovery_Publisher_ServicePublisher::_internal_set_socket_id(const std::string& value) {
1727 
1728  socket_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
1729 }
1730 inline void Discovery_Publisher_ServicePublisher::set_socket_id(std::string&& value) {
1731 
1732  socket_id_.Set(
1733  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
1734  // @@protoc_insertion_point(field_set_rvalue:ignition.msgs.Discovery.Publisher.ServicePublisher.socket_id)
1735 }
1736 inline void Discovery_Publisher_ServicePublisher::set_socket_id(const char* value) {
1737  GOOGLE_DCHECK(value != nullptr);
1738 
1739  socket_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
1740  // @@protoc_insertion_point(field_set_char:ignition.msgs.Discovery.Publisher.ServicePublisher.socket_id)
1741 }
1742 inline void Discovery_Publisher_ServicePublisher::set_socket_id(const char* value,
1743  size_t size) {
1744 
1745  socket_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
1746  reinterpret_cast<const char*>(value), size), GetArena());
1747  // @@protoc_insertion_point(field_set_pointer:ignition.msgs.Discovery.Publisher.ServicePublisher.socket_id)
1748 }
1749 inline std::string* Discovery_Publisher_ServicePublisher::_internal_mutable_socket_id() {
1750 
1751  return socket_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
1752 }
1753 inline std::string* Discovery_Publisher_ServicePublisher::release_socket_id() {
1754  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.ServicePublisher.socket_id)
1755  return socket_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
1756 }
1757 inline void Discovery_Publisher_ServicePublisher::set_allocated_socket_id(std::string* socket_id) {
1758  if (socket_id != nullptr) {
1759 
1760  } else {
1761 
1762  }
1763  socket_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), socket_id,
1764  GetArena());
1765  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.Publisher.ServicePublisher.socket_id)
1766 }
1767 
1768 // string request_type = 2;
1769 inline void Discovery_Publisher_ServicePublisher::clear_request_type() {
1770  request_type_.ClearToEmpty();
1771 }
1772 inline const std::string& Discovery_Publisher_ServicePublisher::request_type() const {
1773  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.ServicePublisher.request_type)
1774  return _internal_request_type();
1775 }
1776 inline void Discovery_Publisher_ServicePublisher::set_request_type(const std::string& value) {
1777  _internal_set_request_type(value);
1778  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.ServicePublisher.request_type)
1779 }
1780 inline std::string* Discovery_Publisher_ServicePublisher::mutable_request_type() {
1781  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.ServicePublisher.request_type)
1782  return _internal_mutable_request_type();
1783 }
1784 inline const std::string& Discovery_Publisher_ServicePublisher::_internal_request_type() const {
1785  return request_type_.Get();
1786 }
1787 inline void Discovery_Publisher_ServicePublisher::_internal_set_request_type(const std::string& value) {
1788 
1789  request_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
1790 }
1791 inline void Discovery_Publisher_ServicePublisher::set_request_type(std::string&& value) {
1792 
1793  request_type_.Set(
1794  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
1795  // @@protoc_insertion_point(field_set_rvalue:ignition.msgs.Discovery.Publisher.ServicePublisher.request_type)
1796 }
1797 inline void Discovery_Publisher_ServicePublisher::set_request_type(const char* value) {
1798  GOOGLE_DCHECK(value != nullptr);
1799 
1800  request_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
1801  // @@protoc_insertion_point(field_set_char:ignition.msgs.Discovery.Publisher.ServicePublisher.request_type)
1802 }
1803 inline void Discovery_Publisher_ServicePublisher::set_request_type(const char* value,
1804  size_t size) {
1805 
1806  request_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
1807  reinterpret_cast<const char*>(value), size), GetArena());
1808  // @@protoc_insertion_point(field_set_pointer:ignition.msgs.Discovery.Publisher.ServicePublisher.request_type)
1809 }
1810 inline std::string* Discovery_Publisher_ServicePublisher::_internal_mutable_request_type() {
1811 
1812  return request_type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
1813 }
1814 inline std::string* Discovery_Publisher_ServicePublisher::release_request_type() {
1815  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.ServicePublisher.request_type)
1816  return request_type_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
1817 }
1818 inline void Discovery_Publisher_ServicePublisher::set_allocated_request_type(std::string* request_type) {
1819  if (request_type != nullptr) {
1820 
1821  } else {
1822 
1823  }
1824  request_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), request_type,
1825  GetArena());
1826  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.Publisher.ServicePublisher.request_type)
1827 }
1828 
1829 // string response_type = 3;
1830 inline void Discovery_Publisher_ServicePublisher::clear_response_type() {
1831  response_type_.ClearToEmpty();
1832 }
1833 inline const std::string& Discovery_Publisher_ServicePublisher::response_type() const {
1834  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.ServicePublisher.response_type)
1835  return _internal_response_type();
1836 }
1837 inline void Discovery_Publisher_ServicePublisher::set_response_type(const std::string& value) {
1838  _internal_set_response_type(value);
1839  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.ServicePublisher.response_type)
1840 }
1841 inline std::string* Discovery_Publisher_ServicePublisher::mutable_response_type() {
1842  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.ServicePublisher.response_type)
1843  return _internal_mutable_response_type();
1844 }
1845 inline const std::string& Discovery_Publisher_ServicePublisher::_internal_response_type() const {
1846  return response_type_.Get();
1847 }
1848 inline void Discovery_Publisher_ServicePublisher::_internal_set_response_type(const std::string& value) {
1849 
1850  response_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
1851 }
1852 inline void Discovery_Publisher_ServicePublisher::set_response_type(std::string&& value) {
1853 
1854  response_type_.Set(
1855  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
1856  // @@protoc_insertion_point(field_set_rvalue:ignition.msgs.Discovery.Publisher.ServicePublisher.response_type)
1857 }
1858 inline void Discovery_Publisher_ServicePublisher::set_response_type(const char* value) {
1859  GOOGLE_DCHECK(value != nullptr);
1860 
1861  response_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
1862  // @@protoc_insertion_point(field_set_char:ignition.msgs.Discovery.Publisher.ServicePublisher.response_type)
1863 }
1864 inline void Discovery_Publisher_ServicePublisher::set_response_type(const char* value,
1865  size_t size) {
1866 
1867  response_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
1868  reinterpret_cast<const char*>(value), size), GetArena());
1869  // @@protoc_insertion_point(field_set_pointer:ignition.msgs.Discovery.Publisher.ServicePublisher.response_type)
1870 }
1871 inline std::string* Discovery_Publisher_ServicePublisher::_internal_mutable_response_type() {
1872 
1873  return response_type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
1874 }
1875 inline std::string* Discovery_Publisher_ServicePublisher::release_response_type() {
1876  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.ServicePublisher.response_type)
1877  return response_type_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
1878 }
1879 inline void Discovery_Publisher_ServicePublisher::set_allocated_response_type(std::string* response_type) {
1880  if (response_type != nullptr) {
1881 
1882  } else {
1883 
1884  }
1885  response_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), response_type,
1886  GetArena());
1887  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.Publisher.ServicePublisher.response_type)
1888 }
1889 
1890 // -------------------------------------------------------------------
1891 
1892 // Discovery_Publisher
1893 
1894 // string topic = 1;
1895 inline void Discovery_Publisher::clear_topic() {
1896  topic_.ClearToEmpty();
1897 }
1898 inline const std::string& Discovery_Publisher::topic() const {
1899  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.topic)
1900  return _internal_topic();
1901 }
1902 inline void Discovery_Publisher::set_topic(const std::string& value) {
1903  _internal_set_topic(value);
1904  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.topic)
1905 }
1906 inline std::string* Discovery_Publisher::mutable_topic() {
1907  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.topic)
1908  return _internal_mutable_topic();
1909 }
1910 inline const std::string& Discovery_Publisher::_internal_topic() const {
1911  return topic_.Get();
1912 }
1913 inline void Discovery_Publisher::_internal_set_topic(const std::string& value) {
1914 
1915  topic_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
1916 }
1917 inline void Discovery_Publisher::set_topic(std::string&& value) {
1918 
1919  topic_.Set(
1920  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
1921  // @@protoc_insertion_point(field_set_rvalue:ignition.msgs.Discovery.Publisher.topic)
1922 }
1923 inline void Discovery_Publisher::set_topic(const char* value) {
1924  GOOGLE_DCHECK(value != nullptr);
1925 
1926  topic_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
1927  // @@protoc_insertion_point(field_set_char:ignition.msgs.Discovery.Publisher.topic)
1928 }
1929 inline void Discovery_Publisher::set_topic(const char* value,
1930  size_t size) {
1931 
1932  topic_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
1933  reinterpret_cast<const char*>(value), size), GetArena());
1934  // @@protoc_insertion_point(field_set_pointer:ignition.msgs.Discovery.Publisher.topic)
1935 }
1936 inline std::string* Discovery_Publisher::_internal_mutable_topic() {
1937 
1938  return topic_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
1939 }
1940 inline std::string* Discovery_Publisher::release_topic() {
1941  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.topic)
1942  return topic_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
1943 }
1944 inline void Discovery_Publisher::set_allocated_topic(std::string* topic) {
1945  if (topic != nullptr) {
1946 
1947  } else {
1948 
1949  }
1950  topic_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), topic,
1951  GetArena());
1952  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.Publisher.topic)
1953 }
1954 
1955 // string address = 2;
1956 inline void Discovery_Publisher::clear_address() {
1957  address_.ClearToEmpty();
1958 }
1959 inline const std::string& Discovery_Publisher::address() const {
1960  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.address)
1961  return _internal_address();
1962 }
1963 inline void Discovery_Publisher::set_address(const std::string& value) {
1964  _internal_set_address(value);
1965  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.address)
1966 }
1967 inline std::string* Discovery_Publisher::mutable_address() {
1968  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.address)
1969  return _internal_mutable_address();
1970 }
1971 inline const std::string& Discovery_Publisher::_internal_address() const {
1972  return address_.Get();
1973 }
1974 inline void Discovery_Publisher::_internal_set_address(const std::string& value) {
1975 
1976  address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
1977 }
1978 inline void Discovery_Publisher::set_address(std::string&& value) {
1979 
1980  address_.Set(
1981  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
1982  // @@protoc_insertion_point(field_set_rvalue:ignition.msgs.Discovery.Publisher.address)
1983 }
1984 inline void Discovery_Publisher::set_address(const char* value) {
1985  GOOGLE_DCHECK(value != nullptr);
1986 
1987  address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
1988  // @@protoc_insertion_point(field_set_char:ignition.msgs.Discovery.Publisher.address)
1989 }
1990 inline void Discovery_Publisher::set_address(const char* value,
1991  size_t size) {
1992 
1993  address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
1994  reinterpret_cast<const char*>(value), size), GetArena());
1995  // @@protoc_insertion_point(field_set_pointer:ignition.msgs.Discovery.Publisher.address)
1996 }
1997 inline std::string* Discovery_Publisher::_internal_mutable_address() {
1998 
1999  return address_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
2000 }
2001 inline std::string* Discovery_Publisher::release_address() {
2002  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.address)
2003  return address_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
2004 }
2005 inline void Discovery_Publisher::set_allocated_address(std::string* address) {
2006  if (address != nullptr) {
2007 
2008  } else {
2009 
2010  }
2011  address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), address,
2012  GetArena());
2013  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.Publisher.address)
2014 }
2015 
2016 // string process_uuid = 3;
2017 inline void Discovery_Publisher::clear_process_uuid() {
2018  process_uuid_.ClearToEmpty();
2019 }
2020 inline const std::string& Discovery_Publisher::process_uuid() const {
2021  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.process_uuid)
2022  return _internal_process_uuid();
2023 }
2024 inline void Discovery_Publisher::set_process_uuid(const std::string& value) {
2025  _internal_set_process_uuid(value);
2026  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.process_uuid)
2027 }
2028 inline std::string* Discovery_Publisher::mutable_process_uuid() {
2029  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.process_uuid)
2030  return _internal_mutable_process_uuid();
2031 }
2032 inline const std::string& Discovery_Publisher::_internal_process_uuid() const {
2033  return process_uuid_.Get();
2034 }
2035 inline void Discovery_Publisher::_internal_set_process_uuid(const std::string& value) {
2036 
2037  process_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
2038 }
2039 inline void Discovery_Publisher::set_process_uuid(std::string&& value) {
2040 
2041  process_uuid_.Set(
2042  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
2043  // @@protoc_insertion_point(field_set_rvalue:ignition.msgs.Discovery.Publisher.process_uuid)
2044 }
2045 inline void Discovery_Publisher::set_process_uuid(const char* value) {
2046  GOOGLE_DCHECK(value != nullptr);
2047 
2048  process_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
2049  // @@protoc_insertion_point(field_set_char:ignition.msgs.Discovery.Publisher.process_uuid)
2050 }
2051 inline void Discovery_Publisher::set_process_uuid(const char* value,
2052  size_t size) {
2053 
2054  process_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
2055  reinterpret_cast<const char*>(value), size), GetArena());
2056  // @@protoc_insertion_point(field_set_pointer:ignition.msgs.Discovery.Publisher.process_uuid)
2057 }
2058 inline std::string* Discovery_Publisher::_internal_mutable_process_uuid() {
2059 
2060  return process_uuid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
2061 }
2062 inline std::string* Discovery_Publisher::release_process_uuid() {
2063  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.process_uuid)
2064  return process_uuid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
2065 }
2066 inline void Discovery_Publisher::set_allocated_process_uuid(std::string* process_uuid) {
2067  if (process_uuid != nullptr) {
2068 
2069  } else {
2070 
2071  }
2072  process_uuid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), process_uuid,
2073  GetArena());
2074  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.Publisher.process_uuid)
2075 }
2076 
2077 // string node_uuid = 4;
2078 inline void Discovery_Publisher::clear_node_uuid() {
2079  node_uuid_.ClearToEmpty();
2080 }
2081 inline const std::string& Discovery_Publisher::node_uuid() const {
2082  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.node_uuid)
2083  return _internal_node_uuid();
2084 }
2085 inline void Discovery_Publisher::set_node_uuid(const std::string& value) {
2086  _internal_set_node_uuid(value);
2087  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.node_uuid)
2088 }
2089 inline std::string* Discovery_Publisher::mutable_node_uuid() {
2090  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.node_uuid)
2091  return _internal_mutable_node_uuid();
2092 }
2093 inline const std::string& Discovery_Publisher::_internal_node_uuid() const {
2094  return node_uuid_.Get();
2095 }
2096 inline void Discovery_Publisher::_internal_set_node_uuid(const std::string& value) {
2097 
2098  node_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
2099 }
2100 inline void Discovery_Publisher::set_node_uuid(std::string&& value) {
2101 
2102  node_uuid_.Set(
2103  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
2104  // @@protoc_insertion_point(field_set_rvalue:ignition.msgs.Discovery.Publisher.node_uuid)
2105 }
2106 inline void Discovery_Publisher::set_node_uuid(const char* value) {
2107  GOOGLE_DCHECK(value != nullptr);
2108 
2109  node_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
2110  // @@protoc_insertion_point(field_set_char:ignition.msgs.Discovery.Publisher.node_uuid)
2111 }
2112 inline void Discovery_Publisher::set_node_uuid(const char* value,
2113  size_t size) {
2114 
2115  node_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
2116  reinterpret_cast<const char*>(value), size), GetArena());
2117  // @@protoc_insertion_point(field_set_pointer:ignition.msgs.Discovery.Publisher.node_uuid)
2118 }
2119 inline std::string* Discovery_Publisher::_internal_mutable_node_uuid() {
2120 
2121  return node_uuid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
2122 }
2123 inline std::string* Discovery_Publisher::release_node_uuid() {
2124  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.node_uuid)
2125  return node_uuid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
2126 }
2127 inline void Discovery_Publisher::set_allocated_node_uuid(std::string* node_uuid) {
2128  if (node_uuid != nullptr) {
2129 
2130  } else {
2131 
2132  }
2133  node_uuid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), node_uuid,
2134  GetArena());
2135  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.Publisher.node_uuid)
2136 }
2137 
2138 // .ignition.msgs.Discovery.Publisher.Scope scope = 5;
2139 inline void Discovery_Publisher::clear_scope() {
2140  scope_ = 0;
2141 }
2142 inline ::ignition::msgs::Discovery_Publisher_Scope Discovery_Publisher::_internal_scope() const {
2143  return static_cast< ::ignition::msgs::Discovery_Publisher_Scope >(scope_);
2144 }
2145 inline ::ignition::msgs::Discovery_Publisher_Scope Discovery_Publisher::scope() const {
2146  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.scope)
2147  return _internal_scope();
2148 }
2149 inline void Discovery_Publisher::_internal_set_scope(::ignition::msgs::Discovery_Publisher_Scope value) {
2150 
2151  scope_ = value;
2152 }
2153 inline void Discovery_Publisher::set_scope(::ignition::msgs::Discovery_Publisher_Scope value) {
2154  _internal_set_scope(value);
2155  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.scope)
2156 }
2157 
2158 // .ignition.msgs.Discovery.Publisher.MessagePublisher msg_pub = 6;
2159 inline bool Discovery_Publisher::_internal_has_msg_pub() const {
2160  return pub_type_case() == kMsgPub;
2161 }
2162 inline bool Discovery_Publisher::has_msg_pub() const {
2163  return _internal_has_msg_pub();
2164 }
2165 inline void Discovery_Publisher::set_has_msg_pub() {
2166  _oneof_case_[0] = kMsgPub;
2167 }
2168 inline void Discovery_Publisher::clear_msg_pub() {
2169  if (_internal_has_msg_pub()) {
2170  if (GetArena() == nullptr) {
2171  delete pub_type_.msg_pub_;
2172  }
2173  clear_has_pub_type();
2174  }
2175 }
2176 inline ::ignition::msgs::Discovery_Publisher_MessagePublisher* Discovery_Publisher::release_msg_pub() {
2177  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.msg_pub)
2178  if (_internal_has_msg_pub()) {
2179  clear_has_pub_type();
2180  ::ignition::msgs::Discovery_Publisher_MessagePublisher* temp = pub_type_.msg_pub_;
2181  if (GetArena() != nullptr) {
2182  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2183  }
2184  pub_type_.msg_pub_ = nullptr;
2185  return temp;
2186  } else {
2187  return nullptr;
2188  }
2189 }
2190 inline const ::ignition::msgs::Discovery_Publisher_MessagePublisher& Discovery_Publisher::_internal_msg_pub() const {
2191  return _internal_has_msg_pub()
2192  ? *pub_type_.msg_pub_
2193  : reinterpret_cast< ::ignition::msgs::Discovery_Publisher_MessagePublisher&>(::ignition::msgs::_Discovery_Publisher_MessagePublisher_default_instance_);
2194 }
2195 inline const ::ignition::msgs::Discovery_Publisher_MessagePublisher& Discovery_Publisher::msg_pub() const {
2196  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.msg_pub)
2197  return _internal_msg_pub();
2198 }
2199 inline ::ignition::msgs::Discovery_Publisher_MessagePublisher* Discovery_Publisher::unsafe_arena_release_msg_pub() {
2200  // @@protoc_insertion_point(field_unsafe_arena_release:ignition.msgs.Discovery.Publisher.msg_pub)
2201  if (_internal_has_msg_pub()) {
2202  clear_has_pub_type();
2203  ::ignition::msgs::Discovery_Publisher_MessagePublisher* temp = pub_type_.msg_pub_;
2204  pub_type_.msg_pub_ = nullptr;
2205  return temp;
2206  } else {
2207  return nullptr;
2208  }
2209 }
2210 inline void Discovery_Publisher::unsafe_arena_set_allocated_msg_pub(::ignition::msgs::Discovery_Publisher_MessagePublisher* msg_pub) {
2211  clear_pub_type();
2212  if (msg_pub) {
2213  set_has_msg_pub();
2214  pub_type_.msg_pub_ = msg_pub;
2215  }
2216  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ignition.msgs.Discovery.Publisher.msg_pub)
2217 }
2218 inline ::ignition::msgs::Discovery_Publisher_MessagePublisher* Discovery_Publisher::_internal_mutable_msg_pub() {
2219  if (!_internal_has_msg_pub()) {
2220  clear_pub_type();
2221  set_has_msg_pub();
2222  pub_type_.msg_pub_ = CreateMaybeMessage< ::ignition::msgs::Discovery_Publisher_MessagePublisher >(GetArena());
2223  }
2224  return pub_type_.msg_pub_;
2225 }
2226 inline ::ignition::msgs::Discovery_Publisher_MessagePublisher* Discovery_Publisher::mutable_msg_pub() {
2227  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.msg_pub)
2228  return _internal_mutable_msg_pub();
2229 }
2230 
2231 // .ignition.msgs.Discovery.Publisher.ServicePublisher srv_pub = 7;
2232 inline bool Discovery_Publisher::_internal_has_srv_pub() const {
2233  return pub_type_case() == kSrvPub;
2234 }
2235 inline bool Discovery_Publisher::has_srv_pub() const {
2236  return _internal_has_srv_pub();
2237 }
2238 inline void Discovery_Publisher::set_has_srv_pub() {
2239  _oneof_case_[0] = kSrvPub;
2240 }
2241 inline void Discovery_Publisher::clear_srv_pub() {
2242  if (_internal_has_srv_pub()) {
2243  if (GetArena() == nullptr) {
2244  delete pub_type_.srv_pub_;
2245  }
2246  clear_has_pub_type();
2247  }
2248 }
2249 inline ::ignition::msgs::Discovery_Publisher_ServicePublisher* Discovery_Publisher::release_srv_pub() {
2250  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.srv_pub)
2251  if (_internal_has_srv_pub()) {
2252  clear_has_pub_type();
2253  ::ignition::msgs::Discovery_Publisher_ServicePublisher* temp = pub_type_.srv_pub_;
2254  if (GetArena() != nullptr) {
2255  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2256  }
2257  pub_type_.srv_pub_ = nullptr;
2258  return temp;
2259  } else {
2260  return nullptr;
2261  }
2262 }
2263 inline const ::ignition::msgs::Discovery_Publisher_ServicePublisher& Discovery_Publisher::_internal_srv_pub() const {
2264  return _internal_has_srv_pub()
2265  ? *pub_type_.srv_pub_
2266  : reinterpret_cast< ::ignition::msgs::Discovery_Publisher_ServicePublisher&>(::ignition::msgs::_Discovery_Publisher_ServicePublisher_default_instance_);
2267 }
2268 inline const ::ignition::msgs::Discovery_Publisher_ServicePublisher& Discovery_Publisher::srv_pub() const {
2269  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.srv_pub)
2270  return _internal_srv_pub();
2271 }
2272 inline ::ignition::msgs::Discovery_Publisher_ServicePublisher* Discovery_Publisher::unsafe_arena_release_srv_pub() {
2273  // @@protoc_insertion_point(field_unsafe_arena_release:ignition.msgs.Discovery.Publisher.srv_pub)
2274  if (_internal_has_srv_pub()) {
2275  clear_has_pub_type();
2276  ::ignition::msgs::Discovery_Publisher_ServicePublisher* temp = pub_type_.srv_pub_;
2277  pub_type_.srv_pub_ = nullptr;
2278  return temp;
2279  } else {
2280  return nullptr;
2281  }
2282 }
2283 inline void Discovery_Publisher::unsafe_arena_set_allocated_srv_pub(::ignition::msgs::Discovery_Publisher_ServicePublisher* srv_pub) {
2284  clear_pub_type();
2285  if (srv_pub) {
2286  set_has_srv_pub();
2287  pub_type_.srv_pub_ = srv_pub;
2288  }
2289  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ignition.msgs.Discovery.Publisher.srv_pub)
2290 }
2291 inline ::ignition::msgs::Discovery_Publisher_ServicePublisher* Discovery_Publisher::_internal_mutable_srv_pub() {
2292  if (!_internal_has_srv_pub()) {
2293  clear_pub_type();
2294  set_has_srv_pub();
2295  pub_type_.srv_pub_ = CreateMaybeMessage< ::ignition::msgs::Discovery_Publisher_ServicePublisher >(GetArena());
2296  }
2297  return pub_type_.srv_pub_;
2298 }
2299 inline ::ignition::msgs::Discovery_Publisher_ServicePublisher* Discovery_Publisher::mutable_srv_pub() {
2300  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.srv_pub)
2301  return _internal_mutable_srv_pub();
2302 }
2303 
2304 inline bool Discovery_Publisher::has_pub_type() const {
2305  return pub_type_case() != PUB_TYPE_NOT_SET;
2306 }
2307 inline void Discovery_Publisher::clear_has_pub_type() {
2308  _oneof_case_[0] = PUB_TYPE_NOT_SET;
2309 }
2310 inline Discovery_Publisher::PubTypeCase Discovery_Publisher::pub_type_case() const {
2311  return Discovery_Publisher::PubTypeCase(_oneof_case_[0]);
2312 }
2313 // -------------------------------------------------------------------
2314 
2315 // Discovery
2316 
2317 // .ignition.msgs.Header header = 1;
2318 inline bool Discovery::_internal_has_header() const {
2319  return this != internal_default_instance() && header_ != nullptr;
2320 }
2321 inline bool Discovery::has_header() const {
2322  return _internal_has_header();
2323 }
2324 inline const ::ignition::msgs::Header& Discovery::_internal_header() const {
2325  const ::ignition::msgs::Header* p = header_;
2326  return p != nullptr ? *p : reinterpret_cast<const ::ignition::msgs::Header&>(
2328 }
2329 inline const ::ignition::msgs::Header& Discovery::header() const {
2330  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.header)
2331  return _internal_header();
2332 }
2333 inline void Discovery::unsafe_arena_set_allocated_header(
2334  ::ignition::msgs::Header* header) {
2335  if (GetArena() == nullptr) {
2336  delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(header_);
2337  }
2338  header_ = header;
2339  if (header) {
2340 
2341  } else {
2342 
2343  }
2344  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ignition.msgs.Discovery.header)
2345 }
2346 inline ::ignition::msgs::Header* Discovery::release_header() {
2347 
2348  ::ignition::msgs::Header* temp = header_;
2349  header_ = nullptr;
2350  if (GetArena() != nullptr) {
2351  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2352  }
2353  return temp;
2354 }
2355 inline ::ignition::msgs::Header* Discovery::unsafe_arena_release_header() {
2356  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.header)
2357 
2358  ::ignition::msgs::Header* temp = header_;
2359  header_ = nullptr;
2360  return temp;
2361 }
2362 inline ::ignition::msgs::Header* Discovery::_internal_mutable_header() {
2363 
2364  if (header_ == nullptr) {
2365  auto* p = CreateMaybeMessage<::ignition::msgs::Header>(GetArena());
2366  header_ = p;
2367  }
2368  return header_;
2369 }
2370 inline ::ignition::msgs::Header* Discovery::mutable_header() {
2371  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.header)
2372  return _internal_mutable_header();
2373 }
2374 inline void Discovery::set_allocated_header(::ignition::msgs::Header* header) {
2375  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
2376  if (message_arena == nullptr) {
2377  delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(header_);
2378  }
2379  if (header) {
2380  ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2381  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(header)->GetArena();
2382  if (message_arena != submessage_arena) {
2383  header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2384  message_arena, header, submessage_arena);
2385  }
2386 
2387  } else {
2388 
2389  }
2390  header_ = header;
2391  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.header)
2392 }
2393 
2394 // uint32 version = 2;
2395 inline void Discovery::clear_version() {
2396  version_ = 0u;
2397 }
2398 inline ::PROTOBUF_NAMESPACE_ID::uint32 Discovery::_internal_version() const {
2399  return version_;
2400 }
2401 inline ::PROTOBUF_NAMESPACE_ID::uint32 Discovery::version() const {
2402  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.version)
2403  return _internal_version();
2404 }
2405 inline void Discovery::_internal_set_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
2406 
2407  version_ = value;
2408 }
2409 inline void Discovery::set_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
2410  _internal_set_version(value);
2411  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.version)
2412 }
2413 
2414 // string process_uuid = 3;
2415 inline void Discovery::clear_process_uuid() {
2416  process_uuid_.ClearToEmpty();
2417 }
2418 inline const std::string& Discovery::process_uuid() const {
2419  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.process_uuid)
2420  return _internal_process_uuid();
2421 }
2422 inline void Discovery::set_process_uuid(const std::string& value) {
2423  _internal_set_process_uuid(value);
2424  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.process_uuid)
2425 }
2426 inline std::string* Discovery::mutable_process_uuid() {
2427  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.process_uuid)
2428  return _internal_mutable_process_uuid();
2429 }
2430 inline const std::string& Discovery::_internal_process_uuid() const {
2431  return process_uuid_.Get();
2432 }
2433 inline void Discovery::_internal_set_process_uuid(const std::string& value) {
2434 
2435  process_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
2436 }
2437 inline void Discovery::set_process_uuid(std::string&& value) {
2438 
2439  process_uuid_.Set(
2440  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
2441  // @@protoc_insertion_point(field_set_rvalue:ignition.msgs.Discovery.process_uuid)
2442 }
2443 inline void Discovery::set_process_uuid(const char* value) {
2444  GOOGLE_DCHECK(value != nullptr);
2445 
2446  process_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
2447  // @@protoc_insertion_point(field_set_char:ignition.msgs.Discovery.process_uuid)
2448 }
2449 inline void Discovery::set_process_uuid(const char* value,
2450  size_t size) {
2451 
2452  process_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
2453  reinterpret_cast<const char*>(value), size), GetArena());
2454  // @@protoc_insertion_point(field_set_pointer:ignition.msgs.Discovery.process_uuid)
2455 }
2456 inline std::string* Discovery::_internal_mutable_process_uuid() {
2457 
2458  return process_uuid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
2459 }
2460 inline std::string* Discovery::release_process_uuid() {
2461  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.process_uuid)
2462  return process_uuid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
2463 }
2464 inline void Discovery::set_allocated_process_uuid(std::string* process_uuid) {
2465  if (process_uuid != nullptr) {
2466 
2467  } else {
2468 
2469  }
2470  process_uuid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), process_uuid,
2471  GetArena());
2472  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.process_uuid)
2473 }
2474 
2475 // .ignition.msgs.Discovery.Type type = 4;
2476 inline void Discovery::clear_type() {
2477  type_ = 0;
2478 }
2479 inline ::ignition::msgs::Discovery_Type Discovery::_internal_type() const {
2480  return static_cast< ::ignition::msgs::Discovery_Type >(type_);
2481 }
2482 inline ::ignition::msgs::Discovery_Type Discovery::type() const {
2483  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.type)
2484  return _internal_type();
2485 }
2486 inline void Discovery::_internal_set_type(::ignition::msgs::Discovery_Type value) {
2487 
2488  type_ = value;
2489 }
2490 inline void Discovery::set_type(::ignition::msgs::Discovery_Type value) {
2491  _internal_set_type(value);
2492  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.type)
2493 }
2494 
2495 // .ignition.msgs.Discovery.Flags flags = 5;
2496 inline bool Discovery::_internal_has_flags() const {
2497  return this != internal_default_instance() && flags_ != nullptr;
2498 }
2499 inline bool Discovery::has_flags() const {
2500  return _internal_has_flags();
2501 }
2502 inline void Discovery::clear_flags() {
2503  if (GetArena() == nullptr && flags_ != nullptr) {
2504  delete flags_;
2505  }
2506  flags_ = nullptr;
2507 }
2508 inline const ::ignition::msgs::Discovery_Flags& Discovery::_internal_flags() const {
2509  const ::ignition::msgs::Discovery_Flags* p = flags_;
2510  return p != nullptr ? *p : reinterpret_cast<const ::ignition::msgs::Discovery_Flags&>(
2512 }
2513 inline const ::ignition::msgs::Discovery_Flags& Discovery::flags() const {
2514  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.flags)
2515  return _internal_flags();
2516 }
2517 inline void Discovery::unsafe_arena_set_allocated_flags(
2518  ::ignition::msgs::Discovery_Flags* flags) {
2519  if (GetArena() == nullptr) {
2520  delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(flags_);
2521  }
2522  flags_ = flags;
2523  if (flags) {
2524 
2525  } else {
2526 
2527  }
2528  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ignition.msgs.Discovery.flags)
2529 }
2530 inline ::ignition::msgs::Discovery_Flags* Discovery::release_flags() {
2531 
2532  ::ignition::msgs::Discovery_Flags* temp = flags_;
2533  flags_ = nullptr;
2534  if (GetArena() != nullptr) {
2535  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2536  }
2537  return temp;
2538 }
2539 inline ::ignition::msgs::Discovery_Flags* Discovery::unsafe_arena_release_flags() {
2540  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.flags)
2541 
2542  ::ignition::msgs::Discovery_Flags* temp = flags_;
2543  flags_ = nullptr;
2544  return temp;
2545 }
2546 inline ::ignition::msgs::Discovery_Flags* Discovery::_internal_mutable_flags() {
2547 
2548  if (flags_ == nullptr) {
2549  auto* p = CreateMaybeMessage<::ignition::msgs::Discovery_Flags>(GetArena());
2550  flags_ = p;
2551  }
2552  return flags_;
2553 }
2554 inline ::ignition::msgs::Discovery_Flags* Discovery::mutable_flags() {
2555  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.flags)
2556  return _internal_mutable_flags();
2557 }
2558 inline void Discovery::set_allocated_flags(::ignition::msgs::Discovery_Flags* flags) {
2559  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
2560  if (message_arena == nullptr) {
2561  delete flags_;
2562  }
2563  if (flags) {
2564  ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2565  ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(flags);
2566  if (message_arena != submessage_arena) {
2567  flags = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2568  message_arena, flags, submessage_arena);
2569  }
2570 
2571  } else {
2572 
2573  }
2574  flags_ = flags;
2575  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.flags)
2576 }
2577 
2578 // .ignition.msgs.Discovery.Subscriber sub = 6;
2579 inline bool Discovery::_internal_has_sub() const {
2580  return disc_contents_case() == kSub;
2581 }
2582 inline bool Discovery::has_sub() const {
2583  return _internal_has_sub();
2584 }
2585 inline void Discovery::set_has_sub() {
2586  _oneof_case_[0] = kSub;
2587 }
2588 inline void Discovery::clear_sub() {
2589  if (_internal_has_sub()) {
2590  if (GetArena() == nullptr) {
2591  delete disc_contents_.sub_;
2592  }
2593  clear_has_disc_contents();
2594  }
2595 }
2596 inline ::ignition::msgs::Discovery_Subscriber* Discovery::release_sub() {
2597  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.sub)
2598  if (_internal_has_sub()) {
2599  clear_has_disc_contents();
2600  ::ignition::msgs::Discovery_Subscriber* temp = disc_contents_.sub_;
2601  if (GetArena() != nullptr) {
2602  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2603  }
2604  disc_contents_.sub_ = nullptr;
2605  return temp;
2606  } else {
2607  return nullptr;
2608  }
2609 }
2610 inline const ::ignition::msgs::Discovery_Subscriber& Discovery::_internal_sub() const {
2611  return _internal_has_sub()
2612  ? *disc_contents_.sub_
2613  : reinterpret_cast< ::ignition::msgs::Discovery_Subscriber&>(::ignition::msgs::_Discovery_Subscriber_default_instance_);
2614 }
2615 inline const ::ignition::msgs::Discovery_Subscriber& Discovery::sub() const {
2616  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.sub)
2617  return _internal_sub();
2618 }
2619 inline ::ignition::msgs::Discovery_Subscriber* Discovery::unsafe_arena_release_sub() {
2620  // @@protoc_insertion_point(field_unsafe_arena_release:ignition.msgs.Discovery.sub)
2621  if (_internal_has_sub()) {
2622  clear_has_disc_contents();
2623  ::ignition::msgs::Discovery_Subscriber* temp = disc_contents_.sub_;
2624  disc_contents_.sub_ = nullptr;
2625  return temp;
2626  } else {
2627  return nullptr;
2628  }
2629 }
2630 inline void Discovery::unsafe_arena_set_allocated_sub(::ignition::msgs::Discovery_Subscriber* sub) {
2631  clear_disc_contents();
2632  if (sub) {
2633  set_has_sub();
2634  disc_contents_.sub_ = sub;
2635  }
2636  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ignition.msgs.Discovery.sub)
2637 }
2638 inline ::ignition::msgs::Discovery_Subscriber* Discovery::_internal_mutable_sub() {
2639  if (!_internal_has_sub()) {
2640  clear_disc_contents();
2641  set_has_sub();
2642  disc_contents_.sub_ = CreateMaybeMessage< ::ignition::msgs::Discovery_Subscriber >(GetArena());
2643  }
2644  return disc_contents_.sub_;
2645 }
2646 inline ::ignition::msgs::Discovery_Subscriber* Discovery::mutable_sub() {
2647  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.sub)
2648  return _internal_mutable_sub();
2649 }
2650 
2651 // .ignition.msgs.Discovery.Publisher pub = 7;
2652 inline bool Discovery::_internal_has_pub() const {
2653  return disc_contents_case() == kPub;
2654 }
2655 inline bool Discovery::has_pub() const {
2656  return _internal_has_pub();
2657 }
2658 inline void Discovery::set_has_pub() {
2659  _oneof_case_[0] = kPub;
2660 }
2661 inline void Discovery::clear_pub() {
2662  if (_internal_has_pub()) {
2663  if (GetArena() == nullptr) {
2664  delete disc_contents_.pub_;
2665  }
2666  clear_has_disc_contents();
2667  }
2668 }
2669 inline ::ignition::msgs::Discovery_Publisher* Discovery::release_pub() {
2670  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.pub)
2671  if (_internal_has_pub()) {
2672  clear_has_disc_contents();
2673  ::ignition::msgs::Discovery_Publisher* temp = disc_contents_.pub_;
2674  if (GetArena() != nullptr) {
2675  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2676  }
2677  disc_contents_.pub_ = nullptr;
2678  return temp;
2679  } else {
2680  return nullptr;
2681  }
2682 }
2683 inline const ::ignition::msgs::Discovery_Publisher& Discovery::_internal_pub() const {
2684  return _internal_has_pub()
2685  ? *disc_contents_.pub_
2686  : reinterpret_cast< ::ignition::msgs::Discovery_Publisher&>(::ignition::msgs::_Discovery_Publisher_default_instance_);
2687 }
2688 inline const ::ignition::msgs::Discovery_Publisher& Discovery::pub() const {
2689  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.pub)
2690  return _internal_pub();
2691 }
2692 inline ::ignition::msgs::Discovery_Publisher* Discovery::unsafe_arena_release_pub() {
2693  // @@protoc_insertion_point(field_unsafe_arena_release:ignition.msgs.Discovery.pub)
2694  if (_internal_has_pub()) {
2695  clear_has_disc_contents();
2696  ::ignition::msgs::Discovery_Publisher* temp = disc_contents_.pub_;
2697  disc_contents_.pub_ = nullptr;
2698  return temp;
2699  } else {
2700  return nullptr;
2701  }
2702 }
2703 inline void Discovery::unsafe_arena_set_allocated_pub(::ignition::msgs::Discovery_Publisher* pub) {
2704  clear_disc_contents();
2705  if (pub) {
2706  set_has_pub();
2707  disc_contents_.pub_ = pub;
2708  }
2709  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ignition.msgs.Discovery.pub)
2710 }
2711 inline ::ignition::msgs::Discovery_Publisher* Discovery::_internal_mutable_pub() {
2712  if (!_internal_has_pub()) {
2713  clear_disc_contents();
2714  set_has_pub();
2715  disc_contents_.pub_ = CreateMaybeMessage< ::ignition::msgs::Discovery_Publisher >(GetArena());
2716  }
2717  return disc_contents_.pub_;
2718 }
2719 inline ::ignition::msgs::Discovery_Publisher* Discovery::mutable_pub() {
2720  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.pub)
2721  return _internal_mutable_pub();
2722 }
2723 
2724 inline bool Discovery::has_disc_contents() const {
2725  return disc_contents_case() != DISC_CONTENTS_NOT_SET;
2726 }
2727 inline void Discovery::clear_has_disc_contents() {
2728  _oneof_case_[0] = DISC_CONTENTS_NOT_SET;
2729 }
2730 inline Discovery::DiscContentsCase Discovery::disc_contents_case() const {
2731  return Discovery::DiscContentsCase(_oneof_case_[0]);
2732 }
2733 #ifdef __GNUC__
2734  #pragma GCC diagnostic pop
2735 #endif // __GNUC__
2736 // -------------------------------------------------------------------
2737 
2738 // -------------------------------------------------------------------
2739 
2740 // -------------------------------------------------------------------
2741 
2742 // -------------------------------------------------------------------
2743 
2744 // -------------------------------------------------------------------
2745 
2746 
2751 // @@protoc_insertion_point(namespace_scope)
2752 
2753 } // namespace msgs
2754 } // namespace ignition
2755 
2756 PROTOBUF_NAMESPACE_OPEN
2757 
2758 template <> struct is_proto_enum< ::ignition::msgs::Discovery_Publisher_Scope> : ::std::true_type {};
2759 template <>
2760 inline const EnumDescriptor* GetEnumDescriptor< ::ignition::msgs::Discovery_Publisher_Scope>() {
2762 }
2763 template <> struct is_proto_enum< ::ignition::msgs::Discovery_Type> : ::std::true_type {};
2764 template <>
2765 inline const EnumDescriptor* GetEnumDescriptor< ::ignition::msgs::Discovery_Type>() {
2767 }
2768 
2769 PROTOBUF_NAMESPACE_CLOSE
2770 
2771 #ifdef _MSC_VER
2772 #pragma warning(pop)
2773 #endif
2774 // @@protoc_insertion_point(global_scope)
2775 
2776 #include <google/protobuf/port_undef.inc>
2777 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_ignition_2fmsgs_2fdiscovery_2eproto
Definition: actor.pb.h:98
void UnsafeArenaSwap(Discovery_Subscriber *other)
Definition: discovery.pb.h:362
Discovery_Publisher_MessagePublisher MessagePublisher
Definition: discovery.pb.h:928
std::string * release_process_uuid()
static const Discovery_Publisher * internal_default_instance()
Definition: discovery.pb.h:855
::PROTOBUF_NAMESPACE_ID::uint32 version() const
static bool Scope_IsValid(int value)
Definition: discovery.pb.h:938
void set_socket_id(std::string &&value)
virtual ~Discovery_Publisher_MessagePublisher()
Discovery(::PROTOBUF_NAMESPACE_ID::Arena *arena)
static const ::PROTOBUF_NAMESPACE_ID::Reflection * GetReflection()
Definition: discovery.pb.h:192
PubTypeCase pub_type_case() const
void set_allocated_sub(::ignition::msgs::Discovery_Subscriber *sub)
Discovery_Publisher()
Definition: discovery.pb.h:816
void set_socket_id(const char *value, size_t size)
void set_version(::PROTOBUF_NAMESPACE_ID::uint32 value)
Discovery_Publisher & operator=(const Discovery_Publisher &from)
Definition: discovery.pb.h:825
friend void swap(Discovery_Flags &a, Discovery_Flags &b)
Definition: discovery.pb.h:204
Discovery_Type Type
Definition: discovery.pb.h:1233
friend void swap(Discovery_Publisher &a, Discovery_Publisher &b)
Definition: discovery.pb.h:862
friend void swap(Discovery_Publisher_MessagePublisher &a, Discovery_Publisher_MessagePublisher &b)
Definition: discovery.pb.h:494
static const std::string & Type_Name(T enum_t_value)
Definition: discovery.pb.h:1264
void Swap(Discovery *other)
Definition: discovery.pb.h:1166
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final
void unsafe_arena_set_allocated_msg_pub(::ignition::msgs::Discovery_Publisher_MessagePublisher *msg_pub)
Discovery_Publisher_MessagePublisher * New(::PROTOBUF_NAMESPACE_ID::Arena *arena) const final
Definition: discovery.pb.h:517
::ignition::msgs::Header * release_header()
DiscContentsCase
Definition: discovery.pb.h:1150
static const Discovery * internal_default_instance()
Definition: discovery.pb.h:1156
const std::string & socket_id() const
Discovery_Subscriber * New() const final
Definition: discovery.pb.h:370
::ignition::msgs::Header * mutable_header()
void CopyFrom(const Discovery &from)
Discovery_Publisher * New(::PROTOBUF_NAMESPACE_ID::Arena *arena) const final
Definition: discovery.pb.h:885
Discovery_Flags(const Discovery_Flags &from)
static const ::PROTOBUF_NAMESPACE_ID::Descriptor * descriptor()
Definition: discovery.pb.h:186
void UnsafeArenaSwap(Discovery_Publisher *other)
Definition: discovery.pb.h:873
void set_allocated_process_uuid(std::string *process_uuid)
Discovery_Subscriber(const Discovery_Subscriber &from)
static const Discovery_Subscriber * internal_default_instance()
Definition: discovery.pb.h:344
void set_ctrl(const char *value)
const ::ignition::msgs::Discovery_Publisher_MessagePublisher & msg_pub() const
void set_process_uuid(const std::string &value)
void set_address(const char *value)
Discovery * New() const final
Definition: discovery.pb.h:1182
const std::string & topic() const
Discovery_Flags * New(::PROTOBUF_NAMESPACE_ID::Arena *arena) const final
Definition: discovery.pb.h:227
Discovery_Publisher_MessagePublisher & operator=(Discovery_Publisher_MessagePublisher &&from) noexcept
Definition: discovery.pb.h:467
Discovery_Publisher_MessagePublisher * New() const final
Definition: discovery.pb.h:513
Discovery & operator=(const Discovery &from)
Definition: discovery.pb.h:1126
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * Type_descriptor()
Definition: discovery.pb.h:1260
static const Discovery_Publisher_MessagePublisher * internal_default_instance()
Definition: discovery.pb.h:487
void CopyFrom(const Discovery_Subscriber &from)
static bool Scope_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Scope *value)
Definition: discovery.pb.h:958
void set_allocated_msg_type(std::string *msg_type)
void set_topic(const std::string &value)
Discovery_Publisher_ServicePublisher(Discovery_Publisher_ServicePublisher &&from) noexcept
Definition: discovery.pb.h:641
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message &from) final
std::string * release_socket_id()
void set_allocated_flags(::ignition::msgs::Discovery_Flags *flags)
const std::string & process_uuid() const
::PROTOBUF_NAMESPACE_ID::uint64 msgs_per_sec() const
Discovery_Publisher_ServicePublisher ServicePublisher
Definition: discovery.pb.h:929
void CopyFrom(const Discovery_Flags &from)
::ignition::msgs::Discovery_Subscriber * unsafe_arena_release_sub()
Discovery_Publisher_MessagePublisher(const Discovery_Publisher_MessagePublisher &from)
Discovery_Flags & operator=(const Discovery_Flags &from)
Definition: discovery.pb.h:173
DiscContentsCase disc_contents_case() const
::ignition::msgs::Discovery_Flags * mutable_flags()
Discovery_Publisher(::PROTOBUF_NAMESPACE_ID::Arena *arena)
::ignition::msgs::Discovery_Publisher_Scope scope() const
void set_address(const char *value, size_t size)
void UnsafeArenaSwap(Discovery *other)
Definition: discovery.pb.h:1174
Discovery_Publisher(Discovery_Publisher &&from) noexcept
Definition: discovery.pb.h:820
PubTypeCase
Definition: discovery.pb.h:849
void set_allocated_srv_pub(::ignition::msgs::Discovery_Publisher_ServicePublisher *srv_pub)
friend void swap(Discovery_Subscriber &a, Discovery_Subscriber &b)
Definition: discovery.pb.h:351
std::string * mutable_response_type()
static bool Type_IsValid(int value)
Definition: discovery.pb.h:1250
Discovery_Publisher & operator=(Discovery_Publisher &&from) noexcept
Definition: discovery.pb.h:829
void set_msgs_per_sec(::PROTOBUF_NAMESPACE_ID::uint64 value)
Discovery_Publisher_MessagePublisher(::PROTOBUF_NAMESPACE_ID::Arena *arena)
static const Discovery_Publisher_MessagePublisher & default_instance()
void set_allocated_address(std::string *address)
::ignition::msgs::Discovery_Publisher_MessagePublisher * unsafe_arena_release_msg_pub()
void Swap(Discovery_Publisher_MessagePublisher *other)
Definition: discovery.pb.h:497
static const Discovery_Publisher_ServicePublisher & default_instance()
Discovery * New(::PROTOBUF_NAMESPACE_ID::Arena *arena) const final
Definition: discovery.pb.h:1186
void set_allocated_response_type(std::string *response_type)
::ignition::msgs::Discovery_Flags * unsafe_arena_release_flags()
void unsafe_arena_set_allocated_header(::ignition::msgs::Header *header)
std::string * mutable_request_type()
Discovery_Publisher Publisher
Definition: discovery.pb.h:1231
friend void swap(Discovery &a, Discovery &b)
Definition: discovery.pb.h:1163
::ignition::msgs::Discovery_Publisher_ServicePublisher * release_srv_pub()
Discovery_Subscriber Subscriber
Definition: discovery.pb.h:1230
void set_allocated_ctrl(std::string *ctrl)
void unsafe_arena_set_allocated_srv_pub(::ignition::msgs::Discovery_Publisher_ServicePublisher *srv_pub)
static const std::string & Scope_Name(T enum_t_value)
Definition: discovery.pb.h:952
static const Discovery & default_instance()
void set_msg_type(std::string &&value)
void set_ctrl(const char *value, size_t size)
void set_process_uuid(const char *value, size_t size)
void MergeFrom(const Discovery_Publisher_ServicePublisher &from)
Discovery_Publisher_ServicePublisher(const Discovery_Publisher_ServicePublisher &from)
Discovery_Subscriber(Discovery_Subscriber &&from) noexcept
Definition: discovery.pb.h:315
void set_node_uuid(const char *value, size_t size)
void UnsafeArenaSwap(Discovery_Publisher_MessagePublisher *other)
Definition: discovery.pb.h:505
friend void swap(Discovery_Publisher_ServicePublisher &a, Discovery_Publisher_ServicePublisher &b)
Definition: discovery.pb.h:677
void Swap(Discovery_Flags *other)
Definition: discovery.pb.h:207
std::string * release_request_type()
Discovery_Publisher_ServicePublisher & operator=(Discovery_Publisher_ServicePublisher &&from) noexcept
Definition: discovery.pb.h:650
void set_allocated_topic(std::string *topic)
Discovery_Flags(Discovery_Flags &&from) noexcept
Definition: discovery.pb.h:168
void MergeFrom(const Discovery_Flags &from)
::ignition::msgs::Header * unsafe_arena_release_header()
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message &from) final
void set_topic(const char *value, size_t size)
std::string * mutable_socket_id()
void set_topic(std::string &&value)
void set_ctrl(const std::string &value)
void set_response_type(const char *value)
Discovery_Publisher_ServicePublisher * New(::PROTOBUF_NAMESPACE_ID::Arena *arena) const final
Definition: discovery.pb.h:700
std::string * release_msg_type()
void set_request_type(std::string &&value)
Discovery & operator=(Discovery &&from) noexcept
Definition: discovery.pb.h:1130
Discovery(const Discovery &from)
::ignition::msgs::Discovery_Subscriber * mutable_sub()
Discovery_Publisher(const Discovery_Publisher &from)
const std::string & msg_type() const
Discovery_Subscriber & operator=(const Discovery_Subscriber &from)
Definition: discovery.pb.h:320
const std::string & node_uuid() const
void set_response_type(const std::string &value)
static const Discovery_Publisher & default_instance()
void set_response_type(const char *value, size_t size)
static bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Type *value)
Definition: discovery.pb.h:1270
void set_process_uuid(std::string &&value)
Discovery_Flags Flags
Definition: discovery.pb.h:1229
void set_allocated_pub(::ignition::msgs::Discovery_Publisher *pub)
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * Scope_descriptor()
Definition: discovery.pb.h:948
void MergeFrom(const Discovery_Publisher &from)
void set_scope(::ignition::msgs::Discovery_Publisher_Scope value)
void unsafe_arena_set_allocated_sub(::ignition::msgs::Discovery_Subscriber *sub)
void set_msg_type(const char *value, size_t size)
void set_response_type(std::string &&value)
::ignition::msgs::Discovery_Publisher_ServicePublisher * mutable_srv_pub()
void set_allocated_header(::ignition::msgs::Header *header)
void set_address(std::string &&value)
void set_allocated_msg_pub(::ignition::msgs::Discovery_Publisher_MessagePublisher *msg_pub)
void MergeFrom(const Discovery &from)
void set_throttled(bool value)
::ignition::msgs::Discovery_Publisher_MessagePublisher * mutable_msg_pub()
Discovery_Publisher_ServicePublisher * New() const final
Definition: discovery.pb.h:696
const std::string & ctrl() const
void set_ctrl(std::string &&value)
::ignition::msgs::Discovery_Subscriber * release_sub()
Discovery_Subscriber()
Definition: discovery.pb.h:311
void CopyFrom(const Discovery_Publisher_ServicePublisher &from)
const std::string & request_type() const
std::string * mutable_node_uuid()
void set_allocated_request_type(std::string *request_type)
void set_node_uuid(const std::string &value)
Discovery_Flags * New() const final
Definition: discovery.pb.h:223
::ignition::msgs::Discovery_Publisher * unsafe_arena_release_pub()
std::string * mutable_msg_type()
Discovery_Publisher_ServicePublisher()
Definition: discovery.pb.h:637
Discovery_Publisher_MessagePublisher(Discovery_Publisher_MessagePublisher &&from) noexcept
Definition: discovery.pb.h:458
Discovery_Publisher_MessagePublisher()
Definition: discovery.pb.h:454
Discovery_Publisher * New() const final
Definition: discovery.pb.h:881
const std::string & address() const
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final
Discovery_Subscriber & operator=(Discovery_Subscriber &&from) noexcept
Definition: discovery.pb.h:324
Discovery(Discovery &&from) noexcept
Definition: discovery.pb.h:1121
Discovery_Subscriber(::PROTOBUF_NAMESPACE_ID::Arena *arena)
static const ::PROTOBUF_NAMESPACE_ID::Descriptor * GetDescriptor()
Definition: discovery.pb.h:189
void set_topic(const char *value)
Discovery()
Definition: discovery.pb.h:1117
Discovery_Publisher_Scope Scope
Definition: discovery.pb.h:931
const ::ignition::msgs::Discovery_Publisher & pub() const
const std::string & response_type() const
void CopyFrom(const Discovery_Publisher_MessagePublisher &from)
void Swap(Discovery_Publisher_ServicePublisher *other)
Definition: discovery.pb.h:680
::ignition::msgs::Discovery_Publisher * release_pub()
Discovery_Flags & operator=(Discovery_Flags &&from) noexcept
Definition: discovery.pb.h:177
std::string * mutable_process_uuid()
Discovery_Publisher_ServicePublisher & operator=(const Discovery_Publisher_ServicePublisher &from)
Definition: discovery.pb.h:646
void set_type(::ignition::msgs::Discovery_Type value)
void UnsafeArenaSwap(Discovery_Publisher_ServicePublisher *other)
Definition: discovery.pb.h:688
void UnsafeArenaSwap(Discovery_Flags *other)
Definition: discovery.pb.h:215
void unsafe_arena_set_allocated_pub(::ignition::msgs::Discovery_Publisher *pub)
void set_allocated_node_uuid(std::string *node_uuid)
const ::ignition::msgs::Discovery_Subscriber & sub() const
static const Discovery_Subscriber & default_instance()
Discovery_Flags()
Definition: discovery.pb.h:164
void set_node_uuid(const char *value)
void MergeFrom(const Discovery_Publisher_MessagePublisher &from)
::ignition::msgs::Discovery_Flags * release_flags()
void Swap(Discovery_Publisher *other)
Definition: discovery.pb.h:865
void unsafe_arena_set_allocated_flags(::ignition::msgs::Discovery_Flags *flags)
void set_address(const std::string &value)
::ignition::msgs::Discovery_Publisher_MessagePublisher * release_msg_pub()
void MergeFrom(const Discovery_Subscriber &from)
::ignition::msgs::Discovery_Publisher * mutable_pub()
Discovery_Subscriber * New(::PROTOBUF_NAMESPACE_ID::Arena *arena) const final
Definition: discovery.pb.h:374
void set_socket_id(const char *value)
void Swap(Discovery_Subscriber *other)
Definition: discovery.pb.h:354
const ::ignition::msgs::Discovery_Publisher_ServicePublisher & srv_pub() const
static const Discovery_Flags * internal_default_instance()
Definition: discovery.pb.h:197
void set_allocated_socket_id(std::string *socket_id)
void CopyFrom(const Discovery_Publisher &from)
void set_process_uuid(const char *value)
void set_request_type(const char *value, size_t size)
std::string * release_node_uuid()
static const Discovery_Publisher_ServicePublisher * internal_default_instance()
Definition: discovery.pb.h:670
static const Discovery_Flags & default_instance()
void set_msg_type(const char *value)
void set_node_uuid(std::string &&value)
void set_msg_type(const std::string &value)
const ::ignition::msgs::Header & header() const
void set_request_type(const std::string &value)
void set_socket_id(const std::string &value)
Discovery_Publisher_MessagePublisher & operator=(const Discovery_Publisher_MessagePublisher &from)
Definition: discovery.pb.h:463
const ::ignition::msgs::Discovery_Flags & flags() const
Discovery_Flags(::PROTOBUF_NAMESPACE_ID::Arena *arena)
::ignition::msgs::Discovery_Type type() const
virtual ~Discovery_Publisher_ServicePublisher()
Discovery_Publisher_ServicePublisher(::PROTOBUF_NAMESPACE_ID::Arena *arena)
void set_request_type(const char *value)
::ignition::msgs::Discovery_Publisher_ServicePublisher * unsafe_arena_release_srv_pub()
std::string * release_response_type()
IGNITION_MSGS_VISIBLEconst ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_ignition_2fmsgs_2fdiscovery_2eproto
T max(T... args)
T min(T... args)
IGNITION_MSGS_VISIBLE Discovery_SubscriberDefaultTypeInternal _Discovery_Subscriber_default_instance_
constexpr Discovery_Publisher_Scope Discovery_Publisher_Scope_Scope_MIN
Definition: discovery.pb.h:110
IGNITION_MSGS_VISIBLE DiscoveryDefaultTypeInternal _Discovery_default_instance_
constexpr Discovery_Type Discovery_Type_Type_MAX
Definition: discovery.pb.h:142
std::unique_ptr< const Discovery > ConstDiscoveryUniquePtr
Definition: discovery.pb.h:2748
IGNITION_MSGS_VISIBLE bool Discovery_Publisher_Scope_IsValid(int value)
IGNITION_MSGS_VISIBLEconst ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * Discovery_Type_descriptor()
constexpr Discovery_Publisher_Scope Discovery_Publisher_Scope_Scope_MAX
Definition: discovery.pb.h:111
IGNITION_MSGS_VISIBLE Discovery_Publisher_ServicePublisherDefaultTypeInternal _Discovery_Publisher_ServicePublisher_default_instance_
std::unique_ptr< Discovery > DiscoveryUniquePtr
Definition: discovery.pb.h:2747
bool Discovery_Publisher_Scope_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Discovery_Publisher_Scope *value)
Definition: discovery.pb.h:123
bool Discovery_Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Discovery_Type *value)
Definition: discovery.pb.h:154
IGNITION_MSGS_VISIBLE bool Discovery_Type_IsValid(int value)
IGNITION_MSGS_VISIBLE HeaderDefaultTypeInternal _Header_default_instance_
constexpr Discovery_Type Discovery_Type_Type_MIN
Definition: discovery.pb.h:141
Discovery_Publisher_Scope
Definition: discovery.pb.h:102
@ Discovery_Publisher_Scope_HOST
Definition: discovery.pb.h:104
@ Discovery_Publisher_Scope_Discovery_Publisher_Scope_INT_MAX_SENTINEL_DO_NOT_USE_
Definition: discovery.pb.h:107
@ Discovery_Publisher_Scope_ALL
Definition: discovery.pb.h:105
@ Discovery_Publisher_Scope_PROCESS
Definition: discovery.pb.h:103
@ Discovery_Publisher_Scope_Discovery_Publisher_Scope_INT_MIN_SENTINEL_DO_NOT_USE_
Definition: discovery.pb.h:106
IGNITION_MSGS_VISIBLE Discovery_Publisher_MessagePublisherDefaultTypeInternal _Discovery_Publisher_MessagePublisher_default_instance_
IGNITION_MSGS_VISIBLE Discovery_PublisherDefaultTypeInternal _Discovery_Publisher_default_instance_
constexpr int Discovery_Type_Type_ARRAYSIZE
Definition: discovery.pb.h:143
std::shared_ptr< const Discovery > ConstDiscoverySharedPtr
Definition: discovery.pb.h:2750
constexpr int Discovery_Publisher_Scope_Scope_ARRAYSIZE
Definition: discovery.pb.h:112
const std::string & Discovery_Type_Name(T enum_t_value)
Definition: discovery.pb.h:147
IGNITION_MSGS_VISIBLE Discovery_FlagsDefaultTypeInternal _Discovery_Flags_default_instance_
Atmosphere_Type
Definition: atmosphere.pb.h:82
IGNITION_MSGS_VISIBLEconst ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * Discovery_Publisher_Scope_descriptor()
const std::string & Discovery_Publisher_Scope_Name(T enum_t_value)
Definition: discovery.pb.h:116
Discovery_Type
Definition: discovery.pb.h:128
@ Discovery_Type_ADVERTISE
Definition: discovery.pb.h:130
@ Discovery_Type_Discovery_Type_INT_MAX_SENTINEL_DO_NOT_USE_
Definition: discovery.pb.h:138
@ Discovery_Type_HEARTBEAT
Definition: discovery.pb.h:133
@ Discovery_Type_Discovery_Type_INT_MIN_SENTINEL_DO_NOT_USE_
Definition: discovery.pb.h:137
@ Discovery_Type_NEW_CONNECTION
Definition: discovery.pb.h:135
@ Discovery_Type_UNADVERTISE
Definition: discovery.pb.h:132
@ Discovery_Type_UNINITIALIZED
Definition: discovery.pb.h:129
@ Discovery_Type_END_CONNECTION
Definition: discovery.pb.h:136
@ Discovery_Type_SUBSCRIBE
Definition: discovery.pb.h:131
@ Discovery_Type_BYE
Definition: discovery.pb.h:134
std::shared_ptr< Discovery > DiscoverySharedPtr
Definition: discovery.pb.h:2749
Definition: actor.pb.h:52
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold)
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] PROTOBUF_SECTION_VARIABLE(protodesc_cold)
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[6] PROTOBUF_SECTION_VARIABLE(protodesc_cold)