// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: ignition/msgs/discovery.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_ignition_2fmsgs_2fdiscovery_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_ignition_2fmsgs_2fdiscovery_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3018000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3018000 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "ignition/msgs/header.pb.h"
#ifndef _MSC_VER
#pragma GCC system_header
#else
#pragma warning(push)
#pragma warning(disable: 4244 4267 4100 4244 4512 4127 4068 4275 4251)
#endif
#ifdef __linux__
#include <sys/sysmacros.h>
#endif
#include <memory>
#include <ignition/msgs/Export.hh>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_ignition_2fmsgs_2fdiscovery_2eproto IGNITION_MSGS_VISIBLE
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct IGNITION_MSGS_VISIBLE TableStruct_ignition_2fmsgs_2fdiscovery_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[6]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
IGNITION_MSGS_VISIBLE extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_ignition_2fmsgs_2fdiscovery_2eproto;
namespace ignition {
namespace msgs {
class Discovery;
struct DiscoveryDefaultTypeInternal;
IGNITION_MSGS_VISIBLE extern DiscoveryDefaultTypeInternal _Discovery_default_instance_;
class Discovery_Flags;
struct Discovery_FlagsDefaultTypeInternal;
IGNITION_MSGS_VISIBLE extern Discovery_FlagsDefaultTypeInternal _Discovery_Flags_default_instance_;
class Discovery_Publisher;
struct Discovery_PublisherDefaultTypeInternal;
IGNITION_MSGS_VISIBLE extern Discovery_PublisherDefaultTypeInternal _Discovery_Publisher_default_instance_;
class Discovery_Publisher_MessagePublisher;
struct Discovery_Publisher_MessagePublisherDefaultTypeInternal;
IGNITION_MSGS_VISIBLE extern Discovery_Publisher_MessagePublisherDefaultTypeInternal _Discovery_Publisher_MessagePublisher_default_instance_;
class Discovery_Publisher_ServicePublisher;
struct Discovery_Publisher_ServicePublisherDefaultTypeInternal;
IGNITION_MSGS_VISIBLE extern Discovery_Publisher_ServicePublisherDefaultTypeInternal _Discovery_Publisher_ServicePublisher_default_instance_;
class Discovery_Subscriber;
struct Discovery_SubscriberDefaultTypeInternal;
IGNITION_MSGS_VISIBLE extern Discovery_SubscriberDefaultTypeInternal _Discovery_Subscriber_default_instance_;
}  // namespace msgs
}  // namespace ignition
PROTOBUF_NAMESPACE_OPEN
template<> IGNITION_MSGS_VISIBLE ::ignition::msgs::Discovery* Arena::CreateMaybeMessage<::ignition::msgs::Discovery>(Arena*);
template<> IGNITION_MSGS_VISIBLE ::ignition::msgs::Discovery_Flags* Arena::CreateMaybeMessage<::ignition::msgs::Discovery_Flags>(Arena*);
template<> IGNITION_MSGS_VISIBLE ::ignition::msgs::Discovery_Publisher* Arena::CreateMaybeMessage<::ignition::msgs::Discovery_Publisher>(Arena*);
template<> IGNITION_MSGS_VISIBLE ::ignition::msgs::Discovery_Publisher_MessagePublisher* Arena::CreateMaybeMessage<::ignition::msgs::Discovery_Publisher_MessagePublisher>(Arena*);
template<> IGNITION_MSGS_VISIBLE ::ignition::msgs::Discovery_Publisher_ServicePublisher* Arena::CreateMaybeMessage<::ignition::msgs::Discovery_Publisher_ServicePublisher>(Arena*);
template<> IGNITION_MSGS_VISIBLE ::ignition::msgs::Discovery_Subscriber* Arena::CreateMaybeMessage<::ignition::msgs::Discovery_Subscriber>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace ignition {
namespace msgs {

enum Discovery_Publisher_Scope : int {
  Discovery_Publisher_Scope_PROCESS = 0,
  Discovery_Publisher_Scope_HOST = 1,
  Discovery_Publisher_Scope_ALL = 2,
  Discovery_Publisher_Scope_Discovery_Publisher_Scope_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  Discovery_Publisher_Scope_Discovery_Publisher_Scope_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
IGNITION_MSGS_VISIBLE bool Discovery_Publisher_Scope_IsValid(int value);
constexpr Discovery_Publisher_Scope Discovery_Publisher_Scope_Scope_MIN = Discovery_Publisher_Scope_PROCESS;
constexpr Discovery_Publisher_Scope Discovery_Publisher_Scope_Scope_MAX = Discovery_Publisher_Scope_ALL;
constexpr int Discovery_Publisher_Scope_Scope_ARRAYSIZE = Discovery_Publisher_Scope_Scope_MAX + 1;

IGNITION_MSGS_VISIBLE const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Discovery_Publisher_Scope_descriptor();
template<typename T>
inline const std::string& Discovery_Publisher_Scope_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Discovery_Publisher_Scope>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Discovery_Publisher_Scope_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Discovery_Publisher_Scope_descriptor(), enum_t_value);
}
inline bool Discovery_Publisher_Scope_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Discovery_Publisher_Scope* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Discovery_Publisher_Scope>(
    Discovery_Publisher_Scope_descriptor(), name, value);
}
enum Discovery_Type : int {
  Discovery_Type_UNINITIALIZED = 0,
  Discovery_Type_ADVERTISE = 1,
  Discovery_Type_SUBSCRIBE = 2,
  Discovery_Type_UNADVERTISE = 3,
  Discovery_Type_HEARTBEAT = 4,
  Discovery_Type_BYE = 5,
  Discovery_Type_NEW_CONNECTION = 6,
  Discovery_Type_END_CONNECTION = 7,
  Discovery_Type_Discovery_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  Discovery_Type_Discovery_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
IGNITION_MSGS_VISIBLE bool Discovery_Type_IsValid(int value);
constexpr Discovery_Type Discovery_Type_Type_MIN = Discovery_Type_UNINITIALIZED;
constexpr Discovery_Type Discovery_Type_Type_MAX = Discovery_Type_END_CONNECTION;
constexpr int Discovery_Type_Type_ARRAYSIZE = Discovery_Type_Type_MAX + 1;

IGNITION_MSGS_VISIBLE const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Discovery_Type_descriptor();
template<typename T>
inline const std::string& Discovery_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Discovery_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Discovery_Type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Discovery_Type_descriptor(), enum_t_value);
}
inline bool Discovery_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Discovery_Type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Discovery_Type>(
    Discovery_Type_descriptor(), name, value);
}
// ===================================================================

class IGNITION_MSGS_VISIBLE Discovery_Flags final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ignition.msgs.Discovery.Flags) */ {
 public:
  inline Discovery_Flags() : Discovery_Flags(nullptr) {}
  ~Discovery_Flags() override;
  explicit constexpr Discovery_Flags(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Discovery_Flags(const Discovery_Flags& from);
  Discovery_Flags(Discovery_Flags&& from) noexcept
    : Discovery_Flags() {
    *this = ::std::move(from);
  }

  inline Discovery_Flags& operator=(const Discovery_Flags& from) {
    CopyFrom(from);
    return *this;
  }
  inline Discovery_Flags& operator=(Discovery_Flags&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Discovery_Flags& default_instance() {
    return *internal_default_instance();
  }
  static inline const Discovery_Flags* internal_default_instance() {
    return reinterpret_cast<const Discovery_Flags*>(
               &_Discovery_Flags_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(Discovery_Flags& a, Discovery_Flags& b) {
    a.Swap(&b);
  }
  inline void Swap(Discovery_Flags* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Discovery_Flags* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Discovery_Flags* New() const final {
    return new Discovery_Flags();
  }

  Discovery_Flags* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Discovery_Flags>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Discovery_Flags& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Discovery_Flags& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Discovery_Flags* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ignition.msgs.Discovery.Flags";
  }
  protected:
  explicit Discovery_Flags(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRelayFieldNumber = 1,
    kNoRelayFieldNumber = 2,
  };
  // bool relay = 1;
  void clear_relay();
  bool relay() const;
  void set_relay(bool value);
  private:
  bool _internal_relay() const;
  void _internal_set_relay(bool value);
  public:

  // bool no_relay = 2;
  void clear_no_relay();
  bool no_relay() const;
  void set_no_relay(bool value);
  private:
  bool _internal_no_relay() const;
  void _internal_set_no_relay(bool value);
  public:

  // @@protoc_insertion_point(class_scope:ignition.msgs.Discovery.Flags)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  bool relay_;
  bool no_relay_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ignition_2fmsgs_2fdiscovery_2eproto;
};
// -------------------------------------------------------------------

class IGNITION_MSGS_VISIBLE Discovery_Subscriber final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ignition.msgs.Discovery.Subscriber) */ {
 public:
  inline Discovery_Subscriber() : Discovery_Subscriber(nullptr) {}
  ~Discovery_Subscriber() override;
  explicit constexpr Discovery_Subscriber(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Discovery_Subscriber(const Discovery_Subscriber& from);
  Discovery_Subscriber(Discovery_Subscriber&& from) noexcept
    : Discovery_Subscriber() {
    *this = ::std::move(from);
  }

  inline Discovery_Subscriber& operator=(const Discovery_Subscriber& from) {
    CopyFrom(from);
    return *this;
  }
  inline Discovery_Subscriber& operator=(Discovery_Subscriber&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Discovery_Subscriber& default_instance() {
    return *internal_default_instance();
  }
  static inline const Discovery_Subscriber* internal_default_instance() {
    return reinterpret_cast<const Discovery_Subscriber*>(
               &_Discovery_Subscriber_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(Discovery_Subscriber& a, Discovery_Subscriber& b) {
    a.Swap(&b);
  }
  inline void Swap(Discovery_Subscriber* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Discovery_Subscriber* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Discovery_Subscriber* New() const final {
    return new Discovery_Subscriber();
  }

  Discovery_Subscriber* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Discovery_Subscriber>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Discovery_Subscriber& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Discovery_Subscriber& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Discovery_Subscriber* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ignition.msgs.Discovery.Subscriber";
  }
  protected:
  explicit Discovery_Subscriber(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTopicFieldNumber = 1,
  };
  // string topic = 1;
  void clear_topic();
  const std::string& topic() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_topic(ArgT0&& arg0, ArgT... args);
  std::string* mutable_topic();
  PROTOBUF_MUST_USE_RESULT std::string* release_topic();
  void set_allocated_topic(std::string* topic);
  private:
  const std::string& _internal_topic() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_topic(const std::string& value);
  std::string* _internal_mutable_topic();
  public:

  // @@protoc_insertion_point(class_scope:ignition.msgs.Discovery.Subscriber)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr topic_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ignition_2fmsgs_2fdiscovery_2eproto;
};
// -------------------------------------------------------------------

class IGNITION_MSGS_VISIBLE Discovery_Publisher_MessagePublisher final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ignition.msgs.Discovery.Publisher.MessagePublisher) */ {
 public:
  inline Discovery_Publisher_MessagePublisher() : Discovery_Publisher_MessagePublisher(nullptr) {}
  ~Discovery_Publisher_MessagePublisher() override;
  explicit constexpr Discovery_Publisher_MessagePublisher(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Discovery_Publisher_MessagePublisher(const Discovery_Publisher_MessagePublisher& from);
  Discovery_Publisher_MessagePublisher(Discovery_Publisher_MessagePublisher&& from) noexcept
    : Discovery_Publisher_MessagePublisher() {
    *this = ::std::move(from);
  }

  inline Discovery_Publisher_MessagePublisher& operator=(const Discovery_Publisher_MessagePublisher& from) {
    CopyFrom(from);
    return *this;
  }
  inline Discovery_Publisher_MessagePublisher& operator=(Discovery_Publisher_MessagePublisher&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Discovery_Publisher_MessagePublisher& default_instance() {
    return *internal_default_instance();
  }
  static inline const Discovery_Publisher_MessagePublisher* internal_default_instance() {
    return reinterpret_cast<const Discovery_Publisher_MessagePublisher*>(
               &_Discovery_Publisher_MessagePublisher_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(Discovery_Publisher_MessagePublisher& a, Discovery_Publisher_MessagePublisher& b) {
    a.Swap(&b);
  }
  inline void Swap(Discovery_Publisher_MessagePublisher* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Discovery_Publisher_MessagePublisher* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Discovery_Publisher_MessagePublisher* New() const final {
    return new Discovery_Publisher_MessagePublisher();
  }

  Discovery_Publisher_MessagePublisher* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Discovery_Publisher_MessagePublisher>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Discovery_Publisher_MessagePublisher& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Discovery_Publisher_MessagePublisher& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Discovery_Publisher_MessagePublisher* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ignition.msgs.Discovery.Publisher.MessagePublisher";
  }
  protected:
  explicit Discovery_Publisher_MessagePublisher(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCtrlFieldNumber = 1,
    kMsgTypeFieldNumber = 2,
    kMsgsPerSecFieldNumber = 4,
    kThrottledFieldNumber = 3,
  };
  // string ctrl = 1;
  void clear_ctrl();
  const std::string& ctrl() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_ctrl(ArgT0&& arg0, ArgT... args);
  std::string* mutable_ctrl();
  PROTOBUF_MUST_USE_RESULT std::string* release_ctrl();
  void set_allocated_ctrl(std::string* ctrl);
  private:
  const std::string& _internal_ctrl() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ctrl(const std::string& value);
  std::string* _internal_mutable_ctrl();
  public:

  // string msg_type = 2;
  void clear_msg_type();
  const std::string& msg_type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_msg_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_msg_type();
  PROTOBUF_MUST_USE_RESULT std::string* release_msg_type();
  void set_allocated_msg_type(std::string* msg_type);
  private:
  const std::string& _internal_msg_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_msg_type(const std::string& value);
  std::string* _internal_mutable_msg_type();
  public:

  // uint64 msgs_per_sec = 4;
  void clear_msgs_per_sec();
  ::PROTOBUF_NAMESPACE_ID::uint64 msgs_per_sec() const;
  void set_msgs_per_sec(::PROTOBUF_NAMESPACE_ID::uint64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_msgs_per_sec() const;
  void _internal_set_msgs_per_sec(::PROTOBUF_NAMESPACE_ID::uint64 value);
  public:

  // bool throttled = 3;
  void clear_throttled();
  bool throttled() const;
  void set_throttled(bool value);
  private:
  bool _internal_throttled() const;
  void _internal_set_throttled(bool value);
  public:

  // @@protoc_insertion_point(class_scope:ignition.msgs.Discovery.Publisher.MessagePublisher)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ctrl_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr msg_type_;
  ::PROTOBUF_NAMESPACE_ID::uint64 msgs_per_sec_;
  bool throttled_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ignition_2fmsgs_2fdiscovery_2eproto;
};
// -------------------------------------------------------------------

class IGNITION_MSGS_VISIBLE Discovery_Publisher_ServicePublisher final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ignition.msgs.Discovery.Publisher.ServicePublisher) */ {
 public:
  inline Discovery_Publisher_ServicePublisher() : Discovery_Publisher_ServicePublisher(nullptr) {}
  ~Discovery_Publisher_ServicePublisher() override;
  explicit constexpr Discovery_Publisher_ServicePublisher(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Discovery_Publisher_ServicePublisher(const Discovery_Publisher_ServicePublisher& from);
  Discovery_Publisher_ServicePublisher(Discovery_Publisher_ServicePublisher&& from) noexcept
    : Discovery_Publisher_ServicePublisher() {
    *this = ::std::move(from);
  }

  inline Discovery_Publisher_ServicePublisher& operator=(const Discovery_Publisher_ServicePublisher& from) {
    CopyFrom(from);
    return *this;
  }
  inline Discovery_Publisher_ServicePublisher& operator=(Discovery_Publisher_ServicePublisher&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Discovery_Publisher_ServicePublisher& default_instance() {
    return *internal_default_instance();
  }
  static inline const Discovery_Publisher_ServicePublisher* internal_default_instance() {
    return reinterpret_cast<const Discovery_Publisher_ServicePublisher*>(
               &_Discovery_Publisher_ServicePublisher_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(Discovery_Publisher_ServicePublisher& a, Discovery_Publisher_ServicePublisher& b) {
    a.Swap(&b);
  }
  inline void Swap(Discovery_Publisher_ServicePublisher* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Discovery_Publisher_ServicePublisher* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Discovery_Publisher_ServicePublisher* New() const final {
    return new Discovery_Publisher_ServicePublisher();
  }

  Discovery_Publisher_ServicePublisher* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Discovery_Publisher_ServicePublisher>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Discovery_Publisher_ServicePublisher& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Discovery_Publisher_ServicePublisher& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Discovery_Publisher_ServicePublisher* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ignition.msgs.Discovery.Publisher.ServicePublisher";
  }
  protected:
  explicit Discovery_Publisher_ServicePublisher(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSocketIdFieldNumber = 1,
    kRequestTypeFieldNumber = 2,
    kResponseTypeFieldNumber = 3,
  };
  // string socket_id = 1;
  void clear_socket_id();
  const std::string& socket_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_socket_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_socket_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_socket_id();
  void set_allocated_socket_id(std::string* socket_id);
  private:
  const std::string& _internal_socket_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_socket_id(const std::string& value);
  std::string* _internal_mutable_socket_id();
  public:

  // string request_type = 2;
  void clear_request_type();
  const std::string& request_type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_request_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_request_type();
  PROTOBUF_MUST_USE_RESULT std::string* release_request_type();
  void set_allocated_request_type(std::string* request_type);
  private:
  const std::string& _internal_request_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_type(const std::string& value);
  std::string* _internal_mutable_request_type();
  public:

  // string response_type = 3;
  void clear_response_type();
  const std::string& response_type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_response_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_response_type();
  PROTOBUF_MUST_USE_RESULT std::string* release_response_type();
  void set_allocated_response_type(std::string* response_type);
  private:
  const std::string& _internal_response_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_response_type(const std::string& value);
  std::string* _internal_mutable_response_type();
  public:

  // @@protoc_insertion_point(class_scope:ignition.msgs.Discovery.Publisher.ServicePublisher)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr socket_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_type_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr response_type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ignition_2fmsgs_2fdiscovery_2eproto;
};
// -------------------------------------------------------------------

class IGNITION_MSGS_VISIBLE Discovery_Publisher final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ignition.msgs.Discovery.Publisher) */ {
 public:
  inline Discovery_Publisher() : Discovery_Publisher(nullptr) {}
  ~Discovery_Publisher() override;
  explicit constexpr Discovery_Publisher(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Discovery_Publisher(const Discovery_Publisher& from);
  Discovery_Publisher(Discovery_Publisher&& from) noexcept
    : Discovery_Publisher() {
    *this = ::std::move(from);
  }

  inline Discovery_Publisher& operator=(const Discovery_Publisher& from) {
    CopyFrom(from);
    return *this;
  }
  inline Discovery_Publisher& operator=(Discovery_Publisher&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Discovery_Publisher& default_instance() {
    return *internal_default_instance();
  }
  enum PubTypeCase {
    kMsgPub = 6,
    kSrvPub = 7,
    PUB_TYPE_NOT_SET = 0,
  };

  static inline const Discovery_Publisher* internal_default_instance() {
    return reinterpret_cast<const Discovery_Publisher*>(
               &_Discovery_Publisher_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(Discovery_Publisher& a, Discovery_Publisher& b) {
    a.Swap(&b);
  }
  inline void Swap(Discovery_Publisher* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Discovery_Publisher* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Discovery_Publisher* New() const final {
    return new Discovery_Publisher();
  }

  Discovery_Publisher* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Discovery_Publisher>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Discovery_Publisher& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Discovery_Publisher& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Discovery_Publisher* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ignition.msgs.Discovery.Publisher";
  }
  protected:
  explicit Discovery_Publisher(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Discovery_Publisher_MessagePublisher MessagePublisher;
  typedef Discovery_Publisher_ServicePublisher ServicePublisher;

  typedef Discovery_Publisher_Scope Scope;
  static constexpr Scope PROCESS =
    Discovery_Publisher_Scope_PROCESS;
  static constexpr Scope HOST =
    Discovery_Publisher_Scope_HOST;
  static constexpr Scope ALL =
    Discovery_Publisher_Scope_ALL;
  static inline bool Scope_IsValid(int value) {
    return Discovery_Publisher_Scope_IsValid(value);
  }
  static constexpr Scope Scope_MIN =
    Discovery_Publisher_Scope_Scope_MIN;
  static constexpr Scope Scope_MAX =
    Discovery_Publisher_Scope_Scope_MAX;
  static constexpr int Scope_ARRAYSIZE =
    Discovery_Publisher_Scope_Scope_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Scope_descriptor() {
    return Discovery_Publisher_Scope_descriptor();
  }
  template<typename T>
  static inline const std::string& Scope_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Scope>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Scope_Name.");
    return Discovery_Publisher_Scope_Name(enum_t_value);
  }
  static inline bool Scope_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Scope* value) {
    return Discovery_Publisher_Scope_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kTopicFieldNumber = 1,
    kAddressFieldNumber = 2,
    kProcessUuidFieldNumber = 3,
    kNodeUuidFieldNumber = 4,
    kScopeFieldNumber = 5,
    kMsgPubFieldNumber = 6,
    kSrvPubFieldNumber = 7,
  };
  // string topic = 1;
  void clear_topic();
  const std::string& topic() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_topic(ArgT0&& arg0, ArgT... args);
  std::string* mutable_topic();
  PROTOBUF_MUST_USE_RESULT std::string* release_topic();
  void set_allocated_topic(std::string* topic);
  private:
  const std::string& _internal_topic() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_topic(const std::string& value);
  std::string* _internal_mutable_topic();
  public:

  // string address = 2;
  void clear_address();
  const std::string& address() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_address(ArgT0&& arg0, ArgT... args);
  std::string* mutable_address();
  PROTOBUF_MUST_USE_RESULT std::string* release_address();
  void set_allocated_address(std::string* address);
  private:
  const std::string& _internal_address() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_address(const std::string& value);
  std::string* _internal_mutable_address();
  public:

  // string process_uuid = 3;
  void clear_process_uuid();
  const std::string& process_uuid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_process_uuid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_process_uuid();
  PROTOBUF_MUST_USE_RESULT std::string* release_process_uuid();
  void set_allocated_process_uuid(std::string* process_uuid);
  private:
  const std::string& _internal_process_uuid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_process_uuid(const std::string& value);
  std::string* _internal_mutable_process_uuid();
  public:

  // string node_uuid = 4;
  void clear_node_uuid();
  const std::string& node_uuid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_node_uuid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_node_uuid();
  PROTOBUF_MUST_USE_RESULT std::string* release_node_uuid();
  void set_allocated_node_uuid(std::string* node_uuid);
  private:
  const std::string& _internal_node_uuid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_node_uuid(const std::string& value);
  std::string* _internal_mutable_node_uuid();
  public:

  // .ignition.msgs.Discovery.Publisher.Scope scope = 5;
  void clear_scope();
  ::ignition::msgs::Discovery_Publisher_Scope scope() const;
  void set_scope(::ignition::msgs::Discovery_Publisher_Scope value);
  private:
  ::ignition::msgs::Discovery_Publisher_Scope _internal_scope() const;
  void _internal_set_scope(::ignition::msgs::Discovery_Publisher_Scope value);
  public:

  // .ignition.msgs.Discovery.Publisher.MessagePublisher msg_pub = 6;
  bool has_msg_pub() const;
  private:
  bool _internal_has_msg_pub() const;
  public:
  void clear_msg_pub();
  const ::ignition::msgs::Discovery_Publisher_MessagePublisher& msg_pub() const;
  PROTOBUF_MUST_USE_RESULT ::ignition::msgs::Discovery_Publisher_MessagePublisher* release_msg_pub();
  ::ignition::msgs::Discovery_Publisher_MessagePublisher* mutable_msg_pub();
  void set_allocated_msg_pub(::ignition::msgs::Discovery_Publisher_MessagePublisher* msg_pub);
  private:
  const ::ignition::msgs::Discovery_Publisher_MessagePublisher& _internal_msg_pub() const;
  ::ignition::msgs::Discovery_Publisher_MessagePublisher* _internal_mutable_msg_pub();
  public:
  void unsafe_arena_set_allocated_msg_pub(
      ::ignition::msgs::Discovery_Publisher_MessagePublisher* msg_pub);
  ::ignition::msgs::Discovery_Publisher_MessagePublisher* unsafe_arena_release_msg_pub();

  // .ignition.msgs.Discovery.Publisher.ServicePublisher srv_pub = 7;
  bool has_srv_pub() const;
  private:
  bool _internal_has_srv_pub() const;
  public:
  void clear_srv_pub();
  const ::ignition::msgs::Discovery_Publisher_ServicePublisher& srv_pub() const;
  PROTOBUF_MUST_USE_RESULT ::ignition::msgs::Discovery_Publisher_ServicePublisher* release_srv_pub();
  ::ignition::msgs::Discovery_Publisher_ServicePublisher* mutable_srv_pub();
  void set_allocated_srv_pub(::ignition::msgs::Discovery_Publisher_ServicePublisher* srv_pub);
  private:
  const ::ignition::msgs::Discovery_Publisher_ServicePublisher& _internal_srv_pub() const;
  ::ignition::msgs::Discovery_Publisher_ServicePublisher* _internal_mutable_srv_pub();
  public:
  void unsafe_arena_set_allocated_srv_pub(
      ::ignition::msgs::Discovery_Publisher_ServicePublisher* srv_pub);
  ::ignition::msgs::Discovery_Publisher_ServicePublisher* unsafe_arena_release_srv_pub();

  void clear_pub_type();
  PubTypeCase pub_type_case() const;
  // @@protoc_insertion_point(class_scope:ignition.msgs.Discovery.Publisher)
 private:
  class _Internal;
  void set_has_msg_pub();
  void set_has_srv_pub();

  inline bool has_pub_type() const;
  inline void clear_has_pub_type();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr topic_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr address_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr process_uuid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr node_uuid_;
  int scope_;
  union PubTypeUnion {
    constexpr PubTypeUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::ignition::msgs::Discovery_Publisher_MessagePublisher* msg_pub_;
    ::ignition::msgs::Discovery_Publisher_ServicePublisher* srv_pub_;
  } pub_type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_ignition_2fmsgs_2fdiscovery_2eproto;
};
// -------------------------------------------------------------------

class IGNITION_MSGS_VISIBLE Discovery final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ignition.msgs.Discovery) */ {
 public:
  inline Discovery() : Discovery(nullptr) {}
  ~Discovery() override;
  explicit constexpr Discovery(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Discovery(const Discovery& from);
  Discovery(Discovery&& from) noexcept
    : Discovery() {
    *this = ::std::move(from);
  }

  inline Discovery& operator=(const Discovery& from) {
    CopyFrom(from);
    return *this;
  }
  inline Discovery& operator=(Discovery&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Discovery& default_instance() {
    return *internal_default_instance();
  }
  enum DiscContentsCase {
    kSub = 6,
    kPub = 7,
    DISC_CONTENTS_NOT_SET = 0,
  };

  static inline const Discovery* internal_default_instance() {
    return reinterpret_cast<const Discovery*>(
               &_Discovery_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(Discovery& a, Discovery& b) {
    a.Swap(&b);
  }
  inline void Swap(Discovery* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Discovery* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Discovery* New() const final {
    return new Discovery();
  }

  Discovery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Discovery>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Discovery& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Discovery& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Discovery* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ignition.msgs.Discovery";
  }
  protected:
  explicit Discovery(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Discovery_Flags Flags;
  typedef Discovery_Subscriber Subscriber;
  typedef Discovery_Publisher Publisher;

  typedef Discovery_Type Type;
  static constexpr Type UNINITIALIZED =
    Discovery_Type_UNINITIALIZED;
  static constexpr Type ADVERTISE =
    Discovery_Type_ADVERTISE;
  static constexpr Type SUBSCRIBE =
    Discovery_Type_SUBSCRIBE;
  static constexpr Type UNADVERTISE =
    Discovery_Type_UNADVERTISE;
  static constexpr Type HEARTBEAT =
    Discovery_Type_HEARTBEAT;
  static constexpr Type BYE =
    Discovery_Type_BYE;
  static constexpr Type NEW_CONNECTION =
    Discovery_Type_NEW_CONNECTION;
  static constexpr Type END_CONNECTION =
    Discovery_Type_END_CONNECTION;
  static inline bool Type_IsValid(int value) {
    return Discovery_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    Discovery_Type_Type_MIN;
  static constexpr Type Type_MAX =
    Discovery_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    Discovery_Type_Type_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Type_descriptor() {
    return Discovery_Type_descriptor();
  }
  template<typename T>
  static inline const std::string& Type_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Type>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Type_Name.");
    return Discovery_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return Discovery_Type_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kProcessUuidFieldNumber = 3,
    kHeaderFieldNumber = 1,
    kFlagsFieldNumber = 5,
    kVersionFieldNumber = 2,
    kTypeFieldNumber = 4,
    kSubFieldNumber = 6,
    kPubFieldNumber = 7,
  };
  // string process_uuid = 3;
  void clear_process_uuid();
  const std::string& process_uuid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_process_uuid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_process_uuid();
  PROTOBUF_MUST_USE_RESULT std::string* release_process_uuid();
  void set_allocated_process_uuid(std::string* process_uuid);
  private:
  const std::string& _internal_process_uuid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_process_uuid(const std::string& value);
  std::string* _internal_mutable_process_uuid();
  public:

  // .ignition.msgs.Header header = 1;
  bool has_header() const;
  private:
  bool _internal_has_header() const;
  public:
  void clear_header();
  const ::ignition::msgs::Header& header() const;
  PROTOBUF_MUST_USE_RESULT ::ignition::msgs::Header* release_header();
  ::ignition::msgs::Header* mutable_header();
  void set_allocated_header(::ignition::msgs::Header* header);
  private:
  const ::ignition::msgs::Header& _internal_header() const;
  ::ignition::msgs::Header* _internal_mutable_header();
  public:
  void unsafe_arena_set_allocated_header(
      ::ignition::msgs::Header* header);
  ::ignition::msgs::Header* unsafe_arena_release_header();

  // .ignition.msgs.Discovery.Flags flags = 5;
  bool has_flags() const;
  private:
  bool _internal_has_flags() const;
  public:
  void clear_flags();
  const ::ignition::msgs::Discovery_Flags& flags() const;
  PROTOBUF_MUST_USE_RESULT ::ignition::msgs::Discovery_Flags* release_flags();
  ::ignition::msgs::Discovery_Flags* mutable_flags();
  void set_allocated_flags(::ignition::msgs::Discovery_Flags* flags);
  private:
  const ::ignition::msgs::Discovery_Flags& _internal_flags() const;
  ::ignition::msgs::Discovery_Flags* _internal_mutable_flags();
  public:
  void unsafe_arena_set_allocated_flags(
      ::ignition::msgs::Discovery_Flags* flags);
  ::ignition::msgs::Discovery_Flags* unsafe_arena_release_flags();

  // uint32 version = 2;
  void clear_version();
  ::PROTOBUF_NAMESPACE_ID::uint32 version() const;
  void set_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_version() const;
  void _internal_set_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // .ignition.msgs.Discovery.Type type = 4;
  void clear_type();
  ::ignition::msgs::Discovery_Type type() const;
  void set_type(::ignition::msgs::Discovery_Type value);
  private:
  ::ignition::msgs::Discovery_Type _internal_type() const;
  void _internal_set_type(::ignition::msgs::Discovery_Type value);
  public:

  // .ignition.msgs.Discovery.Subscriber sub = 6;
  bool has_sub() const;
  private:
  bool _internal_has_sub() const;
  public:
  void clear_sub();
  const ::ignition::msgs::Discovery_Subscriber& sub() const;
  PROTOBUF_MUST_USE_RESULT ::ignition::msgs::Discovery_Subscriber* release_sub();
  ::ignition::msgs::Discovery_Subscriber* mutable_sub();
  void set_allocated_sub(::ignition::msgs::Discovery_Subscriber* sub);
  private:
  const ::ignition::msgs::Discovery_Subscriber& _internal_sub() const;
  ::ignition::msgs::Discovery_Subscriber* _internal_mutable_sub();
  public:
  void unsafe_arena_set_allocated_sub(
      ::ignition::msgs::Discovery_Subscriber* sub);
  ::ignition::msgs::Discovery_Subscriber* unsafe_arena_release_sub();

  // .ignition.msgs.Discovery.Publisher pub = 7;
  bool has_pub() const;
  private:
  bool _internal_has_pub() const;
  public:
  void clear_pub();
  const ::ignition::msgs::Discovery_Publisher& pub() const;
  PROTOBUF_MUST_USE_RESULT ::ignition::msgs::Discovery_Publisher* release_pub();
  ::ignition::msgs::Discovery_Publisher* mutable_pub();
  void set_allocated_pub(::ignition::msgs::Discovery_Publisher* pub);
  private:
  const ::ignition::msgs::Discovery_Publisher& _internal_pub() const;
  ::ignition::msgs::Discovery_Publisher* _internal_mutable_pub();
  public:
  void unsafe_arena_set_allocated_pub(
      ::ignition::msgs::Discovery_Publisher* pub);
  ::ignition::msgs::Discovery_Publisher* unsafe_arena_release_pub();

  void clear_disc_contents();
  DiscContentsCase disc_contents_case() const;
  // @@protoc_insertion_point(class_scope:ignition.msgs.Discovery)
 private:
  class _Internal;
  void set_has_sub();
  void set_has_pub();

  inline bool has_disc_contents() const;
  inline void clear_has_disc_contents();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr process_uuid_;
  ::ignition::msgs::Header* header_;
  ::ignition::msgs::Discovery_Flags* flags_;
  ::PROTOBUF_NAMESPACE_ID::uint32 version_;
  int type_;
  union DiscContentsUnion {
    constexpr DiscContentsUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::ignition::msgs::Discovery_Subscriber* sub_;
    ::ignition::msgs::Discovery_Publisher* pub_;
  } disc_contents_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_ignition_2fmsgs_2fdiscovery_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// Discovery_Flags

// bool relay = 1;
inline void Discovery_Flags::clear_relay() {
  relay_ = false;
}
inline bool Discovery_Flags::_internal_relay() const {
  return relay_;
}
inline bool Discovery_Flags::relay() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Flags.relay)
  return _internal_relay();
}
inline void Discovery_Flags::_internal_set_relay(bool value) {
  
  relay_ = value;
}
inline void Discovery_Flags::set_relay(bool value) {
  _internal_set_relay(value);
  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Flags.relay)
}

// bool no_relay = 2;
inline void Discovery_Flags::clear_no_relay() {
  no_relay_ = false;
}
inline bool Discovery_Flags::_internal_no_relay() const {
  return no_relay_;
}
inline bool Discovery_Flags::no_relay() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Flags.no_relay)
  return _internal_no_relay();
}
inline void Discovery_Flags::_internal_set_no_relay(bool value) {
  
  no_relay_ = value;
}
inline void Discovery_Flags::set_no_relay(bool value) {
  _internal_set_no_relay(value);
  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Flags.no_relay)
}

// -------------------------------------------------------------------

// Discovery_Subscriber

// string topic = 1;
inline void Discovery_Subscriber::clear_topic() {
  topic_.ClearToEmpty();
}
inline const std::string& Discovery_Subscriber::topic() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Subscriber.topic)
  return _internal_topic();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Discovery_Subscriber::set_topic(ArgT0&& arg0, ArgT... args) {
 
 topic_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Subscriber.topic)
}
inline std::string* Discovery_Subscriber::mutable_topic() {
  std::string* _s = _internal_mutable_topic();
  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Subscriber.topic)
  return _s;
}
inline const std::string& Discovery_Subscriber::_internal_topic() const {
  return topic_.Get();
}
inline void Discovery_Subscriber::_internal_set_topic(const std::string& value) {
  
  topic_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Discovery_Subscriber::_internal_mutable_topic() {
  
  return topic_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Discovery_Subscriber::release_topic() {
  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Subscriber.topic)
  return topic_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Discovery_Subscriber::set_allocated_topic(std::string* topic) {
  if (topic != nullptr) {
    
  } else {
    
  }
  topic_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), topic,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.Subscriber.topic)
}

// -------------------------------------------------------------------

// Discovery_Publisher_MessagePublisher

// string ctrl = 1;
inline void Discovery_Publisher_MessagePublisher::clear_ctrl() {
  ctrl_.ClearToEmpty();
}
inline const std::string& Discovery_Publisher_MessagePublisher::ctrl() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.MessagePublisher.ctrl)
  return _internal_ctrl();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Discovery_Publisher_MessagePublisher::set_ctrl(ArgT0&& arg0, ArgT... args) {
 
 ctrl_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.MessagePublisher.ctrl)
}
inline std::string* Discovery_Publisher_MessagePublisher::mutable_ctrl() {
  std::string* _s = _internal_mutable_ctrl();
  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.MessagePublisher.ctrl)
  return _s;
}
inline const std::string& Discovery_Publisher_MessagePublisher::_internal_ctrl() const {
  return ctrl_.Get();
}
inline void Discovery_Publisher_MessagePublisher::_internal_set_ctrl(const std::string& value) {
  
  ctrl_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Discovery_Publisher_MessagePublisher::_internal_mutable_ctrl() {
  
  return ctrl_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Discovery_Publisher_MessagePublisher::release_ctrl() {
  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.MessagePublisher.ctrl)
  return ctrl_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Discovery_Publisher_MessagePublisher::set_allocated_ctrl(std::string* ctrl) {
  if (ctrl != nullptr) {
    
  } else {
    
  }
  ctrl_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ctrl,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.Publisher.MessagePublisher.ctrl)
}

// string msg_type = 2;
inline void Discovery_Publisher_MessagePublisher::clear_msg_type() {
  msg_type_.ClearToEmpty();
}
inline const std::string& Discovery_Publisher_MessagePublisher::msg_type() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.MessagePublisher.msg_type)
  return _internal_msg_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Discovery_Publisher_MessagePublisher::set_msg_type(ArgT0&& arg0, ArgT... args) {
 
 msg_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.MessagePublisher.msg_type)
}
inline std::string* Discovery_Publisher_MessagePublisher::mutable_msg_type() {
  std::string* _s = _internal_mutable_msg_type();
  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.MessagePublisher.msg_type)
  return _s;
}
inline const std::string& Discovery_Publisher_MessagePublisher::_internal_msg_type() const {
  return msg_type_.Get();
}
inline void Discovery_Publisher_MessagePublisher::_internal_set_msg_type(const std::string& value) {
  
  msg_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Discovery_Publisher_MessagePublisher::_internal_mutable_msg_type() {
  
  return msg_type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Discovery_Publisher_MessagePublisher::release_msg_type() {
  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.MessagePublisher.msg_type)
  return msg_type_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Discovery_Publisher_MessagePublisher::set_allocated_msg_type(std::string* msg_type) {
  if (msg_type != nullptr) {
    
  } else {
    
  }
  msg_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), msg_type,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.Publisher.MessagePublisher.msg_type)
}

// bool throttled = 3;
inline void Discovery_Publisher_MessagePublisher::clear_throttled() {
  throttled_ = false;
}
inline bool Discovery_Publisher_MessagePublisher::_internal_throttled() const {
  return throttled_;
}
inline bool Discovery_Publisher_MessagePublisher::throttled() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.MessagePublisher.throttled)
  return _internal_throttled();
}
inline void Discovery_Publisher_MessagePublisher::_internal_set_throttled(bool value) {
  
  throttled_ = value;
}
inline void Discovery_Publisher_MessagePublisher::set_throttled(bool value) {
  _internal_set_throttled(value);
  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.MessagePublisher.throttled)
}

// uint64 msgs_per_sec = 4;
inline void Discovery_Publisher_MessagePublisher::clear_msgs_per_sec() {
  msgs_per_sec_ = uint64_t{0u};
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 Discovery_Publisher_MessagePublisher::_internal_msgs_per_sec() const {
  return msgs_per_sec_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 Discovery_Publisher_MessagePublisher::msgs_per_sec() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.MessagePublisher.msgs_per_sec)
  return _internal_msgs_per_sec();
}
inline void Discovery_Publisher_MessagePublisher::_internal_set_msgs_per_sec(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  msgs_per_sec_ = value;
}
inline void Discovery_Publisher_MessagePublisher::set_msgs_per_sec(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _internal_set_msgs_per_sec(value);
  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.MessagePublisher.msgs_per_sec)
}

// -------------------------------------------------------------------

// Discovery_Publisher_ServicePublisher

// string socket_id = 1;
inline void Discovery_Publisher_ServicePublisher::clear_socket_id() {
  socket_id_.ClearToEmpty();
}
inline const std::string& Discovery_Publisher_ServicePublisher::socket_id() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.ServicePublisher.socket_id)
  return _internal_socket_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Discovery_Publisher_ServicePublisher::set_socket_id(ArgT0&& arg0, ArgT... args) {
 
 socket_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.ServicePublisher.socket_id)
}
inline std::string* Discovery_Publisher_ServicePublisher::mutable_socket_id() {
  std::string* _s = _internal_mutable_socket_id();
  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.ServicePublisher.socket_id)
  return _s;
}
inline const std::string& Discovery_Publisher_ServicePublisher::_internal_socket_id() const {
  return socket_id_.Get();
}
inline void Discovery_Publisher_ServicePublisher::_internal_set_socket_id(const std::string& value) {
  
  socket_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Discovery_Publisher_ServicePublisher::_internal_mutable_socket_id() {
  
  return socket_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Discovery_Publisher_ServicePublisher::release_socket_id() {
  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.ServicePublisher.socket_id)
  return socket_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Discovery_Publisher_ServicePublisher::set_allocated_socket_id(std::string* socket_id) {
  if (socket_id != nullptr) {
    
  } else {
    
  }
  socket_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), socket_id,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.Publisher.ServicePublisher.socket_id)
}

// string request_type = 2;
inline void Discovery_Publisher_ServicePublisher::clear_request_type() {
  request_type_.ClearToEmpty();
}
inline const std::string& Discovery_Publisher_ServicePublisher::request_type() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.ServicePublisher.request_type)
  return _internal_request_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Discovery_Publisher_ServicePublisher::set_request_type(ArgT0&& arg0, ArgT... args) {
 
 request_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.ServicePublisher.request_type)
}
inline std::string* Discovery_Publisher_ServicePublisher::mutable_request_type() {
  std::string* _s = _internal_mutable_request_type();
  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.ServicePublisher.request_type)
  return _s;
}
inline const std::string& Discovery_Publisher_ServicePublisher::_internal_request_type() const {
  return request_type_.Get();
}
inline void Discovery_Publisher_ServicePublisher::_internal_set_request_type(const std::string& value) {
  
  request_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Discovery_Publisher_ServicePublisher::_internal_mutable_request_type() {
  
  return request_type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Discovery_Publisher_ServicePublisher::release_request_type() {
  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.ServicePublisher.request_type)
  return request_type_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Discovery_Publisher_ServicePublisher::set_allocated_request_type(std::string* request_type) {
  if (request_type != nullptr) {
    
  } else {
    
  }
  request_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), request_type,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.Publisher.ServicePublisher.request_type)
}

// string response_type = 3;
inline void Discovery_Publisher_ServicePublisher::clear_response_type() {
  response_type_.ClearToEmpty();
}
inline const std::string& Discovery_Publisher_ServicePublisher::response_type() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.ServicePublisher.response_type)
  return _internal_response_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Discovery_Publisher_ServicePublisher::set_response_type(ArgT0&& arg0, ArgT... args) {
 
 response_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.ServicePublisher.response_type)
}
inline std::string* Discovery_Publisher_ServicePublisher::mutable_response_type() {
  std::string* _s = _internal_mutable_response_type();
  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.ServicePublisher.response_type)
  return _s;
}
inline const std::string& Discovery_Publisher_ServicePublisher::_internal_response_type() const {
  return response_type_.Get();
}
inline void Discovery_Publisher_ServicePublisher::_internal_set_response_type(const std::string& value) {
  
  response_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Discovery_Publisher_ServicePublisher::_internal_mutable_response_type() {
  
  return response_type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Discovery_Publisher_ServicePublisher::release_response_type() {
  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.ServicePublisher.response_type)
  return response_type_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Discovery_Publisher_ServicePublisher::set_allocated_response_type(std::string* response_type) {
  if (response_type != nullptr) {
    
  } else {
    
  }
  response_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), response_type,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.Publisher.ServicePublisher.response_type)
}

// -------------------------------------------------------------------

// Discovery_Publisher

// string topic = 1;
inline void Discovery_Publisher::clear_topic() {
  topic_.ClearToEmpty();
}
inline const std::string& Discovery_Publisher::topic() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.topic)
  return _internal_topic();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Discovery_Publisher::set_topic(ArgT0&& arg0, ArgT... args) {
 
 topic_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.topic)
}
inline std::string* Discovery_Publisher::mutable_topic() {
  std::string* _s = _internal_mutable_topic();
  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.topic)
  return _s;
}
inline const std::string& Discovery_Publisher::_internal_topic() const {
  return topic_.Get();
}
inline void Discovery_Publisher::_internal_set_topic(const std::string& value) {
  
  topic_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Discovery_Publisher::_internal_mutable_topic() {
  
  return topic_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Discovery_Publisher::release_topic() {
  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.topic)
  return topic_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Discovery_Publisher::set_allocated_topic(std::string* topic) {
  if (topic != nullptr) {
    
  } else {
    
  }
  topic_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), topic,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.Publisher.topic)
}

// string address = 2;
inline void Discovery_Publisher::clear_address() {
  address_.ClearToEmpty();
}
inline const std::string& Discovery_Publisher::address() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.address)
  return _internal_address();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Discovery_Publisher::set_address(ArgT0&& arg0, ArgT... args) {
 
 address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.address)
}
inline std::string* Discovery_Publisher::mutable_address() {
  std::string* _s = _internal_mutable_address();
  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.address)
  return _s;
}
inline const std::string& Discovery_Publisher::_internal_address() const {
  return address_.Get();
}
inline void Discovery_Publisher::_internal_set_address(const std::string& value) {
  
  address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Discovery_Publisher::_internal_mutable_address() {
  
  return address_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Discovery_Publisher::release_address() {
  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.address)
  return address_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Discovery_Publisher::set_allocated_address(std::string* address) {
  if (address != nullptr) {
    
  } else {
    
  }
  address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), address,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.Publisher.address)
}

// string process_uuid = 3;
inline void Discovery_Publisher::clear_process_uuid() {
  process_uuid_.ClearToEmpty();
}
inline const std::string& Discovery_Publisher::process_uuid() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.process_uuid)
  return _internal_process_uuid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Discovery_Publisher::set_process_uuid(ArgT0&& arg0, ArgT... args) {
 
 process_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.process_uuid)
}
inline std::string* Discovery_Publisher::mutable_process_uuid() {
  std::string* _s = _internal_mutable_process_uuid();
  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.process_uuid)
  return _s;
}
inline const std::string& Discovery_Publisher::_internal_process_uuid() const {
  return process_uuid_.Get();
}
inline void Discovery_Publisher::_internal_set_process_uuid(const std::string& value) {
  
  process_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Discovery_Publisher::_internal_mutable_process_uuid() {
  
  return process_uuid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Discovery_Publisher::release_process_uuid() {
  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.process_uuid)
  return process_uuid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Discovery_Publisher::set_allocated_process_uuid(std::string* process_uuid) {
  if (process_uuid != nullptr) {
    
  } else {
    
  }
  process_uuid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), process_uuid,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.Publisher.process_uuid)
}

// string node_uuid = 4;
inline void Discovery_Publisher::clear_node_uuid() {
  node_uuid_.ClearToEmpty();
}
inline const std::string& Discovery_Publisher::node_uuid() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.node_uuid)
  return _internal_node_uuid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Discovery_Publisher::set_node_uuid(ArgT0&& arg0, ArgT... args) {
 
 node_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.node_uuid)
}
inline std::string* Discovery_Publisher::mutable_node_uuid() {
  std::string* _s = _internal_mutable_node_uuid();
  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.node_uuid)
  return _s;
}
inline const std::string& Discovery_Publisher::_internal_node_uuid() const {
  return node_uuid_.Get();
}
inline void Discovery_Publisher::_internal_set_node_uuid(const std::string& value) {
  
  node_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Discovery_Publisher::_internal_mutable_node_uuid() {
  
  return node_uuid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Discovery_Publisher::release_node_uuid() {
  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.node_uuid)
  return node_uuid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Discovery_Publisher::set_allocated_node_uuid(std::string* node_uuid) {
  if (node_uuid != nullptr) {
    
  } else {
    
  }
  node_uuid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), node_uuid,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.Publisher.node_uuid)
}

// .ignition.msgs.Discovery.Publisher.Scope scope = 5;
inline void Discovery_Publisher::clear_scope() {
  scope_ = 0;
}
inline ::ignition::msgs::Discovery_Publisher_Scope Discovery_Publisher::_internal_scope() const {
  return static_cast< ::ignition::msgs::Discovery_Publisher_Scope >(scope_);
}
inline ::ignition::msgs::Discovery_Publisher_Scope Discovery_Publisher::scope() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.scope)
  return _internal_scope();
}
inline void Discovery_Publisher::_internal_set_scope(::ignition::msgs::Discovery_Publisher_Scope value) {
  
  scope_ = value;
}
inline void Discovery_Publisher::set_scope(::ignition::msgs::Discovery_Publisher_Scope value) {
  _internal_set_scope(value);
  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.Publisher.scope)
}

// .ignition.msgs.Discovery.Publisher.MessagePublisher msg_pub = 6;
inline bool Discovery_Publisher::_internal_has_msg_pub() const {
  return pub_type_case() == kMsgPub;
}
inline bool Discovery_Publisher::has_msg_pub() const {
  return _internal_has_msg_pub();
}
inline void Discovery_Publisher::set_has_msg_pub() {
  _oneof_case_[0] = kMsgPub;
}
inline void Discovery_Publisher::clear_msg_pub() {
  if (_internal_has_msg_pub()) {
    if (GetArenaForAllocation() == nullptr) {
      delete pub_type_.msg_pub_;
    }
    clear_has_pub_type();
  }
}
inline ::ignition::msgs::Discovery_Publisher_MessagePublisher* Discovery_Publisher::release_msg_pub() {
  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.msg_pub)
  if (_internal_has_msg_pub()) {
    clear_has_pub_type();
      ::ignition::msgs::Discovery_Publisher_MessagePublisher* temp = pub_type_.msg_pub_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    pub_type_.msg_pub_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::ignition::msgs::Discovery_Publisher_MessagePublisher& Discovery_Publisher::_internal_msg_pub() const {
  return _internal_has_msg_pub()
      ? *pub_type_.msg_pub_
      : reinterpret_cast< ::ignition::msgs::Discovery_Publisher_MessagePublisher&>(::ignition::msgs::_Discovery_Publisher_MessagePublisher_default_instance_);
}
inline const ::ignition::msgs::Discovery_Publisher_MessagePublisher& Discovery_Publisher::msg_pub() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.msg_pub)
  return _internal_msg_pub();
}
inline ::ignition::msgs::Discovery_Publisher_MessagePublisher* Discovery_Publisher::unsafe_arena_release_msg_pub() {
  // @@protoc_insertion_point(field_unsafe_arena_release:ignition.msgs.Discovery.Publisher.msg_pub)
  if (_internal_has_msg_pub()) {
    clear_has_pub_type();
    ::ignition::msgs::Discovery_Publisher_MessagePublisher* temp = pub_type_.msg_pub_;
    pub_type_.msg_pub_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Discovery_Publisher::unsafe_arena_set_allocated_msg_pub(::ignition::msgs::Discovery_Publisher_MessagePublisher* msg_pub) {
  clear_pub_type();
  if (msg_pub) {
    set_has_msg_pub();
    pub_type_.msg_pub_ = msg_pub;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ignition.msgs.Discovery.Publisher.msg_pub)
}
inline ::ignition::msgs::Discovery_Publisher_MessagePublisher* Discovery_Publisher::_internal_mutable_msg_pub() {
  if (!_internal_has_msg_pub()) {
    clear_pub_type();
    set_has_msg_pub();
    pub_type_.msg_pub_ = CreateMaybeMessage< ::ignition::msgs::Discovery_Publisher_MessagePublisher >(GetArenaForAllocation());
  }
  return pub_type_.msg_pub_;
}
inline ::ignition::msgs::Discovery_Publisher_MessagePublisher* Discovery_Publisher::mutable_msg_pub() {
  ::ignition::msgs::Discovery_Publisher_MessagePublisher* _msg = _internal_mutable_msg_pub();
  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.msg_pub)
  return _msg;
}

// .ignition.msgs.Discovery.Publisher.ServicePublisher srv_pub = 7;
inline bool Discovery_Publisher::_internal_has_srv_pub() const {
  return pub_type_case() == kSrvPub;
}
inline bool Discovery_Publisher::has_srv_pub() const {
  return _internal_has_srv_pub();
}
inline void Discovery_Publisher::set_has_srv_pub() {
  _oneof_case_[0] = kSrvPub;
}
inline void Discovery_Publisher::clear_srv_pub() {
  if (_internal_has_srv_pub()) {
    if (GetArenaForAllocation() == nullptr) {
      delete pub_type_.srv_pub_;
    }
    clear_has_pub_type();
  }
}
inline ::ignition::msgs::Discovery_Publisher_ServicePublisher* Discovery_Publisher::release_srv_pub() {
  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.Publisher.srv_pub)
  if (_internal_has_srv_pub()) {
    clear_has_pub_type();
      ::ignition::msgs::Discovery_Publisher_ServicePublisher* temp = pub_type_.srv_pub_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    pub_type_.srv_pub_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::ignition::msgs::Discovery_Publisher_ServicePublisher& Discovery_Publisher::_internal_srv_pub() const {
  return _internal_has_srv_pub()
      ? *pub_type_.srv_pub_
      : reinterpret_cast< ::ignition::msgs::Discovery_Publisher_ServicePublisher&>(::ignition::msgs::_Discovery_Publisher_ServicePublisher_default_instance_);
}
inline const ::ignition::msgs::Discovery_Publisher_ServicePublisher& Discovery_Publisher::srv_pub() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.Publisher.srv_pub)
  return _internal_srv_pub();
}
inline ::ignition::msgs::Discovery_Publisher_ServicePublisher* Discovery_Publisher::unsafe_arena_release_srv_pub() {
  // @@protoc_insertion_point(field_unsafe_arena_release:ignition.msgs.Discovery.Publisher.srv_pub)
  if (_internal_has_srv_pub()) {
    clear_has_pub_type();
    ::ignition::msgs::Discovery_Publisher_ServicePublisher* temp = pub_type_.srv_pub_;
    pub_type_.srv_pub_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Discovery_Publisher::unsafe_arena_set_allocated_srv_pub(::ignition::msgs::Discovery_Publisher_ServicePublisher* srv_pub) {
  clear_pub_type();
  if (srv_pub) {
    set_has_srv_pub();
    pub_type_.srv_pub_ = srv_pub;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ignition.msgs.Discovery.Publisher.srv_pub)
}
inline ::ignition::msgs::Discovery_Publisher_ServicePublisher* Discovery_Publisher::_internal_mutable_srv_pub() {
  if (!_internal_has_srv_pub()) {
    clear_pub_type();
    set_has_srv_pub();
    pub_type_.srv_pub_ = CreateMaybeMessage< ::ignition::msgs::Discovery_Publisher_ServicePublisher >(GetArenaForAllocation());
  }
  return pub_type_.srv_pub_;
}
inline ::ignition::msgs::Discovery_Publisher_ServicePublisher* Discovery_Publisher::mutable_srv_pub() {
  ::ignition::msgs::Discovery_Publisher_ServicePublisher* _msg = _internal_mutable_srv_pub();
  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.Publisher.srv_pub)
  return _msg;
}

inline bool Discovery_Publisher::has_pub_type() const {
  return pub_type_case() != PUB_TYPE_NOT_SET;
}
inline void Discovery_Publisher::clear_has_pub_type() {
  _oneof_case_[0] = PUB_TYPE_NOT_SET;
}
inline Discovery_Publisher::PubTypeCase Discovery_Publisher::pub_type_case() const {
  return Discovery_Publisher::PubTypeCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// Discovery

// .ignition.msgs.Header header = 1;
inline bool Discovery::_internal_has_header() const {
  return this != internal_default_instance() && header_ != nullptr;
}
inline bool Discovery::has_header() const {
  return _internal_has_header();
}
inline const ::ignition::msgs::Header& Discovery::_internal_header() const {
  const ::ignition::msgs::Header* p = header_;
  return p != nullptr ? *p : reinterpret_cast<const ::ignition::msgs::Header&>(
      ::ignition::msgs::_Header_default_instance_);
}
inline const ::ignition::msgs::Header& Discovery::header() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.header)
  return _internal_header();
}
inline void Discovery::unsafe_arena_set_allocated_header(
    ::ignition::msgs::Header* header) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(header_);
  }
  header_ = header;
  if (header) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ignition.msgs.Discovery.header)
}
inline ::ignition::msgs::Header* Discovery::release_header() {
  
  ::ignition::msgs::Header* temp = header_;
  header_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::ignition::msgs::Header* Discovery::unsafe_arena_release_header() {
  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.header)
  
  ::ignition::msgs::Header* temp = header_;
  header_ = nullptr;
  return temp;
}
inline ::ignition::msgs::Header* Discovery::_internal_mutable_header() {
  
  if (header_ == nullptr) {
    auto* p = CreateMaybeMessage<::ignition::msgs::Header>(GetArenaForAllocation());
    header_ = p;
  }
  return header_;
}
inline ::ignition::msgs::Header* Discovery::mutable_header() {
  ::ignition::msgs::Header* _msg = _internal_mutable_header();
  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.header)
  return _msg;
}
inline void Discovery::set_allocated_header(::ignition::msgs::Header* header) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(header_);
  }
  if (header) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(header));
    if (message_arena != submessage_arena) {
      header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, header, submessage_arena);
    }
    
  } else {
    
  }
  header_ = header;
  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.header)
}

// uint32 version = 2;
inline void Discovery::clear_version() {
  version_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Discovery::_internal_version() const {
  return version_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Discovery::version() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.version)
  return _internal_version();
}
inline void Discovery::_internal_set_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  version_ = value;
}
inline void Discovery::set_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.version)
}

// string process_uuid = 3;
inline void Discovery::clear_process_uuid() {
  process_uuid_.ClearToEmpty();
}
inline const std::string& Discovery::process_uuid() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.process_uuid)
  return _internal_process_uuid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Discovery::set_process_uuid(ArgT0&& arg0, ArgT... args) {
 
 process_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.process_uuid)
}
inline std::string* Discovery::mutable_process_uuid() {
  std::string* _s = _internal_mutable_process_uuid();
  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.process_uuid)
  return _s;
}
inline const std::string& Discovery::_internal_process_uuid() const {
  return process_uuid_.Get();
}
inline void Discovery::_internal_set_process_uuid(const std::string& value) {
  
  process_uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Discovery::_internal_mutable_process_uuid() {
  
  return process_uuid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Discovery::release_process_uuid() {
  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.process_uuid)
  return process_uuid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Discovery::set_allocated_process_uuid(std::string* process_uuid) {
  if (process_uuid != nullptr) {
    
  } else {
    
  }
  process_uuid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), process_uuid,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.process_uuid)
}

// .ignition.msgs.Discovery.Type type = 4;
inline void Discovery::clear_type() {
  type_ = 0;
}
inline ::ignition::msgs::Discovery_Type Discovery::_internal_type() const {
  return static_cast< ::ignition::msgs::Discovery_Type >(type_);
}
inline ::ignition::msgs::Discovery_Type Discovery::type() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.type)
  return _internal_type();
}
inline void Discovery::_internal_set_type(::ignition::msgs::Discovery_Type value) {
  
  type_ = value;
}
inline void Discovery::set_type(::ignition::msgs::Discovery_Type value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:ignition.msgs.Discovery.type)
}

// .ignition.msgs.Discovery.Flags flags = 5;
inline bool Discovery::_internal_has_flags() const {
  return this != internal_default_instance() && flags_ != nullptr;
}
inline bool Discovery::has_flags() const {
  return _internal_has_flags();
}
inline void Discovery::clear_flags() {
  if (GetArenaForAllocation() == nullptr && flags_ != nullptr) {
    delete flags_;
  }
  flags_ = nullptr;
}
inline const ::ignition::msgs::Discovery_Flags& Discovery::_internal_flags() const {
  const ::ignition::msgs::Discovery_Flags* p = flags_;
  return p != nullptr ? *p : reinterpret_cast<const ::ignition::msgs::Discovery_Flags&>(
      ::ignition::msgs::_Discovery_Flags_default_instance_);
}
inline const ::ignition::msgs::Discovery_Flags& Discovery::flags() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.flags)
  return _internal_flags();
}
inline void Discovery::unsafe_arena_set_allocated_flags(
    ::ignition::msgs::Discovery_Flags* flags) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(flags_);
  }
  flags_ = flags;
  if (flags) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ignition.msgs.Discovery.flags)
}
inline ::ignition::msgs::Discovery_Flags* Discovery::release_flags() {
  
  ::ignition::msgs::Discovery_Flags* temp = flags_;
  flags_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::ignition::msgs::Discovery_Flags* Discovery::unsafe_arena_release_flags() {
  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.flags)
  
  ::ignition::msgs::Discovery_Flags* temp = flags_;
  flags_ = nullptr;
  return temp;
}
inline ::ignition::msgs::Discovery_Flags* Discovery::_internal_mutable_flags() {
  
  if (flags_ == nullptr) {
    auto* p = CreateMaybeMessage<::ignition::msgs::Discovery_Flags>(GetArenaForAllocation());
    flags_ = p;
  }
  return flags_;
}
inline ::ignition::msgs::Discovery_Flags* Discovery::mutable_flags() {
  ::ignition::msgs::Discovery_Flags* _msg = _internal_mutable_flags();
  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.flags)
  return _msg;
}
inline void Discovery::set_allocated_flags(::ignition::msgs::Discovery_Flags* flags) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete flags_;
  }
  if (flags) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::ignition::msgs::Discovery_Flags>::GetOwningArena(flags);
    if (message_arena != submessage_arena) {
      flags = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flags, submessage_arena);
    }
    
  } else {
    
  }
  flags_ = flags;
  // @@protoc_insertion_point(field_set_allocated:ignition.msgs.Discovery.flags)
}

// .ignition.msgs.Discovery.Subscriber sub = 6;
inline bool Discovery::_internal_has_sub() const {
  return disc_contents_case() == kSub;
}
inline bool Discovery::has_sub() const {
  return _internal_has_sub();
}
inline void Discovery::set_has_sub() {
  _oneof_case_[0] = kSub;
}
inline void Discovery::clear_sub() {
  if (_internal_has_sub()) {
    if (GetArenaForAllocation() == nullptr) {
      delete disc_contents_.sub_;
    }
    clear_has_disc_contents();
  }
}
inline ::ignition::msgs::Discovery_Subscriber* Discovery::release_sub() {
  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.sub)
  if (_internal_has_sub()) {
    clear_has_disc_contents();
      ::ignition::msgs::Discovery_Subscriber* temp = disc_contents_.sub_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    disc_contents_.sub_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::ignition::msgs::Discovery_Subscriber& Discovery::_internal_sub() const {
  return _internal_has_sub()
      ? *disc_contents_.sub_
      : reinterpret_cast< ::ignition::msgs::Discovery_Subscriber&>(::ignition::msgs::_Discovery_Subscriber_default_instance_);
}
inline const ::ignition::msgs::Discovery_Subscriber& Discovery::sub() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.sub)
  return _internal_sub();
}
inline ::ignition::msgs::Discovery_Subscriber* Discovery::unsafe_arena_release_sub() {
  // @@protoc_insertion_point(field_unsafe_arena_release:ignition.msgs.Discovery.sub)
  if (_internal_has_sub()) {
    clear_has_disc_contents();
    ::ignition::msgs::Discovery_Subscriber* temp = disc_contents_.sub_;
    disc_contents_.sub_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Discovery::unsafe_arena_set_allocated_sub(::ignition::msgs::Discovery_Subscriber* sub) {
  clear_disc_contents();
  if (sub) {
    set_has_sub();
    disc_contents_.sub_ = sub;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ignition.msgs.Discovery.sub)
}
inline ::ignition::msgs::Discovery_Subscriber* Discovery::_internal_mutable_sub() {
  if (!_internal_has_sub()) {
    clear_disc_contents();
    set_has_sub();
    disc_contents_.sub_ = CreateMaybeMessage< ::ignition::msgs::Discovery_Subscriber >(GetArenaForAllocation());
  }
  return disc_contents_.sub_;
}
inline ::ignition::msgs::Discovery_Subscriber* Discovery::mutable_sub() {
  ::ignition::msgs::Discovery_Subscriber* _msg = _internal_mutable_sub();
  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.sub)
  return _msg;
}

// .ignition.msgs.Discovery.Publisher pub = 7;
inline bool Discovery::_internal_has_pub() const {
  return disc_contents_case() == kPub;
}
inline bool Discovery::has_pub() const {
  return _internal_has_pub();
}
inline void Discovery::set_has_pub() {
  _oneof_case_[0] = kPub;
}
inline void Discovery::clear_pub() {
  if (_internal_has_pub()) {
    if (GetArenaForAllocation() == nullptr) {
      delete disc_contents_.pub_;
    }
    clear_has_disc_contents();
  }
}
inline ::ignition::msgs::Discovery_Publisher* Discovery::release_pub() {
  // @@protoc_insertion_point(field_release:ignition.msgs.Discovery.pub)
  if (_internal_has_pub()) {
    clear_has_disc_contents();
      ::ignition::msgs::Discovery_Publisher* temp = disc_contents_.pub_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    disc_contents_.pub_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::ignition::msgs::Discovery_Publisher& Discovery::_internal_pub() const {
  return _internal_has_pub()
      ? *disc_contents_.pub_
      : reinterpret_cast< ::ignition::msgs::Discovery_Publisher&>(::ignition::msgs::_Discovery_Publisher_default_instance_);
}
inline const ::ignition::msgs::Discovery_Publisher& Discovery::pub() const {
  // @@protoc_insertion_point(field_get:ignition.msgs.Discovery.pub)
  return _internal_pub();
}
inline ::ignition::msgs::Discovery_Publisher* Discovery::unsafe_arena_release_pub() {
  // @@protoc_insertion_point(field_unsafe_arena_release:ignition.msgs.Discovery.pub)
  if (_internal_has_pub()) {
    clear_has_disc_contents();
    ::ignition::msgs::Discovery_Publisher* temp = disc_contents_.pub_;
    disc_contents_.pub_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Discovery::unsafe_arena_set_allocated_pub(::ignition::msgs::Discovery_Publisher* pub) {
  clear_disc_contents();
  if (pub) {
    set_has_pub();
    disc_contents_.pub_ = pub;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ignition.msgs.Discovery.pub)
}
inline ::ignition::msgs::Discovery_Publisher* Discovery::_internal_mutable_pub() {
  if (!_internal_has_pub()) {
    clear_disc_contents();
    set_has_pub();
    disc_contents_.pub_ = CreateMaybeMessage< ::ignition::msgs::Discovery_Publisher >(GetArenaForAllocation());
  }
  return disc_contents_.pub_;
}
inline ::ignition::msgs::Discovery_Publisher* Discovery::mutable_pub() {
  ::ignition::msgs::Discovery_Publisher* _msg = _internal_mutable_pub();
  // @@protoc_insertion_point(field_mutable:ignition.msgs.Discovery.pub)
  return _msg;
}

inline bool Discovery::has_disc_contents() const {
  return disc_contents_case() != DISC_CONTENTS_NOT_SET;
}
inline void Discovery::clear_has_disc_contents() {
  _oneof_case_[0] = DISC_CONTENTS_NOT_SET;
}
inline Discovery::DiscContentsCase Discovery::disc_contents_case() const {
  return Discovery::DiscContentsCase(_oneof_case_[0]);
}
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


typedef std::unique_ptr<Discovery> DiscoveryUniquePtr;
typedef std::unique_ptr<const Discovery> ConstDiscoveryUniquePtr;
typedef std::shared_ptr<Discovery> DiscoverySharedPtr;
typedef std::shared_ptr<const Discovery> ConstDiscoverySharedPtr;
// @@protoc_insertion_point(namespace_scope)

}  // namespace msgs
}  // namespace ignition

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::ignition::msgs::Discovery_Publisher_Scope> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ignition::msgs::Discovery_Publisher_Scope>() {
  return ::ignition::msgs::Discovery_Publisher_Scope_descriptor();
}
template <> struct is_proto_enum< ::ignition::msgs::Discovery_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ignition::msgs::Discovery_Type>() {
  return ::ignition::msgs::Discovery_Type_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

#ifdef _MSC_VER
#pragma warning(pop)
#endif
// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_ignition_2fmsgs_2fdiscovery_2eproto
