// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: uxcontrol.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_uxcontrol_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_uxcontrol_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#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 3021012 < 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_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/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_uxcontrol_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_uxcontrol_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_uxcontrol_2eproto;
namespace uxcontrol {
class AddressMessage;
struct AddressMessageDefaultTypeInternal;
extern AddressMessageDefaultTypeInternal _AddressMessage_default_instance_;
class HelloMessage;
struct HelloMessageDefaultTypeInternal;
extern HelloMessageDefaultTypeInternal _HelloMessage_default_instance_;
class MetaHeader;
struct MetaHeaderDefaultTypeInternal;
extern MetaHeaderDefaultTypeInternal _MetaHeader_default_instance_;
class PacketMessage;
struct PacketMessageDefaultTypeInternal;
extern PacketMessageDefaultTypeInternal _PacketMessage_default_instance_;
class RouteMessage;
struct RouteMessageDefaultTypeInternal;
extern RouteMessageDefaultTypeInternal _RouteMessage_default_instance_;
class SimpleMessage;
struct SimpleMessageDefaultTypeInternal;
extern SimpleMessageDefaultTypeInternal _SimpleMessage_default_instance_;
}  // namespace uxcontrol
PROTOBUF_NAMESPACE_OPEN
template<> ::uxcontrol::AddressMessage* Arena::CreateMaybeMessage<::uxcontrol::AddressMessage>(Arena*);
template<> ::uxcontrol::HelloMessage* Arena::CreateMaybeMessage<::uxcontrol::HelloMessage>(Arena*);
template<> ::uxcontrol::MetaHeader* Arena::CreateMaybeMessage<::uxcontrol::MetaHeader>(Arena*);
template<> ::uxcontrol::PacketMessage* Arena::CreateMaybeMessage<::uxcontrol::PacketMessage>(Arena*);
template<> ::uxcontrol::RouteMessage* Arena::CreateMaybeMessage<::uxcontrol::RouteMessage>(Arena*);
template<> ::uxcontrol::SimpleMessage* Arena::CreateMaybeMessage<::uxcontrol::SimpleMessage>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace uxcontrol {

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

class MetaHeader final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:uxcontrol.MetaHeader) */ {
 public:
  inline MetaHeader() : MetaHeader(nullptr) {}
  ~MetaHeader() override;
  explicit PROTOBUF_CONSTEXPR MetaHeader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline MetaHeader& operator=(const MetaHeader& from) {
    CopyFrom(from);
    return *this;
  }
  inline MetaHeader& operator=(MetaHeader&& 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 MetaHeader& default_instance() {
    return *internal_default_instance();
  }
  static inline const MetaHeader* internal_default_instance() {
    return reinterpret_cast<const MetaHeader*>(
               &_MetaHeader_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(MetaHeader& a, MetaHeader& b) {
    a.Swap(&b);
  }
  inline void Swap(MetaHeader* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MetaHeader* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MetaHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MetaHeader>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MetaHeader& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MetaHeader& from) {
    MetaHeader::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MetaHeader* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "uxcontrol.MetaHeader";
  }
  protected:
  explicit MetaHeader(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kKindFieldNumber = 1,
  };
  // string kind = 1;
  void clear_kind();
  const std::string& kind() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_kind(ArgT0&& arg0, ArgT... args);
  std::string* mutable_kind();
  PROTOBUF_NODISCARD std::string* release_kind();
  void set_allocated_kind(std::string* kind);
  private:
  const std::string& _internal_kind() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_kind(const std::string& value);
  std::string* _internal_mutable_kind();
  public:

  // @@protoc_insertion_point(class_scope:uxcontrol.MetaHeader)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr kind_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_uxcontrol_2eproto;
};
// -------------------------------------------------------------------

class SimpleMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:uxcontrol.SimpleMessage) */ {
 public:
  inline SimpleMessage() : SimpleMessage(nullptr) {}
  ~SimpleMessage() override;
  explicit PROTOBUF_CONSTEXPR SimpleMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SimpleMessage& operator=(const SimpleMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline SimpleMessage& operator=(SimpleMessage&& 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 SimpleMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const SimpleMessage* internal_default_instance() {
    return reinterpret_cast<const SimpleMessage*>(
               &_SimpleMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(SimpleMessage& a, SimpleMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(SimpleMessage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SimpleMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SimpleMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SimpleMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SimpleMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SimpleMessage& from) {
    SimpleMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SimpleMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "uxcontrol.SimpleMessage";
  }
  protected:
  explicit SimpleMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kMetaFieldNumber = 1,
  };
  // .uxcontrol.MetaHeader meta = 1;
  bool has_meta() const;
  private:
  bool _internal_has_meta() const;
  public:
  void clear_meta();
  const ::uxcontrol::MetaHeader& meta() const;
  PROTOBUF_NODISCARD ::uxcontrol::MetaHeader* release_meta();
  ::uxcontrol::MetaHeader* mutable_meta();
  void set_allocated_meta(::uxcontrol::MetaHeader* meta);
  private:
  const ::uxcontrol::MetaHeader& _internal_meta() const;
  ::uxcontrol::MetaHeader* _internal_mutable_meta();
  public:
  void unsafe_arena_set_allocated_meta(
      ::uxcontrol::MetaHeader* meta);
  ::uxcontrol::MetaHeader* unsafe_arena_release_meta();

  // @@protoc_insertion_point(class_scope:uxcontrol.SimpleMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::uxcontrol::MetaHeader* meta_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_uxcontrol_2eproto;
};
// -------------------------------------------------------------------

class PacketMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:uxcontrol.PacketMessage) */ {
 public:
  inline PacketMessage() : PacketMessage(nullptr) {}
  ~PacketMessage() override;
  explicit PROTOBUF_CONSTEXPR PacketMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline PacketMessage& operator=(const PacketMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline PacketMessage& operator=(PacketMessage&& 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 PacketMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const PacketMessage* internal_default_instance() {
    return reinterpret_cast<const PacketMessage*>(
               &_PacketMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(PacketMessage& a, PacketMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(PacketMessage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PacketMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  PacketMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PacketMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PacketMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PacketMessage& from) {
    PacketMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PacketMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "uxcontrol.PacketMessage";
  }
  protected:
  explicit PacketMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kPayloadFieldNumber = 2,
    kMetaFieldNumber = 1,
  };
  // bytes payload = 2;
  void clear_payload();
  const std::string& payload() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_payload(ArgT0&& arg0, ArgT... args);
  std::string* mutable_payload();
  PROTOBUF_NODISCARD std::string* release_payload();
  void set_allocated_payload(std::string* payload);
  private:
  const std::string& _internal_payload() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_payload(const std::string& value);
  std::string* _internal_mutable_payload();
  public:

  // .uxcontrol.MetaHeader meta = 1;
  bool has_meta() const;
  private:
  bool _internal_has_meta() const;
  public:
  void clear_meta();
  const ::uxcontrol::MetaHeader& meta() const;
  PROTOBUF_NODISCARD ::uxcontrol::MetaHeader* release_meta();
  ::uxcontrol::MetaHeader* mutable_meta();
  void set_allocated_meta(::uxcontrol::MetaHeader* meta);
  private:
  const ::uxcontrol::MetaHeader& _internal_meta() const;
  ::uxcontrol::MetaHeader* _internal_mutable_meta();
  public:
  void unsafe_arena_set_allocated_meta(
      ::uxcontrol::MetaHeader* meta);
  ::uxcontrol::MetaHeader* unsafe_arena_release_meta();

  // @@protoc_insertion_point(class_scope:uxcontrol.PacketMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_;
    ::uxcontrol::MetaHeader* meta_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_uxcontrol_2eproto;
};
// -------------------------------------------------------------------

class AddressMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:uxcontrol.AddressMessage) */ {
 public:
  inline AddressMessage() : AddressMessage(nullptr) {}
  ~AddressMessage() override;
  explicit PROTOBUF_CONSTEXPR AddressMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline AddressMessage& operator=(const AddressMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline AddressMessage& operator=(AddressMessage&& 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 AddressMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const AddressMessage* internal_default_instance() {
    return reinterpret_cast<const AddressMessage*>(
               &_AddressMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(AddressMessage& a, AddressMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(AddressMessage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AddressMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  AddressMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AddressMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const AddressMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const AddressMessage& from) {
    AddressMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AddressMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "uxcontrol.AddressMessage";
  }
  protected:
  explicit AddressMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kAddressFieldNumber = 2,
    kMetaFieldNumber = 1,
    kPrefixFieldNumber = 3,
  };
  // 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_NODISCARD 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:

  // .uxcontrol.MetaHeader meta = 1;
  bool has_meta() const;
  private:
  bool _internal_has_meta() const;
  public:
  void clear_meta();
  const ::uxcontrol::MetaHeader& meta() const;
  PROTOBUF_NODISCARD ::uxcontrol::MetaHeader* release_meta();
  ::uxcontrol::MetaHeader* mutable_meta();
  void set_allocated_meta(::uxcontrol::MetaHeader* meta);
  private:
  const ::uxcontrol::MetaHeader& _internal_meta() const;
  ::uxcontrol::MetaHeader* _internal_mutable_meta();
  public:
  void unsafe_arena_set_allocated_meta(
      ::uxcontrol::MetaHeader* meta);
  ::uxcontrol::MetaHeader* unsafe_arena_release_meta();

  // uint64 prefix = 3;
  void clear_prefix();
  uint64_t prefix() const;
  void set_prefix(uint64_t value);
  private:
  uint64_t _internal_prefix() const;
  void _internal_set_prefix(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:uxcontrol.AddressMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr address_;
    ::uxcontrol::MetaHeader* meta_;
    uint64_t prefix_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_uxcontrol_2eproto;
};
// -------------------------------------------------------------------

class RouteMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:uxcontrol.RouteMessage) */ {
 public:
  inline RouteMessage() : RouteMessage(nullptr) {}
  ~RouteMessage() override;
  explicit PROTOBUF_CONSTEXPR RouteMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline RouteMessage& operator=(const RouteMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline RouteMessage& operator=(RouteMessage&& 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 RouteMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const RouteMessage* internal_default_instance() {
    return reinterpret_cast<const RouteMessage*>(
               &_RouteMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(RouteMessage& a, RouteMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(RouteMessage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RouteMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  RouteMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RouteMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RouteMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RouteMessage& from) {
    RouteMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RouteMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "uxcontrol.RouteMessage";
  }
  protected:
  explicit RouteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kAddressFieldNumber = 2,
    kMetaFieldNumber = 1,
    kPrefixFieldNumber = 3,
  };
  // 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_NODISCARD 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:

  // .uxcontrol.MetaHeader meta = 1;
  bool has_meta() const;
  private:
  bool _internal_has_meta() const;
  public:
  void clear_meta();
  const ::uxcontrol::MetaHeader& meta() const;
  PROTOBUF_NODISCARD ::uxcontrol::MetaHeader* release_meta();
  ::uxcontrol::MetaHeader* mutable_meta();
  void set_allocated_meta(::uxcontrol::MetaHeader* meta);
  private:
  const ::uxcontrol::MetaHeader& _internal_meta() const;
  ::uxcontrol::MetaHeader* _internal_mutable_meta();
  public:
  void unsafe_arena_set_allocated_meta(
      ::uxcontrol::MetaHeader* meta);
  ::uxcontrol::MetaHeader* unsafe_arena_release_meta();

  // uint64 prefix = 3;
  void clear_prefix();
  uint64_t prefix() const;
  void set_prefix(uint64_t value);
  private:
  uint64_t _internal_prefix() const;
  void _internal_set_prefix(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:uxcontrol.RouteMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr address_;
    ::uxcontrol::MetaHeader* meta_;
    uint64_t prefix_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_uxcontrol_2eproto;
};
// -------------------------------------------------------------------

class HelloMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:uxcontrol.HelloMessage) */ {
 public:
  inline HelloMessage() : HelloMessage(nullptr) {}
  ~HelloMessage() override;
  explicit PROTOBUF_CONSTEXPR HelloMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline HelloMessage& operator=(const HelloMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline HelloMessage& operator=(HelloMessage&& 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 HelloMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const HelloMessage* internal_default_instance() {
    return reinterpret_cast<const HelloMessage*>(
               &_HelloMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(HelloMessage& a, HelloMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(HelloMessage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(HelloMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  HelloMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HelloMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HelloMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HelloMessage& from) {
    HelloMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HelloMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "uxcontrol.HelloMessage";
  }
  protected:
  explicit HelloMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  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 {
    kMessageFieldNumber = 2,
    kMetaFieldNumber = 1,
  };
  // string message = 2;
  void clear_message();
  const std::string& message() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_message(ArgT0&& arg0, ArgT... args);
  std::string* mutable_message();
  PROTOBUF_NODISCARD std::string* release_message();
  void set_allocated_message(std::string* message);
  private:
  const std::string& _internal_message() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_message(const std::string& value);
  std::string* _internal_mutable_message();
  public:

  // .uxcontrol.MetaHeader meta = 1;
  bool has_meta() const;
  private:
  bool _internal_has_meta() const;
  public:
  void clear_meta();
  const ::uxcontrol::MetaHeader& meta() const;
  PROTOBUF_NODISCARD ::uxcontrol::MetaHeader* release_meta();
  ::uxcontrol::MetaHeader* mutable_meta();
  void set_allocated_meta(::uxcontrol::MetaHeader* meta);
  private:
  const ::uxcontrol::MetaHeader& _internal_meta() const;
  ::uxcontrol::MetaHeader* _internal_mutable_meta();
  public:
  void unsafe_arena_set_allocated_meta(
      ::uxcontrol::MetaHeader* meta);
  ::uxcontrol::MetaHeader* unsafe_arena_release_meta();

  // @@protoc_insertion_point(class_scope:uxcontrol.HelloMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_;
    ::uxcontrol::MetaHeader* meta_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_uxcontrol_2eproto;
};
// ===================================================================


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

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

// string kind = 1;
inline void MetaHeader::clear_kind() {
  _impl_.kind_.ClearToEmpty();
}
inline const std::string& MetaHeader::kind() const {
  // @@protoc_insertion_point(field_get:uxcontrol.MetaHeader.kind)
  return _internal_kind();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MetaHeader::set_kind(ArgT0&& arg0, ArgT... args) {
 
 _impl_.kind_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:uxcontrol.MetaHeader.kind)
}
inline std::string* MetaHeader::mutable_kind() {
  std::string* _s = _internal_mutable_kind();
  // @@protoc_insertion_point(field_mutable:uxcontrol.MetaHeader.kind)
  return _s;
}
inline const std::string& MetaHeader::_internal_kind() const {
  return _impl_.kind_.Get();
}
inline void MetaHeader::_internal_set_kind(const std::string& value) {
  
  _impl_.kind_.Set(value, GetArenaForAllocation());
}
inline std::string* MetaHeader::_internal_mutable_kind() {
  
  return _impl_.kind_.Mutable(GetArenaForAllocation());
}
inline std::string* MetaHeader::release_kind() {
  // @@protoc_insertion_point(field_release:uxcontrol.MetaHeader.kind)
  return _impl_.kind_.Release();
}
inline void MetaHeader::set_allocated_kind(std::string* kind) {
  if (kind != nullptr) {
    
  } else {
    
  }
  _impl_.kind_.SetAllocated(kind, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.kind_.IsDefault()) {
    _impl_.kind_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:uxcontrol.MetaHeader.kind)
}

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

// SimpleMessage

// .uxcontrol.MetaHeader meta = 1;
inline bool SimpleMessage::_internal_has_meta() const {
  return this != internal_default_instance() && _impl_.meta_ != nullptr;
}
inline bool SimpleMessage::has_meta() const {
  return _internal_has_meta();
}
inline void SimpleMessage::clear_meta() {
  if (GetArenaForAllocation() == nullptr && _impl_.meta_ != nullptr) {
    delete _impl_.meta_;
  }
  _impl_.meta_ = nullptr;
}
inline const ::uxcontrol::MetaHeader& SimpleMessage::_internal_meta() const {
  const ::uxcontrol::MetaHeader* p = _impl_.meta_;
  return p != nullptr ? *p : reinterpret_cast<const ::uxcontrol::MetaHeader&>(
      ::uxcontrol::_MetaHeader_default_instance_);
}
inline const ::uxcontrol::MetaHeader& SimpleMessage::meta() const {
  // @@protoc_insertion_point(field_get:uxcontrol.SimpleMessage.meta)
  return _internal_meta();
}
inline void SimpleMessage::unsafe_arena_set_allocated_meta(
    ::uxcontrol::MetaHeader* meta) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.meta_);
  }
  _impl_.meta_ = meta;
  if (meta) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:uxcontrol.SimpleMessage.meta)
}
inline ::uxcontrol::MetaHeader* SimpleMessage::release_meta() {
  
  ::uxcontrol::MetaHeader* temp = _impl_.meta_;
  _impl_.meta_ = 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 ::uxcontrol::MetaHeader* SimpleMessage::unsafe_arena_release_meta() {
  // @@protoc_insertion_point(field_release:uxcontrol.SimpleMessage.meta)
  
  ::uxcontrol::MetaHeader* temp = _impl_.meta_;
  _impl_.meta_ = nullptr;
  return temp;
}
inline ::uxcontrol::MetaHeader* SimpleMessage::_internal_mutable_meta() {
  
  if (_impl_.meta_ == nullptr) {
    auto* p = CreateMaybeMessage<::uxcontrol::MetaHeader>(GetArenaForAllocation());
    _impl_.meta_ = p;
  }
  return _impl_.meta_;
}
inline ::uxcontrol::MetaHeader* SimpleMessage::mutable_meta() {
  ::uxcontrol::MetaHeader* _msg = _internal_mutable_meta();
  // @@protoc_insertion_point(field_mutable:uxcontrol.SimpleMessage.meta)
  return _msg;
}
inline void SimpleMessage::set_allocated_meta(::uxcontrol::MetaHeader* meta) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.meta_;
  }
  if (meta) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(meta);
    if (message_arena != submessage_arena) {
      meta = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, meta, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.meta_ = meta;
  // @@protoc_insertion_point(field_set_allocated:uxcontrol.SimpleMessage.meta)
}

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

// PacketMessage

// .uxcontrol.MetaHeader meta = 1;
inline bool PacketMessage::_internal_has_meta() const {
  return this != internal_default_instance() && _impl_.meta_ != nullptr;
}
inline bool PacketMessage::has_meta() const {
  return _internal_has_meta();
}
inline void PacketMessage::clear_meta() {
  if (GetArenaForAllocation() == nullptr && _impl_.meta_ != nullptr) {
    delete _impl_.meta_;
  }
  _impl_.meta_ = nullptr;
}
inline const ::uxcontrol::MetaHeader& PacketMessage::_internal_meta() const {
  const ::uxcontrol::MetaHeader* p = _impl_.meta_;
  return p != nullptr ? *p : reinterpret_cast<const ::uxcontrol::MetaHeader&>(
      ::uxcontrol::_MetaHeader_default_instance_);
}
inline const ::uxcontrol::MetaHeader& PacketMessage::meta() const {
  // @@protoc_insertion_point(field_get:uxcontrol.PacketMessage.meta)
  return _internal_meta();
}
inline void PacketMessage::unsafe_arena_set_allocated_meta(
    ::uxcontrol::MetaHeader* meta) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.meta_);
  }
  _impl_.meta_ = meta;
  if (meta) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:uxcontrol.PacketMessage.meta)
}
inline ::uxcontrol::MetaHeader* PacketMessage::release_meta() {
  
  ::uxcontrol::MetaHeader* temp = _impl_.meta_;
  _impl_.meta_ = 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 ::uxcontrol::MetaHeader* PacketMessage::unsafe_arena_release_meta() {
  // @@protoc_insertion_point(field_release:uxcontrol.PacketMessage.meta)
  
  ::uxcontrol::MetaHeader* temp = _impl_.meta_;
  _impl_.meta_ = nullptr;
  return temp;
}
inline ::uxcontrol::MetaHeader* PacketMessage::_internal_mutable_meta() {
  
  if (_impl_.meta_ == nullptr) {
    auto* p = CreateMaybeMessage<::uxcontrol::MetaHeader>(GetArenaForAllocation());
    _impl_.meta_ = p;
  }
  return _impl_.meta_;
}
inline ::uxcontrol::MetaHeader* PacketMessage::mutable_meta() {
  ::uxcontrol::MetaHeader* _msg = _internal_mutable_meta();
  // @@protoc_insertion_point(field_mutable:uxcontrol.PacketMessage.meta)
  return _msg;
}
inline void PacketMessage::set_allocated_meta(::uxcontrol::MetaHeader* meta) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.meta_;
  }
  if (meta) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(meta);
    if (message_arena != submessage_arena) {
      meta = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, meta, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.meta_ = meta;
  // @@protoc_insertion_point(field_set_allocated:uxcontrol.PacketMessage.meta)
}

// bytes payload = 2;
inline void PacketMessage::clear_payload() {
  _impl_.payload_.ClearToEmpty();
}
inline const std::string& PacketMessage::payload() const {
  // @@protoc_insertion_point(field_get:uxcontrol.PacketMessage.payload)
  return _internal_payload();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PacketMessage::set_payload(ArgT0&& arg0, ArgT... args) {
 
 _impl_.payload_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:uxcontrol.PacketMessage.payload)
}
inline std::string* PacketMessage::mutable_payload() {
  std::string* _s = _internal_mutable_payload();
  // @@protoc_insertion_point(field_mutable:uxcontrol.PacketMessage.payload)
  return _s;
}
inline const std::string& PacketMessage::_internal_payload() const {
  return _impl_.payload_.Get();
}
inline void PacketMessage::_internal_set_payload(const std::string& value) {
  
  _impl_.payload_.Set(value, GetArenaForAllocation());
}
inline std::string* PacketMessage::_internal_mutable_payload() {
  
  return _impl_.payload_.Mutable(GetArenaForAllocation());
}
inline std::string* PacketMessage::release_payload() {
  // @@protoc_insertion_point(field_release:uxcontrol.PacketMessage.payload)
  return _impl_.payload_.Release();
}
inline void PacketMessage::set_allocated_payload(std::string* payload) {
  if (payload != nullptr) {
    
  } else {
    
  }
  _impl_.payload_.SetAllocated(payload, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.payload_.IsDefault()) {
    _impl_.payload_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:uxcontrol.PacketMessage.payload)
}

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

// AddressMessage

// .uxcontrol.MetaHeader meta = 1;
inline bool AddressMessage::_internal_has_meta() const {
  return this != internal_default_instance() && _impl_.meta_ != nullptr;
}
inline bool AddressMessage::has_meta() const {
  return _internal_has_meta();
}
inline void AddressMessage::clear_meta() {
  if (GetArenaForAllocation() == nullptr && _impl_.meta_ != nullptr) {
    delete _impl_.meta_;
  }
  _impl_.meta_ = nullptr;
}
inline const ::uxcontrol::MetaHeader& AddressMessage::_internal_meta() const {
  const ::uxcontrol::MetaHeader* p = _impl_.meta_;
  return p != nullptr ? *p : reinterpret_cast<const ::uxcontrol::MetaHeader&>(
      ::uxcontrol::_MetaHeader_default_instance_);
}
inline const ::uxcontrol::MetaHeader& AddressMessage::meta() const {
  // @@protoc_insertion_point(field_get:uxcontrol.AddressMessage.meta)
  return _internal_meta();
}
inline void AddressMessage::unsafe_arena_set_allocated_meta(
    ::uxcontrol::MetaHeader* meta) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.meta_);
  }
  _impl_.meta_ = meta;
  if (meta) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:uxcontrol.AddressMessage.meta)
}
inline ::uxcontrol::MetaHeader* AddressMessage::release_meta() {
  
  ::uxcontrol::MetaHeader* temp = _impl_.meta_;
  _impl_.meta_ = 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 ::uxcontrol::MetaHeader* AddressMessage::unsafe_arena_release_meta() {
  // @@protoc_insertion_point(field_release:uxcontrol.AddressMessage.meta)
  
  ::uxcontrol::MetaHeader* temp = _impl_.meta_;
  _impl_.meta_ = nullptr;
  return temp;
}
inline ::uxcontrol::MetaHeader* AddressMessage::_internal_mutable_meta() {
  
  if (_impl_.meta_ == nullptr) {
    auto* p = CreateMaybeMessage<::uxcontrol::MetaHeader>(GetArenaForAllocation());
    _impl_.meta_ = p;
  }
  return _impl_.meta_;
}
inline ::uxcontrol::MetaHeader* AddressMessage::mutable_meta() {
  ::uxcontrol::MetaHeader* _msg = _internal_mutable_meta();
  // @@protoc_insertion_point(field_mutable:uxcontrol.AddressMessage.meta)
  return _msg;
}
inline void AddressMessage::set_allocated_meta(::uxcontrol::MetaHeader* meta) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.meta_;
  }
  if (meta) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(meta);
    if (message_arena != submessage_arena) {
      meta = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, meta, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.meta_ = meta;
  // @@protoc_insertion_point(field_set_allocated:uxcontrol.AddressMessage.meta)
}

// string address = 2;
inline void AddressMessage::clear_address() {
  _impl_.address_.ClearToEmpty();
}
inline const std::string& AddressMessage::address() const {
  // @@protoc_insertion_point(field_get:uxcontrol.AddressMessage.address)
  return _internal_address();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AddressMessage::set_address(ArgT0&& arg0, ArgT... args) {
 
 _impl_.address_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:uxcontrol.AddressMessage.address)
}
inline std::string* AddressMessage::mutable_address() {
  std::string* _s = _internal_mutable_address();
  // @@protoc_insertion_point(field_mutable:uxcontrol.AddressMessage.address)
  return _s;
}
inline const std::string& AddressMessage::_internal_address() const {
  return _impl_.address_.Get();
}
inline void AddressMessage::_internal_set_address(const std::string& value) {
  
  _impl_.address_.Set(value, GetArenaForAllocation());
}
inline std::string* AddressMessage::_internal_mutable_address() {
  
  return _impl_.address_.Mutable(GetArenaForAllocation());
}
inline std::string* AddressMessage::release_address() {
  // @@protoc_insertion_point(field_release:uxcontrol.AddressMessage.address)
  return _impl_.address_.Release();
}
inline void AddressMessage::set_allocated_address(std::string* address) {
  if (address != nullptr) {
    
  } else {
    
  }
  _impl_.address_.SetAllocated(address, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.address_.IsDefault()) {
    _impl_.address_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:uxcontrol.AddressMessage.address)
}

// uint64 prefix = 3;
inline void AddressMessage::clear_prefix() {
  _impl_.prefix_ = uint64_t{0u};
}
inline uint64_t AddressMessage::_internal_prefix() const {
  return _impl_.prefix_;
}
inline uint64_t AddressMessage::prefix() const {
  // @@protoc_insertion_point(field_get:uxcontrol.AddressMessage.prefix)
  return _internal_prefix();
}
inline void AddressMessage::_internal_set_prefix(uint64_t value) {
  
  _impl_.prefix_ = value;
}
inline void AddressMessage::set_prefix(uint64_t value) {
  _internal_set_prefix(value);
  // @@protoc_insertion_point(field_set:uxcontrol.AddressMessage.prefix)
}

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

// RouteMessage

// .uxcontrol.MetaHeader meta = 1;
inline bool RouteMessage::_internal_has_meta() const {
  return this != internal_default_instance() && _impl_.meta_ != nullptr;
}
inline bool RouteMessage::has_meta() const {
  return _internal_has_meta();
}
inline void RouteMessage::clear_meta() {
  if (GetArenaForAllocation() == nullptr && _impl_.meta_ != nullptr) {
    delete _impl_.meta_;
  }
  _impl_.meta_ = nullptr;
}
inline const ::uxcontrol::MetaHeader& RouteMessage::_internal_meta() const {
  const ::uxcontrol::MetaHeader* p = _impl_.meta_;
  return p != nullptr ? *p : reinterpret_cast<const ::uxcontrol::MetaHeader&>(
      ::uxcontrol::_MetaHeader_default_instance_);
}
inline const ::uxcontrol::MetaHeader& RouteMessage::meta() const {
  // @@protoc_insertion_point(field_get:uxcontrol.RouteMessage.meta)
  return _internal_meta();
}
inline void RouteMessage::unsafe_arena_set_allocated_meta(
    ::uxcontrol::MetaHeader* meta) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.meta_);
  }
  _impl_.meta_ = meta;
  if (meta) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:uxcontrol.RouteMessage.meta)
}
inline ::uxcontrol::MetaHeader* RouteMessage::release_meta() {
  
  ::uxcontrol::MetaHeader* temp = _impl_.meta_;
  _impl_.meta_ = 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 ::uxcontrol::MetaHeader* RouteMessage::unsafe_arena_release_meta() {
  // @@protoc_insertion_point(field_release:uxcontrol.RouteMessage.meta)
  
  ::uxcontrol::MetaHeader* temp = _impl_.meta_;
  _impl_.meta_ = nullptr;
  return temp;
}
inline ::uxcontrol::MetaHeader* RouteMessage::_internal_mutable_meta() {
  
  if (_impl_.meta_ == nullptr) {
    auto* p = CreateMaybeMessage<::uxcontrol::MetaHeader>(GetArenaForAllocation());
    _impl_.meta_ = p;
  }
  return _impl_.meta_;
}
inline ::uxcontrol::MetaHeader* RouteMessage::mutable_meta() {
  ::uxcontrol::MetaHeader* _msg = _internal_mutable_meta();
  // @@protoc_insertion_point(field_mutable:uxcontrol.RouteMessage.meta)
  return _msg;
}
inline void RouteMessage::set_allocated_meta(::uxcontrol::MetaHeader* meta) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.meta_;
  }
  if (meta) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(meta);
    if (message_arena != submessage_arena) {
      meta = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, meta, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.meta_ = meta;
  // @@protoc_insertion_point(field_set_allocated:uxcontrol.RouteMessage.meta)
}

// string address = 2;
inline void RouteMessage::clear_address() {
  _impl_.address_.ClearToEmpty();
}
inline const std::string& RouteMessage::address() const {
  // @@protoc_insertion_point(field_get:uxcontrol.RouteMessage.address)
  return _internal_address();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RouteMessage::set_address(ArgT0&& arg0, ArgT... args) {
 
 _impl_.address_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:uxcontrol.RouteMessage.address)
}
inline std::string* RouteMessage::mutable_address() {
  std::string* _s = _internal_mutable_address();
  // @@protoc_insertion_point(field_mutable:uxcontrol.RouteMessage.address)
  return _s;
}
inline const std::string& RouteMessage::_internal_address() const {
  return _impl_.address_.Get();
}
inline void RouteMessage::_internal_set_address(const std::string& value) {
  
  _impl_.address_.Set(value, GetArenaForAllocation());
}
inline std::string* RouteMessage::_internal_mutable_address() {
  
  return _impl_.address_.Mutable(GetArenaForAllocation());
}
inline std::string* RouteMessage::release_address() {
  // @@protoc_insertion_point(field_release:uxcontrol.RouteMessage.address)
  return _impl_.address_.Release();
}
inline void RouteMessage::set_allocated_address(std::string* address) {
  if (address != nullptr) {
    
  } else {
    
  }
  _impl_.address_.SetAllocated(address, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.address_.IsDefault()) {
    _impl_.address_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:uxcontrol.RouteMessage.address)
}

// uint64 prefix = 3;
inline void RouteMessage::clear_prefix() {
  _impl_.prefix_ = uint64_t{0u};
}
inline uint64_t RouteMessage::_internal_prefix() const {
  return _impl_.prefix_;
}
inline uint64_t RouteMessage::prefix() const {
  // @@protoc_insertion_point(field_get:uxcontrol.RouteMessage.prefix)
  return _internal_prefix();
}
inline void RouteMessage::_internal_set_prefix(uint64_t value) {
  
  _impl_.prefix_ = value;
}
inline void RouteMessage::set_prefix(uint64_t value) {
  _internal_set_prefix(value);
  // @@protoc_insertion_point(field_set:uxcontrol.RouteMessage.prefix)
}

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

// HelloMessage

// .uxcontrol.MetaHeader meta = 1;
inline bool HelloMessage::_internal_has_meta() const {
  return this != internal_default_instance() && _impl_.meta_ != nullptr;
}
inline bool HelloMessage::has_meta() const {
  return _internal_has_meta();
}
inline void HelloMessage::clear_meta() {
  if (GetArenaForAllocation() == nullptr && _impl_.meta_ != nullptr) {
    delete _impl_.meta_;
  }
  _impl_.meta_ = nullptr;
}
inline const ::uxcontrol::MetaHeader& HelloMessage::_internal_meta() const {
  const ::uxcontrol::MetaHeader* p = _impl_.meta_;
  return p != nullptr ? *p : reinterpret_cast<const ::uxcontrol::MetaHeader&>(
      ::uxcontrol::_MetaHeader_default_instance_);
}
inline const ::uxcontrol::MetaHeader& HelloMessage::meta() const {
  // @@protoc_insertion_point(field_get:uxcontrol.HelloMessage.meta)
  return _internal_meta();
}
inline void HelloMessage::unsafe_arena_set_allocated_meta(
    ::uxcontrol::MetaHeader* meta) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.meta_);
  }
  _impl_.meta_ = meta;
  if (meta) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:uxcontrol.HelloMessage.meta)
}
inline ::uxcontrol::MetaHeader* HelloMessage::release_meta() {
  
  ::uxcontrol::MetaHeader* temp = _impl_.meta_;
  _impl_.meta_ = 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 ::uxcontrol::MetaHeader* HelloMessage::unsafe_arena_release_meta() {
  // @@protoc_insertion_point(field_release:uxcontrol.HelloMessage.meta)
  
  ::uxcontrol::MetaHeader* temp = _impl_.meta_;
  _impl_.meta_ = nullptr;
  return temp;
}
inline ::uxcontrol::MetaHeader* HelloMessage::_internal_mutable_meta() {
  
  if (_impl_.meta_ == nullptr) {
    auto* p = CreateMaybeMessage<::uxcontrol::MetaHeader>(GetArenaForAllocation());
    _impl_.meta_ = p;
  }
  return _impl_.meta_;
}
inline ::uxcontrol::MetaHeader* HelloMessage::mutable_meta() {
  ::uxcontrol::MetaHeader* _msg = _internal_mutable_meta();
  // @@protoc_insertion_point(field_mutable:uxcontrol.HelloMessage.meta)
  return _msg;
}
inline void HelloMessage::set_allocated_meta(::uxcontrol::MetaHeader* meta) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.meta_;
  }
  if (meta) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(meta);
    if (message_arena != submessage_arena) {
      meta = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, meta, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.meta_ = meta;
  // @@protoc_insertion_point(field_set_allocated:uxcontrol.HelloMessage.meta)
}

// string message = 2;
inline void HelloMessage::clear_message() {
  _impl_.message_.ClearToEmpty();
}
inline const std::string& HelloMessage::message() const {
  // @@protoc_insertion_point(field_get:uxcontrol.HelloMessage.message)
  return _internal_message();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HelloMessage::set_message(ArgT0&& arg0, ArgT... args) {
 
 _impl_.message_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:uxcontrol.HelloMessage.message)
}
inline std::string* HelloMessage::mutable_message() {
  std::string* _s = _internal_mutable_message();
  // @@protoc_insertion_point(field_mutable:uxcontrol.HelloMessage.message)
  return _s;
}
inline const std::string& HelloMessage::_internal_message() const {
  return _impl_.message_.Get();
}
inline void HelloMessage::_internal_set_message(const std::string& value) {
  
  _impl_.message_.Set(value, GetArenaForAllocation());
}
inline std::string* HelloMessage::_internal_mutable_message() {
  
  return _impl_.message_.Mutable(GetArenaForAllocation());
}
inline std::string* HelloMessage::release_message() {
  // @@protoc_insertion_point(field_release:uxcontrol.HelloMessage.message)
  return _impl_.message_.Release();
}
inline void HelloMessage::set_allocated_message(std::string* message) {
  if (message != nullptr) {
    
  } else {
    
  }
  _impl_.message_.SetAllocated(message, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.message_.IsDefault()) {
    _impl_.message_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:uxcontrol.HelloMessage.message)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace uxcontrol

// @@protoc_insertion_point(global_scope)

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