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

#ifndef GOOGLE_PROTOBUF_INCLUDED_parameter_2eproto_2epb_2eh
#define GOOGLE_PROTOBUF_INCLUDED_parameter_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>

#include "google/protobuf/port_def.inc"
#if PROTOBUF_VERSION < 4023000
#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  // PROTOBUF_VERSION

#if 4023001 < 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  // PROTOBUF_MIN_PROTOC_VERSION
#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)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_parameter_2eproto

PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_parameter_2eproto {
  static const ::uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable
    descriptor_table_parameter_2eproto;
namespace NavParameter {
class Accuracy;
struct AccuracyDefaultTypeInternal;
extern AccuracyDefaultTypeInternal _Accuracy_default_instance_;
class AgvEmqx_parameter;
struct AgvEmqx_parameterDefaultTypeInternal;
extern AgvEmqx_parameterDefaultTypeInternal _AgvEmqx_parameter_default_instance_;
class BrotherEmqx;
struct BrotherEmqxDefaultTypeInternal;
extern BrotherEmqxDefaultTypeInternal _BrotherEmqx_default_instance_;
class Emqx_parameter;
struct Emqx_parameterDefaultTypeInternal;
extern Emqx_parameterDefaultTypeInternal _Emqx_parameter_default_instance_;
class MPC_parameter;
struct MPC_parameterDefaultTypeInternal;
extern MPC_parameterDefaultTypeInternal _MPC_parameter_default_instance_;
class Navigation_parameter;
struct Navigation_parameterDefaultTypeInternal;
extern Navigation_parameterDefaultTypeInternal _Navigation_parameter_default_instance_;
class SpeedLimit;
struct SpeedLimitDefaultTypeInternal;
extern SpeedLimitDefaultTypeInternal _SpeedLimit_default_instance_;
}  // namespace NavParameter
PROTOBUF_NAMESPACE_OPEN
template <>
::NavParameter::Accuracy* Arena::CreateMaybeMessage<::NavParameter::Accuracy>(Arena*);
template <>
::NavParameter::AgvEmqx_parameter* Arena::CreateMaybeMessage<::NavParameter::AgvEmqx_parameter>(Arena*);
template <>
::NavParameter::BrotherEmqx* Arena::CreateMaybeMessage<::NavParameter::BrotherEmqx>(Arena*);
template <>
::NavParameter::Emqx_parameter* Arena::CreateMaybeMessage<::NavParameter::Emqx_parameter>(Arena*);
template <>
::NavParameter::MPC_parameter* Arena::CreateMaybeMessage<::NavParameter::MPC_parameter>(Arena*);
template <>
::NavParameter::Navigation_parameter* Arena::CreateMaybeMessage<::NavParameter::Navigation_parameter>(Arena*);
template <>
::NavParameter::SpeedLimit* Arena::CreateMaybeMessage<::NavParameter::SpeedLimit>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

namespace NavParameter {

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


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

class AgvEmqx_parameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavParameter.AgvEmqx_parameter) */ {
 public:
  inline AgvEmqx_parameter() : AgvEmqx_parameter(nullptr) {}
  ~AgvEmqx_parameter() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AgvEmqx_parameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline AgvEmqx_parameter& operator=(const AgvEmqx_parameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline AgvEmqx_parameter& operator=(AgvEmqx_parameter&& 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;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  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 AgvEmqx_parameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const AgvEmqx_parameter* internal_default_instance() {
    return reinterpret_cast<const AgvEmqx_parameter*>(
               &_AgvEmqx_parameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(AgvEmqx_parameter& a, AgvEmqx_parameter& b) {
    a.Swap(&b);
  }
  inline void Swap(AgvEmqx_parameter* 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(AgvEmqx_parameter* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  AgvEmqx_parameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AgvEmqx_parameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const AgvEmqx_parameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const AgvEmqx_parameter& from) {
    AgvEmqx_parameter::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);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AgvEmqx_parameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "NavParameter.AgvEmqx_parameter";
  }
  protected:
  explicit AgvEmqx_parameter(::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 {
    kNodeIdFieldNumber = 1,
    kIpFieldNumber = 2,
    kPubSpeedTopicFieldNumber = 4,
    kSubPoseTopicFieldNumber = 5,
    kSubSpeedTopicFieldNumber = 6,
    kPortFieldNumber = 3,
  };
  // string NodeId = 1;
  void clear_nodeid() ;
  const std::string& nodeid() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_nodeid(Arg_&& arg, Args_... args);
  std::string* mutable_nodeid();
  PROTOBUF_NODISCARD std::string* release_nodeid();
  void set_allocated_nodeid(std::string* ptr);

  private:
  const std::string& _internal_nodeid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_nodeid(
      const std::string& value);
  std::string* _internal_mutable_nodeid();

  public:
  // string ip = 2;
  void clear_ip() ;
  const std::string& ip() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_ip(Arg_&& arg, Args_... args);
  std::string* mutable_ip();
  PROTOBUF_NODISCARD std::string* release_ip();
  void set_allocated_ip(std::string* ptr);

  private:
  const std::string& _internal_ip() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ip(
      const std::string& value);
  std::string* _internal_mutable_ip();

  public:
  // string pubSpeedTopic = 4;
  void clear_pubspeedtopic() ;
  const std::string& pubspeedtopic() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_pubspeedtopic(Arg_&& arg, Args_... args);
  std::string* mutable_pubspeedtopic();
  PROTOBUF_NODISCARD std::string* release_pubspeedtopic();
  void set_allocated_pubspeedtopic(std::string* ptr);

  private:
  const std::string& _internal_pubspeedtopic() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pubspeedtopic(
      const std::string& value);
  std::string* _internal_mutable_pubspeedtopic();

  public:
  // string subPoseTopic = 5;
  void clear_subposetopic() ;
  const std::string& subposetopic() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_subposetopic(Arg_&& arg, Args_... args);
  std::string* mutable_subposetopic();
  PROTOBUF_NODISCARD std::string* release_subposetopic();
  void set_allocated_subposetopic(std::string* ptr);

  private:
  const std::string& _internal_subposetopic() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_subposetopic(
      const std::string& value);
  std::string* _internal_mutable_subposetopic();

  public:
  // string subSpeedTopic = 6;
  void clear_subspeedtopic() ;
  const std::string& subspeedtopic() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_subspeedtopic(Arg_&& arg, Args_... args);
  std::string* mutable_subspeedtopic();
  PROTOBUF_NODISCARD std::string* release_subspeedtopic();
  void set_allocated_subspeedtopic(std::string* ptr);

  private:
  const std::string& _internal_subspeedtopic() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_subspeedtopic(
      const std::string& value);
  std::string* _internal_mutable_subspeedtopic();

  public:
  // int32 port = 3;
  void clear_port() ;
  ::int32_t port() const;
  void set_port(::int32_t value);

  private:
  ::int32_t _internal_port() const;
  void _internal_set_port(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:NavParameter.AgvEmqx_parameter)
 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 nodeid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ip_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pubspeedtopic_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subposetopic_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subspeedtopic_;
    ::int32_t port_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_parameter_2eproto;
};// -------------------------------------------------------------------

class Emqx_parameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavParameter.Emqx_parameter) */ {
 public:
  inline Emqx_parameter() : Emqx_parameter(nullptr) {}
  ~Emqx_parameter() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR Emqx_parameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline Emqx_parameter& operator=(const Emqx_parameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline Emqx_parameter& operator=(Emqx_parameter&& 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;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  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 Emqx_parameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const Emqx_parameter* internal_default_instance() {
    return reinterpret_cast<const Emqx_parameter*>(
               &_Emqx_parameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(Emqx_parameter& a, Emqx_parameter& b) {
    a.Swap(&b);
  }
  inline void Swap(Emqx_parameter* 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(Emqx_parameter* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Emqx_parameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Emqx_parameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Emqx_parameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Emqx_parameter& from) {
    Emqx_parameter::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);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Emqx_parameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "NavParameter.Emqx_parameter";
  }
  protected:
  explicit Emqx_parameter(::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 {
    kNodeIdFieldNumber = 1,
    kIpFieldNumber = 2,
    kPubStatuTopicFieldNumber = 4,
    kPubNavStatuTopicFieldNumber = 5,
    kPortFieldNumber = 3,
  };
  // string NodeId = 1;
  void clear_nodeid() ;
  const std::string& nodeid() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_nodeid(Arg_&& arg, Args_... args);
  std::string* mutable_nodeid();
  PROTOBUF_NODISCARD std::string* release_nodeid();
  void set_allocated_nodeid(std::string* ptr);

  private:
  const std::string& _internal_nodeid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_nodeid(
      const std::string& value);
  std::string* _internal_mutable_nodeid();

  public:
  // string ip = 2;
  void clear_ip() ;
  const std::string& ip() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_ip(Arg_&& arg, Args_... args);
  std::string* mutable_ip();
  PROTOBUF_NODISCARD std::string* release_ip();
  void set_allocated_ip(std::string* ptr);

  private:
  const std::string& _internal_ip() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ip(
      const std::string& value);
  std::string* _internal_mutable_ip();

  public:
  // string pubStatuTopic = 4;
  void clear_pubstatutopic() ;
  const std::string& pubstatutopic() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_pubstatutopic(Arg_&& arg, Args_... args);
  std::string* mutable_pubstatutopic();
  PROTOBUF_NODISCARD std::string* release_pubstatutopic();
  void set_allocated_pubstatutopic(std::string* ptr);

  private:
  const std::string& _internal_pubstatutopic() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pubstatutopic(
      const std::string& value);
  std::string* _internal_mutable_pubstatutopic();

  public:
  // string pubNavStatuTopic = 5;
  void clear_pubnavstatutopic() ;
  const std::string& pubnavstatutopic() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_pubnavstatutopic(Arg_&& arg, Args_... args);
  std::string* mutable_pubnavstatutopic();
  PROTOBUF_NODISCARD std::string* release_pubnavstatutopic();
  void set_allocated_pubnavstatutopic(std::string* ptr);

  private:
  const std::string& _internal_pubnavstatutopic() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pubnavstatutopic(
      const std::string& value);
  std::string* _internal_mutable_pubnavstatutopic();

  public:
  // int32 port = 3;
  void clear_port() ;
  ::int32_t port() const;
  void set_port(::int32_t value);

  private:
  ::int32_t _internal_port() const;
  void _internal_set_port(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:NavParameter.Emqx_parameter)
 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 nodeid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ip_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pubstatutopic_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pubnavstatutopic_;
    ::int32_t port_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_parameter_2eproto;
};// -------------------------------------------------------------------

class BrotherEmqx final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavParameter.BrotherEmqx) */ {
 public:
  inline BrotherEmqx() : BrotherEmqx(nullptr) {}
  ~BrotherEmqx() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR BrotherEmqx(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline BrotherEmqx& operator=(const BrotherEmqx& from) {
    CopyFrom(from);
    return *this;
  }
  inline BrotherEmqx& operator=(BrotherEmqx&& 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;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  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 BrotherEmqx& default_instance() {
    return *internal_default_instance();
  }
  static inline const BrotherEmqx* internal_default_instance() {
    return reinterpret_cast<const BrotherEmqx*>(
               &_BrotherEmqx_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(BrotherEmqx& a, BrotherEmqx& b) {
    a.Swap(&b);
  }
  inline void Swap(BrotherEmqx* 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(BrotherEmqx* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BrotherEmqx* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BrotherEmqx>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BrotherEmqx& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BrotherEmqx& from) {
    BrotherEmqx::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);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BrotherEmqx* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "NavParameter.BrotherEmqx";
  }
  protected:
  explicit BrotherEmqx(::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 {
    kNodeIdFieldNumber = 1,
    kIpFieldNumber = 2,
    kSubBrotherStatuTopicFieldNumber = 4,
    kPortFieldNumber = 3,
  };
  // string NodeId = 1;
  void clear_nodeid() ;
  const std::string& nodeid() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_nodeid(Arg_&& arg, Args_... args);
  std::string* mutable_nodeid();
  PROTOBUF_NODISCARD std::string* release_nodeid();
  void set_allocated_nodeid(std::string* ptr);

  private:
  const std::string& _internal_nodeid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_nodeid(
      const std::string& value);
  std::string* _internal_mutable_nodeid();

  public:
  // string ip = 2;
  void clear_ip() ;
  const std::string& ip() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_ip(Arg_&& arg, Args_... args);
  std::string* mutable_ip();
  PROTOBUF_NODISCARD std::string* release_ip();
  void set_allocated_ip(std::string* ptr);

  private:
  const std::string& _internal_ip() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ip(
      const std::string& value);
  std::string* _internal_mutable_ip();

  public:
  // string subBrotherStatuTopic = 4;
  void clear_subbrotherstatutopic() ;
  const std::string& subbrotherstatutopic() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_subbrotherstatutopic(Arg_&& arg, Args_... args);
  std::string* mutable_subbrotherstatutopic();
  PROTOBUF_NODISCARD std::string* release_subbrotherstatutopic();
  void set_allocated_subbrotherstatutopic(std::string* ptr);

  private:
  const std::string& _internal_subbrotherstatutopic() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_subbrotherstatutopic(
      const std::string& value);
  std::string* _internal_mutable_subbrotherstatutopic();

  public:
  // int32 port = 3;
  void clear_port() ;
  ::int32_t port() const;
  void set_port(::int32_t value);

  private:
  ::int32_t _internal_port() const;
  void _internal_set_port(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:NavParameter.BrotherEmqx)
 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 nodeid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ip_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subbrotherstatutopic_;
    ::int32_t port_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_parameter_2eproto;
};// -------------------------------------------------------------------

class MPC_parameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavParameter.MPC_parameter) */ {
 public:
  inline MPC_parameter() : MPC_parameter(nullptr) {}
  ~MPC_parameter() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR MPC_parameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline MPC_parameter& operator=(const MPC_parameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline MPC_parameter& operator=(MPC_parameter&& 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;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  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 MPC_parameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const MPC_parameter* internal_default_instance() {
    return reinterpret_cast<const MPC_parameter*>(
               &_MPC_parameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(MPC_parameter& a, MPC_parameter& b) {
    a.Swap(&b);
  }
  inline void Swap(MPC_parameter* 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(MPC_parameter* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MPC_parameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MPC_parameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MPC_parameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MPC_parameter& from) {
    MPC_parameter::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);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MPC_parameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "NavParameter.MPC_parameter";
  }
  protected:
  explicit MPC_parameter(::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 {
    kShortestRadiusFieldNumber = 1,
    kDtFieldNumber = 2,
    kAccVelocityFieldNumber = 3,
    kAccAngularFieldNumber = 4,
  };
  // float shortest_radius = 1;
  void clear_shortest_radius() ;
  float shortest_radius() const;
  void set_shortest_radius(float value);

  private:
  float _internal_shortest_radius() const;
  void _internal_set_shortest_radius(float value);

  public:
  // float dt = 2;
  void clear_dt() ;
  float dt() const;
  void set_dt(float value);

  private:
  float _internal_dt() const;
  void _internal_set_dt(float value);

  public:
  // float acc_velocity = 3;
  void clear_acc_velocity() ;
  float acc_velocity() const;
  void set_acc_velocity(float value);

  private:
  float _internal_acc_velocity() const;
  void _internal_set_acc_velocity(float value);

  public:
  // float acc_angular = 4;
  void clear_acc_angular() ;
  float acc_angular() const;
  void set_acc_angular(float value);

  private:
  float _internal_acc_angular() const;
  void _internal_set_acc_angular(float value);

  public:
  // @@protoc_insertion_point(class_scope:NavParameter.MPC_parameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    float shortest_radius_;
    float dt_;
    float acc_velocity_;
    float acc_angular_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_parameter_2eproto;
};// -------------------------------------------------------------------

class SpeedLimit final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavParameter.SpeedLimit) */ {
 public:
  inline SpeedLimit() : SpeedLimit(nullptr) {}
  ~SpeedLimit() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR SpeedLimit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline SpeedLimit& operator=(const SpeedLimit& from) {
    CopyFrom(from);
    return *this;
  }
  inline SpeedLimit& operator=(SpeedLimit&& 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;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  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 SpeedLimit& default_instance() {
    return *internal_default_instance();
  }
  static inline const SpeedLimit* internal_default_instance() {
    return reinterpret_cast<const SpeedLimit*>(
               &_SpeedLimit_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(SpeedLimit& a, SpeedLimit& b) {
    a.Swap(&b);
  }
  inline void Swap(SpeedLimit* 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(SpeedLimit* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SpeedLimit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SpeedLimit>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SpeedLimit& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SpeedLimit& from) {
    SpeedLimit::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);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SpeedLimit* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "NavParameter.SpeedLimit";
  }
  protected:
  explicit SpeedLimit(::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 {
    kMinFieldNumber = 1,
    kMaxFieldNumber = 2,
  };
  // float min = 1;
  void clear_min() ;
  float min() const;
  void set_min(float value);

  private:
  float _internal_min() const;
  void _internal_set_min(float value);

  public:
  // float max = 2;
  void clear_max() ;
  float max() const;
  void set_max(float value);

  private:
  float _internal_max() const;
  void _internal_set_max(float value);

  public:
  // @@protoc_insertion_point(class_scope:NavParameter.SpeedLimit)
 private:
  class _Internal;

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

class Accuracy final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavParameter.Accuracy) */ {
 public:
  inline Accuracy() : Accuracy(nullptr) {}
  ~Accuracy() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR Accuracy(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline Accuracy& operator=(const Accuracy& from) {
    CopyFrom(from);
    return *this;
  }
  inline Accuracy& operator=(Accuracy&& 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;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  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 Accuracy& default_instance() {
    return *internal_default_instance();
  }
  static inline const Accuracy* internal_default_instance() {
    return reinterpret_cast<const Accuracy*>(
               &_Accuracy_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(Accuracy& a, Accuracy& b) {
    a.Swap(&b);
  }
  inline void Swap(Accuracy* 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(Accuracy* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Accuracy* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Accuracy>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Accuracy& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Accuracy& from) {
    Accuracy::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);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Accuracy* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "NavParameter.Accuracy";
  }
  protected:
  explicit Accuracy(::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 {
    kLFieldNumber = 1,
    kWFieldNumber = 2,
  };
  // float l = 1;
  void clear_l() ;
  float l() const;
  void set_l(float value);

  private:
  float _internal_l() const;
  void _internal_set_l(float value);

  public:
  // float w = 2;
  void clear_w() ;
  float w() const;
  void set_w(float value);

  private:
  float _internal_w() const;
  void _internal_set_w(float value);

  public:
  // @@protoc_insertion_point(class_scope:NavParameter.Accuracy)
 private:
  class _Internal;

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

class Navigation_parameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavParameter.Navigation_parameter) */ {
 public:
  inline Navigation_parameter() : Navigation_parameter(nullptr) {}
  ~Navigation_parameter() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR Navigation_parameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline Navigation_parameter& operator=(const Navigation_parameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline Navigation_parameter& operator=(Navigation_parameter&& 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;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  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 Navigation_parameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const Navigation_parameter* internal_default_instance() {
    return reinterpret_cast<const Navigation_parameter*>(
               &_Navigation_parameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(Navigation_parameter& a, Navigation_parameter& b) {
    a.Swap(&b);
  }
  inline void Swap(Navigation_parameter* 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(Navigation_parameter* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Navigation_parameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Navigation_parameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Navigation_parameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Navigation_parameter& from) {
    Navigation_parameter::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);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Navigation_parameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "NavParameter.Navigation_parameter";
  }
  protected:
  explicit Navigation_parameter(::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 {
    kRpcIpportFieldNumber = 10,
    kAgvEmqxFieldNumber = 2,
    kTerminalEmqxFieldNumber = 3,
    kBrotherEmqxFieldNumber = 4,
    kXMpcParameterFieldNumber = 5,
    kYMpcParameterFieldNumber = 6,
    kInOutVLimitFieldNumber = 7,
    kNodeVelocityLimitFieldNumber = 8,
    kNodeAngularLimitFieldNumber = 9,
    kMainAgvFieldNumber = 1,
  };
  // string rpc_ipport = 10;
  void clear_rpc_ipport() ;
  const std::string& rpc_ipport() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_rpc_ipport(Arg_&& arg, Args_... args);
  std::string* mutable_rpc_ipport();
  PROTOBUF_NODISCARD std::string* release_rpc_ipport();
  void set_allocated_rpc_ipport(std::string* ptr);

  private:
  const std::string& _internal_rpc_ipport() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_rpc_ipport(
      const std::string& value);
  std::string* _internal_mutable_rpc_ipport();

  public:
  // .NavParameter.AgvEmqx_parameter Agv_emqx = 2;
  bool has_agv_emqx() const;
  void clear_agv_emqx() ;
  const ::NavParameter::AgvEmqx_parameter& agv_emqx() const;
  PROTOBUF_NODISCARD ::NavParameter::AgvEmqx_parameter* release_agv_emqx();
  ::NavParameter::AgvEmqx_parameter* mutable_agv_emqx();
  void set_allocated_agv_emqx(::NavParameter::AgvEmqx_parameter* agv_emqx);
  private:
  const ::NavParameter::AgvEmqx_parameter& _internal_agv_emqx() const;
  ::NavParameter::AgvEmqx_parameter* _internal_mutable_agv_emqx();
  public:
  void unsafe_arena_set_allocated_agv_emqx(
      ::NavParameter::AgvEmqx_parameter* agv_emqx);
  ::NavParameter::AgvEmqx_parameter* unsafe_arena_release_agv_emqx();
  // .NavParameter.Emqx_parameter Terminal_emqx = 3;
  bool has_terminal_emqx() const;
  void clear_terminal_emqx() ;
  const ::NavParameter::Emqx_parameter& terminal_emqx() const;
  PROTOBUF_NODISCARD ::NavParameter::Emqx_parameter* release_terminal_emqx();
  ::NavParameter::Emqx_parameter* mutable_terminal_emqx();
  void set_allocated_terminal_emqx(::NavParameter::Emqx_parameter* terminal_emqx);
  private:
  const ::NavParameter::Emqx_parameter& _internal_terminal_emqx() const;
  ::NavParameter::Emqx_parameter* _internal_mutable_terminal_emqx();
  public:
  void unsafe_arena_set_allocated_terminal_emqx(
      ::NavParameter::Emqx_parameter* terminal_emqx);
  ::NavParameter::Emqx_parameter* unsafe_arena_release_terminal_emqx();
  // .NavParameter.BrotherEmqx brother_emqx = 4;
  bool has_brother_emqx() const;
  void clear_brother_emqx() ;
  const ::NavParameter::BrotherEmqx& brother_emqx() const;
  PROTOBUF_NODISCARD ::NavParameter::BrotherEmqx* release_brother_emqx();
  ::NavParameter::BrotherEmqx* mutable_brother_emqx();
  void set_allocated_brother_emqx(::NavParameter::BrotherEmqx* brother_emqx);
  private:
  const ::NavParameter::BrotherEmqx& _internal_brother_emqx() const;
  ::NavParameter::BrotherEmqx* _internal_mutable_brother_emqx();
  public:
  void unsafe_arena_set_allocated_brother_emqx(
      ::NavParameter::BrotherEmqx* brother_emqx);
  ::NavParameter::BrotherEmqx* unsafe_arena_release_brother_emqx();
  // .NavParameter.MPC_parameter x_mpc_parameter = 5;
  bool has_x_mpc_parameter() const;
  void clear_x_mpc_parameter() ;
  const ::NavParameter::MPC_parameter& x_mpc_parameter() const;
  PROTOBUF_NODISCARD ::NavParameter::MPC_parameter* release_x_mpc_parameter();
  ::NavParameter::MPC_parameter* mutable_x_mpc_parameter();
  void set_allocated_x_mpc_parameter(::NavParameter::MPC_parameter* x_mpc_parameter);
  private:
  const ::NavParameter::MPC_parameter& _internal_x_mpc_parameter() const;
  ::NavParameter::MPC_parameter* _internal_mutable_x_mpc_parameter();
  public:
  void unsafe_arena_set_allocated_x_mpc_parameter(
      ::NavParameter::MPC_parameter* x_mpc_parameter);
  ::NavParameter::MPC_parameter* unsafe_arena_release_x_mpc_parameter();
  // .NavParameter.MPC_parameter y_mpc_parameter = 6;
  bool has_y_mpc_parameter() const;
  void clear_y_mpc_parameter() ;
  const ::NavParameter::MPC_parameter& y_mpc_parameter() const;
  PROTOBUF_NODISCARD ::NavParameter::MPC_parameter* release_y_mpc_parameter();
  ::NavParameter::MPC_parameter* mutable_y_mpc_parameter();
  void set_allocated_y_mpc_parameter(::NavParameter::MPC_parameter* y_mpc_parameter);
  private:
  const ::NavParameter::MPC_parameter& _internal_y_mpc_parameter() const;
  ::NavParameter::MPC_parameter* _internal_mutable_y_mpc_parameter();
  public:
  void unsafe_arena_set_allocated_y_mpc_parameter(
      ::NavParameter::MPC_parameter* y_mpc_parameter);
  ::NavParameter::MPC_parameter* unsafe_arena_release_y_mpc_parameter();
  // .NavParameter.SpeedLimit InOutVLimit = 7;
  bool has_inoutvlimit() const;
  void clear_inoutvlimit() ;
  const ::NavParameter::SpeedLimit& inoutvlimit() const;
  PROTOBUF_NODISCARD ::NavParameter::SpeedLimit* release_inoutvlimit();
  ::NavParameter::SpeedLimit* mutable_inoutvlimit();
  void set_allocated_inoutvlimit(::NavParameter::SpeedLimit* inoutvlimit);
  private:
  const ::NavParameter::SpeedLimit& _internal_inoutvlimit() const;
  ::NavParameter::SpeedLimit* _internal_mutable_inoutvlimit();
  public:
  void unsafe_arena_set_allocated_inoutvlimit(
      ::NavParameter::SpeedLimit* inoutvlimit);
  ::NavParameter::SpeedLimit* unsafe_arena_release_inoutvlimit();
  // .NavParameter.SpeedLimit NodeVelocityLimit = 8;
  bool has_nodevelocitylimit() const;
  void clear_nodevelocitylimit() ;
  const ::NavParameter::SpeedLimit& nodevelocitylimit() const;
  PROTOBUF_NODISCARD ::NavParameter::SpeedLimit* release_nodevelocitylimit();
  ::NavParameter::SpeedLimit* mutable_nodevelocitylimit();
  void set_allocated_nodevelocitylimit(::NavParameter::SpeedLimit* nodevelocitylimit);
  private:
  const ::NavParameter::SpeedLimit& _internal_nodevelocitylimit() const;
  ::NavParameter::SpeedLimit* _internal_mutable_nodevelocitylimit();
  public:
  void unsafe_arena_set_allocated_nodevelocitylimit(
      ::NavParameter::SpeedLimit* nodevelocitylimit);
  ::NavParameter::SpeedLimit* unsafe_arena_release_nodevelocitylimit();
  // .NavParameter.SpeedLimit NodeAngularLimit = 9;
  bool has_nodeangularlimit() const;
  void clear_nodeangularlimit() ;
  const ::NavParameter::SpeedLimit& nodeangularlimit() const;
  PROTOBUF_NODISCARD ::NavParameter::SpeedLimit* release_nodeangularlimit();
  ::NavParameter::SpeedLimit* mutable_nodeangularlimit();
  void set_allocated_nodeangularlimit(::NavParameter::SpeedLimit* nodeangularlimit);
  private:
  const ::NavParameter::SpeedLimit& _internal_nodeangularlimit() const;
  ::NavParameter::SpeedLimit* _internal_mutable_nodeangularlimit();
  public:
  void unsafe_arena_set_allocated_nodeangularlimit(
      ::NavParameter::SpeedLimit* nodeangularlimit);
  ::NavParameter::SpeedLimit* unsafe_arena_release_nodeangularlimit();
  // bool main_agv = 1;
  void clear_main_agv() ;
  bool main_agv() const;
  void set_main_agv(bool value);

  private:
  bool _internal_main_agv() const;
  void _internal_set_main_agv(bool value);

  public:
  // @@protoc_insertion_point(class_scope:NavParameter.Navigation_parameter)
 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::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rpc_ipport_;
    ::NavParameter::AgvEmqx_parameter* agv_emqx_;
    ::NavParameter::Emqx_parameter* terminal_emqx_;
    ::NavParameter::BrotherEmqx* brother_emqx_;
    ::NavParameter::MPC_parameter* x_mpc_parameter_;
    ::NavParameter::MPC_parameter* y_mpc_parameter_;
    ::NavParameter::SpeedLimit* inoutvlimit_;
    ::NavParameter::SpeedLimit* nodevelocitylimit_;
    ::NavParameter::SpeedLimit* nodeangularlimit_;
    bool main_agv_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_parameter_2eproto;
};

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




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


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

// AgvEmqx_parameter

// string NodeId = 1;
inline void AgvEmqx_parameter::clear_nodeid() {
  _impl_.nodeid_.ClearToEmpty();
}
inline const std::string& AgvEmqx_parameter::nodeid() const {
  // @@protoc_insertion_point(field_get:NavParameter.AgvEmqx_parameter.NodeId)
  return _internal_nodeid();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AgvEmqx_parameter::set_nodeid(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.nodeid_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NavParameter.AgvEmqx_parameter.NodeId)
}
inline std::string* AgvEmqx_parameter::mutable_nodeid() {
  std::string* _s = _internal_mutable_nodeid();
  // @@protoc_insertion_point(field_mutable:NavParameter.AgvEmqx_parameter.NodeId)
  return _s;
}
inline const std::string& AgvEmqx_parameter::_internal_nodeid() const {
  return _impl_.nodeid_.Get();
}
inline void AgvEmqx_parameter::_internal_set_nodeid(const std::string& value) {
  ;


  _impl_.nodeid_.Set(value, GetArenaForAllocation());
}
inline std::string* AgvEmqx_parameter::_internal_mutable_nodeid() {
  ;
  return _impl_.nodeid_.Mutable( GetArenaForAllocation());
}
inline std::string* AgvEmqx_parameter::release_nodeid() {
  // @@protoc_insertion_point(field_release:NavParameter.AgvEmqx_parameter.NodeId)
  return _impl_.nodeid_.Release();
}
inline void AgvEmqx_parameter::set_allocated_nodeid(std::string* value) {
  _impl_.nodeid_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.nodeid_.IsDefault()) {
          _impl_.nodeid_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:NavParameter.AgvEmqx_parameter.NodeId)
}

// string ip = 2;
inline void AgvEmqx_parameter::clear_ip() {
  _impl_.ip_.ClearToEmpty();
}
inline const std::string& AgvEmqx_parameter::ip() const {
  // @@protoc_insertion_point(field_get:NavParameter.AgvEmqx_parameter.ip)
  return _internal_ip();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AgvEmqx_parameter::set_ip(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.ip_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NavParameter.AgvEmqx_parameter.ip)
}
inline std::string* AgvEmqx_parameter::mutable_ip() {
  std::string* _s = _internal_mutable_ip();
  // @@protoc_insertion_point(field_mutable:NavParameter.AgvEmqx_parameter.ip)
  return _s;
}
inline const std::string& AgvEmqx_parameter::_internal_ip() const {
  return _impl_.ip_.Get();
}
inline void AgvEmqx_parameter::_internal_set_ip(const std::string& value) {
  ;


  _impl_.ip_.Set(value, GetArenaForAllocation());
}
inline std::string* AgvEmqx_parameter::_internal_mutable_ip() {
  ;
  return _impl_.ip_.Mutable( GetArenaForAllocation());
}
inline std::string* AgvEmqx_parameter::release_ip() {
  // @@protoc_insertion_point(field_release:NavParameter.AgvEmqx_parameter.ip)
  return _impl_.ip_.Release();
}
inline void AgvEmqx_parameter::set_allocated_ip(std::string* value) {
  _impl_.ip_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.ip_.IsDefault()) {
          _impl_.ip_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:NavParameter.AgvEmqx_parameter.ip)
}

// int32 port = 3;
inline void AgvEmqx_parameter::clear_port() {
  _impl_.port_ = 0;
}
inline ::int32_t AgvEmqx_parameter::port() const {
  // @@protoc_insertion_point(field_get:NavParameter.AgvEmqx_parameter.port)
  return _internal_port();
}
inline void AgvEmqx_parameter::set_port(::int32_t value) {
  _internal_set_port(value);
  // @@protoc_insertion_point(field_set:NavParameter.AgvEmqx_parameter.port)
}
inline ::int32_t AgvEmqx_parameter::_internal_port() const {
  return _impl_.port_;
}
inline void AgvEmqx_parameter::_internal_set_port(::int32_t value) {
  ;
  _impl_.port_ = value;
}

// string pubSpeedTopic = 4;
inline void AgvEmqx_parameter::clear_pubspeedtopic() {
  _impl_.pubspeedtopic_.ClearToEmpty();
}
inline const std::string& AgvEmqx_parameter::pubspeedtopic() const {
  // @@protoc_insertion_point(field_get:NavParameter.AgvEmqx_parameter.pubSpeedTopic)
  return _internal_pubspeedtopic();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AgvEmqx_parameter::set_pubspeedtopic(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.pubspeedtopic_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NavParameter.AgvEmqx_parameter.pubSpeedTopic)
}
inline std::string* AgvEmqx_parameter::mutable_pubspeedtopic() {
  std::string* _s = _internal_mutable_pubspeedtopic();
  // @@protoc_insertion_point(field_mutable:NavParameter.AgvEmqx_parameter.pubSpeedTopic)
  return _s;
}
inline const std::string& AgvEmqx_parameter::_internal_pubspeedtopic() const {
  return _impl_.pubspeedtopic_.Get();
}
inline void AgvEmqx_parameter::_internal_set_pubspeedtopic(const std::string& value) {
  ;


  _impl_.pubspeedtopic_.Set(value, GetArenaForAllocation());
}
inline std::string* AgvEmqx_parameter::_internal_mutable_pubspeedtopic() {
  ;
  return _impl_.pubspeedtopic_.Mutable( GetArenaForAllocation());
}
inline std::string* AgvEmqx_parameter::release_pubspeedtopic() {
  // @@protoc_insertion_point(field_release:NavParameter.AgvEmqx_parameter.pubSpeedTopic)
  return _impl_.pubspeedtopic_.Release();
}
inline void AgvEmqx_parameter::set_allocated_pubspeedtopic(std::string* value) {
  _impl_.pubspeedtopic_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.pubspeedtopic_.IsDefault()) {
          _impl_.pubspeedtopic_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:NavParameter.AgvEmqx_parameter.pubSpeedTopic)
}

// string subPoseTopic = 5;
inline void AgvEmqx_parameter::clear_subposetopic() {
  _impl_.subposetopic_.ClearToEmpty();
}
inline const std::string& AgvEmqx_parameter::subposetopic() const {
  // @@protoc_insertion_point(field_get:NavParameter.AgvEmqx_parameter.subPoseTopic)
  return _internal_subposetopic();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AgvEmqx_parameter::set_subposetopic(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.subposetopic_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NavParameter.AgvEmqx_parameter.subPoseTopic)
}
inline std::string* AgvEmqx_parameter::mutable_subposetopic() {
  std::string* _s = _internal_mutable_subposetopic();
  // @@protoc_insertion_point(field_mutable:NavParameter.AgvEmqx_parameter.subPoseTopic)
  return _s;
}
inline const std::string& AgvEmqx_parameter::_internal_subposetopic() const {
  return _impl_.subposetopic_.Get();
}
inline void AgvEmqx_parameter::_internal_set_subposetopic(const std::string& value) {
  ;


  _impl_.subposetopic_.Set(value, GetArenaForAllocation());
}
inline std::string* AgvEmqx_parameter::_internal_mutable_subposetopic() {
  ;
  return _impl_.subposetopic_.Mutable( GetArenaForAllocation());
}
inline std::string* AgvEmqx_parameter::release_subposetopic() {
  // @@protoc_insertion_point(field_release:NavParameter.AgvEmqx_parameter.subPoseTopic)
  return _impl_.subposetopic_.Release();
}
inline void AgvEmqx_parameter::set_allocated_subposetopic(std::string* value) {
  _impl_.subposetopic_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.subposetopic_.IsDefault()) {
          _impl_.subposetopic_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:NavParameter.AgvEmqx_parameter.subPoseTopic)
}

// string subSpeedTopic = 6;
inline void AgvEmqx_parameter::clear_subspeedtopic() {
  _impl_.subspeedtopic_.ClearToEmpty();
}
inline const std::string& AgvEmqx_parameter::subspeedtopic() const {
  // @@protoc_insertion_point(field_get:NavParameter.AgvEmqx_parameter.subSpeedTopic)
  return _internal_subspeedtopic();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AgvEmqx_parameter::set_subspeedtopic(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.subspeedtopic_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NavParameter.AgvEmqx_parameter.subSpeedTopic)
}
inline std::string* AgvEmqx_parameter::mutable_subspeedtopic() {
  std::string* _s = _internal_mutable_subspeedtopic();
  // @@protoc_insertion_point(field_mutable:NavParameter.AgvEmqx_parameter.subSpeedTopic)
  return _s;
}
inline const std::string& AgvEmqx_parameter::_internal_subspeedtopic() const {
  return _impl_.subspeedtopic_.Get();
}
inline void AgvEmqx_parameter::_internal_set_subspeedtopic(const std::string& value) {
  ;


  _impl_.subspeedtopic_.Set(value, GetArenaForAllocation());
}
inline std::string* AgvEmqx_parameter::_internal_mutable_subspeedtopic() {
  ;
  return _impl_.subspeedtopic_.Mutable( GetArenaForAllocation());
}
inline std::string* AgvEmqx_parameter::release_subspeedtopic() {
  // @@protoc_insertion_point(field_release:NavParameter.AgvEmqx_parameter.subSpeedTopic)
  return _impl_.subspeedtopic_.Release();
}
inline void AgvEmqx_parameter::set_allocated_subspeedtopic(std::string* value) {
  _impl_.subspeedtopic_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.subspeedtopic_.IsDefault()) {
          _impl_.subspeedtopic_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:NavParameter.AgvEmqx_parameter.subSpeedTopic)
}

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

// Emqx_parameter

// string NodeId = 1;
inline void Emqx_parameter::clear_nodeid() {
  _impl_.nodeid_.ClearToEmpty();
}
inline const std::string& Emqx_parameter::nodeid() const {
  // @@protoc_insertion_point(field_get:NavParameter.Emqx_parameter.NodeId)
  return _internal_nodeid();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Emqx_parameter::set_nodeid(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.nodeid_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NavParameter.Emqx_parameter.NodeId)
}
inline std::string* Emqx_parameter::mutable_nodeid() {
  std::string* _s = _internal_mutable_nodeid();
  // @@protoc_insertion_point(field_mutable:NavParameter.Emqx_parameter.NodeId)
  return _s;
}
inline const std::string& Emqx_parameter::_internal_nodeid() const {
  return _impl_.nodeid_.Get();
}
inline void Emqx_parameter::_internal_set_nodeid(const std::string& value) {
  ;


  _impl_.nodeid_.Set(value, GetArenaForAllocation());
}
inline std::string* Emqx_parameter::_internal_mutable_nodeid() {
  ;
  return _impl_.nodeid_.Mutable( GetArenaForAllocation());
}
inline std::string* Emqx_parameter::release_nodeid() {
  // @@protoc_insertion_point(field_release:NavParameter.Emqx_parameter.NodeId)
  return _impl_.nodeid_.Release();
}
inline void Emqx_parameter::set_allocated_nodeid(std::string* value) {
  _impl_.nodeid_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.nodeid_.IsDefault()) {
          _impl_.nodeid_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:NavParameter.Emqx_parameter.NodeId)
}

// string ip = 2;
inline void Emqx_parameter::clear_ip() {
  _impl_.ip_.ClearToEmpty();
}
inline const std::string& Emqx_parameter::ip() const {
  // @@protoc_insertion_point(field_get:NavParameter.Emqx_parameter.ip)
  return _internal_ip();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Emqx_parameter::set_ip(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.ip_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NavParameter.Emqx_parameter.ip)
}
inline std::string* Emqx_parameter::mutable_ip() {
  std::string* _s = _internal_mutable_ip();
  // @@protoc_insertion_point(field_mutable:NavParameter.Emqx_parameter.ip)
  return _s;
}
inline const std::string& Emqx_parameter::_internal_ip() const {
  return _impl_.ip_.Get();
}
inline void Emqx_parameter::_internal_set_ip(const std::string& value) {
  ;


  _impl_.ip_.Set(value, GetArenaForAllocation());
}
inline std::string* Emqx_parameter::_internal_mutable_ip() {
  ;
  return _impl_.ip_.Mutable( GetArenaForAllocation());
}
inline std::string* Emqx_parameter::release_ip() {
  // @@protoc_insertion_point(field_release:NavParameter.Emqx_parameter.ip)
  return _impl_.ip_.Release();
}
inline void Emqx_parameter::set_allocated_ip(std::string* value) {
  _impl_.ip_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.ip_.IsDefault()) {
          _impl_.ip_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:NavParameter.Emqx_parameter.ip)
}

// int32 port = 3;
inline void Emqx_parameter::clear_port() {
  _impl_.port_ = 0;
}
inline ::int32_t Emqx_parameter::port() const {
  // @@protoc_insertion_point(field_get:NavParameter.Emqx_parameter.port)
  return _internal_port();
}
inline void Emqx_parameter::set_port(::int32_t value) {
  _internal_set_port(value);
  // @@protoc_insertion_point(field_set:NavParameter.Emqx_parameter.port)
}
inline ::int32_t Emqx_parameter::_internal_port() const {
  return _impl_.port_;
}
inline void Emqx_parameter::_internal_set_port(::int32_t value) {
  ;
  _impl_.port_ = value;
}

// string pubStatuTopic = 4;
inline void Emqx_parameter::clear_pubstatutopic() {
  _impl_.pubstatutopic_.ClearToEmpty();
}
inline const std::string& Emqx_parameter::pubstatutopic() const {
  // @@protoc_insertion_point(field_get:NavParameter.Emqx_parameter.pubStatuTopic)
  return _internal_pubstatutopic();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Emqx_parameter::set_pubstatutopic(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.pubstatutopic_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NavParameter.Emqx_parameter.pubStatuTopic)
}
inline std::string* Emqx_parameter::mutable_pubstatutopic() {
  std::string* _s = _internal_mutable_pubstatutopic();
  // @@protoc_insertion_point(field_mutable:NavParameter.Emqx_parameter.pubStatuTopic)
  return _s;
}
inline const std::string& Emqx_parameter::_internal_pubstatutopic() const {
  return _impl_.pubstatutopic_.Get();
}
inline void Emqx_parameter::_internal_set_pubstatutopic(const std::string& value) {
  ;


  _impl_.pubstatutopic_.Set(value, GetArenaForAllocation());
}
inline std::string* Emqx_parameter::_internal_mutable_pubstatutopic() {
  ;
  return _impl_.pubstatutopic_.Mutable( GetArenaForAllocation());
}
inline std::string* Emqx_parameter::release_pubstatutopic() {
  // @@protoc_insertion_point(field_release:NavParameter.Emqx_parameter.pubStatuTopic)
  return _impl_.pubstatutopic_.Release();
}
inline void Emqx_parameter::set_allocated_pubstatutopic(std::string* value) {
  _impl_.pubstatutopic_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.pubstatutopic_.IsDefault()) {
          _impl_.pubstatutopic_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:NavParameter.Emqx_parameter.pubStatuTopic)
}

// string pubNavStatuTopic = 5;
inline void Emqx_parameter::clear_pubnavstatutopic() {
  _impl_.pubnavstatutopic_.ClearToEmpty();
}
inline const std::string& Emqx_parameter::pubnavstatutopic() const {
  // @@protoc_insertion_point(field_get:NavParameter.Emqx_parameter.pubNavStatuTopic)
  return _internal_pubnavstatutopic();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Emqx_parameter::set_pubnavstatutopic(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.pubnavstatutopic_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NavParameter.Emqx_parameter.pubNavStatuTopic)
}
inline std::string* Emqx_parameter::mutable_pubnavstatutopic() {
  std::string* _s = _internal_mutable_pubnavstatutopic();
  // @@protoc_insertion_point(field_mutable:NavParameter.Emqx_parameter.pubNavStatuTopic)
  return _s;
}
inline const std::string& Emqx_parameter::_internal_pubnavstatutopic() const {
  return _impl_.pubnavstatutopic_.Get();
}
inline void Emqx_parameter::_internal_set_pubnavstatutopic(const std::string& value) {
  ;


  _impl_.pubnavstatutopic_.Set(value, GetArenaForAllocation());
}
inline std::string* Emqx_parameter::_internal_mutable_pubnavstatutopic() {
  ;
  return _impl_.pubnavstatutopic_.Mutable( GetArenaForAllocation());
}
inline std::string* Emqx_parameter::release_pubnavstatutopic() {
  // @@protoc_insertion_point(field_release:NavParameter.Emqx_parameter.pubNavStatuTopic)
  return _impl_.pubnavstatutopic_.Release();
}
inline void Emqx_parameter::set_allocated_pubnavstatutopic(std::string* value) {
  _impl_.pubnavstatutopic_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.pubnavstatutopic_.IsDefault()) {
          _impl_.pubnavstatutopic_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:NavParameter.Emqx_parameter.pubNavStatuTopic)
}

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

// BrotherEmqx

// string NodeId = 1;
inline void BrotherEmqx::clear_nodeid() {
  _impl_.nodeid_.ClearToEmpty();
}
inline const std::string& BrotherEmqx::nodeid() const {
  // @@protoc_insertion_point(field_get:NavParameter.BrotherEmqx.NodeId)
  return _internal_nodeid();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void BrotherEmqx::set_nodeid(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.nodeid_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NavParameter.BrotherEmqx.NodeId)
}
inline std::string* BrotherEmqx::mutable_nodeid() {
  std::string* _s = _internal_mutable_nodeid();
  // @@protoc_insertion_point(field_mutable:NavParameter.BrotherEmqx.NodeId)
  return _s;
}
inline const std::string& BrotherEmqx::_internal_nodeid() const {
  return _impl_.nodeid_.Get();
}
inline void BrotherEmqx::_internal_set_nodeid(const std::string& value) {
  ;


  _impl_.nodeid_.Set(value, GetArenaForAllocation());
}
inline std::string* BrotherEmqx::_internal_mutable_nodeid() {
  ;
  return _impl_.nodeid_.Mutable( GetArenaForAllocation());
}
inline std::string* BrotherEmqx::release_nodeid() {
  // @@protoc_insertion_point(field_release:NavParameter.BrotherEmqx.NodeId)
  return _impl_.nodeid_.Release();
}
inline void BrotherEmqx::set_allocated_nodeid(std::string* value) {
  _impl_.nodeid_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.nodeid_.IsDefault()) {
          _impl_.nodeid_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:NavParameter.BrotherEmqx.NodeId)
}

// string ip = 2;
inline void BrotherEmqx::clear_ip() {
  _impl_.ip_.ClearToEmpty();
}
inline const std::string& BrotherEmqx::ip() const {
  // @@protoc_insertion_point(field_get:NavParameter.BrotherEmqx.ip)
  return _internal_ip();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void BrotherEmqx::set_ip(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.ip_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NavParameter.BrotherEmqx.ip)
}
inline std::string* BrotherEmqx::mutable_ip() {
  std::string* _s = _internal_mutable_ip();
  // @@protoc_insertion_point(field_mutable:NavParameter.BrotherEmqx.ip)
  return _s;
}
inline const std::string& BrotherEmqx::_internal_ip() const {
  return _impl_.ip_.Get();
}
inline void BrotherEmqx::_internal_set_ip(const std::string& value) {
  ;


  _impl_.ip_.Set(value, GetArenaForAllocation());
}
inline std::string* BrotherEmqx::_internal_mutable_ip() {
  ;
  return _impl_.ip_.Mutable( GetArenaForAllocation());
}
inline std::string* BrotherEmqx::release_ip() {
  // @@protoc_insertion_point(field_release:NavParameter.BrotherEmqx.ip)
  return _impl_.ip_.Release();
}
inline void BrotherEmqx::set_allocated_ip(std::string* value) {
  _impl_.ip_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.ip_.IsDefault()) {
          _impl_.ip_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:NavParameter.BrotherEmqx.ip)
}

// int32 port = 3;
inline void BrotherEmqx::clear_port() {
  _impl_.port_ = 0;
}
inline ::int32_t BrotherEmqx::port() const {
  // @@protoc_insertion_point(field_get:NavParameter.BrotherEmqx.port)
  return _internal_port();
}
inline void BrotherEmqx::set_port(::int32_t value) {
  _internal_set_port(value);
  // @@protoc_insertion_point(field_set:NavParameter.BrotherEmqx.port)
}
inline ::int32_t BrotherEmqx::_internal_port() const {
  return _impl_.port_;
}
inline void BrotherEmqx::_internal_set_port(::int32_t value) {
  ;
  _impl_.port_ = value;
}

// string subBrotherStatuTopic = 4;
inline void BrotherEmqx::clear_subbrotherstatutopic() {
  _impl_.subbrotherstatutopic_.ClearToEmpty();
}
inline const std::string& BrotherEmqx::subbrotherstatutopic() const {
  // @@protoc_insertion_point(field_get:NavParameter.BrotherEmqx.subBrotherStatuTopic)
  return _internal_subbrotherstatutopic();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void BrotherEmqx::set_subbrotherstatutopic(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.subbrotherstatutopic_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NavParameter.BrotherEmqx.subBrotherStatuTopic)
}
inline std::string* BrotherEmqx::mutable_subbrotherstatutopic() {
  std::string* _s = _internal_mutable_subbrotherstatutopic();
  // @@protoc_insertion_point(field_mutable:NavParameter.BrotherEmqx.subBrotherStatuTopic)
  return _s;
}
inline const std::string& BrotherEmqx::_internal_subbrotherstatutopic() const {
  return _impl_.subbrotherstatutopic_.Get();
}
inline void BrotherEmqx::_internal_set_subbrotherstatutopic(const std::string& value) {
  ;


  _impl_.subbrotherstatutopic_.Set(value, GetArenaForAllocation());
}
inline std::string* BrotherEmqx::_internal_mutable_subbrotherstatutopic() {
  ;
  return _impl_.subbrotherstatutopic_.Mutable( GetArenaForAllocation());
}
inline std::string* BrotherEmqx::release_subbrotherstatutopic() {
  // @@protoc_insertion_point(field_release:NavParameter.BrotherEmqx.subBrotherStatuTopic)
  return _impl_.subbrotherstatutopic_.Release();
}
inline void BrotherEmqx::set_allocated_subbrotherstatutopic(std::string* value) {
  _impl_.subbrotherstatutopic_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.subbrotherstatutopic_.IsDefault()) {
          _impl_.subbrotherstatutopic_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:NavParameter.BrotherEmqx.subBrotherStatuTopic)
}

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

// MPC_parameter

// float shortest_radius = 1;
inline void MPC_parameter::clear_shortest_radius() {
  _impl_.shortest_radius_ = 0;
}
inline float MPC_parameter::shortest_radius() const {
  // @@protoc_insertion_point(field_get:NavParameter.MPC_parameter.shortest_radius)
  return _internal_shortest_radius();
}
inline void MPC_parameter::set_shortest_radius(float value) {
  _internal_set_shortest_radius(value);
  // @@protoc_insertion_point(field_set:NavParameter.MPC_parameter.shortest_radius)
}
inline float MPC_parameter::_internal_shortest_radius() const {
  return _impl_.shortest_radius_;
}
inline void MPC_parameter::_internal_set_shortest_radius(float value) {
  ;
  _impl_.shortest_radius_ = value;
}

// float dt = 2;
inline void MPC_parameter::clear_dt() {
  _impl_.dt_ = 0;
}
inline float MPC_parameter::dt() const {
  // @@protoc_insertion_point(field_get:NavParameter.MPC_parameter.dt)
  return _internal_dt();
}
inline void MPC_parameter::set_dt(float value) {
  _internal_set_dt(value);
  // @@protoc_insertion_point(field_set:NavParameter.MPC_parameter.dt)
}
inline float MPC_parameter::_internal_dt() const {
  return _impl_.dt_;
}
inline void MPC_parameter::_internal_set_dt(float value) {
  ;
  _impl_.dt_ = value;
}

// float acc_velocity = 3;
inline void MPC_parameter::clear_acc_velocity() {
  _impl_.acc_velocity_ = 0;
}
inline float MPC_parameter::acc_velocity() const {
  // @@protoc_insertion_point(field_get:NavParameter.MPC_parameter.acc_velocity)
  return _internal_acc_velocity();
}
inline void MPC_parameter::set_acc_velocity(float value) {
  _internal_set_acc_velocity(value);
  // @@protoc_insertion_point(field_set:NavParameter.MPC_parameter.acc_velocity)
}
inline float MPC_parameter::_internal_acc_velocity() const {
  return _impl_.acc_velocity_;
}
inline void MPC_parameter::_internal_set_acc_velocity(float value) {
  ;
  _impl_.acc_velocity_ = value;
}

// float acc_angular = 4;
inline void MPC_parameter::clear_acc_angular() {
  _impl_.acc_angular_ = 0;
}
inline float MPC_parameter::acc_angular() const {
  // @@protoc_insertion_point(field_get:NavParameter.MPC_parameter.acc_angular)
  return _internal_acc_angular();
}
inline void MPC_parameter::set_acc_angular(float value) {
  _internal_set_acc_angular(value);
  // @@protoc_insertion_point(field_set:NavParameter.MPC_parameter.acc_angular)
}
inline float MPC_parameter::_internal_acc_angular() const {
  return _impl_.acc_angular_;
}
inline void MPC_parameter::_internal_set_acc_angular(float value) {
  ;
  _impl_.acc_angular_ = value;
}

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

// SpeedLimit

// float min = 1;
inline void SpeedLimit::clear_min() {
  _impl_.min_ = 0;
}
inline float SpeedLimit::min() const {
  // @@protoc_insertion_point(field_get:NavParameter.SpeedLimit.min)
  return _internal_min();
}
inline void SpeedLimit::set_min(float value) {
  _internal_set_min(value);
  // @@protoc_insertion_point(field_set:NavParameter.SpeedLimit.min)
}
inline float SpeedLimit::_internal_min() const {
  return _impl_.min_;
}
inline void SpeedLimit::_internal_set_min(float value) {
  ;
  _impl_.min_ = value;
}

// float max = 2;
inline void SpeedLimit::clear_max() {
  _impl_.max_ = 0;
}
inline float SpeedLimit::max() const {
  // @@protoc_insertion_point(field_get:NavParameter.SpeedLimit.max)
  return _internal_max();
}
inline void SpeedLimit::set_max(float value) {
  _internal_set_max(value);
  // @@protoc_insertion_point(field_set:NavParameter.SpeedLimit.max)
}
inline float SpeedLimit::_internal_max() const {
  return _impl_.max_;
}
inline void SpeedLimit::_internal_set_max(float value) {
  ;
  _impl_.max_ = value;
}

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

// Accuracy

// float l = 1;
inline void Accuracy::clear_l() {
  _impl_.l_ = 0;
}
inline float Accuracy::l() const {
  // @@protoc_insertion_point(field_get:NavParameter.Accuracy.l)
  return _internal_l();
}
inline void Accuracy::set_l(float value) {
  _internal_set_l(value);
  // @@protoc_insertion_point(field_set:NavParameter.Accuracy.l)
}
inline float Accuracy::_internal_l() const {
  return _impl_.l_;
}
inline void Accuracy::_internal_set_l(float value) {
  ;
  _impl_.l_ = value;
}

// float w = 2;
inline void Accuracy::clear_w() {
  _impl_.w_ = 0;
}
inline float Accuracy::w() const {
  // @@protoc_insertion_point(field_get:NavParameter.Accuracy.w)
  return _internal_w();
}
inline void Accuracy::set_w(float value) {
  _internal_set_w(value);
  // @@protoc_insertion_point(field_set:NavParameter.Accuracy.w)
}
inline float Accuracy::_internal_w() const {
  return _impl_.w_;
}
inline void Accuracy::_internal_set_w(float value) {
  ;
  _impl_.w_ = value;
}

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

// Navigation_parameter

// bool main_agv = 1;
inline void Navigation_parameter::clear_main_agv() {
  _impl_.main_agv_ = false;
}
inline bool Navigation_parameter::main_agv() const {
  // @@protoc_insertion_point(field_get:NavParameter.Navigation_parameter.main_agv)
  return _internal_main_agv();
}
inline void Navigation_parameter::set_main_agv(bool value) {
  _internal_set_main_agv(value);
  // @@protoc_insertion_point(field_set:NavParameter.Navigation_parameter.main_agv)
}
inline bool Navigation_parameter::_internal_main_agv() const {
  return _impl_.main_agv_;
}
inline void Navigation_parameter::_internal_set_main_agv(bool value) {
  ;
  _impl_.main_agv_ = value;
}

// .NavParameter.AgvEmqx_parameter Agv_emqx = 2;
inline bool Navigation_parameter::has_agv_emqx() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.agv_emqx_ != nullptr);
  return value;
}
inline void Navigation_parameter::clear_agv_emqx() {
  if (_impl_.agv_emqx_ != nullptr) _impl_.agv_emqx_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::NavParameter::AgvEmqx_parameter& Navigation_parameter::_internal_agv_emqx() const {
  const ::NavParameter::AgvEmqx_parameter* p = _impl_.agv_emqx_;
  return p != nullptr ? *p : reinterpret_cast<const ::NavParameter::AgvEmqx_parameter&>(
      ::NavParameter::_AgvEmqx_parameter_default_instance_);
}
inline const ::NavParameter::AgvEmqx_parameter& Navigation_parameter::agv_emqx() const {
  // @@protoc_insertion_point(field_get:NavParameter.Navigation_parameter.Agv_emqx)
  return _internal_agv_emqx();
}
inline void Navigation_parameter::unsafe_arena_set_allocated_agv_emqx(
    ::NavParameter::AgvEmqx_parameter* agv_emqx) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.agv_emqx_);
  }
  _impl_.agv_emqx_ = agv_emqx;
  if (agv_emqx) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavParameter.Navigation_parameter.Agv_emqx)
}
inline ::NavParameter::AgvEmqx_parameter* Navigation_parameter::release_agv_emqx() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::NavParameter::AgvEmqx_parameter* temp = _impl_.agv_emqx_;
  _impl_.agv_emqx_ = 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 ::NavParameter::AgvEmqx_parameter* Navigation_parameter::unsafe_arena_release_agv_emqx() {
  // @@protoc_insertion_point(field_release:NavParameter.Navigation_parameter.Agv_emqx)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::NavParameter::AgvEmqx_parameter* temp = _impl_.agv_emqx_;
  _impl_.agv_emqx_ = nullptr;
  return temp;
}
inline ::NavParameter::AgvEmqx_parameter* Navigation_parameter::_internal_mutable_agv_emqx() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.agv_emqx_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavParameter::AgvEmqx_parameter>(GetArenaForAllocation());
    _impl_.agv_emqx_ = p;
  }
  return _impl_.agv_emqx_;
}
inline ::NavParameter::AgvEmqx_parameter* Navigation_parameter::mutable_agv_emqx() {
  ::NavParameter::AgvEmqx_parameter* _msg = _internal_mutable_agv_emqx();
  // @@protoc_insertion_point(field_mutable:NavParameter.Navigation_parameter.Agv_emqx)
  return _msg;
}
inline void Navigation_parameter::set_allocated_agv_emqx(::NavParameter::AgvEmqx_parameter* agv_emqx) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.agv_emqx_;
  }
  if (agv_emqx) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(agv_emqx);
    if (message_arena != submessage_arena) {
      agv_emqx = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, agv_emqx, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.agv_emqx_ = agv_emqx;
  // @@protoc_insertion_point(field_set_allocated:NavParameter.Navigation_parameter.Agv_emqx)
}

// .NavParameter.Emqx_parameter Terminal_emqx = 3;
inline bool Navigation_parameter::has_terminal_emqx() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.terminal_emqx_ != nullptr);
  return value;
}
inline void Navigation_parameter::clear_terminal_emqx() {
  if (_impl_.terminal_emqx_ != nullptr) _impl_.terminal_emqx_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::NavParameter::Emqx_parameter& Navigation_parameter::_internal_terminal_emqx() const {
  const ::NavParameter::Emqx_parameter* p = _impl_.terminal_emqx_;
  return p != nullptr ? *p : reinterpret_cast<const ::NavParameter::Emqx_parameter&>(
      ::NavParameter::_Emqx_parameter_default_instance_);
}
inline const ::NavParameter::Emqx_parameter& Navigation_parameter::terminal_emqx() const {
  // @@protoc_insertion_point(field_get:NavParameter.Navigation_parameter.Terminal_emqx)
  return _internal_terminal_emqx();
}
inline void Navigation_parameter::unsafe_arena_set_allocated_terminal_emqx(
    ::NavParameter::Emqx_parameter* terminal_emqx) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.terminal_emqx_);
  }
  _impl_.terminal_emqx_ = terminal_emqx;
  if (terminal_emqx) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavParameter.Navigation_parameter.Terminal_emqx)
}
inline ::NavParameter::Emqx_parameter* Navigation_parameter::release_terminal_emqx() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::NavParameter::Emqx_parameter* temp = _impl_.terminal_emqx_;
  _impl_.terminal_emqx_ = 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 ::NavParameter::Emqx_parameter* Navigation_parameter::unsafe_arena_release_terminal_emqx() {
  // @@protoc_insertion_point(field_release:NavParameter.Navigation_parameter.Terminal_emqx)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::NavParameter::Emqx_parameter* temp = _impl_.terminal_emqx_;
  _impl_.terminal_emqx_ = nullptr;
  return temp;
}
inline ::NavParameter::Emqx_parameter* Navigation_parameter::_internal_mutable_terminal_emqx() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.terminal_emqx_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavParameter::Emqx_parameter>(GetArenaForAllocation());
    _impl_.terminal_emqx_ = p;
  }
  return _impl_.terminal_emqx_;
}
inline ::NavParameter::Emqx_parameter* Navigation_parameter::mutable_terminal_emqx() {
  ::NavParameter::Emqx_parameter* _msg = _internal_mutable_terminal_emqx();
  // @@protoc_insertion_point(field_mutable:NavParameter.Navigation_parameter.Terminal_emqx)
  return _msg;
}
inline void Navigation_parameter::set_allocated_terminal_emqx(::NavParameter::Emqx_parameter* terminal_emqx) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.terminal_emqx_;
  }
  if (terminal_emqx) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(terminal_emqx);
    if (message_arena != submessage_arena) {
      terminal_emqx = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, terminal_emqx, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.terminal_emqx_ = terminal_emqx;
  // @@protoc_insertion_point(field_set_allocated:NavParameter.Navigation_parameter.Terminal_emqx)
}

// .NavParameter.BrotherEmqx brother_emqx = 4;
inline bool Navigation_parameter::has_brother_emqx() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.brother_emqx_ != nullptr);
  return value;
}
inline void Navigation_parameter::clear_brother_emqx() {
  if (_impl_.brother_emqx_ != nullptr) _impl_.brother_emqx_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::NavParameter::BrotherEmqx& Navigation_parameter::_internal_brother_emqx() const {
  const ::NavParameter::BrotherEmqx* p = _impl_.brother_emqx_;
  return p != nullptr ? *p : reinterpret_cast<const ::NavParameter::BrotherEmqx&>(
      ::NavParameter::_BrotherEmqx_default_instance_);
}
inline const ::NavParameter::BrotherEmqx& Navigation_parameter::brother_emqx() const {
  // @@protoc_insertion_point(field_get:NavParameter.Navigation_parameter.brother_emqx)
  return _internal_brother_emqx();
}
inline void Navigation_parameter::unsafe_arena_set_allocated_brother_emqx(
    ::NavParameter::BrotherEmqx* brother_emqx) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.brother_emqx_);
  }
  _impl_.brother_emqx_ = brother_emqx;
  if (brother_emqx) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavParameter.Navigation_parameter.brother_emqx)
}
inline ::NavParameter::BrotherEmqx* Navigation_parameter::release_brother_emqx() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::NavParameter::BrotherEmqx* temp = _impl_.brother_emqx_;
  _impl_.brother_emqx_ = 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 ::NavParameter::BrotherEmqx* Navigation_parameter::unsafe_arena_release_brother_emqx() {
  // @@protoc_insertion_point(field_release:NavParameter.Navigation_parameter.brother_emqx)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::NavParameter::BrotherEmqx* temp = _impl_.brother_emqx_;
  _impl_.brother_emqx_ = nullptr;
  return temp;
}
inline ::NavParameter::BrotherEmqx* Navigation_parameter::_internal_mutable_brother_emqx() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.brother_emqx_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavParameter::BrotherEmqx>(GetArenaForAllocation());
    _impl_.brother_emqx_ = p;
  }
  return _impl_.brother_emqx_;
}
inline ::NavParameter::BrotherEmqx* Navigation_parameter::mutable_brother_emqx() {
  ::NavParameter::BrotherEmqx* _msg = _internal_mutable_brother_emqx();
  // @@protoc_insertion_point(field_mutable:NavParameter.Navigation_parameter.brother_emqx)
  return _msg;
}
inline void Navigation_parameter::set_allocated_brother_emqx(::NavParameter::BrotherEmqx* brother_emqx) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.brother_emqx_;
  }
  if (brother_emqx) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(brother_emqx);
    if (message_arena != submessage_arena) {
      brother_emqx = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, brother_emqx, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.brother_emqx_ = brother_emqx;
  // @@protoc_insertion_point(field_set_allocated:NavParameter.Navigation_parameter.brother_emqx)
}

// .NavParameter.MPC_parameter x_mpc_parameter = 5;
inline bool Navigation_parameter::has_x_mpc_parameter() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.x_mpc_parameter_ != nullptr);
  return value;
}
inline void Navigation_parameter::clear_x_mpc_parameter() {
  if (_impl_.x_mpc_parameter_ != nullptr) _impl_.x_mpc_parameter_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::NavParameter::MPC_parameter& Navigation_parameter::_internal_x_mpc_parameter() const {
  const ::NavParameter::MPC_parameter* p = _impl_.x_mpc_parameter_;
  return p != nullptr ? *p : reinterpret_cast<const ::NavParameter::MPC_parameter&>(
      ::NavParameter::_MPC_parameter_default_instance_);
}
inline const ::NavParameter::MPC_parameter& Navigation_parameter::x_mpc_parameter() const {
  // @@protoc_insertion_point(field_get:NavParameter.Navigation_parameter.x_mpc_parameter)
  return _internal_x_mpc_parameter();
}
inline void Navigation_parameter::unsafe_arena_set_allocated_x_mpc_parameter(
    ::NavParameter::MPC_parameter* x_mpc_parameter) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.x_mpc_parameter_);
  }
  _impl_.x_mpc_parameter_ = x_mpc_parameter;
  if (x_mpc_parameter) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavParameter.Navigation_parameter.x_mpc_parameter)
}
inline ::NavParameter::MPC_parameter* Navigation_parameter::release_x_mpc_parameter() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::NavParameter::MPC_parameter* temp = _impl_.x_mpc_parameter_;
  _impl_.x_mpc_parameter_ = 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 ::NavParameter::MPC_parameter* Navigation_parameter::unsafe_arena_release_x_mpc_parameter() {
  // @@protoc_insertion_point(field_release:NavParameter.Navigation_parameter.x_mpc_parameter)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::NavParameter::MPC_parameter* temp = _impl_.x_mpc_parameter_;
  _impl_.x_mpc_parameter_ = nullptr;
  return temp;
}
inline ::NavParameter::MPC_parameter* Navigation_parameter::_internal_mutable_x_mpc_parameter() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.x_mpc_parameter_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavParameter::MPC_parameter>(GetArenaForAllocation());
    _impl_.x_mpc_parameter_ = p;
  }
  return _impl_.x_mpc_parameter_;
}
inline ::NavParameter::MPC_parameter* Navigation_parameter::mutable_x_mpc_parameter() {
  ::NavParameter::MPC_parameter* _msg = _internal_mutable_x_mpc_parameter();
  // @@protoc_insertion_point(field_mutable:NavParameter.Navigation_parameter.x_mpc_parameter)
  return _msg;
}
inline void Navigation_parameter::set_allocated_x_mpc_parameter(::NavParameter::MPC_parameter* x_mpc_parameter) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.x_mpc_parameter_;
  }
  if (x_mpc_parameter) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(x_mpc_parameter);
    if (message_arena != submessage_arena) {
      x_mpc_parameter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, x_mpc_parameter, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.x_mpc_parameter_ = x_mpc_parameter;
  // @@protoc_insertion_point(field_set_allocated:NavParameter.Navigation_parameter.x_mpc_parameter)
}

// .NavParameter.MPC_parameter y_mpc_parameter = 6;
inline bool Navigation_parameter::has_y_mpc_parameter() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.y_mpc_parameter_ != nullptr);
  return value;
}
inline void Navigation_parameter::clear_y_mpc_parameter() {
  if (_impl_.y_mpc_parameter_ != nullptr) _impl_.y_mpc_parameter_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::NavParameter::MPC_parameter& Navigation_parameter::_internal_y_mpc_parameter() const {
  const ::NavParameter::MPC_parameter* p = _impl_.y_mpc_parameter_;
  return p != nullptr ? *p : reinterpret_cast<const ::NavParameter::MPC_parameter&>(
      ::NavParameter::_MPC_parameter_default_instance_);
}
inline const ::NavParameter::MPC_parameter& Navigation_parameter::y_mpc_parameter() const {
  // @@protoc_insertion_point(field_get:NavParameter.Navigation_parameter.y_mpc_parameter)
  return _internal_y_mpc_parameter();
}
inline void Navigation_parameter::unsafe_arena_set_allocated_y_mpc_parameter(
    ::NavParameter::MPC_parameter* y_mpc_parameter) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.y_mpc_parameter_);
  }
  _impl_.y_mpc_parameter_ = y_mpc_parameter;
  if (y_mpc_parameter) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavParameter.Navigation_parameter.y_mpc_parameter)
}
inline ::NavParameter::MPC_parameter* Navigation_parameter::release_y_mpc_parameter() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::NavParameter::MPC_parameter* temp = _impl_.y_mpc_parameter_;
  _impl_.y_mpc_parameter_ = 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 ::NavParameter::MPC_parameter* Navigation_parameter::unsafe_arena_release_y_mpc_parameter() {
  // @@protoc_insertion_point(field_release:NavParameter.Navigation_parameter.y_mpc_parameter)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::NavParameter::MPC_parameter* temp = _impl_.y_mpc_parameter_;
  _impl_.y_mpc_parameter_ = nullptr;
  return temp;
}
inline ::NavParameter::MPC_parameter* Navigation_parameter::_internal_mutable_y_mpc_parameter() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.y_mpc_parameter_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavParameter::MPC_parameter>(GetArenaForAllocation());
    _impl_.y_mpc_parameter_ = p;
  }
  return _impl_.y_mpc_parameter_;
}
inline ::NavParameter::MPC_parameter* Navigation_parameter::mutable_y_mpc_parameter() {
  ::NavParameter::MPC_parameter* _msg = _internal_mutable_y_mpc_parameter();
  // @@protoc_insertion_point(field_mutable:NavParameter.Navigation_parameter.y_mpc_parameter)
  return _msg;
}
inline void Navigation_parameter::set_allocated_y_mpc_parameter(::NavParameter::MPC_parameter* y_mpc_parameter) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.y_mpc_parameter_;
  }
  if (y_mpc_parameter) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(y_mpc_parameter);
    if (message_arena != submessage_arena) {
      y_mpc_parameter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, y_mpc_parameter, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.y_mpc_parameter_ = y_mpc_parameter;
  // @@protoc_insertion_point(field_set_allocated:NavParameter.Navigation_parameter.y_mpc_parameter)
}

// .NavParameter.SpeedLimit InOutVLimit = 7;
inline bool Navigation_parameter::has_inoutvlimit() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.inoutvlimit_ != nullptr);
  return value;
}
inline void Navigation_parameter::clear_inoutvlimit() {
  if (_impl_.inoutvlimit_ != nullptr) _impl_.inoutvlimit_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::NavParameter::SpeedLimit& Navigation_parameter::_internal_inoutvlimit() const {
  const ::NavParameter::SpeedLimit* p = _impl_.inoutvlimit_;
  return p != nullptr ? *p : reinterpret_cast<const ::NavParameter::SpeedLimit&>(
      ::NavParameter::_SpeedLimit_default_instance_);
}
inline const ::NavParameter::SpeedLimit& Navigation_parameter::inoutvlimit() const {
  // @@protoc_insertion_point(field_get:NavParameter.Navigation_parameter.InOutVLimit)
  return _internal_inoutvlimit();
}
inline void Navigation_parameter::unsafe_arena_set_allocated_inoutvlimit(
    ::NavParameter::SpeedLimit* inoutvlimit) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.inoutvlimit_);
  }
  _impl_.inoutvlimit_ = inoutvlimit;
  if (inoutvlimit) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavParameter.Navigation_parameter.InOutVLimit)
}
inline ::NavParameter::SpeedLimit* Navigation_parameter::release_inoutvlimit() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::NavParameter::SpeedLimit* temp = _impl_.inoutvlimit_;
  _impl_.inoutvlimit_ = 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 ::NavParameter::SpeedLimit* Navigation_parameter::unsafe_arena_release_inoutvlimit() {
  // @@protoc_insertion_point(field_release:NavParameter.Navigation_parameter.InOutVLimit)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::NavParameter::SpeedLimit* temp = _impl_.inoutvlimit_;
  _impl_.inoutvlimit_ = nullptr;
  return temp;
}
inline ::NavParameter::SpeedLimit* Navigation_parameter::_internal_mutable_inoutvlimit() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.inoutvlimit_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavParameter::SpeedLimit>(GetArenaForAllocation());
    _impl_.inoutvlimit_ = p;
  }
  return _impl_.inoutvlimit_;
}
inline ::NavParameter::SpeedLimit* Navigation_parameter::mutable_inoutvlimit() {
  ::NavParameter::SpeedLimit* _msg = _internal_mutable_inoutvlimit();
  // @@protoc_insertion_point(field_mutable:NavParameter.Navigation_parameter.InOutVLimit)
  return _msg;
}
inline void Navigation_parameter::set_allocated_inoutvlimit(::NavParameter::SpeedLimit* inoutvlimit) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.inoutvlimit_;
  }
  if (inoutvlimit) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(inoutvlimit);
    if (message_arena != submessage_arena) {
      inoutvlimit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, inoutvlimit, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.inoutvlimit_ = inoutvlimit;
  // @@protoc_insertion_point(field_set_allocated:NavParameter.Navigation_parameter.InOutVLimit)
}

// .NavParameter.SpeedLimit NodeVelocityLimit = 8;
inline bool Navigation_parameter::has_nodevelocitylimit() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.nodevelocitylimit_ != nullptr);
  return value;
}
inline void Navigation_parameter::clear_nodevelocitylimit() {
  if (_impl_.nodevelocitylimit_ != nullptr) _impl_.nodevelocitylimit_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::NavParameter::SpeedLimit& Navigation_parameter::_internal_nodevelocitylimit() const {
  const ::NavParameter::SpeedLimit* p = _impl_.nodevelocitylimit_;
  return p != nullptr ? *p : reinterpret_cast<const ::NavParameter::SpeedLimit&>(
      ::NavParameter::_SpeedLimit_default_instance_);
}
inline const ::NavParameter::SpeedLimit& Navigation_parameter::nodevelocitylimit() const {
  // @@protoc_insertion_point(field_get:NavParameter.Navigation_parameter.NodeVelocityLimit)
  return _internal_nodevelocitylimit();
}
inline void Navigation_parameter::unsafe_arena_set_allocated_nodevelocitylimit(
    ::NavParameter::SpeedLimit* nodevelocitylimit) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.nodevelocitylimit_);
  }
  _impl_.nodevelocitylimit_ = nodevelocitylimit;
  if (nodevelocitylimit) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavParameter.Navigation_parameter.NodeVelocityLimit)
}
inline ::NavParameter::SpeedLimit* Navigation_parameter::release_nodevelocitylimit() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::NavParameter::SpeedLimit* temp = _impl_.nodevelocitylimit_;
  _impl_.nodevelocitylimit_ = 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 ::NavParameter::SpeedLimit* Navigation_parameter::unsafe_arena_release_nodevelocitylimit() {
  // @@protoc_insertion_point(field_release:NavParameter.Navigation_parameter.NodeVelocityLimit)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::NavParameter::SpeedLimit* temp = _impl_.nodevelocitylimit_;
  _impl_.nodevelocitylimit_ = nullptr;
  return temp;
}
inline ::NavParameter::SpeedLimit* Navigation_parameter::_internal_mutable_nodevelocitylimit() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.nodevelocitylimit_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavParameter::SpeedLimit>(GetArenaForAllocation());
    _impl_.nodevelocitylimit_ = p;
  }
  return _impl_.nodevelocitylimit_;
}
inline ::NavParameter::SpeedLimit* Navigation_parameter::mutable_nodevelocitylimit() {
  ::NavParameter::SpeedLimit* _msg = _internal_mutable_nodevelocitylimit();
  // @@protoc_insertion_point(field_mutable:NavParameter.Navigation_parameter.NodeVelocityLimit)
  return _msg;
}
inline void Navigation_parameter::set_allocated_nodevelocitylimit(::NavParameter::SpeedLimit* nodevelocitylimit) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.nodevelocitylimit_;
  }
  if (nodevelocitylimit) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(nodevelocitylimit);
    if (message_arena != submessage_arena) {
      nodevelocitylimit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, nodevelocitylimit, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.nodevelocitylimit_ = nodevelocitylimit;
  // @@protoc_insertion_point(field_set_allocated:NavParameter.Navigation_parameter.NodeVelocityLimit)
}

// .NavParameter.SpeedLimit NodeAngularLimit = 9;
inline bool Navigation_parameter::has_nodeangularlimit() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.nodeangularlimit_ != nullptr);
  return value;
}
inline void Navigation_parameter::clear_nodeangularlimit() {
  if (_impl_.nodeangularlimit_ != nullptr) _impl_.nodeangularlimit_->Clear();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const ::NavParameter::SpeedLimit& Navigation_parameter::_internal_nodeangularlimit() const {
  const ::NavParameter::SpeedLimit* p = _impl_.nodeangularlimit_;
  return p != nullptr ? *p : reinterpret_cast<const ::NavParameter::SpeedLimit&>(
      ::NavParameter::_SpeedLimit_default_instance_);
}
inline const ::NavParameter::SpeedLimit& Navigation_parameter::nodeangularlimit() const {
  // @@protoc_insertion_point(field_get:NavParameter.Navigation_parameter.NodeAngularLimit)
  return _internal_nodeangularlimit();
}
inline void Navigation_parameter::unsafe_arena_set_allocated_nodeangularlimit(
    ::NavParameter::SpeedLimit* nodeangularlimit) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.nodeangularlimit_);
  }
  _impl_.nodeangularlimit_ = nodeangularlimit;
  if (nodeangularlimit) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavParameter.Navigation_parameter.NodeAngularLimit)
}
inline ::NavParameter::SpeedLimit* Navigation_parameter::release_nodeangularlimit() {
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::NavParameter::SpeedLimit* temp = _impl_.nodeangularlimit_;
  _impl_.nodeangularlimit_ = 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 ::NavParameter::SpeedLimit* Navigation_parameter::unsafe_arena_release_nodeangularlimit() {
  // @@protoc_insertion_point(field_release:NavParameter.Navigation_parameter.NodeAngularLimit)
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::NavParameter::SpeedLimit* temp = _impl_.nodeangularlimit_;
  _impl_.nodeangularlimit_ = nullptr;
  return temp;
}
inline ::NavParameter::SpeedLimit* Navigation_parameter::_internal_mutable_nodeangularlimit() {
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.nodeangularlimit_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavParameter::SpeedLimit>(GetArenaForAllocation());
    _impl_.nodeangularlimit_ = p;
  }
  return _impl_.nodeangularlimit_;
}
inline ::NavParameter::SpeedLimit* Navigation_parameter::mutable_nodeangularlimit() {
  ::NavParameter::SpeedLimit* _msg = _internal_mutable_nodeangularlimit();
  // @@protoc_insertion_point(field_mutable:NavParameter.Navigation_parameter.NodeAngularLimit)
  return _msg;
}
inline void Navigation_parameter::set_allocated_nodeangularlimit(::NavParameter::SpeedLimit* nodeangularlimit) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.nodeangularlimit_;
  }
  if (nodeangularlimit) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(nodeangularlimit);
    if (message_arena != submessage_arena) {
      nodeangularlimit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, nodeangularlimit, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.nodeangularlimit_ = nodeangularlimit;
  // @@protoc_insertion_point(field_set_allocated:NavParameter.Navigation_parameter.NodeAngularLimit)
}

// string rpc_ipport = 10;
inline void Navigation_parameter::clear_rpc_ipport() {
  _impl_.rpc_ipport_.ClearToEmpty();
}
inline const std::string& Navigation_parameter::rpc_ipport() const {
  // @@protoc_insertion_point(field_get:NavParameter.Navigation_parameter.rpc_ipport)
  return _internal_rpc_ipport();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Navigation_parameter::set_rpc_ipport(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.rpc_ipport_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NavParameter.Navigation_parameter.rpc_ipport)
}
inline std::string* Navigation_parameter::mutable_rpc_ipport() {
  std::string* _s = _internal_mutable_rpc_ipport();
  // @@protoc_insertion_point(field_mutable:NavParameter.Navigation_parameter.rpc_ipport)
  return _s;
}
inline const std::string& Navigation_parameter::_internal_rpc_ipport() const {
  return _impl_.rpc_ipport_.Get();
}
inline void Navigation_parameter::_internal_set_rpc_ipport(const std::string& value) {
  ;


  _impl_.rpc_ipport_.Set(value, GetArenaForAllocation());
}
inline std::string* Navigation_parameter::_internal_mutable_rpc_ipport() {
  ;
  return _impl_.rpc_ipport_.Mutable( GetArenaForAllocation());
}
inline std::string* Navigation_parameter::release_rpc_ipport() {
  // @@protoc_insertion_point(field_release:NavParameter.Navigation_parameter.rpc_ipport)
  return _impl_.rpc_ipport_.Release();
}
inline void Navigation_parameter::set_allocated_rpc_ipport(std::string* value) {
  _impl_.rpc_ipport_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.rpc_ipport_.IsDefault()) {
          _impl_.rpc_ipport_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:NavParameter.Navigation_parameter.rpc_ipport)
}

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

// @@protoc_insertion_point(namespace_scope)
}  // namespace NavParameter


// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"

#endif  // GOOGLE_PROTOBUF_INCLUDED_parameter_2eproto_2epb_2eh
