AGV/MPC/monitor/emqx/message.pb.h

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_message_2eproto_2epb_2eh
#define GOOGLE_PROTOBUF_INCLUDED_message_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_message_2eproto

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

// Internal implementation detail -- do not use these members.
struct TableStruct_message_2eproto {
  static const ::uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable
    descriptor_table_message_2eproto;
namespace NavMessage {
class AgvStatu;
struct AgvStatuDefaultTypeInternal;
extern AgvStatuDefaultTypeInternal _AgvStatu_default_instance_;
class LidarOdomStatu;
struct LidarOdomStatuDefaultTypeInternal;
extern LidarOdomStatuDefaultTypeInternal _LidarOdomStatu_default_instance_;
class ManualCmd;
struct ManualCmdDefaultTypeInternal;
extern ManualCmdDefaultTypeInternal _ManualCmd_default_instance_;
class NavCmd;
struct NavCmdDefaultTypeInternal;
extern NavCmdDefaultTypeInternal _NavCmd_default_instance_;
class NavResponse;
struct NavResponseDefaultTypeInternal;
extern NavResponseDefaultTypeInternal _NavResponse_default_instance_;
class NavStatu;
struct NavStatuDefaultTypeInternal;
extern NavStatuDefaultTypeInternal _NavStatu_default_instance_;
class NewAction;
struct NewActionDefaultTypeInternal;
extern NewActionDefaultTypeInternal _NewAction_default_instance_;
class PathNode;
struct PathNodeDefaultTypeInternal;
extern PathNodeDefaultTypeInternal _PathNode_default_instance_;
class Pose2d;
struct Pose2dDefaultTypeInternal;
extern Pose2dDefaultTypeInternal _Pose2d_default_instance_;
class RobotStatu;
struct RobotStatuDefaultTypeInternal;
extern RobotStatuDefaultTypeInternal _RobotStatu_default_instance_;
class ToAgvCmd;
struct ToAgvCmdDefaultTypeInternal;
extern ToAgvCmdDefaultTypeInternal _ToAgvCmd_default_instance_;
class Trajectory;
struct TrajectoryDefaultTypeInternal;
extern TrajectoryDefaultTypeInternal _Trajectory_default_instance_;
}  // namespace NavMessage
PROTOBUF_NAMESPACE_OPEN
template <>
::NavMessage::AgvStatu* Arena::CreateMaybeMessage<::NavMessage::AgvStatu>(Arena*);
template <>
::NavMessage::LidarOdomStatu* Arena::CreateMaybeMessage<::NavMessage::LidarOdomStatu>(Arena*);
template <>
::NavMessage::ManualCmd* Arena::CreateMaybeMessage<::NavMessage::ManualCmd>(Arena*);
template <>
::NavMessage::NavCmd* Arena::CreateMaybeMessage<::NavMessage::NavCmd>(Arena*);
template <>
::NavMessage::NavResponse* Arena::CreateMaybeMessage<::NavMessage::NavResponse>(Arena*);
template <>
::NavMessage::NavStatu* Arena::CreateMaybeMessage<::NavMessage::NavStatu>(Arena*);
template <>
::NavMessage::NewAction* Arena::CreateMaybeMessage<::NavMessage::NewAction>(Arena*);
template <>
::NavMessage::PathNode* Arena::CreateMaybeMessage<::NavMessage::PathNode>(Arena*);
template <>
::NavMessage::Pose2d* Arena::CreateMaybeMessage<::NavMessage::Pose2d>(Arena*);
template <>
::NavMessage::RobotStatu* Arena::CreateMaybeMessage<::NavMessage::RobotStatu>(Arena*);
template <>
::NavMessage::ToAgvCmd* Arena::CreateMaybeMessage<::NavMessage::ToAgvCmd>(Arena*);
template <>
::NavMessage::Trajectory* Arena::CreateMaybeMessage<::NavMessage::Trajectory>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

namespace NavMessage {

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


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

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "NavMessage.LidarOdomStatu";
  }
  protected:
  explicit LidarOdomStatu(::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 {
    kXFieldNumber = 1,
    kYFieldNumber = 2,
    kThetaFieldNumber = 3,
    kVFieldNumber = 4,
    kVthFieldNumber = 5,
  };
  // float x = 1;
  void clear_x() ;
  float x() const;
  void set_x(float value);

  private:
  float _internal_x() const;
  void _internal_set_x(float value);

  public:
  // float y = 2;
  void clear_y() ;
  float y() const;
  void set_y(float value);

  private:
  float _internal_y() const;
  void _internal_set_y(float value);

  public:
  // float theta = 3;
  void clear_theta() ;
  float theta() const;
  void set_theta(float value);

  private:
  float _internal_theta() const;
  void _internal_set_theta(float value);

  public:
  // float v = 4;
  void clear_v() ;
  float v() const;
  void set_v(float value);

  private:
  float _internal_v() const;
  void _internal_set_v(float value);

  public:
  // float vth = 5;
  void clear_vth() ;
  float vth() const;
  void set_vth(float value);

  private:
  float _internal_vth() const;
  void _internal_set_vth(float value);

  public:
  // @@protoc_insertion_point(class_scope:NavMessage.LidarOdomStatu)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    float x_;
    float y_;
    float theta_;
    float v_;
    float vth_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_message_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "NavMessage.AgvStatu";
  }
  protected:
  explicit AgvStatu(::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 {
    kZcbFieldNumber = 7,
    kVFieldNumber = 1,
    kWFieldNumber = 2,
    kClampFieldNumber = 3,
    kClampOtherFieldNumber = 4,
    kLifterFieldNumber = 5,
    kLifterOtherFieldNumber = 6,
    kDoorFieldNumber = 8,
  };
  // repeated int32 zcb = 7;
  int zcb_size() const;
  private:
  int _internal_zcb_size() const;

  public:
  void clear_zcb() ;
  ::int32_t zcb(int index) const;
  void set_zcb(int index, ::int32_t value);
  void add_zcb(::int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& zcb() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* mutable_zcb();

  private:
  ::int32_t _internal_zcb(int index) const;
  void _internal_add_zcb(::int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& _internal_zcb() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* _internal_mutable_zcb();

  public:
  // float v = 1;
  void clear_v() ;
  float v() const;
  void set_v(float value);

  private:
  float _internal_v() const;
  void _internal_set_v(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:
  // int32 clamp = 3;
  void clear_clamp() ;
  ::int32_t clamp() const;
  void set_clamp(::int32_t value);

  private:
  ::int32_t _internal_clamp() const;
  void _internal_set_clamp(::int32_t value);

  public:
  // int32 clamp_other = 4;
  void clear_clamp_other() ;
  ::int32_t clamp_other() const;
  void set_clamp_other(::int32_t value);

  private:
  ::int32_t _internal_clamp_other() const;
  void _internal_set_clamp_other(::int32_t value);

  public:
  // int32 lifter = 5;
  void clear_lifter() ;
  ::int32_t lifter() const;
  void set_lifter(::int32_t value);

  private:
  ::int32_t _internal_lifter() const;
  void _internal_set_lifter(::int32_t value);

  public:
  // int32 lifter_other = 6;
  void clear_lifter_other() ;
  ::int32_t lifter_other() const;
  void set_lifter_other(::int32_t value);

  private:
  ::int32_t _internal_lifter_other() const;
  void _internal_set_lifter_other(::int32_t value);

  public:
  // int32 door = 8;
  void clear_door() ;
  ::int32_t door() const;
  void set_door(::int32_t value);

  private:
  ::int32_t _internal_door() const;
  void _internal_set_door(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:NavMessage.AgvStatu)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t> zcb_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _zcb_cached_byte_size_;
    float v_;
    float w_;
    ::int32_t clamp_;
    ::int32_t clamp_other_;
    ::int32_t lifter_;
    ::int32_t lifter_other_;
    ::int32_t door_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_message_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "NavMessage.ToAgvCmd";
  }
  protected:
  explicit ToAgvCmd(::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 {
    kH1FieldNumber = 1,
    kM1FieldNumber = 2,
    kT1FieldNumber = 3,
    kV1FieldNumber = 4,
    kW1FieldNumber = 5,
    kV2FieldNumber = 6,
    kW2FieldNumber = 7,
    kV3FieldNumber = 8,
    kW3FieldNumber = 9,
    kL1FieldNumber = 10,
    kP1FieldNumber = 11,
    kD1FieldNumber = 12,
    kY1FieldNumber = 13,
    kY2FieldNumber = 14,
    kCLFieldNumber = 15,
    kEndFieldNumber = 16,
  };
  // int32 H1 = 1;
  void clear_h1() ;
  ::int32_t h1() const;
  void set_h1(::int32_t value);

  private:
  ::int32_t _internal_h1() const;
  void _internal_set_h1(::int32_t value);

  public:
  // int32 M1 = 2;
  void clear_m1() ;
  ::int32_t m1() const;
  void set_m1(::int32_t value);

  private:
  ::int32_t _internal_m1() const;
  void _internal_set_m1(::int32_t value);

  public:
  // int32 T1 = 3;
  void clear_t1() ;
  ::int32_t t1() const;
  void set_t1(::int32_t value);

  private:
  ::int32_t _internal_t1() const;
  void _internal_set_t1(::int32_t value);

  public:
  // float V1 = 4;
  void clear_v1() ;
  float v1() const;
  void set_v1(float value);

  private:
  float _internal_v1() const;
  void _internal_set_v1(float value);

  public:
  // float W1 = 5;
  void clear_w1() ;
  float w1() const;
  void set_w1(float value);

  private:
  float _internal_w1() const;
  void _internal_set_w1(float value);

  public:
  // float V2 = 6;
  void clear_v2() ;
  float v2() const;
  void set_v2(float value);

  private:
  float _internal_v2() const;
  void _internal_set_v2(float value);

  public:
  // float W2 = 7;
  void clear_w2() ;
  float w2() const;
  void set_w2(float value);

  private:
  float _internal_w2() const;
  void _internal_set_w2(float value);

  public:
  // float V3 = 8;
  void clear_v3() ;
  float v3() const;
  void set_v3(float value);

  private:
  float _internal_v3() const;
  void _internal_set_v3(float value);

  public:
  // float W3 = 9;
  void clear_w3() ;
  float w3() const;
  void set_w3(float value);

  private:
  float _internal_w3() const;
  void _internal_set_w3(float value);

  public:
  // float L1 = 10;
  void clear_l1() ;
  float l1() const;
  void set_l1(float value);

  private:
  float _internal_l1() const;
  void _internal_set_l1(float value);

  public:
  // int32 P1 = 11;
  void clear_p1() ;
  ::int32_t p1() const;
  void set_p1(::int32_t value);

  private:
  ::int32_t _internal_p1() const;
  void _internal_set_p1(::int32_t value);

  public:
  // float D1 = 12;
  void clear_d1() ;
  float d1() const;
  void set_d1(float value);

  private:
  float _internal_d1() const;
  void _internal_set_d1(float value);

  public:
  // float Y1 = 13;
  void clear_y1() ;
  float y1() const;
  void set_y1(float value);

  private:
  float _internal_y1() const;
  void _internal_set_y1(float value);

  public:
  // float Y2 = 14;
  void clear_y2() ;
  float y2() const;
  void set_y2(float value);

  private:
  float _internal_y2() const;
  void _internal_set_y2(float value);

  public:
  // int32 CL = 15;
  void clear_cl() ;
  ::int32_t cl() const;
  void set_cl(::int32_t value);

  private:
  ::int32_t _internal_cl() const;
  void _internal_set_cl(::int32_t value);

  public:
  // int32 end = 16;
  void clear_end() ;
  ::int32_t end() const;
  void set_end(::int32_t value);

  private:
  ::int32_t _internal_end() const;
  void _internal_set_end(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:NavMessage.ToAgvCmd)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::int32_t h1_;
    ::int32_t m1_;
    ::int32_t t1_;
    float v1_;
    float w1_;
    float v2_;
    float w2_;
    float v3_;
    float w3_;
    float l1_;
    ::int32_t p1_;
    float d1_;
    float y1_;
    float y2_;
    ::int32_t cl_;
    ::int32_t end_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_message_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "NavMessage.Pose2d";
  }
  protected:
  explicit Pose2d(::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 {
    kXFieldNumber = 1,
    kYFieldNumber = 2,
    kThetaFieldNumber = 3,
  };
  // float x = 1;
  void clear_x() ;
  float x() const;
  void set_x(float value);

  private:
  float _internal_x() const;
  void _internal_set_x(float value);

  public:
  // float y = 2;
  void clear_y() ;
  float y() const;
  void set_y(float value);

  private:
  float _internal_y() const;
  void _internal_set_y(float value);

  public:
  // float theta = 3;
  void clear_theta() ;
  float theta() const;
  void set_theta(float value);

  private:
  float _internal_theta() const;
  void _internal_set_theta(float value);

  public:
  // @@protoc_insertion_point(class_scope:NavMessage.Pose2d)
 private:
  class _Internal;

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

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "NavMessage.PathNode";
  }
  protected:
  explicit PathNode(::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 {
    kIdFieldNumber = 6,
    kXFieldNumber = 1,
    kYFieldNumber = 2,
    kLFieldNumber = 3,
    kWFieldNumber = 4,
    kThetaFieldNumber = 5,
  };
  // optional string id = 6;
  bool has_id() const;
  void clear_id() ;
  const std::string& id() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_id(Arg_&& arg, Args_... args);
  std::string* mutable_id();
  PROTOBUF_NODISCARD std::string* release_id();
  void set_allocated_id(std::string* ptr);

  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(
      const std::string& value);
  std::string* _internal_mutable_id();

  public:
  // float x = 1;
  void clear_x() ;
  float x() const;
  void set_x(float value);

  private:
  float _internal_x() const;
  void _internal_set_x(float value);

  public:
  // float y = 2;
  void clear_y() ;
  float y() const;
  void set_y(float value);

  private:
  float _internal_y() const;
  void _internal_set_y(float value);

  public:
  // float l = 3;
  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 = 4;
  void clear_w() ;
  float w() const;
  void set_w(float value);

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

  public:
  // float theta = 5;
  void clear_theta() ;
  float theta() const;
  void set_theta(float value);

  private:
  float _internal_theta() const;
  void _internal_set_theta(float value);

  public:
  // @@protoc_insertion_point(class_scope:NavMessage.PathNode)
 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 id_;
    float x_;
    float y_;
    float l_;
    float w_;
    float theta_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_message_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "NavMessage.Trajectory";
  }
  protected:
  explicit Trajectory(::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 {
    kPosesFieldNumber = 1,
  };
  // repeated .NavMessage.Pose2d poses = 1;
  int poses_size() const;
  private:
  int _internal_poses_size() const;

  public:
  void clear_poses() ;
  ::NavMessage::Pose2d* mutable_poses(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::Pose2d >*
      mutable_poses();
  private:
  const ::NavMessage::Pose2d& _internal_poses(int index) const;
  ::NavMessage::Pose2d* _internal_add_poses();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::NavMessage::Pose2d>& _internal_poses() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::NavMessage::Pose2d>* _internal_mutable_poses();
  public:
  const ::NavMessage::Pose2d& poses(int index) const;
  ::NavMessage::Pose2d* add_poses();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::Pose2d >&
      poses() const;
  // @@protoc_insertion_point(class_scope:NavMessage.Trajectory)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::Pose2d > poses_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_message_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "NavMessage.NewAction";
  }
  protected:
  explicit NewAction(::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 {
    kPathNodesFieldNumber = 5,
    kSpaceNodeFieldNumber = 2,
    kPassNodeFieldNumber = 3,
    kStreetNodeFieldNumber = 4,
    kTypeFieldNumber = 1,
    kWheelbaseFieldNumber = 6,
    kChangedModeFieldNumber = 7,
  };
  // repeated .NavMessage.PathNode pathNodes = 5;
  int pathnodes_size() const;
  private:
  int _internal_pathnodes_size() const;

  public:
  void clear_pathnodes() ;
  ::NavMessage::PathNode* mutable_pathnodes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::PathNode >*
      mutable_pathnodes();
  private:
  const ::NavMessage::PathNode& _internal_pathnodes(int index) const;
  ::NavMessage::PathNode* _internal_add_pathnodes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::NavMessage::PathNode>& _internal_pathnodes() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::NavMessage::PathNode>* _internal_mutable_pathnodes();
  public:
  const ::NavMessage::PathNode& pathnodes(int index) const;
  ::NavMessage::PathNode* add_pathnodes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::PathNode >&
      pathnodes() const;
  // .NavMessage.PathNode spaceNode = 2;
  bool has_spacenode() const;
  void clear_spacenode() ;
  const ::NavMessage::PathNode& spacenode() const;
  PROTOBUF_NODISCARD ::NavMessage::PathNode* release_spacenode();
  ::NavMessage::PathNode* mutable_spacenode();
  void set_allocated_spacenode(::NavMessage::PathNode* spacenode);
  private:
  const ::NavMessage::PathNode& _internal_spacenode() const;
  ::NavMessage::PathNode* _internal_mutable_spacenode();
  public:
  void unsafe_arena_set_allocated_spacenode(
      ::NavMessage::PathNode* spacenode);
  ::NavMessage::PathNode* unsafe_arena_release_spacenode();
  // .NavMessage.PathNode passNode = 3;
  bool has_passnode() const;
  void clear_passnode() ;
  const ::NavMessage::PathNode& passnode() const;
  PROTOBUF_NODISCARD ::NavMessage::PathNode* release_passnode();
  ::NavMessage::PathNode* mutable_passnode();
  void set_allocated_passnode(::NavMessage::PathNode* passnode);
  private:
  const ::NavMessage::PathNode& _internal_passnode() const;
  ::NavMessage::PathNode* _internal_mutable_passnode();
  public:
  void unsafe_arena_set_allocated_passnode(
      ::NavMessage::PathNode* passnode);
  ::NavMessage::PathNode* unsafe_arena_release_passnode();
  // .NavMessage.PathNode streetNode = 4;
  bool has_streetnode() const;
  void clear_streetnode() ;
  const ::NavMessage::PathNode& streetnode() const;
  PROTOBUF_NODISCARD ::NavMessage::PathNode* release_streetnode();
  ::NavMessage::PathNode* mutable_streetnode();
  void set_allocated_streetnode(::NavMessage::PathNode* streetnode);
  private:
  const ::NavMessage::PathNode& _internal_streetnode() const;
  ::NavMessage::PathNode* _internal_mutable_streetnode();
  public:
  void unsafe_arena_set_allocated_streetnode(
      ::NavMessage::PathNode* streetnode);
  ::NavMessage::PathNode* unsafe_arena_release_streetnode();
  // int32 type = 1;
  void clear_type() ;
  ::int32_t type() const;
  void set_type(::int32_t value);

  private:
  ::int32_t _internal_type() const;
  void _internal_set_type(::int32_t value);

  public:
  // float wheelbase = 6;
  void clear_wheelbase() ;
  float wheelbase() const;
  void set_wheelbase(float value);

  private:
  float _internal_wheelbase() const;
  void _internal_set_wheelbase(float value);

  public:
  // int32 changedMode = 7;
  void clear_changedmode() ;
  ::int32_t changedmode() const;
  void set_changedmode(::int32_t value);

  private:
  ::int32_t _internal_changedmode() const;
  void _internal_set_changedmode(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:NavMessage.NewAction)
 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::RepeatedPtrField< ::NavMessage::PathNode > pathnodes_;
    ::NavMessage::PathNode* spacenode_;
    ::NavMessage::PathNode* passnode_;
    ::NavMessage::PathNode* streetnode_;
    ::int32_t type_;
    float wheelbase_;
    ::int32_t changedmode_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_message_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "NavMessage.NavCmd";
  }
  protected:
  explicit NavCmd(::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 {
    kNewActionsFieldNumber = 5,
    kKeyFieldNumber = 2,
    kActionFieldNumber = 1,
    kSequenceFieldNumber = 6,
  };
  // repeated .NavMessage.NewAction newActions = 5;
  int newactions_size() const;
  private:
  int _internal_newactions_size() const;

  public:
  void clear_newactions() ;
  ::NavMessage::NewAction* mutable_newactions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::NewAction >*
      mutable_newactions();
  private:
  const ::NavMessage::NewAction& _internal_newactions(int index) const;
  ::NavMessage::NewAction* _internal_add_newactions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::NavMessage::NewAction>& _internal_newactions() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::NavMessage::NewAction>* _internal_mutable_newactions();
  public:
  const ::NavMessage::NewAction& newactions(int index) const;
  ::NavMessage::NewAction* add_newactions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::NewAction >&
      newactions() const;
  // string key = 2;
  void clear_key() ;
  const std::string& key() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_key(Arg_&& arg, Args_... args);
  std::string* mutable_key();
  PROTOBUF_NODISCARD std::string* release_key();
  void set_allocated_key(std::string* ptr);

  private:
  const std::string& _internal_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(
      const std::string& value);
  std::string* _internal_mutable_key();

  public:
  // int32 action = 1;
  void clear_action() ;
  ::int32_t action() const;
  void set_action(::int32_t value);

  private:
  ::int32_t _internal_action() const;
  void _internal_set_action(::int32_t value);

  public:
  // optional int32 sequence = 6;
  bool has_sequence() const;
  void clear_sequence() ;
  ::int32_t sequence() const;
  void set_sequence(::int32_t value);

  private:
  ::int32_t _internal_sequence() const;
  void _internal_set_sequence(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:NavMessage.NavCmd)
 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::RepeatedPtrField< ::NavMessage::NewAction > newactions_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
    ::int32_t action_;
    ::int32_t sequence_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_message_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "NavMessage.NavResponse";
  }
  protected:
  explicit NavResponse(::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 {
    kInfoFieldNumber = 2,
    kRetFieldNumber = 1,
  };
  // string info = 2;
  void clear_info() ;
  const std::string& info() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_info(Arg_&& arg, Args_... args);
  std::string* mutable_info();
  PROTOBUF_NODISCARD std::string* release_info();
  void set_allocated_info(std::string* ptr);

  private:
  const std::string& _internal_info() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_info(
      const std::string& value);
  std::string* _internal_mutable_info();

  public:
  // int32 ret = 1;
  void clear_ret() ;
  ::int32_t ret() const;
  void set_ret(::int32_t value);

  private:
  ::int32_t _internal_ret() const;
  void _internal_set_ret(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:NavMessage.NavResponse)
 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 info_;
    ::int32_t ret_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_message_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "NavMessage.ManualCmd";
  }
  protected:
  explicit ManualCmd(::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 {
    kKeyFieldNumber = 1,
    kOperationTypeFieldNumber = 2,
    kVelocityFieldNumber = 3,
  };
  // string key = 1;
  void clear_key() ;
  const std::string& key() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_key(Arg_&& arg, Args_... args);
  std::string* mutable_key();
  PROTOBUF_NODISCARD std::string* release_key();
  void set_allocated_key(std::string* ptr);

  private:
  const std::string& _internal_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(
      const std::string& value);
  std::string* _internal_mutable_key();

  public:
  // int32 operation_type = 2;
  void clear_operation_type() ;
  ::int32_t operation_type() const;
  void set_operation_type(::int32_t value);

  private:
  ::int32_t _internal_operation_type() const;
  void _internal_set_operation_type(::int32_t value);

  public:
  // float velocity = 3;
  void clear_velocity() ;
  float velocity() const;
  void set_velocity(float value);

  private:
  float _internal_velocity() const;
  void _internal_set_velocity(float value);

  public:
  // @@protoc_insertion_point(class_scope:NavMessage.ManualCmd)
 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 key_;
    ::int32_t operation_type_;
    float velocity_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_message_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "NavMessage.NavStatu";
  }
  protected:
  explicit NavStatu(::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 {
    kKeyFieldNumber = 5,
    kSpaceIdFieldNumber = 9,
    kOdomFieldNumber = 4,
    kSelectedTrajFieldNumber = 6,
    kPredictTrajFieldNumber = 7,
    kStatuFieldNumber = 1,
    kMoveModeFieldNumber = 3,
    kMainAgvFieldNumber = 2,
    kInSpaceFieldNumber = 8,
  };
  // string key = 5;
  void clear_key() ;
  const std::string& key() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_key(Arg_&& arg, Args_... args);
  std::string* mutable_key();
  PROTOBUF_NODISCARD std::string* release_key();
  void set_allocated_key(std::string* ptr);

  private:
  const std::string& _internal_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(
      const std::string& value);
  std::string* _internal_mutable_key();

  public:
  // string space_id = 9;
  void clear_space_id() ;
  const std::string& space_id() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_space_id(Arg_&& arg, Args_... args);
  std::string* mutable_space_id();
  PROTOBUF_NODISCARD std::string* release_space_id();
  void set_allocated_space_id(std::string* ptr);

  private:
  const std::string& _internal_space_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_space_id(
      const std::string& value);
  std::string* _internal_mutable_space_id();

  public:
  // .NavMessage.LidarOdomStatu odom = 4;
  bool has_odom() const;
  void clear_odom() ;
  const ::NavMessage::LidarOdomStatu& odom() const;
  PROTOBUF_NODISCARD ::NavMessage::LidarOdomStatu* release_odom();
  ::NavMessage::LidarOdomStatu* mutable_odom();
  void set_allocated_odom(::NavMessage::LidarOdomStatu* odom);
  private:
  const ::NavMessage::LidarOdomStatu& _internal_odom() const;
  ::NavMessage::LidarOdomStatu* _internal_mutable_odom();
  public:
  void unsafe_arena_set_allocated_odom(
      ::NavMessage::LidarOdomStatu* odom);
  ::NavMessage::LidarOdomStatu* unsafe_arena_release_odom();
  // .NavMessage.Trajectory selected_traj = 6;
  bool has_selected_traj() const;
  void clear_selected_traj() ;
  const ::NavMessage::Trajectory& selected_traj() const;
  PROTOBUF_NODISCARD ::NavMessage::Trajectory* release_selected_traj();
  ::NavMessage::Trajectory* mutable_selected_traj();
  void set_allocated_selected_traj(::NavMessage::Trajectory* selected_traj);
  private:
  const ::NavMessage::Trajectory& _internal_selected_traj() const;
  ::NavMessage::Trajectory* _internal_mutable_selected_traj();
  public:
  void unsafe_arena_set_allocated_selected_traj(
      ::NavMessage::Trajectory* selected_traj);
  ::NavMessage::Trajectory* unsafe_arena_release_selected_traj();
  // .NavMessage.Trajectory predict_traj = 7;
  bool has_predict_traj() const;
  void clear_predict_traj() ;
  const ::NavMessage::Trajectory& predict_traj() const;
  PROTOBUF_NODISCARD ::NavMessage::Trajectory* release_predict_traj();
  ::NavMessage::Trajectory* mutable_predict_traj();
  void set_allocated_predict_traj(::NavMessage::Trajectory* predict_traj);
  private:
  const ::NavMessage::Trajectory& _internal_predict_traj() const;
  ::NavMessage::Trajectory* _internal_mutable_predict_traj();
  public:
  void unsafe_arena_set_allocated_predict_traj(
      ::NavMessage::Trajectory* predict_traj);
  ::NavMessage::Trajectory* unsafe_arena_release_predict_traj();
  // int32 statu = 1;
  void clear_statu() ;
  ::int32_t statu() const;
  void set_statu(::int32_t value);

  private:
  ::int32_t _internal_statu() const;
  void _internal_set_statu(::int32_t value);

  public:
  // int32 move_mode = 3;
  void clear_move_mode() ;
  ::int32_t move_mode() const;
  void set_move_mode(::int32_t value);

  private:
  ::int32_t _internal_move_mode() const;
  void _internal_set_move_mode(::int32_t value);

  public:
  // bool main_agv = 2;
  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:
  // bool in_space = 8;
  void clear_in_space() ;
  bool in_space() const;
  void set_in_space(bool value);

  private:
  bool _internal_in_space() const;
  void _internal_set_in_space(bool value);

  public:
  // @@protoc_insertion_point(class_scope:NavMessage.NavStatu)
 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 key_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr space_id_;
    ::NavMessage::LidarOdomStatu* odom_;
    ::NavMessage::Trajectory* selected_traj_;
    ::NavMessage::Trajectory* predict_traj_;
    ::int32_t statu_;
    ::int32_t move_mode_;
    bool main_agv_;
    bool in_space_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_message_2eproto;
};// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "NavMessage.RobotStatu";
  }
  protected:
  explicit RobotStatu(::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 {
    kAgvStatuFieldNumber = 4,
    kXFieldNumber = 1,
    kYFieldNumber = 2,
    kThetaFieldNumber = 3,
  };
  // .NavMessage.AgvStatu agvStatu = 4;
  bool has_agvstatu() const;
  void clear_agvstatu() ;
  const ::NavMessage::AgvStatu& agvstatu() const;
  PROTOBUF_NODISCARD ::NavMessage::AgvStatu* release_agvstatu();
  ::NavMessage::AgvStatu* mutable_agvstatu();
  void set_allocated_agvstatu(::NavMessage::AgvStatu* agvstatu);
  private:
  const ::NavMessage::AgvStatu& _internal_agvstatu() const;
  ::NavMessage::AgvStatu* _internal_mutable_agvstatu();
  public:
  void unsafe_arena_set_allocated_agvstatu(
      ::NavMessage::AgvStatu* agvstatu);
  ::NavMessage::AgvStatu* unsafe_arena_release_agvstatu();
  // float x = 1;
  void clear_x() ;
  float x() const;
  void set_x(float value);

  private:
  float _internal_x() const;
  void _internal_set_x(float value);

  public:
  // float y = 2;
  void clear_y() ;
  float y() const;
  void set_y(float value);

  private:
  float _internal_y() const;
  void _internal_set_y(float value);

  public:
  // float theta = 3;
  void clear_theta() ;
  float theta() const;
  void set_theta(float value);

  private:
  float _internal_theta() const;
  void _internal_set_theta(float value);

  public:
  // @@protoc_insertion_point(class_scope:NavMessage.RobotStatu)
 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_;
    ::NavMessage::AgvStatu* agvstatu_;
    float x_;
    float y_;
    float theta_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_message_2eproto;
};

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




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


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

// LidarOdomStatu

// float x = 1;
inline void LidarOdomStatu::clear_x() {
  _impl_.x_ = 0;
}
inline float LidarOdomStatu::x() const {
  // @@protoc_insertion_point(field_get:NavMessage.LidarOdomStatu.x)
  return _internal_x();
}
inline void LidarOdomStatu::set_x(float value) {
  _internal_set_x(value);
  // @@protoc_insertion_point(field_set:NavMessage.LidarOdomStatu.x)
}
inline float LidarOdomStatu::_internal_x() const {
  return _impl_.x_;
}
inline void LidarOdomStatu::_internal_set_x(float value) {
  ;
  _impl_.x_ = value;
}

// float y = 2;
inline void LidarOdomStatu::clear_y() {
  _impl_.y_ = 0;
}
inline float LidarOdomStatu::y() const {
  // @@protoc_insertion_point(field_get:NavMessage.LidarOdomStatu.y)
  return _internal_y();
}
inline void LidarOdomStatu::set_y(float value) {
  _internal_set_y(value);
  // @@protoc_insertion_point(field_set:NavMessage.LidarOdomStatu.y)
}
inline float LidarOdomStatu::_internal_y() const {
  return _impl_.y_;
}
inline void LidarOdomStatu::_internal_set_y(float value) {
  ;
  _impl_.y_ = value;
}

// float theta = 3;
inline void LidarOdomStatu::clear_theta() {
  _impl_.theta_ = 0;
}
inline float LidarOdomStatu::theta() const {
  // @@protoc_insertion_point(field_get:NavMessage.LidarOdomStatu.theta)
  return _internal_theta();
}
inline void LidarOdomStatu::set_theta(float value) {
  _internal_set_theta(value);
  // @@protoc_insertion_point(field_set:NavMessage.LidarOdomStatu.theta)
}
inline float LidarOdomStatu::_internal_theta() const {
  return _impl_.theta_;
}
inline void LidarOdomStatu::_internal_set_theta(float value) {
  ;
  _impl_.theta_ = value;
}

// float v = 4;
inline void LidarOdomStatu::clear_v() {
  _impl_.v_ = 0;
}
inline float LidarOdomStatu::v() const {
  // @@protoc_insertion_point(field_get:NavMessage.LidarOdomStatu.v)
  return _internal_v();
}
inline void LidarOdomStatu::set_v(float value) {
  _internal_set_v(value);
  // @@protoc_insertion_point(field_set:NavMessage.LidarOdomStatu.v)
}
inline float LidarOdomStatu::_internal_v() const {
  return _impl_.v_;
}
inline void LidarOdomStatu::_internal_set_v(float value) {
  ;
  _impl_.v_ = value;
}

// float vth = 5;
inline void LidarOdomStatu::clear_vth() {
  _impl_.vth_ = 0;
}
inline float LidarOdomStatu::vth() const {
  // @@protoc_insertion_point(field_get:NavMessage.LidarOdomStatu.vth)
  return _internal_vth();
}
inline void LidarOdomStatu::set_vth(float value) {
  _internal_set_vth(value);
  // @@protoc_insertion_point(field_set:NavMessage.LidarOdomStatu.vth)
}
inline float LidarOdomStatu::_internal_vth() const {
  return _impl_.vth_;
}
inline void LidarOdomStatu::_internal_set_vth(float value) {
  ;
  _impl_.vth_ = value;
}

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

// AgvStatu

// float v = 1;
inline void AgvStatu::clear_v() {
  _impl_.v_ = 0;
}
inline float AgvStatu::v() const {
  // @@protoc_insertion_point(field_get:NavMessage.AgvStatu.v)
  return _internal_v();
}
inline void AgvStatu::set_v(float value) {
  _internal_set_v(value);
  // @@protoc_insertion_point(field_set:NavMessage.AgvStatu.v)
}
inline float AgvStatu::_internal_v() const {
  return _impl_.v_;
}
inline void AgvStatu::_internal_set_v(float value) {
  ;
  _impl_.v_ = value;
}

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

// int32 clamp = 3;
inline void AgvStatu::clear_clamp() {
  _impl_.clamp_ = 0;
}
inline ::int32_t AgvStatu::clamp() const {
  // @@protoc_insertion_point(field_get:NavMessage.AgvStatu.clamp)
  return _internal_clamp();
}
inline void AgvStatu::set_clamp(::int32_t value) {
  _internal_set_clamp(value);
  // @@protoc_insertion_point(field_set:NavMessage.AgvStatu.clamp)
}
inline ::int32_t AgvStatu::_internal_clamp() const {
  return _impl_.clamp_;
}
inline void AgvStatu::_internal_set_clamp(::int32_t value) {
  ;
  _impl_.clamp_ = value;
}

// int32 clamp_other = 4;
inline void AgvStatu::clear_clamp_other() {
  _impl_.clamp_other_ = 0;
}
inline ::int32_t AgvStatu::clamp_other() const {
  // @@protoc_insertion_point(field_get:NavMessage.AgvStatu.clamp_other)
  return _internal_clamp_other();
}
inline void AgvStatu::set_clamp_other(::int32_t value) {
  _internal_set_clamp_other(value);
  // @@protoc_insertion_point(field_set:NavMessage.AgvStatu.clamp_other)
}
inline ::int32_t AgvStatu::_internal_clamp_other() const {
  return _impl_.clamp_other_;
}
inline void AgvStatu::_internal_set_clamp_other(::int32_t value) {
  ;
  _impl_.clamp_other_ = value;
}

// int32 lifter = 5;
inline void AgvStatu::clear_lifter() {
  _impl_.lifter_ = 0;
}
inline ::int32_t AgvStatu::lifter() const {
  // @@protoc_insertion_point(field_get:NavMessage.AgvStatu.lifter)
  return _internal_lifter();
}
inline void AgvStatu::set_lifter(::int32_t value) {
  _internal_set_lifter(value);
  // @@protoc_insertion_point(field_set:NavMessage.AgvStatu.lifter)
}
inline ::int32_t AgvStatu::_internal_lifter() const {
  return _impl_.lifter_;
}
inline void AgvStatu::_internal_set_lifter(::int32_t value) {
  ;
  _impl_.lifter_ = value;
}

// int32 lifter_other = 6;
inline void AgvStatu::clear_lifter_other() {
  _impl_.lifter_other_ = 0;
}
inline ::int32_t AgvStatu::lifter_other() const {
  // @@protoc_insertion_point(field_get:NavMessage.AgvStatu.lifter_other)
  return _internal_lifter_other();
}
inline void AgvStatu::set_lifter_other(::int32_t value) {
  _internal_set_lifter_other(value);
  // @@protoc_insertion_point(field_set:NavMessage.AgvStatu.lifter_other)
}
inline ::int32_t AgvStatu::_internal_lifter_other() const {
  return _impl_.lifter_other_;
}
inline void AgvStatu::_internal_set_lifter_other(::int32_t value) {
  ;
  _impl_.lifter_other_ = value;
}

// repeated int32 zcb = 7;
inline int AgvStatu::_internal_zcb_size() const {
  return _impl_.zcb_.size();
}
inline int AgvStatu::zcb_size() const {
  return _internal_zcb_size();
}
inline void AgvStatu::clear_zcb() {
  _internal_mutable_zcb()->Clear();
}
inline ::int32_t AgvStatu::zcb(int index) const {
  // @@protoc_insertion_point(field_get:NavMessage.AgvStatu.zcb)
  return _internal_zcb(index);
}
inline void AgvStatu::set_zcb(int index, ::int32_t value) {
  _internal_mutable_zcb()->Set(index, value);
  // @@protoc_insertion_point(field_set:NavMessage.AgvStatu.zcb)
}
inline void AgvStatu::add_zcb(::int32_t value) {
  _internal_add_zcb(value);
  // @@protoc_insertion_point(field_add:NavMessage.AgvStatu.zcb)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& AgvStatu::zcb() const {
  // @@protoc_insertion_point(field_list:NavMessage.AgvStatu.zcb)
  return _internal_zcb();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* AgvStatu::mutable_zcb() {
  // @@protoc_insertion_point(field_mutable_list:NavMessage.AgvStatu.zcb)
  return _internal_mutable_zcb();
}

inline ::int32_t AgvStatu::_internal_zcb(int index) const {
  return _internal_zcb().Get(index);
}
inline void AgvStatu::_internal_add_zcb(::int32_t value) {
  _internal_mutable_zcb()->Add(value);
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>& AgvStatu::_internal_zcb() const {
  return _impl_.zcb_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<::int32_t>* AgvStatu::_internal_mutable_zcb() {
  return &_impl_.zcb_;
}

// int32 door = 8;
inline void AgvStatu::clear_door() {
  _impl_.door_ = 0;
}
inline ::int32_t AgvStatu::door() const {
  // @@protoc_insertion_point(field_get:NavMessage.AgvStatu.door)
  return _internal_door();
}
inline void AgvStatu::set_door(::int32_t value) {
  _internal_set_door(value);
  // @@protoc_insertion_point(field_set:NavMessage.AgvStatu.door)
}
inline ::int32_t AgvStatu::_internal_door() const {
  return _impl_.door_;
}
inline void AgvStatu::_internal_set_door(::int32_t value) {
  ;
  _impl_.door_ = value;
}

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

// ToAgvCmd

// int32 H1 = 1;
inline void ToAgvCmd::clear_h1() {
  _impl_.h1_ = 0;
}
inline ::int32_t ToAgvCmd::h1() const {
  // @@protoc_insertion_point(field_get:NavMessage.ToAgvCmd.H1)
  return _internal_h1();
}
inline void ToAgvCmd::set_h1(::int32_t value) {
  _internal_set_h1(value);
  // @@protoc_insertion_point(field_set:NavMessage.ToAgvCmd.H1)
}
inline ::int32_t ToAgvCmd::_internal_h1() const {
  return _impl_.h1_;
}
inline void ToAgvCmd::_internal_set_h1(::int32_t value) {
  ;
  _impl_.h1_ = value;
}

// int32 M1 = 2;
inline void ToAgvCmd::clear_m1() {
  _impl_.m1_ = 0;
}
inline ::int32_t ToAgvCmd::m1() const {
  // @@protoc_insertion_point(field_get:NavMessage.ToAgvCmd.M1)
  return _internal_m1();
}
inline void ToAgvCmd::set_m1(::int32_t value) {
  _internal_set_m1(value);
  // @@protoc_insertion_point(field_set:NavMessage.ToAgvCmd.M1)
}
inline ::int32_t ToAgvCmd::_internal_m1() const {
  return _impl_.m1_;
}
inline void ToAgvCmd::_internal_set_m1(::int32_t value) {
  ;
  _impl_.m1_ = value;
}

// int32 T1 = 3;
inline void ToAgvCmd::clear_t1() {
  _impl_.t1_ = 0;
}
inline ::int32_t ToAgvCmd::t1() const {
  // @@protoc_insertion_point(field_get:NavMessage.ToAgvCmd.T1)
  return _internal_t1();
}
inline void ToAgvCmd::set_t1(::int32_t value) {
  _internal_set_t1(value);
  // @@protoc_insertion_point(field_set:NavMessage.ToAgvCmd.T1)
}
inline ::int32_t ToAgvCmd::_internal_t1() const {
  return _impl_.t1_;
}
inline void ToAgvCmd::_internal_set_t1(::int32_t value) {
  ;
  _impl_.t1_ = value;
}

// float V1 = 4;
inline void ToAgvCmd::clear_v1() {
  _impl_.v1_ = 0;
}
inline float ToAgvCmd::v1() const {
  // @@protoc_insertion_point(field_get:NavMessage.ToAgvCmd.V1)
  return _internal_v1();
}
inline void ToAgvCmd::set_v1(float value) {
  _internal_set_v1(value);
  // @@protoc_insertion_point(field_set:NavMessage.ToAgvCmd.V1)
}
inline float ToAgvCmd::_internal_v1() const {
  return _impl_.v1_;
}
inline void ToAgvCmd::_internal_set_v1(float value) {
  ;
  _impl_.v1_ = value;
}

// float W1 = 5;
inline void ToAgvCmd::clear_w1() {
  _impl_.w1_ = 0;
}
inline float ToAgvCmd::w1() const {
  // @@protoc_insertion_point(field_get:NavMessage.ToAgvCmd.W1)
  return _internal_w1();
}
inline void ToAgvCmd::set_w1(float value) {
  _internal_set_w1(value);
  // @@protoc_insertion_point(field_set:NavMessage.ToAgvCmd.W1)
}
inline float ToAgvCmd::_internal_w1() const {
  return _impl_.w1_;
}
inline void ToAgvCmd::_internal_set_w1(float value) {
  ;
  _impl_.w1_ = value;
}

// float V2 = 6;
inline void ToAgvCmd::clear_v2() {
  _impl_.v2_ = 0;
}
inline float ToAgvCmd::v2() const {
  // @@protoc_insertion_point(field_get:NavMessage.ToAgvCmd.V2)
  return _internal_v2();
}
inline void ToAgvCmd::set_v2(float value) {
  _internal_set_v2(value);
  // @@protoc_insertion_point(field_set:NavMessage.ToAgvCmd.V2)
}
inline float ToAgvCmd::_internal_v2() const {
  return _impl_.v2_;
}
inline void ToAgvCmd::_internal_set_v2(float value) {
  ;
  _impl_.v2_ = value;
}

// float W2 = 7;
inline void ToAgvCmd::clear_w2() {
  _impl_.w2_ = 0;
}
inline float ToAgvCmd::w2() const {
  // @@protoc_insertion_point(field_get:NavMessage.ToAgvCmd.W2)
  return _internal_w2();
}
inline void ToAgvCmd::set_w2(float value) {
  _internal_set_w2(value);
  // @@protoc_insertion_point(field_set:NavMessage.ToAgvCmd.W2)
}
inline float ToAgvCmd::_internal_w2() const {
  return _impl_.w2_;
}
inline void ToAgvCmd::_internal_set_w2(float value) {
  ;
  _impl_.w2_ = value;
}

// float V3 = 8;
inline void ToAgvCmd::clear_v3() {
  _impl_.v3_ = 0;
}
inline float ToAgvCmd::v3() const {
  // @@protoc_insertion_point(field_get:NavMessage.ToAgvCmd.V3)
  return _internal_v3();
}
inline void ToAgvCmd::set_v3(float value) {
  _internal_set_v3(value);
  // @@protoc_insertion_point(field_set:NavMessage.ToAgvCmd.V3)
}
inline float ToAgvCmd::_internal_v3() const {
  return _impl_.v3_;
}
inline void ToAgvCmd::_internal_set_v3(float value) {
  ;
  _impl_.v3_ = value;
}

// float W3 = 9;
inline void ToAgvCmd::clear_w3() {
  _impl_.w3_ = 0;
}
inline float ToAgvCmd::w3() const {
  // @@protoc_insertion_point(field_get:NavMessage.ToAgvCmd.W3)
  return _internal_w3();
}
inline void ToAgvCmd::set_w3(float value) {
  _internal_set_w3(value);
  // @@protoc_insertion_point(field_set:NavMessage.ToAgvCmd.W3)
}
inline float ToAgvCmd::_internal_w3() const {
  return _impl_.w3_;
}
inline void ToAgvCmd::_internal_set_w3(float value) {
  ;
  _impl_.w3_ = value;
}

// float L1 = 10;
inline void ToAgvCmd::clear_l1() {
  _impl_.l1_ = 0;
}
inline float ToAgvCmd::l1() const {
  // @@protoc_insertion_point(field_get:NavMessage.ToAgvCmd.L1)
  return _internal_l1();
}
inline void ToAgvCmd::set_l1(float value) {
  _internal_set_l1(value);
  // @@protoc_insertion_point(field_set:NavMessage.ToAgvCmd.L1)
}
inline float ToAgvCmd::_internal_l1() const {
  return _impl_.l1_;
}
inline void ToAgvCmd::_internal_set_l1(float value) {
  ;
  _impl_.l1_ = value;
}

// int32 P1 = 11;
inline void ToAgvCmd::clear_p1() {
  _impl_.p1_ = 0;
}
inline ::int32_t ToAgvCmd::p1() const {
  // @@protoc_insertion_point(field_get:NavMessage.ToAgvCmd.P1)
  return _internal_p1();
}
inline void ToAgvCmd::set_p1(::int32_t value) {
  _internal_set_p1(value);
  // @@protoc_insertion_point(field_set:NavMessage.ToAgvCmd.P1)
}
inline ::int32_t ToAgvCmd::_internal_p1() const {
  return _impl_.p1_;
}
inline void ToAgvCmd::_internal_set_p1(::int32_t value) {
  ;
  _impl_.p1_ = value;
}

// float D1 = 12;
inline void ToAgvCmd::clear_d1() {
  _impl_.d1_ = 0;
}
inline float ToAgvCmd::d1() const {
  // @@protoc_insertion_point(field_get:NavMessage.ToAgvCmd.D1)
  return _internal_d1();
}
inline void ToAgvCmd::set_d1(float value) {
  _internal_set_d1(value);
  // @@protoc_insertion_point(field_set:NavMessage.ToAgvCmd.D1)
}
inline float ToAgvCmd::_internal_d1() const {
  return _impl_.d1_;
}
inline void ToAgvCmd::_internal_set_d1(float value) {
  ;
  _impl_.d1_ = value;
}

// float Y1 = 13;
inline void ToAgvCmd::clear_y1() {
  _impl_.y1_ = 0;
}
inline float ToAgvCmd::y1() const {
  // @@protoc_insertion_point(field_get:NavMessage.ToAgvCmd.Y1)
  return _internal_y1();
}
inline void ToAgvCmd::set_y1(float value) {
  _internal_set_y1(value);
  // @@protoc_insertion_point(field_set:NavMessage.ToAgvCmd.Y1)
}
inline float ToAgvCmd::_internal_y1() const {
  return _impl_.y1_;
}
inline void ToAgvCmd::_internal_set_y1(float value) {
  ;
  _impl_.y1_ = value;
}

// float Y2 = 14;
inline void ToAgvCmd::clear_y2() {
  _impl_.y2_ = 0;
}
inline float ToAgvCmd::y2() const {
  // @@protoc_insertion_point(field_get:NavMessage.ToAgvCmd.Y2)
  return _internal_y2();
}
inline void ToAgvCmd::set_y2(float value) {
  _internal_set_y2(value);
  // @@protoc_insertion_point(field_set:NavMessage.ToAgvCmd.Y2)
}
inline float ToAgvCmd::_internal_y2() const {
  return _impl_.y2_;
}
inline void ToAgvCmd::_internal_set_y2(float value) {
  ;
  _impl_.y2_ = value;
}

// int32 CL = 15;
inline void ToAgvCmd::clear_cl() {
  _impl_.cl_ = 0;
}
inline ::int32_t ToAgvCmd::cl() const {
  // @@protoc_insertion_point(field_get:NavMessage.ToAgvCmd.CL)
  return _internal_cl();
}
inline void ToAgvCmd::set_cl(::int32_t value) {
  _internal_set_cl(value);
  // @@protoc_insertion_point(field_set:NavMessage.ToAgvCmd.CL)
}
inline ::int32_t ToAgvCmd::_internal_cl() const {
  return _impl_.cl_;
}
inline void ToAgvCmd::_internal_set_cl(::int32_t value) {
  ;
  _impl_.cl_ = value;
}

// int32 end = 16;
inline void ToAgvCmd::clear_end() {
  _impl_.end_ = 0;
}
inline ::int32_t ToAgvCmd::end() const {
  // @@protoc_insertion_point(field_get:NavMessage.ToAgvCmd.end)
  return _internal_end();
}
inline void ToAgvCmd::set_end(::int32_t value) {
  _internal_set_end(value);
  // @@protoc_insertion_point(field_set:NavMessage.ToAgvCmd.end)
}
inline ::int32_t ToAgvCmd::_internal_end() const {
  return _impl_.end_;
}
inline void ToAgvCmd::_internal_set_end(::int32_t value) {
  ;
  _impl_.end_ = value;
}

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

// Pose2d

// float x = 1;
inline void Pose2d::clear_x() {
  _impl_.x_ = 0;
}
inline float Pose2d::x() const {
  // @@protoc_insertion_point(field_get:NavMessage.Pose2d.x)
  return _internal_x();
}
inline void Pose2d::set_x(float value) {
  _internal_set_x(value);
  // @@protoc_insertion_point(field_set:NavMessage.Pose2d.x)
}
inline float Pose2d::_internal_x() const {
  return _impl_.x_;
}
inline void Pose2d::_internal_set_x(float value) {
  ;
  _impl_.x_ = value;
}

// float y = 2;
inline void Pose2d::clear_y() {
  _impl_.y_ = 0;
}
inline float Pose2d::y() const {
  // @@protoc_insertion_point(field_get:NavMessage.Pose2d.y)
  return _internal_y();
}
inline void Pose2d::set_y(float value) {
  _internal_set_y(value);
  // @@protoc_insertion_point(field_set:NavMessage.Pose2d.y)
}
inline float Pose2d::_internal_y() const {
  return _impl_.y_;
}
inline void Pose2d::_internal_set_y(float value) {
  ;
  _impl_.y_ = value;
}

// float theta = 3;
inline void Pose2d::clear_theta() {
  _impl_.theta_ = 0;
}
inline float Pose2d::theta() const {
  // @@protoc_insertion_point(field_get:NavMessage.Pose2d.theta)
  return _internal_theta();
}
inline void Pose2d::set_theta(float value) {
  _internal_set_theta(value);
  // @@protoc_insertion_point(field_set:NavMessage.Pose2d.theta)
}
inline float Pose2d::_internal_theta() const {
  return _impl_.theta_;
}
inline void Pose2d::_internal_set_theta(float value) {
  ;
  _impl_.theta_ = value;
}

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

// PathNode

// float x = 1;
inline void PathNode::clear_x() {
  _impl_.x_ = 0;
}
inline float PathNode::x() const {
  // @@protoc_insertion_point(field_get:NavMessage.PathNode.x)
  return _internal_x();
}
inline void PathNode::set_x(float value) {
  _internal_set_x(value);
  // @@protoc_insertion_point(field_set:NavMessage.PathNode.x)
}
inline float PathNode::_internal_x() const {
  return _impl_.x_;
}
inline void PathNode::_internal_set_x(float value) {
  ;
  _impl_.x_ = value;
}

// float y = 2;
inline void PathNode::clear_y() {
  _impl_.y_ = 0;
}
inline float PathNode::y() const {
  // @@protoc_insertion_point(field_get:NavMessage.PathNode.y)
  return _internal_y();
}
inline void PathNode::set_y(float value) {
  _internal_set_y(value);
  // @@protoc_insertion_point(field_set:NavMessage.PathNode.y)
}
inline float PathNode::_internal_y() const {
  return _impl_.y_;
}
inline void PathNode::_internal_set_y(float value) {
  ;
  _impl_.y_ = value;
}

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

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

// float theta = 5;
inline void PathNode::clear_theta() {
  _impl_.theta_ = 0;
}
inline float PathNode::theta() const {
  // @@protoc_insertion_point(field_get:NavMessage.PathNode.theta)
  return _internal_theta();
}
inline void PathNode::set_theta(float value) {
  _internal_set_theta(value);
  // @@protoc_insertion_point(field_set:NavMessage.PathNode.theta)
}
inline float PathNode::_internal_theta() const {
  return _impl_.theta_;
}
inline void PathNode::_internal_set_theta(float value) {
  ;
  _impl_.theta_ = value;
}

// optional string id = 6;
inline bool PathNode::has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline void PathNode::clear_id() {
  _impl_.id_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PathNode::id() const {
  // @@protoc_insertion_point(field_get:NavMessage.PathNode.id)
  return _internal_id();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void PathNode::set_id(Arg_&& arg,
                                                     Args_... args) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.id_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NavMessage.PathNode.id)
}
inline std::string* PathNode::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:NavMessage.PathNode.id)
  return _s;
}
inline const std::string& PathNode::_internal_id() const {
  return _impl_.id_.Get();
}
inline void PathNode::_internal_set_id(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;


  _impl_.id_.Set(value, GetArenaForAllocation());
}
inline std::string* PathNode::_internal_mutable_id() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.id_.Mutable( GetArenaForAllocation());
}
inline std::string* PathNode::release_id() {
  // @@protoc_insertion_point(field_release:NavMessage.PathNode.id)
  if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* released = _impl_.id_.Release();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return released;
}
inline void PathNode::set_allocated_id(std::string* value) {
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.id_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.id_.IsDefault()) {
          _impl_.id_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:NavMessage.PathNode.id)
}

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

// Trajectory

// repeated .NavMessage.Pose2d poses = 1;
inline int Trajectory::_internal_poses_size() const {
  return _impl_.poses_.size();
}
inline int Trajectory::poses_size() const {
  return _internal_poses_size();
}
inline void Trajectory::clear_poses() {
  _internal_mutable_poses()->Clear();
}
inline ::NavMessage::Pose2d* Trajectory::mutable_poses(int index) {
  // @@protoc_insertion_point(field_mutable:NavMessage.Trajectory.poses)
  return _internal_mutable_poses()->Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::Pose2d >*
Trajectory::mutable_poses() {
  // @@protoc_insertion_point(field_mutable_list:NavMessage.Trajectory.poses)
  return _internal_mutable_poses();
}
inline const ::NavMessage::Pose2d& Trajectory::_internal_poses(int index) const {
  return _internal_poses().Get(index);
}
inline const ::NavMessage::Pose2d& Trajectory::poses(int index) const {
  // @@protoc_insertion_point(field_get:NavMessage.Trajectory.poses)
  return _internal_poses(index);
}
inline ::NavMessage::Pose2d* Trajectory::_internal_add_poses() {
  return _internal_mutable_poses()->Add();
}
inline ::NavMessage::Pose2d* Trajectory::add_poses() {
  ::NavMessage::Pose2d* _add = _internal_add_poses();
  // @@protoc_insertion_point(field_add:NavMessage.Trajectory.poses)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::Pose2d >&
Trajectory::poses() const {
  // @@protoc_insertion_point(field_list:NavMessage.Trajectory.poses)
  return _internal_poses();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::NavMessage::Pose2d>&
Trajectory::_internal_poses() const {
  return _impl_.poses_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::NavMessage::Pose2d>*
Trajectory::_internal_mutable_poses() {
  return &_impl_.poses_;
}

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

// NewAction

// int32 type = 1;
inline void NewAction::clear_type() {
  _impl_.type_ = 0;
}
inline ::int32_t NewAction::type() const {
  // @@protoc_insertion_point(field_get:NavMessage.NewAction.type)
  return _internal_type();
}
inline void NewAction::set_type(::int32_t value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:NavMessage.NewAction.type)
}
inline ::int32_t NewAction::_internal_type() const {
  return _impl_.type_;
}
inline void NewAction::_internal_set_type(::int32_t value) {
  ;
  _impl_.type_ = value;
}

// .NavMessage.PathNode spaceNode = 2;
inline bool NewAction::has_spacenode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.spacenode_ != nullptr);
  return value;
}
inline void NewAction::clear_spacenode() {
  if (_impl_.spacenode_ != nullptr) _impl_.spacenode_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::NavMessage::PathNode& NewAction::_internal_spacenode() const {
  const ::NavMessage::PathNode* p = _impl_.spacenode_;
  return p != nullptr ? *p : reinterpret_cast<const ::NavMessage::PathNode&>(
      ::NavMessage::_PathNode_default_instance_);
}
inline const ::NavMessage::PathNode& NewAction::spacenode() const {
  // @@protoc_insertion_point(field_get:NavMessage.NewAction.spaceNode)
  return _internal_spacenode();
}
inline void NewAction::unsafe_arena_set_allocated_spacenode(
    ::NavMessage::PathNode* spacenode) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.spacenode_);
  }
  _impl_.spacenode_ = spacenode;
  if (spacenode) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.NewAction.spaceNode)
}
inline ::NavMessage::PathNode* NewAction::release_spacenode() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::NavMessage::PathNode* temp = _impl_.spacenode_;
  _impl_.spacenode_ = 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 ::NavMessage::PathNode* NewAction::unsafe_arena_release_spacenode() {
  // @@protoc_insertion_point(field_release:NavMessage.NewAction.spaceNode)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::NavMessage::PathNode* temp = _impl_.spacenode_;
  _impl_.spacenode_ = nullptr;
  return temp;
}
inline ::NavMessage::PathNode* NewAction::_internal_mutable_spacenode() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.spacenode_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::PathNode>(GetArenaForAllocation());
    _impl_.spacenode_ = p;
  }
  return _impl_.spacenode_;
}
inline ::NavMessage::PathNode* NewAction::mutable_spacenode() {
  ::NavMessage::PathNode* _msg = _internal_mutable_spacenode();
  // @@protoc_insertion_point(field_mutable:NavMessage.NewAction.spaceNode)
  return _msg;
}
inline void NewAction::set_allocated_spacenode(::NavMessage::PathNode* spacenode) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.spacenode_;
  }
  if (spacenode) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(spacenode);
    if (message_arena != submessage_arena) {
      spacenode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, spacenode, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.spacenode_ = spacenode;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NewAction.spaceNode)
}

// .NavMessage.PathNode passNode = 3;
inline bool NewAction::has_passnode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.passnode_ != nullptr);
  return value;
}
inline void NewAction::clear_passnode() {
  if (_impl_.passnode_ != nullptr) _impl_.passnode_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::NavMessage::PathNode& NewAction::_internal_passnode() const {
  const ::NavMessage::PathNode* p = _impl_.passnode_;
  return p != nullptr ? *p : reinterpret_cast<const ::NavMessage::PathNode&>(
      ::NavMessage::_PathNode_default_instance_);
}
inline const ::NavMessage::PathNode& NewAction::passnode() const {
  // @@protoc_insertion_point(field_get:NavMessage.NewAction.passNode)
  return _internal_passnode();
}
inline void NewAction::unsafe_arena_set_allocated_passnode(
    ::NavMessage::PathNode* passnode) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.passnode_);
  }
  _impl_.passnode_ = passnode;
  if (passnode) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.NewAction.passNode)
}
inline ::NavMessage::PathNode* NewAction::release_passnode() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::NavMessage::PathNode* temp = _impl_.passnode_;
  _impl_.passnode_ = 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 ::NavMessage::PathNode* NewAction::unsafe_arena_release_passnode() {
  // @@protoc_insertion_point(field_release:NavMessage.NewAction.passNode)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::NavMessage::PathNode* temp = _impl_.passnode_;
  _impl_.passnode_ = nullptr;
  return temp;
}
inline ::NavMessage::PathNode* NewAction::_internal_mutable_passnode() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.passnode_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::PathNode>(GetArenaForAllocation());
    _impl_.passnode_ = p;
  }
  return _impl_.passnode_;
}
inline ::NavMessage::PathNode* NewAction::mutable_passnode() {
  ::NavMessage::PathNode* _msg = _internal_mutable_passnode();
  // @@protoc_insertion_point(field_mutable:NavMessage.NewAction.passNode)
  return _msg;
}
inline void NewAction::set_allocated_passnode(::NavMessage::PathNode* passnode) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.passnode_;
  }
  if (passnode) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(passnode);
    if (message_arena != submessage_arena) {
      passnode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, passnode, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.passnode_ = passnode;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NewAction.passNode)
}

// .NavMessage.PathNode streetNode = 4;
inline bool NewAction::has_streetnode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.streetnode_ != nullptr);
  return value;
}
inline void NewAction::clear_streetnode() {
  if (_impl_.streetnode_ != nullptr) _impl_.streetnode_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::NavMessage::PathNode& NewAction::_internal_streetnode() const {
  const ::NavMessage::PathNode* p = _impl_.streetnode_;
  return p != nullptr ? *p : reinterpret_cast<const ::NavMessage::PathNode&>(
      ::NavMessage::_PathNode_default_instance_);
}
inline const ::NavMessage::PathNode& NewAction::streetnode() const {
  // @@protoc_insertion_point(field_get:NavMessage.NewAction.streetNode)
  return _internal_streetnode();
}
inline void NewAction::unsafe_arena_set_allocated_streetnode(
    ::NavMessage::PathNode* streetnode) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.streetnode_);
  }
  _impl_.streetnode_ = streetnode;
  if (streetnode) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.NewAction.streetNode)
}
inline ::NavMessage::PathNode* NewAction::release_streetnode() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::NavMessage::PathNode* temp = _impl_.streetnode_;
  _impl_.streetnode_ = 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 ::NavMessage::PathNode* NewAction::unsafe_arena_release_streetnode() {
  // @@protoc_insertion_point(field_release:NavMessage.NewAction.streetNode)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::NavMessage::PathNode* temp = _impl_.streetnode_;
  _impl_.streetnode_ = nullptr;
  return temp;
}
inline ::NavMessage::PathNode* NewAction::_internal_mutable_streetnode() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.streetnode_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::PathNode>(GetArenaForAllocation());
    _impl_.streetnode_ = p;
  }
  return _impl_.streetnode_;
}
inline ::NavMessage::PathNode* NewAction::mutable_streetnode() {
  ::NavMessage::PathNode* _msg = _internal_mutable_streetnode();
  // @@protoc_insertion_point(field_mutable:NavMessage.NewAction.streetNode)
  return _msg;
}
inline void NewAction::set_allocated_streetnode(::NavMessage::PathNode* streetnode) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.streetnode_;
  }
  if (streetnode) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(streetnode);
    if (message_arena != submessage_arena) {
      streetnode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, streetnode, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.streetnode_ = streetnode;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NewAction.streetNode)
}

// repeated .NavMessage.PathNode pathNodes = 5;
inline int NewAction::_internal_pathnodes_size() const {
  return _impl_.pathnodes_.size();
}
inline int NewAction::pathnodes_size() const {
  return _internal_pathnodes_size();
}
inline void NewAction::clear_pathnodes() {
  _internal_mutable_pathnodes()->Clear();
}
inline ::NavMessage::PathNode* NewAction::mutable_pathnodes(int index) {
  // @@protoc_insertion_point(field_mutable:NavMessage.NewAction.pathNodes)
  return _internal_mutable_pathnodes()->Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::PathNode >*
NewAction::mutable_pathnodes() {
  // @@protoc_insertion_point(field_mutable_list:NavMessage.NewAction.pathNodes)
  return _internal_mutable_pathnodes();
}
inline const ::NavMessage::PathNode& NewAction::_internal_pathnodes(int index) const {
  return _internal_pathnodes().Get(index);
}
inline const ::NavMessage::PathNode& NewAction::pathnodes(int index) const {
  // @@protoc_insertion_point(field_get:NavMessage.NewAction.pathNodes)
  return _internal_pathnodes(index);
}
inline ::NavMessage::PathNode* NewAction::_internal_add_pathnodes() {
  return _internal_mutable_pathnodes()->Add();
}
inline ::NavMessage::PathNode* NewAction::add_pathnodes() {
  ::NavMessage::PathNode* _add = _internal_add_pathnodes();
  // @@protoc_insertion_point(field_add:NavMessage.NewAction.pathNodes)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::PathNode >&
NewAction::pathnodes() const {
  // @@protoc_insertion_point(field_list:NavMessage.NewAction.pathNodes)
  return _internal_pathnodes();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::NavMessage::PathNode>&
NewAction::_internal_pathnodes() const {
  return _impl_.pathnodes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::NavMessage::PathNode>*
NewAction::_internal_mutable_pathnodes() {
  return &_impl_.pathnodes_;
}

// float wheelbase = 6;
inline void NewAction::clear_wheelbase() {
  _impl_.wheelbase_ = 0;
}
inline float NewAction::wheelbase() const {
  // @@protoc_insertion_point(field_get:NavMessage.NewAction.wheelbase)
  return _internal_wheelbase();
}
inline void NewAction::set_wheelbase(float value) {
  _internal_set_wheelbase(value);
  // @@protoc_insertion_point(field_set:NavMessage.NewAction.wheelbase)
}
inline float NewAction::_internal_wheelbase() const {
  return _impl_.wheelbase_;
}
inline void NewAction::_internal_set_wheelbase(float value) {
  ;
  _impl_.wheelbase_ = value;
}

// int32 changedMode = 7;
inline void NewAction::clear_changedmode() {
  _impl_.changedmode_ = 0;
}
inline ::int32_t NewAction::changedmode() const {
  // @@protoc_insertion_point(field_get:NavMessage.NewAction.changedMode)
  return _internal_changedmode();
}
inline void NewAction::set_changedmode(::int32_t value) {
  _internal_set_changedmode(value);
  // @@protoc_insertion_point(field_set:NavMessage.NewAction.changedMode)
}
inline ::int32_t NewAction::_internal_changedmode() const {
  return _impl_.changedmode_;
}
inline void NewAction::_internal_set_changedmode(::int32_t value) {
  ;
  _impl_.changedmode_ = value;
}

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

// NavCmd

// int32 action = 1;
inline void NavCmd::clear_action() {
  _impl_.action_ = 0;
}
inline ::int32_t NavCmd::action() const {
  // @@protoc_insertion_point(field_get:NavMessage.NavCmd.action)
  return _internal_action();
}
inline void NavCmd::set_action(::int32_t value) {
  _internal_set_action(value);
  // @@protoc_insertion_point(field_set:NavMessage.NavCmd.action)
}
inline ::int32_t NavCmd::_internal_action() const {
  return _impl_.action_;
}
inline void NavCmd::_internal_set_action(::int32_t value) {
  ;
  _impl_.action_ = value;
}

// string key = 2;
inline void NavCmd::clear_key() {
  _impl_.key_.ClearToEmpty();
}
inline const std::string& NavCmd::key() const {
  // @@protoc_insertion_point(field_get:NavMessage.NavCmd.key)
  return _internal_key();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void NavCmd::set_key(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.key_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NavMessage.NavCmd.key)
}
inline std::string* NavCmd::mutable_key() {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:NavMessage.NavCmd.key)
  return _s;
}
inline const std::string& NavCmd::_internal_key() const {
  return _impl_.key_.Get();
}
inline void NavCmd::_internal_set_key(const std::string& value) {
  ;


  _impl_.key_.Set(value, GetArenaForAllocation());
}
inline std::string* NavCmd::_internal_mutable_key() {
  ;
  return _impl_.key_.Mutable( GetArenaForAllocation());
}
inline std::string* NavCmd::release_key() {
  // @@protoc_insertion_point(field_release:NavMessage.NavCmd.key)
  return _impl_.key_.Release();
}
inline void NavCmd::set_allocated_key(std::string* value) {
  _impl_.key_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.key_.IsDefault()) {
          _impl_.key_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NavCmd.key)
}

// repeated .NavMessage.NewAction newActions = 5;
inline int NavCmd::_internal_newactions_size() const {
  return _impl_.newactions_.size();
}
inline int NavCmd::newactions_size() const {
  return _internal_newactions_size();
}
inline void NavCmd::clear_newactions() {
  _internal_mutable_newactions()->Clear();
}
inline ::NavMessage::NewAction* NavCmd::mutable_newactions(int index) {
  // @@protoc_insertion_point(field_mutable:NavMessage.NavCmd.newActions)
  return _internal_mutable_newactions()->Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::NewAction >*
NavCmd::mutable_newactions() {
  // @@protoc_insertion_point(field_mutable_list:NavMessage.NavCmd.newActions)
  return _internal_mutable_newactions();
}
inline const ::NavMessage::NewAction& NavCmd::_internal_newactions(int index) const {
  return _internal_newactions().Get(index);
}
inline const ::NavMessage::NewAction& NavCmd::newactions(int index) const {
  // @@protoc_insertion_point(field_get:NavMessage.NavCmd.newActions)
  return _internal_newactions(index);
}
inline ::NavMessage::NewAction* NavCmd::_internal_add_newactions() {
  return _internal_mutable_newactions()->Add();
}
inline ::NavMessage::NewAction* NavCmd::add_newactions() {
  ::NavMessage::NewAction* _add = _internal_add_newactions();
  // @@protoc_insertion_point(field_add:NavMessage.NavCmd.newActions)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::NewAction >&
NavCmd::newactions() const {
  // @@protoc_insertion_point(field_list:NavMessage.NavCmd.newActions)
  return _internal_newactions();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::NavMessage::NewAction>&
NavCmd::_internal_newactions() const {
  return _impl_.newactions_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::NavMessage::NewAction>*
NavCmd::_internal_mutable_newactions() {
  return &_impl_.newactions_;
}

// optional int32 sequence = 6;
inline bool NavCmd::has_sequence() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline void NavCmd::clear_sequence() {
  _impl_.sequence_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::int32_t NavCmd::sequence() const {
  // @@protoc_insertion_point(field_get:NavMessage.NavCmd.sequence)
  return _internal_sequence();
}
inline void NavCmd::set_sequence(::int32_t value) {
  _internal_set_sequence(value);
  // @@protoc_insertion_point(field_set:NavMessage.NavCmd.sequence)
}
inline ::int32_t NavCmd::_internal_sequence() const {
  return _impl_.sequence_;
}
inline void NavCmd::_internal_set_sequence(::int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.sequence_ = value;
}

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

// NavResponse

// int32 ret = 1;
inline void NavResponse::clear_ret() {
  _impl_.ret_ = 0;
}
inline ::int32_t NavResponse::ret() const {
  // @@protoc_insertion_point(field_get:NavMessage.NavResponse.ret)
  return _internal_ret();
}
inline void NavResponse::set_ret(::int32_t value) {
  _internal_set_ret(value);
  // @@protoc_insertion_point(field_set:NavMessage.NavResponse.ret)
}
inline ::int32_t NavResponse::_internal_ret() const {
  return _impl_.ret_;
}
inline void NavResponse::_internal_set_ret(::int32_t value) {
  ;
  _impl_.ret_ = value;
}

// string info = 2;
inline void NavResponse::clear_info() {
  _impl_.info_.ClearToEmpty();
}
inline const std::string& NavResponse::info() const {
  // @@protoc_insertion_point(field_get:NavMessage.NavResponse.info)
  return _internal_info();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void NavResponse::set_info(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.info_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NavMessage.NavResponse.info)
}
inline std::string* NavResponse::mutable_info() {
  std::string* _s = _internal_mutable_info();
  // @@protoc_insertion_point(field_mutable:NavMessage.NavResponse.info)
  return _s;
}
inline const std::string& NavResponse::_internal_info() const {
  return _impl_.info_.Get();
}
inline void NavResponse::_internal_set_info(const std::string& value) {
  ;


  _impl_.info_.Set(value, GetArenaForAllocation());
}
inline std::string* NavResponse::_internal_mutable_info() {
  ;
  return _impl_.info_.Mutable( GetArenaForAllocation());
}
inline std::string* NavResponse::release_info() {
  // @@protoc_insertion_point(field_release:NavMessage.NavResponse.info)
  return _impl_.info_.Release();
}
inline void NavResponse::set_allocated_info(std::string* value) {
  _impl_.info_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.info_.IsDefault()) {
          _impl_.info_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NavResponse.info)
}

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

// ManualCmd

// string key = 1;
inline void ManualCmd::clear_key() {
  _impl_.key_.ClearToEmpty();
}
inline const std::string& ManualCmd::key() const {
  // @@protoc_insertion_point(field_get:NavMessage.ManualCmd.key)
  return _internal_key();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ManualCmd::set_key(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.key_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NavMessage.ManualCmd.key)
}
inline std::string* ManualCmd::mutable_key() {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:NavMessage.ManualCmd.key)
  return _s;
}
inline const std::string& ManualCmd::_internal_key() const {
  return _impl_.key_.Get();
}
inline void ManualCmd::_internal_set_key(const std::string& value) {
  ;


  _impl_.key_.Set(value, GetArenaForAllocation());
}
inline std::string* ManualCmd::_internal_mutable_key() {
  ;
  return _impl_.key_.Mutable( GetArenaForAllocation());
}
inline std::string* ManualCmd::release_key() {
  // @@protoc_insertion_point(field_release:NavMessage.ManualCmd.key)
  return _impl_.key_.Release();
}
inline void ManualCmd::set_allocated_key(std::string* value) {
  _impl_.key_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.key_.IsDefault()) {
          _impl_.key_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:NavMessage.ManualCmd.key)
}

// int32 operation_type = 2;
inline void ManualCmd::clear_operation_type() {
  _impl_.operation_type_ = 0;
}
inline ::int32_t ManualCmd::operation_type() const {
  // @@protoc_insertion_point(field_get:NavMessage.ManualCmd.operation_type)
  return _internal_operation_type();
}
inline void ManualCmd::set_operation_type(::int32_t value) {
  _internal_set_operation_type(value);
  // @@protoc_insertion_point(field_set:NavMessage.ManualCmd.operation_type)
}
inline ::int32_t ManualCmd::_internal_operation_type() const {
  return _impl_.operation_type_;
}
inline void ManualCmd::_internal_set_operation_type(::int32_t value) {
  ;
  _impl_.operation_type_ = value;
}

// float velocity = 3;
inline void ManualCmd::clear_velocity() {
  _impl_.velocity_ = 0;
}
inline float ManualCmd::velocity() const {
  // @@protoc_insertion_point(field_get:NavMessage.ManualCmd.velocity)
  return _internal_velocity();
}
inline void ManualCmd::set_velocity(float value) {
  _internal_set_velocity(value);
  // @@protoc_insertion_point(field_set:NavMessage.ManualCmd.velocity)
}
inline float ManualCmd::_internal_velocity() const {
  return _impl_.velocity_;
}
inline void ManualCmd::_internal_set_velocity(float value) {
  ;
  _impl_.velocity_ = value;
}

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

// NavStatu

// int32 statu = 1;
inline void NavStatu::clear_statu() {
  _impl_.statu_ = 0;
}
inline ::int32_t NavStatu::statu() const {
  // @@protoc_insertion_point(field_get:NavMessage.NavStatu.statu)
  return _internal_statu();
}
inline void NavStatu::set_statu(::int32_t value) {
  _internal_set_statu(value);
  // @@protoc_insertion_point(field_set:NavMessage.NavStatu.statu)
}
inline ::int32_t NavStatu::_internal_statu() const {
  return _impl_.statu_;
}
inline void NavStatu::_internal_set_statu(::int32_t value) {
  ;
  _impl_.statu_ = value;
}

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

// int32 move_mode = 3;
inline void NavStatu::clear_move_mode() {
  _impl_.move_mode_ = 0;
}
inline ::int32_t NavStatu::move_mode() const {
  // @@protoc_insertion_point(field_get:NavMessage.NavStatu.move_mode)
  return _internal_move_mode();
}
inline void NavStatu::set_move_mode(::int32_t value) {
  _internal_set_move_mode(value);
  // @@protoc_insertion_point(field_set:NavMessage.NavStatu.move_mode)
}
inline ::int32_t NavStatu::_internal_move_mode() const {
  return _impl_.move_mode_;
}
inline void NavStatu::_internal_set_move_mode(::int32_t value) {
  ;
  _impl_.move_mode_ = value;
}

// .NavMessage.LidarOdomStatu odom = 4;
inline bool NavStatu::has_odom() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.odom_ != nullptr);
  return value;
}
inline void NavStatu::clear_odom() {
  if (_impl_.odom_ != nullptr) _impl_.odom_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::NavMessage::LidarOdomStatu& NavStatu::_internal_odom() const {
  const ::NavMessage::LidarOdomStatu* p = _impl_.odom_;
  return p != nullptr ? *p : reinterpret_cast<const ::NavMessage::LidarOdomStatu&>(
      ::NavMessage::_LidarOdomStatu_default_instance_);
}
inline const ::NavMessage::LidarOdomStatu& NavStatu::odom() const {
  // @@protoc_insertion_point(field_get:NavMessage.NavStatu.odom)
  return _internal_odom();
}
inline void NavStatu::unsafe_arena_set_allocated_odom(
    ::NavMessage::LidarOdomStatu* odom) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.odom_);
  }
  _impl_.odom_ = odom;
  if (odom) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.NavStatu.odom)
}
inline ::NavMessage::LidarOdomStatu* NavStatu::release_odom() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::NavMessage::LidarOdomStatu* temp = _impl_.odom_;
  _impl_.odom_ = 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 ::NavMessage::LidarOdomStatu* NavStatu::unsafe_arena_release_odom() {
  // @@protoc_insertion_point(field_release:NavMessage.NavStatu.odom)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::NavMessage::LidarOdomStatu* temp = _impl_.odom_;
  _impl_.odom_ = nullptr;
  return temp;
}
inline ::NavMessage::LidarOdomStatu* NavStatu::_internal_mutable_odom() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.odom_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::LidarOdomStatu>(GetArenaForAllocation());
    _impl_.odom_ = p;
  }
  return _impl_.odom_;
}
inline ::NavMessage::LidarOdomStatu* NavStatu::mutable_odom() {
  ::NavMessage::LidarOdomStatu* _msg = _internal_mutable_odom();
  // @@protoc_insertion_point(field_mutable:NavMessage.NavStatu.odom)
  return _msg;
}
inline void NavStatu::set_allocated_odom(::NavMessage::LidarOdomStatu* odom) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.odom_;
  }
  if (odom) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(odom);
    if (message_arena != submessage_arena) {
      odom = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, odom, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.odom_ = odom;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NavStatu.odom)
}

// string key = 5;
inline void NavStatu::clear_key() {
  _impl_.key_.ClearToEmpty();
}
inline const std::string& NavStatu::key() const {
  // @@protoc_insertion_point(field_get:NavMessage.NavStatu.key)
  return _internal_key();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void NavStatu::set_key(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.key_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NavMessage.NavStatu.key)
}
inline std::string* NavStatu::mutable_key() {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:NavMessage.NavStatu.key)
  return _s;
}
inline const std::string& NavStatu::_internal_key() const {
  return _impl_.key_.Get();
}
inline void NavStatu::_internal_set_key(const std::string& value) {
  ;


  _impl_.key_.Set(value, GetArenaForAllocation());
}
inline std::string* NavStatu::_internal_mutable_key() {
  ;
  return _impl_.key_.Mutable( GetArenaForAllocation());
}
inline std::string* NavStatu::release_key() {
  // @@protoc_insertion_point(field_release:NavMessage.NavStatu.key)
  return _impl_.key_.Release();
}
inline void NavStatu::set_allocated_key(std::string* value) {
  _impl_.key_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.key_.IsDefault()) {
          _impl_.key_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NavStatu.key)
}

// .NavMessage.Trajectory selected_traj = 6;
inline bool NavStatu::has_selected_traj() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.selected_traj_ != nullptr);
  return value;
}
inline void NavStatu::clear_selected_traj() {
  if (_impl_.selected_traj_ != nullptr) _impl_.selected_traj_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::NavMessage::Trajectory& NavStatu::_internal_selected_traj() const {
  const ::NavMessage::Trajectory* p = _impl_.selected_traj_;
  return p != nullptr ? *p : reinterpret_cast<const ::NavMessage::Trajectory&>(
      ::NavMessage::_Trajectory_default_instance_);
}
inline const ::NavMessage::Trajectory& NavStatu::selected_traj() const {
  // @@protoc_insertion_point(field_get:NavMessage.NavStatu.selected_traj)
  return _internal_selected_traj();
}
inline void NavStatu::unsafe_arena_set_allocated_selected_traj(
    ::NavMessage::Trajectory* selected_traj) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.selected_traj_);
  }
  _impl_.selected_traj_ = selected_traj;
  if (selected_traj) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.NavStatu.selected_traj)
}
inline ::NavMessage::Trajectory* NavStatu::release_selected_traj() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::NavMessage::Trajectory* temp = _impl_.selected_traj_;
  _impl_.selected_traj_ = 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 ::NavMessage::Trajectory* NavStatu::unsafe_arena_release_selected_traj() {
  // @@protoc_insertion_point(field_release:NavMessage.NavStatu.selected_traj)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::NavMessage::Trajectory* temp = _impl_.selected_traj_;
  _impl_.selected_traj_ = nullptr;
  return temp;
}
inline ::NavMessage::Trajectory* NavStatu::_internal_mutable_selected_traj() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.selected_traj_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::Trajectory>(GetArenaForAllocation());
    _impl_.selected_traj_ = p;
  }
  return _impl_.selected_traj_;
}
inline ::NavMessage::Trajectory* NavStatu::mutable_selected_traj() {
  ::NavMessage::Trajectory* _msg = _internal_mutable_selected_traj();
  // @@protoc_insertion_point(field_mutable:NavMessage.NavStatu.selected_traj)
  return _msg;
}
inline void NavStatu::set_allocated_selected_traj(::NavMessage::Trajectory* selected_traj) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.selected_traj_;
  }
  if (selected_traj) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(selected_traj);
    if (message_arena != submessage_arena) {
      selected_traj = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, selected_traj, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.selected_traj_ = selected_traj;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NavStatu.selected_traj)
}

// .NavMessage.Trajectory predict_traj = 7;
inline bool NavStatu::has_predict_traj() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.predict_traj_ != nullptr);
  return value;
}
inline void NavStatu::clear_predict_traj() {
  if (_impl_.predict_traj_ != nullptr) _impl_.predict_traj_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::NavMessage::Trajectory& NavStatu::_internal_predict_traj() const {
  const ::NavMessage::Trajectory* p = _impl_.predict_traj_;
  return p != nullptr ? *p : reinterpret_cast<const ::NavMessage::Trajectory&>(
      ::NavMessage::_Trajectory_default_instance_);
}
inline const ::NavMessage::Trajectory& NavStatu::predict_traj() const {
  // @@protoc_insertion_point(field_get:NavMessage.NavStatu.predict_traj)
  return _internal_predict_traj();
}
inline void NavStatu::unsafe_arena_set_allocated_predict_traj(
    ::NavMessage::Trajectory* predict_traj) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.predict_traj_);
  }
  _impl_.predict_traj_ = predict_traj;
  if (predict_traj) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.NavStatu.predict_traj)
}
inline ::NavMessage::Trajectory* NavStatu::release_predict_traj() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::NavMessage::Trajectory* temp = _impl_.predict_traj_;
  _impl_.predict_traj_ = 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 ::NavMessage::Trajectory* NavStatu::unsafe_arena_release_predict_traj() {
  // @@protoc_insertion_point(field_release:NavMessage.NavStatu.predict_traj)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::NavMessage::Trajectory* temp = _impl_.predict_traj_;
  _impl_.predict_traj_ = nullptr;
  return temp;
}
inline ::NavMessage::Trajectory* NavStatu::_internal_mutable_predict_traj() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.predict_traj_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::Trajectory>(GetArenaForAllocation());
    _impl_.predict_traj_ = p;
  }
  return _impl_.predict_traj_;
}
inline ::NavMessage::Trajectory* NavStatu::mutable_predict_traj() {
  ::NavMessage::Trajectory* _msg = _internal_mutable_predict_traj();
  // @@protoc_insertion_point(field_mutable:NavMessage.NavStatu.predict_traj)
  return _msg;
}
inline void NavStatu::set_allocated_predict_traj(::NavMessage::Trajectory* predict_traj) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.predict_traj_;
  }
  if (predict_traj) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(predict_traj);
    if (message_arena != submessage_arena) {
      predict_traj = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, predict_traj, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.predict_traj_ = predict_traj;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NavStatu.predict_traj)
}

// bool in_space = 8;
inline void NavStatu::clear_in_space() {
  _impl_.in_space_ = false;
}
inline bool NavStatu::in_space() const {
  // @@protoc_insertion_point(field_get:NavMessage.NavStatu.in_space)
  return _internal_in_space();
}
inline void NavStatu::set_in_space(bool value) {
  _internal_set_in_space(value);
  // @@protoc_insertion_point(field_set:NavMessage.NavStatu.in_space)
}
inline bool NavStatu::_internal_in_space() const {
  return _impl_.in_space_;
}
inline void NavStatu::_internal_set_in_space(bool value) {
  ;
  _impl_.in_space_ = value;
}

// string space_id = 9;
inline void NavStatu::clear_space_id() {
  _impl_.space_id_.ClearToEmpty();
}
inline const std::string& NavStatu::space_id() const {
  // @@protoc_insertion_point(field_get:NavMessage.NavStatu.space_id)
  return _internal_space_id();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void NavStatu::set_space_id(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.space_id_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NavMessage.NavStatu.space_id)
}
inline std::string* NavStatu::mutable_space_id() {
  std::string* _s = _internal_mutable_space_id();
  // @@protoc_insertion_point(field_mutable:NavMessage.NavStatu.space_id)
  return _s;
}
inline const std::string& NavStatu::_internal_space_id() const {
  return _impl_.space_id_.Get();
}
inline void NavStatu::_internal_set_space_id(const std::string& value) {
  ;


  _impl_.space_id_.Set(value, GetArenaForAllocation());
}
inline std::string* NavStatu::_internal_mutable_space_id() {
  ;
  return _impl_.space_id_.Mutable( GetArenaForAllocation());
}
inline std::string* NavStatu::release_space_id() {
  // @@protoc_insertion_point(field_release:NavMessage.NavStatu.space_id)
  return _impl_.space_id_.Release();
}
inline void NavStatu::set_allocated_space_id(std::string* value) {
  _impl_.space_id_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.space_id_.IsDefault()) {
          _impl_.space_id_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NavStatu.space_id)
}

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

// RobotStatu

// float x = 1;
inline void RobotStatu::clear_x() {
  _impl_.x_ = 0;
}
inline float RobotStatu::x() const {
  // @@protoc_insertion_point(field_get:NavMessage.RobotStatu.x)
  return _internal_x();
}
inline void RobotStatu::set_x(float value) {
  _internal_set_x(value);
  // @@protoc_insertion_point(field_set:NavMessage.RobotStatu.x)
}
inline float RobotStatu::_internal_x() const {
  return _impl_.x_;
}
inline void RobotStatu::_internal_set_x(float value) {
  ;
  _impl_.x_ = value;
}

// float y = 2;
inline void RobotStatu::clear_y() {
  _impl_.y_ = 0;
}
inline float RobotStatu::y() const {
  // @@protoc_insertion_point(field_get:NavMessage.RobotStatu.y)
  return _internal_y();
}
inline void RobotStatu::set_y(float value) {
  _internal_set_y(value);
  // @@protoc_insertion_point(field_set:NavMessage.RobotStatu.y)
}
inline float RobotStatu::_internal_y() const {
  return _impl_.y_;
}
inline void RobotStatu::_internal_set_y(float value) {
  ;
  _impl_.y_ = value;
}

// float theta = 3;
inline void RobotStatu::clear_theta() {
  _impl_.theta_ = 0;
}
inline float RobotStatu::theta() const {
  // @@protoc_insertion_point(field_get:NavMessage.RobotStatu.theta)
  return _internal_theta();
}
inline void RobotStatu::set_theta(float value) {
  _internal_set_theta(value);
  // @@protoc_insertion_point(field_set:NavMessage.RobotStatu.theta)
}
inline float RobotStatu::_internal_theta() const {
  return _impl_.theta_;
}
inline void RobotStatu::_internal_set_theta(float value) {
  ;
  _impl_.theta_ = value;
}

// .NavMessage.AgvStatu agvStatu = 4;
inline bool RobotStatu::has_agvstatu() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.agvstatu_ != nullptr);
  return value;
}
inline void RobotStatu::clear_agvstatu() {
  if (_impl_.agvstatu_ != nullptr) _impl_.agvstatu_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::NavMessage::AgvStatu& RobotStatu::_internal_agvstatu() const {
  const ::NavMessage::AgvStatu* p = _impl_.agvstatu_;
  return p != nullptr ? *p : reinterpret_cast<const ::NavMessage::AgvStatu&>(
      ::NavMessage::_AgvStatu_default_instance_);
}
inline const ::NavMessage::AgvStatu& RobotStatu::agvstatu() const {
  // @@protoc_insertion_point(field_get:NavMessage.RobotStatu.agvStatu)
  return _internal_agvstatu();
}
inline void RobotStatu::unsafe_arena_set_allocated_agvstatu(
    ::NavMessage::AgvStatu* agvstatu) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.agvstatu_);
  }
  _impl_.agvstatu_ = agvstatu;
  if (agvstatu) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.RobotStatu.agvStatu)
}
inline ::NavMessage::AgvStatu* RobotStatu::release_agvstatu() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::NavMessage::AgvStatu* temp = _impl_.agvstatu_;
  _impl_.agvstatu_ = 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 ::NavMessage::AgvStatu* RobotStatu::unsafe_arena_release_agvstatu() {
  // @@protoc_insertion_point(field_release:NavMessage.RobotStatu.agvStatu)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::NavMessage::AgvStatu* temp = _impl_.agvstatu_;
  _impl_.agvstatu_ = nullptr;
  return temp;
}
inline ::NavMessage::AgvStatu* RobotStatu::_internal_mutable_agvstatu() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.agvstatu_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::AgvStatu>(GetArenaForAllocation());
    _impl_.agvstatu_ = p;
  }
  return _impl_.agvstatu_;
}
inline ::NavMessage::AgvStatu* RobotStatu::mutable_agvstatu() {
  ::NavMessage::AgvStatu* _msg = _internal_mutable_agvstatu();
  // @@protoc_insertion_point(field_mutable:NavMessage.RobotStatu.agvStatu)
  return _msg;
}
inline void RobotStatu::set_allocated_agvstatu(::NavMessage::AgvStatu* agvstatu) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.agvstatu_;
  }
  if (agvstatu) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(agvstatu);
    if (message_arena != submessage_arena) {
      agvstatu = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, agvstatu, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.agvstatu_ = agvstatu;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.RobotStatu.agvStatu)
}

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

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


// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"

#endif  // GOOGLE_PROTOBUF_INCLUDED_message_2eproto_2epb_2eh