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

#ifndef GOOGLE_PROTOBUF_INCLUDED_message_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_message_2eproto

#include <limits>
#include <string>

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

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_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 ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[11]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_message_2eproto;
namespace NavMessage {
class AgvStatu;
class AgvStatuDefaultTypeInternal;
extern AgvStatuDefaultTypeInternal _AgvStatu_default_instance_;
class LidarOdomStatu;
class LidarOdomStatuDefaultTypeInternal;
extern LidarOdomStatuDefaultTypeInternal _LidarOdomStatu_default_instance_;
class NavCmd;
class NavCmdDefaultTypeInternal;
extern NavCmdDefaultTypeInternal _NavCmd_default_instance_;
class NavStatu;
class NavStatuDefaultTypeInternal;
extern NavStatuDefaultTypeInternal _NavStatu_default_instance_;
class NewAction;
class NewActionDefaultTypeInternal;
extern NewActionDefaultTypeInternal _NewAction_default_instance_;
class PathNode;
class PathNodeDefaultTypeInternal;
extern PathNodeDefaultTypeInternal _PathNode_default_instance_;
class Pose2d;
class Pose2dDefaultTypeInternal;
extern Pose2dDefaultTypeInternal _Pose2d_default_instance_;
class RobotStatu;
class RobotStatuDefaultTypeInternal;
extern RobotStatuDefaultTypeInternal _RobotStatu_default_instance_;
class SpeedLimit;
class SpeedLimitDefaultTypeInternal;
extern SpeedLimitDefaultTypeInternal _SpeedLimit_default_instance_;
class ToAgvCmd;
class ToAgvCmdDefaultTypeInternal;
extern ToAgvCmdDefaultTypeInternal _ToAgvCmd_default_instance_;
class Trajectory;
class 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::NavCmd* Arena::CreateMaybeMessage<::NavMessage::NavCmd>(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::SpeedLimit* Arena::CreateMaybeMessage<::NavMessage::SpeedLimit>(Arena*);
template<> ::NavMessage::ToAgvCmd* Arena::CreateMaybeMessage<::NavMessage::ToAgvCmd>(Arena*);
template<> ::NavMessage::Trajectory* Arena::CreateMaybeMessage<::NavMessage::Trajectory>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace NavMessage {

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

class LidarOdomStatu PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavMessage.LidarOdomStatu) */ {
 public:
  inline LidarOdomStatu() : LidarOdomStatu(nullptr) {}
  virtual ~LidarOdomStatu();

  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 (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LidarOdomStatu& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  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;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LidarOdomStatu* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline LidarOdomStatu* New() const final {
    return CreateMaybeMessage<LidarOdomStatu>(nullptr);
  }

  LidarOdomStatu* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LidarOdomStatu>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LidarOdomStatu& from);
  void MergeFrom(const LidarOdomStatu& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LidarOdomStatu* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "NavMessage.LidarOdomStatu";
  }
  protected:
  explicit LidarOdomStatu(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // 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_;
  float x_;
  float y_;
  float theta_;
  float v_;
  float vth_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class AgvStatu PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavMessage.AgvStatu) */ {
 public:
  inline AgvStatu() : AgvStatu(nullptr) {}
  virtual ~AgvStatu();

  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 (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AgvStatu& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  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;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AgvStatu* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AgvStatu* New() const final {
    return CreateMaybeMessage<AgvStatu>(nullptr);
  }

  AgvStatu* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AgvStatu>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AgvStatu& from);
  void MergeFrom(const AgvStatu& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AgvStatu* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "NavMessage.AgvStatu";
  }
  protected:
  explicit AgvStatu(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kVFieldNumber = 1,
    kWFieldNumber = 2,
    kClampFieldNumber = 3,
    kClampOtherFieldNumber = 4,
  };
  // 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();
  ::PROTOBUF_NAMESPACE_ID::int32 clamp() const;
  void set_clamp(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_clamp() const;
  void _internal_set_clamp(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 clamp_other = 4;
  void clear_clamp_other();
  ::PROTOBUF_NAMESPACE_ID::int32 clamp_other() const;
  void set_clamp_other(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_clamp_other() const;
  void _internal_set_clamp_other(::PROTOBUF_NAMESPACE_ID::int32 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_;
  float v_;
  float w_;
  ::PROTOBUF_NAMESPACE_ID::int32 clamp_;
  ::PROTOBUF_NAMESPACE_ID::int32 clamp_other_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class ToAgvCmd PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavMessage.ToAgvCmd) */ {
 public:
  inline ToAgvCmd() : ToAgvCmd(nullptr) {}
  virtual ~ToAgvCmd();

  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 (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ToAgvCmd& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  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;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ToAgvCmd* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline ToAgvCmd* New() const final {
    return CreateMaybeMessage<ToAgvCmd>(nullptr);
  }

  ToAgvCmd* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ToAgvCmd>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ToAgvCmd& from);
  void MergeFrom(const ToAgvCmd& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ToAgvCmd* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "NavMessage.ToAgvCmd";
  }
  protected:
  explicit ToAgvCmd(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kHFieldNumber = 1,
    kMFieldNumber = 2,
    kTFieldNumber = 3,
    kVFieldNumber = 4,
    kWFieldNumber = 5,
    kLFieldNumber = 6,
    kEndFieldNumber = 7,
  };
  // int32 H = 1;
  void clear_h();
  ::PROTOBUF_NAMESPACE_ID::int32 h() const;
  void set_h(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_h() const;
  void _internal_set_h(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 M = 2;
  void clear_m();
  ::PROTOBUF_NAMESPACE_ID::int32 m() const;
  void set_m(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_m() const;
  void _internal_set_m(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 T = 3;
  void clear_t();
  ::PROTOBUF_NAMESPACE_ID::int32 t() const;
  void set_t(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_t() const;
  void _internal_set_t(::PROTOBUF_NAMESPACE_ID::int32 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 W = 5;
  void clear_w();
  float w() const;
  void set_w(float value);
  private:
  float _internal_w() const;
  void _internal_set_w(float value);
  public:

  // float L = 6;
  void clear_l();
  float l() const;
  void set_l(float value);
  private:
  float _internal_l() const;
  void _internal_set_l(float value);
  public:

  // int32 end = 7;
  void clear_end();
  ::PROTOBUF_NAMESPACE_ID::int32 end() const;
  void set_end(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_end() const;
  void _internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 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_;
  ::PROTOBUF_NAMESPACE_ID::int32 h_;
  ::PROTOBUF_NAMESPACE_ID::int32 m_;
  ::PROTOBUF_NAMESPACE_ID::int32 t_;
  float v_;
  float w_;
  float l_;
  ::PROTOBUF_NAMESPACE_ID::int32 end_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class SpeedLimit PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavMessage.SpeedLimit) */ {
 public:
  inline SpeedLimit() : SpeedLimit(nullptr) {}
  virtual ~SpeedLimit();

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

  inline SpeedLimit& operator=(const SpeedLimit& from) {
    CopyFrom(from);
    return *this;
  }
  inline SpeedLimit& operator=(SpeedLimit&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SpeedLimit& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SpeedLimit* internal_default_instance() {
    return reinterpret_cast<const SpeedLimit*>(
               &_SpeedLimit_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

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

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

  inline SpeedLimit* New() const final {
    return CreateMaybeMessage<SpeedLimit>(nullptr);
  }

  SpeedLimit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SpeedLimit>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SpeedLimit& from);
  void MergeFrom(const SpeedLimit& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SpeedLimit* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "NavMessage.SpeedLimit";
  }
  protected:
  explicit SpeedLimit(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kMinFieldNumber = 1,
    kMaxFieldNumber = 2,
  };
  // float min = 1;
  void clear_min();
  float min() const;
  void set_min(float value);
  private:
  float _internal_min() const;
  void _internal_set_min(float value);
  public:

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

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

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

class Pose2d PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavMessage.Pose2d) */ {
 public:
  inline Pose2d() : Pose2d(nullptr) {}
  virtual ~Pose2d();

  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 (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Pose2d& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Pose2d* internal_default_instance() {
    return reinterpret_cast<const Pose2d*>(
               &_Pose2d_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

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

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

  inline Pose2d* New() const final {
    return CreateMaybeMessage<Pose2d>(nullptr);
  }

  Pose2d* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Pose2d>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Pose2d& from);
  void MergeFrom(const Pose2d& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Pose2d* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "NavMessage.Pose2d";
  }
  protected:
  explicit Pose2d(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // 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_;
  float x_;
  float y_;
  float theta_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class PathNode PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavMessage.PathNode) */ {
 public:
  inline PathNode() : PathNode(nullptr) {}
  virtual ~PathNode();

  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 (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const PathNode& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PathNode* internal_default_instance() {
    return reinterpret_cast<const PathNode*>(
               &_PathNode_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

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

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

  inline PathNode* New() const final {
    return CreateMaybeMessage<PathNode>(nullptr);
  }

  PathNode* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PathNode>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PathNode& from);
  void MergeFrom(const PathNode& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PathNode* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "NavMessage.PathNode";
  }
  protected:
  explicit PathNode(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kPoseFieldNumber = 1,
    kAccuracyFieldNumber = 2,
  };
  // .NavMessage.Pose2d pose = 1;
  bool has_pose() const;
  private:
  bool _internal_has_pose() const;
  public:
  void clear_pose();
  const ::NavMessage::Pose2d& pose() const;
  ::NavMessage::Pose2d* release_pose();
  ::NavMessage::Pose2d* mutable_pose();
  void set_allocated_pose(::NavMessage::Pose2d* pose);
  private:
  const ::NavMessage::Pose2d& _internal_pose() const;
  ::NavMessage::Pose2d* _internal_mutable_pose();
  public:
  void unsafe_arena_set_allocated_pose(
      ::NavMessage::Pose2d* pose);
  ::NavMessage::Pose2d* unsafe_arena_release_pose();

  // .NavMessage.Pose2d accuracy = 2;
  bool has_accuracy() const;
  private:
  bool _internal_has_accuracy() const;
  public:
  void clear_accuracy();
  const ::NavMessage::Pose2d& accuracy() const;
  ::NavMessage::Pose2d* release_accuracy();
  ::NavMessage::Pose2d* mutable_accuracy();
  void set_allocated_accuracy(::NavMessage::Pose2d* accuracy);
  private:
  const ::NavMessage::Pose2d& _internal_accuracy() const;
  ::NavMessage::Pose2d* _internal_mutable_accuracy();
  public:
  void unsafe_arena_set_allocated_accuracy(
      ::NavMessage::Pose2d* accuracy);
  ::NavMessage::Pose2d* unsafe_arena_release_accuracy();

  // @@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_;
  ::NavMessage::Pose2d* pose_;
  ::NavMessage::Pose2d* accuracy_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class Trajectory PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavMessage.Trajectory) */ {
 public:
  inline Trajectory() : Trajectory(nullptr) {}
  virtual ~Trajectory();

  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 (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Trajectory& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Trajectory* internal_default_instance() {
    return reinterpret_cast<const Trajectory*>(
               &_Trajectory_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

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

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

  inline Trajectory* New() const final {
    return CreateMaybeMessage<Trajectory>(nullptr);
  }

  Trajectory* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Trajectory>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Trajectory& from);
  void MergeFrom(const Trajectory& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Trajectory* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "NavMessage.Trajectory";
  }
  protected:
  explicit Trajectory(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // 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();
  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_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::Pose2d > poses_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class NewAction PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavMessage.NewAction) */ {
 public:
  inline NewAction() : NewAction(nullptr) {}
  virtual ~NewAction();

  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 (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const NewAction& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const NewAction* internal_default_instance() {
    return reinterpret_cast<const NewAction*>(
               &_NewAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

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

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

  inline NewAction* New() const final {
    return CreateMaybeMessage<NewAction>(nullptr);
  }

  NewAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<NewAction>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const NewAction& from);
  void MergeFrom(const NewAction& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NewAction* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "NavMessage.NewAction";
  }
  protected:
  explicit NewAction(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kPathNodesFieldNumber = 5,
    kSpaceNodeFieldNumber = 2,
    kPassNodeFieldNumber = 3,
    kStreetNodeFieldNumber = 4,
    kInOutVLimitFieldNumber = 6,
    kNodeVelocityLimitFieldNumber = 7,
    kNodeAngularLimitFieldNumber = 8,
    kAdjustVelocitylimitFieldNumber = 9,
    kAdjustHorizonLimitFieldNumber = 10,
    kTypeFieldNumber = 1,
    kWheelbaseFieldNumber = 11,
    kChangedModeFieldNumber = 12,
  };
  // 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();
  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;
  private:
  bool _internal_has_spacenode() const;
  public:
  void clear_spacenode();
  const ::NavMessage::PathNode& spacenode() const;
  ::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;
  private:
  bool _internal_has_passnode() const;
  public:
  void clear_passnode();
  const ::NavMessage::PathNode& passnode() const;
  ::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;
  private:
  bool _internal_has_streetnode() const;
  public:
  void clear_streetnode();
  const ::NavMessage::PathNode& streetnode() const;
  ::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();

  // .NavMessage.SpeedLimit InOutVLimit = 6;
  bool has_inoutvlimit() const;
  private:
  bool _internal_has_inoutvlimit() const;
  public:
  void clear_inoutvlimit();
  const ::NavMessage::SpeedLimit& inoutvlimit() const;
  ::NavMessage::SpeedLimit* release_inoutvlimit();
  ::NavMessage::SpeedLimit* mutable_inoutvlimit();
  void set_allocated_inoutvlimit(::NavMessage::SpeedLimit* inoutvlimit);
  private:
  const ::NavMessage::SpeedLimit& _internal_inoutvlimit() const;
  ::NavMessage::SpeedLimit* _internal_mutable_inoutvlimit();
  public:
  void unsafe_arena_set_allocated_inoutvlimit(
      ::NavMessage::SpeedLimit* inoutvlimit);
  ::NavMessage::SpeedLimit* unsafe_arena_release_inoutvlimit();

  // .NavMessage.SpeedLimit NodeVelocityLimit = 7;
  bool has_nodevelocitylimit() const;
  private:
  bool _internal_has_nodevelocitylimit() const;
  public:
  void clear_nodevelocitylimit();
  const ::NavMessage::SpeedLimit& nodevelocitylimit() const;
  ::NavMessage::SpeedLimit* release_nodevelocitylimit();
  ::NavMessage::SpeedLimit* mutable_nodevelocitylimit();
  void set_allocated_nodevelocitylimit(::NavMessage::SpeedLimit* nodevelocitylimit);
  private:
  const ::NavMessage::SpeedLimit& _internal_nodevelocitylimit() const;
  ::NavMessage::SpeedLimit* _internal_mutable_nodevelocitylimit();
  public:
  void unsafe_arena_set_allocated_nodevelocitylimit(
      ::NavMessage::SpeedLimit* nodevelocitylimit);
  ::NavMessage::SpeedLimit* unsafe_arena_release_nodevelocitylimit();

  // .NavMessage.SpeedLimit NodeAngularLimit = 8;
  bool has_nodeangularlimit() const;
  private:
  bool _internal_has_nodeangularlimit() const;
  public:
  void clear_nodeangularlimit();
  const ::NavMessage::SpeedLimit& nodeangularlimit() const;
  ::NavMessage::SpeedLimit* release_nodeangularlimit();
  ::NavMessage::SpeedLimit* mutable_nodeangularlimit();
  void set_allocated_nodeangularlimit(::NavMessage::SpeedLimit* nodeangularlimit);
  private:
  const ::NavMessage::SpeedLimit& _internal_nodeangularlimit() const;
  ::NavMessage::SpeedLimit* _internal_mutable_nodeangularlimit();
  public:
  void unsafe_arena_set_allocated_nodeangularlimit(
      ::NavMessage::SpeedLimit* nodeangularlimit);
  ::NavMessage::SpeedLimit* unsafe_arena_release_nodeangularlimit();

  // .NavMessage.SpeedLimit adjustVelocitylimit = 9;
  bool has_adjustvelocitylimit() const;
  private:
  bool _internal_has_adjustvelocitylimit() const;
  public:
  void clear_adjustvelocitylimit();
  const ::NavMessage::SpeedLimit& adjustvelocitylimit() const;
  ::NavMessage::SpeedLimit* release_adjustvelocitylimit();
  ::NavMessage::SpeedLimit* mutable_adjustvelocitylimit();
  void set_allocated_adjustvelocitylimit(::NavMessage::SpeedLimit* adjustvelocitylimit);
  private:
  const ::NavMessage::SpeedLimit& _internal_adjustvelocitylimit() const;
  ::NavMessage::SpeedLimit* _internal_mutable_adjustvelocitylimit();
  public:
  void unsafe_arena_set_allocated_adjustvelocitylimit(
      ::NavMessage::SpeedLimit* adjustvelocitylimit);
  ::NavMessage::SpeedLimit* unsafe_arena_release_adjustvelocitylimit();

  // .NavMessage.SpeedLimit adjustHorizonLimit = 10;
  bool has_adjusthorizonlimit() const;
  private:
  bool _internal_has_adjusthorizonlimit() const;
  public:
  void clear_adjusthorizonlimit();
  const ::NavMessage::SpeedLimit& adjusthorizonlimit() const;
  ::NavMessage::SpeedLimit* release_adjusthorizonlimit();
  ::NavMessage::SpeedLimit* mutable_adjusthorizonlimit();
  void set_allocated_adjusthorizonlimit(::NavMessage::SpeedLimit* adjusthorizonlimit);
  private:
  const ::NavMessage::SpeedLimit& _internal_adjusthorizonlimit() const;
  ::NavMessage::SpeedLimit* _internal_mutable_adjusthorizonlimit();
  public:
  void unsafe_arena_set_allocated_adjusthorizonlimit(
      ::NavMessage::SpeedLimit* adjusthorizonlimit);
  ::NavMessage::SpeedLimit* unsafe_arena_release_adjusthorizonlimit();

  // int32 type = 1;
  void clear_type();
  ::PROTOBUF_NAMESPACE_ID::int32 type() const;
  void set_type(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_type() const;
  void _internal_set_type(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // float wheelbase = 11;
  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 = 12;
  void clear_changedmode();
  ::PROTOBUF_NAMESPACE_ID::int32 changedmode() const;
  void set_changedmode(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_changedmode() const;
  void _internal_set_changedmode(::PROTOBUF_NAMESPACE_ID::int32 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_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::PathNode > pathnodes_;
  ::NavMessage::PathNode* spacenode_;
  ::NavMessage::PathNode* passnode_;
  ::NavMessage::PathNode* streetnode_;
  ::NavMessage::SpeedLimit* inoutvlimit_;
  ::NavMessage::SpeedLimit* nodevelocitylimit_;
  ::NavMessage::SpeedLimit* nodeangularlimit_;
  ::NavMessage::SpeedLimit* adjustvelocitylimit_;
  ::NavMessage::SpeedLimit* adjusthorizonlimit_;
  ::PROTOBUF_NAMESPACE_ID::int32 type_;
  float wheelbase_;
  ::PROTOBUF_NAMESPACE_ID::int32 changedmode_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class NavCmd PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavMessage.NavCmd) */ {
 public:
  inline NavCmd() : NavCmd(nullptr) {}
  virtual ~NavCmd();

  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 (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const NavCmd& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const NavCmd* internal_default_instance() {
    return reinterpret_cast<const NavCmd*>(
               &_NavCmd_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

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

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

  inline NavCmd* New() const final {
    return CreateMaybeMessage<NavCmd>(nullptr);
  }

  NavCmd* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<NavCmd>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const NavCmd& from);
  void MergeFrom(const NavCmd& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NavCmd* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "NavMessage.NavCmd";
  }
  protected:
  explicit NavCmd(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kNewActionsFieldNumber = 5,
    kKeyFieldNumber = 2,
    kActionFieldNumber = 1,
  };
  // 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();
  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;
  void set_key(const std::string& value);
  void set_key(std::string&& value);
  void set_key(const char* value);
  void set_key(const char* value, size_t size);
  std::string* mutable_key();
  std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

  // int32 action = 1;
  void clear_action();
  ::PROTOBUF_NAMESPACE_ID::int32 action() const;
  void set_action(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_action() const;
  void _internal_set_action(::PROTOBUF_NAMESPACE_ID::int32 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_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::NewAction > newactions_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
  ::PROTOBUF_NAMESPACE_ID::int32 action_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class NavStatu PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavMessage.NavStatu) */ {
 public:
  inline NavStatu() : NavStatu(nullptr) {}
  virtual ~NavStatu();

  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 (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const NavStatu& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const NavStatu* internal_default_instance() {
    return reinterpret_cast<const NavStatu*>(
               &_NavStatu_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

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

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

  inline NavStatu* New() const final {
    return CreateMaybeMessage<NavStatu>(nullptr);
  }

  NavStatu* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<NavStatu>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const NavStatu& from);
  void MergeFrom(const NavStatu& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NavStatu* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "NavMessage.NavStatu";
  }
  protected:
  explicit NavStatu(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kKeyFieldNumber = 4,
    kSelectedTrajFieldNumber = 6,
    kPredictTrajFieldNumber = 7,
    kStatuFieldNumber = 1,
    kMainAgvFieldNumber = 2,
    kMoveModeFieldNumber = 3,
  };
  // string key = 4;
  void clear_key();
  const std::string& key() const;
  void set_key(const std::string& value);
  void set_key(std::string&& value);
  void set_key(const char* value);
  void set_key(const char* value, size_t size);
  std::string* mutable_key();
  std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

  // .NavMessage.Trajectory selected_traj = 6;
  bool has_selected_traj() const;
  private:
  bool _internal_has_selected_traj() const;
  public:
  void clear_selected_traj();
  const ::NavMessage::Trajectory& selected_traj() const;
  ::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;
  private:
  bool _internal_has_predict_traj() const;
  public:
  void clear_predict_traj();
  const ::NavMessage::Trajectory& predict_traj() const;
  ::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();
  ::PROTOBUF_NAMESPACE_ID::int32 statu() const;
  void set_statu(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_statu() const;
  void _internal_set_statu(::PROTOBUF_NAMESPACE_ID::int32 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:

  // int32 move_mode = 3;
  void clear_move_mode();
  ::PROTOBUF_NAMESPACE_ID::int32 move_mode() const;
  void set_move_mode(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_move_mode() const;
  void _internal_set_move_mode(::PROTOBUF_NAMESPACE_ID::int32 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_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
  ::NavMessage::Trajectory* selected_traj_;
  ::NavMessage::Trajectory* predict_traj_;
  ::PROTOBUF_NAMESPACE_ID::int32 statu_;
  bool main_agv_;
  ::PROTOBUF_NAMESPACE_ID::int32 move_mode_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class RobotStatu PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavMessage.RobotStatu) */ {
 public:
  inline RobotStatu() : RobotStatu(nullptr) {}
  virtual ~RobotStatu();

  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 (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RobotStatu& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RobotStatu* internal_default_instance() {
    return reinterpret_cast<const RobotStatu*>(
               &_RobotStatu_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

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

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

  inline RobotStatu* New() const final {
    return CreateMaybeMessage<RobotStatu>(nullptr);
  }

  RobotStatu* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RobotStatu>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RobotStatu& from);
  void MergeFrom(const RobotStatu& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RobotStatu* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "NavMessage.RobotStatu";
  }
  protected:
  explicit RobotStatu(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kAgvStatuFieldNumber = 4,
    kXFieldNumber = 1,
    kYFieldNumber = 2,
    kThetaFieldNumber = 3,
  };
  // .NavMessage.AgvStatu agvStatu = 4;
  bool has_agvstatu() const;
  private:
  bool _internal_has_agvstatu() const;
  public:
  void clear_agvstatu();
  const ::NavMessage::AgvStatu& agvstatu() const;
  ::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_;
  ::NavMessage::AgvStatu* agvstatu_;
  float x_;
  float y_;
  float theta_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  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() {
  x_ = 0;
}
inline float LidarOdomStatu::_internal_x() const {
  return x_;
}
inline float LidarOdomStatu::x() const {
  // @@protoc_insertion_point(field_get:NavMessage.LidarOdomStatu.x)
  return _internal_x();
}
inline void LidarOdomStatu::_internal_set_x(float value) {
  
  x_ = value;
}
inline void LidarOdomStatu::set_x(float value) {
  _internal_set_x(value);
  // @@protoc_insertion_point(field_set:NavMessage.LidarOdomStatu.x)
}

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

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

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

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

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

// AgvStatu

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

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

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

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

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

// ToAgvCmd

// int32 H = 1;
inline void ToAgvCmd::clear_h() {
  h_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ToAgvCmd::_internal_h() const {
  return h_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ToAgvCmd::h() const {
  // @@protoc_insertion_point(field_get:NavMessage.ToAgvCmd.H)
  return _internal_h();
}
inline void ToAgvCmd::_internal_set_h(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  h_ = value;
}
inline void ToAgvCmd::set_h(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_h(value);
  // @@protoc_insertion_point(field_set:NavMessage.ToAgvCmd.H)
}

// int32 M = 2;
inline void ToAgvCmd::clear_m() {
  m_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ToAgvCmd::_internal_m() const {
  return m_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ToAgvCmd::m() const {
  // @@protoc_insertion_point(field_get:NavMessage.ToAgvCmd.M)
  return _internal_m();
}
inline void ToAgvCmd::_internal_set_m(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  m_ = value;
}
inline void ToAgvCmd::set_m(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_m(value);
  // @@protoc_insertion_point(field_set:NavMessage.ToAgvCmd.M)
}

// int32 T = 3;
inline void ToAgvCmd::clear_t() {
  t_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ToAgvCmd::_internal_t() const {
  return t_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ToAgvCmd::t() const {
  // @@protoc_insertion_point(field_get:NavMessage.ToAgvCmd.T)
  return _internal_t();
}
inline void ToAgvCmd::_internal_set_t(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  t_ = value;
}
inline void ToAgvCmd::set_t(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_t(value);
  // @@protoc_insertion_point(field_set:NavMessage.ToAgvCmd.T)
}

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

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

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

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

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

// SpeedLimit

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

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

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

// Pose2d

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

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

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

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

// PathNode

// .NavMessage.Pose2d pose = 1;
inline bool PathNode::_internal_has_pose() const {
  return this != internal_default_instance() && pose_ != nullptr;
}
inline bool PathNode::has_pose() const {
  return _internal_has_pose();
}
inline void PathNode::clear_pose() {
  if (GetArena() == nullptr && pose_ != nullptr) {
    delete pose_;
  }
  pose_ = nullptr;
}
inline const ::NavMessage::Pose2d& PathNode::_internal_pose() const {
  const ::NavMessage::Pose2d* p = pose_;
  return p != nullptr ? *p : *reinterpret_cast<const ::NavMessage::Pose2d*>(
      &::NavMessage::_Pose2d_default_instance_);
}
inline const ::NavMessage::Pose2d& PathNode::pose() const {
  // @@protoc_insertion_point(field_get:NavMessage.PathNode.pose)
  return _internal_pose();
}
inline void PathNode::unsafe_arena_set_allocated_pose(
    ::NavMessage::Pose2d* pose) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(pose_);
  }
  pose_ = pose;
  if (pose) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.PathNode.pose)
}
inline ::NavMessage::Pose2d* PathNode::release_pose() {
  
  ::NavMessage::Pose2d* temp = pose_;
  pose_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::NavMessage::Pose2d* PathNode::unsafe_arena_release_pose() {
  // @@protoc_insertion_point(field_release:NavMessage.PathNode.pose)
  
  ::NavMessage::Pose2d* temp = pose_;
  pose_ = nullptr;
  return temp;
}
inline ::NavMessage::Pose2d* PathNode::_internal_mutable_pose() {
  
  if (pose_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::Pose2d>(GetArena());
    pose_ = p;
  }
  return pose_;
}
inline ::NavMessage::Pose2d* PathNode::mutable_pose() {
  // @@protoc_insertion_point(field_mutable:NavMessage.PathNode.pose)
  return _internal_mutable_pose();
}
inline void PathNode::set_allocated_pose(::NavMessage::Pose2d* pose) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete pose_;
  }
  if (pose) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(pose);
    if (message_arena != submessage_arena) {
      pose = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, pose, submessage_arena);
    }
    
  } else {
    
  }
  pose_ = pose;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.PathNode.pose)
}

// .NavMessage.Pose2d accuracy = 2;
inline bool PathNode::_internal_has_accuracy() const {
  return this != internal_default_instance() && accuracy_ != nullptr;
}
inline bool PathNode::has_accuracy() const {
  return _internal_has_accuracy();
}
inline void PathNode::clear_accuracy() {
  if (GetArena() == nullptr && accuracy_ != nullptr) {
    delete accuracy_;
  }
  accuracy_ = nullptr;
}
inline const ::NavMessage::Pose2d& PathNode::_internal_accuracy() const {
  const ::NavMessage::Pose2d* p = accuracy_;
  return p != nullptr ? *p : *reinterpret_cast<const ::NavMessage::Pose2d*>(
      &::NavMessage::_Pose2d_default_instance_);
}
inline const ::NavMessage::Pose2d& PathNode::accuracy() const {
  // @@protoc_insertion_point(field_get:NavMessage.PathNode.accuracy)
  return _internal_accuracy();
}
inline void PathNode::unsafe_arena_set_allocated_accuracy(
    ::NavMessage::Pose2d* accuracy) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(accuracy_);
  }
  accuracy_ = accuracy;
  if (accuracy) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.PathNode.accuracy)
}
inline ::NavMessage::Pose2d* PathNode::release_accuracy() {
  
  ::NavMessage::Pose2d* temp = accuracy_;
  accuracy_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::NavMessage::Pose2d* PathNode::unsafe_arena_release_accuracy() {
  // @@protoc_insertion_point(field_release:NavMessage.PathNode.accuracy)
  
  ::NavMessage::Pose2d* temp = accuracy_;
  accuracy_ = nullptr;
  return temp;
}
inline ::NavMessage::Pose2d* PathNode::_internal_mutable_accuracy() {
  
  if (accuracy_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::Pose2d>(GetArena());
    accuracy_ = p;
  }
  return accuracy_;
}
inline ::NavMessage::Pose2d* PathNode::mutable_accuracy() {
  // @@protoc_insertion_point(field_mutable:NavMessage.PathNode.accuracy)
  return _internal_mutable_accuracy();
}
inline void PathNode::set_allocated_accuracy(::NavMessage::Pose2d* accuracy) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete accuracy_;
  }
  if (accuracy) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(accuracy);
    if (message_arena != submessage_arena) {
      accuracy = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, accuracy, submessage_arena);
    }
    
  } else {
    
  }
  accuracy_ = accuracy;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.PathNode.accuracy)
}

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

// Trajectory

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

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

// NewAction

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

// .NavMessage.PathNode spaceNode = 2;
inline bool NewAction::_internal_has_spacenode() const {
  return this != internal_default_instance() && spacenode_ != nullptr;
}
inline bool NewAction::has_spacenode() const {
  return _internal_has_spacenode();
}
inline void NewAction::clear_spacenode() {
  if (GetArena() == nullptr && spacenode_ != nullptr) {
    delete spacenode_;
  }
  spacenode_ = nullptr;
}
inline const ::NavMessage::PathNode& NewAction::_internal_spacenode() const {
  const ::NavMessage::PathNode* p = 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 (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(spacenode_);
  }
  spacenode_ = spacenode;
  if (spacenode) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.NewAction.spaceNode)
}
inline ::NavMessage::PathNode* NewAction::release_spacenode() {
  
  ::NavMessage::PathNode* temp = spacenode_;
  spacenode_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::NavMessage::PathNode* NewAction::unsafe_arena_release_spacenode() {
  // @@protoc_insertion_point(field_release:NavMessage.NewAction.spaceNode)
  
  ::NavMessage::PathNode* temp = spacenode_;
  spacenode_ = nullptr;
  return temp;
}
inline ::NavMessage::PathNode* NewAction::_internal_mutable_spacenode() {
  
  if (spacenode_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::PathNode>(GetArena());
    spacenode_ = p;
  }
  return spacenode_;
}
inline ::NavMessage::PathNode* NewAction::mutable_spacenode() {
  // @@protoc_insertion_point(field_mutable:NavMessage.NewAction.spaceNode)
  return _internal_mutable_spacenode();
}
inline void NewAction::set_allocated_spacenode(::NavMessage::PathNode* spacenode) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete spacenode_;
  }
  if (spacenode) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(spacenode);
    if (message_arena != submessage_arena) {
      spacenode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, spacenode, submessage_arena);
    }
    
  } else {
    
  }
  spacenode_ = spacenode;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NewAction.spaceNode)
}

// .NavMessage.PathNode passNode = 3;
inline bool NewAction::_internal_has_passnode() const {
  return this != internal_default_instance() && passnode_ != nullptr;
}
inline bool NewAction::has_passnode() const {
  return _internal_has_passnode();
}
inline void NewAction::clear_passnode() {
  if (GetArena() == nullptr && passnode_ != nullptr) {
    delete passnode_;
  }
  passnode_ = nullptr;
}
inline const ::NavMessage::PathNode& NewAction::_internal_passnode() const {
  const ::NavMessage::PathNode* p = 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 (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(passnode_);
  }
  passnode_ = passnode;
  if (passnode) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.NewAction.passNode)
}
inline ::NavMessage::PathNode* NewAction::release_passnode() {
  
  ::NavMessage::PathNode* temp = passnode_;
  passnode_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::NavMessage::PathNode* NewAction::unsafe_arena_release_passnode() {
  // @@protoc_insertion_point(field_release:NavMessage.NewAction.passNode)
  
  ::NavMessage::PathNode* temp = passnode_;
  passnode_ = nullptr;
  return temp;
}
inline ::NavMessage::PathNode* NewAction::_internal_mutable_passnode() {
  
  if (passnode_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::PathNode>(GetArena());
    passnode_ = p;
  }
  return passnode_;
}
inline ::NavMessage::PathNode* NewAction::mutable_passnode() {
  // @@protoc_insertion_point(field_mutable:NavMessage.NewAction.passNode)
  return _internal_mutable_passnode();
}
inline void NewAction::set_allocated_passnode(::NavMessage::PathNode* passnode) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete passnode_;
  }
  if (passnode) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(passnode);
    if (message_arena != submessage_arena) {
      passnode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, passnode, submessage_arena);
    }
    
  } else {
    
  }
  passnode_ = passnode;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NewAction.passNode)
}

// .NavMessage.PathNode streetNode = 4;
inline bool NewAction::_internal_has_streetnode() const {
  return this != internal_default_instance() && streetnode_ != nullptr;
}
inline bool NewAction::has_streetnode() const {
  return _internal_has_streetnode();
}
inline void NewAction::clear_streetnode() {
  if (GetArena() == nullptr && streetnode_ != nullptr) {
    delete streetnode_;
  }
  streetnode_ = nullptr;
}
inline const ::NavMessage::PathNode& NewAction::_internal_streetnode() const {
  const ::NavMessage::PathNode* p = 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 (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(streetnode_);
  }
  streetnode_ = streetnode;
  if (streetnode) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.NewAction.streetNode)
}
inline ::NavMessage::PathNode* NewAction::release_streetnode() {
  
  ::NavMessage::PathNode* temp = streetnode_;
  streetnode_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::NavMessage::PathNode* NewAction::unsafe_arena_release_streetnode() {
  // @@protoc_insertion_point(field_release:NavMessage.NewAction.streetNode)
  
  ::NavMessage::PathNode* temp = streetnode_;
  streetnode_ = nullptr;
  return temp;
}
inline ::NavMessage::PathNode* NewAction::_internal_mutable_streetnode() {
  
  if (streetnode_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::PathNode>(GetArena());
    streetnode_ = p;
  }
  return streetnode_;
}
inline ::NavMessage::PathNode* NewAction::mutable_streetnode() {
  // @@protoc_insertion_point(field_mutable:NavMessage.NewAction.streetNode)
  return _internal_mutable_streetnode();
}
inline void NewAction::set_allocated_streetnode(::NavMessage::PathNode* streetnode) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete streetnode_;
  }
  if (streetnode) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(streetnode);
    if (message_arena != submessage_arena) {
      streetnode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, streetnode, submessage_arena);
    }
    
  } else {
    
  }
  streetnode_ = streetnode;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NewAction.streetNode)
}

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

// .NavMessage.SpeedLimit InOutVLimit = 6;
inline bool NewAction::_internal_has_inoutvlimit() const {
  return this != internal_default_instance() && inoutvlimit_ != nullptr;
}
inline bool NewAction::has_inoutvlimit() const {
  return _internal_has_inoutvlimit();
}
inline void NewAction::clear_inoutvlimit() {
  if (GetArena() == nullptr && inoutvlimit_ != nullptr) {
    delete inoutvlimit_;
  }
  inoutvlimit_ = nullptr;
}
inline const ::NavMessage::SpeedLimit& NewAction::_internal_inoutvlimit() const {
  const ::NavMessage::SpeedLimit* p = inoutvlimit_;
  return p != nullptr ? *p : *reinterpret_cast<const ::NavMessage::SpeedLimit*>(
      &::NavMessage::_SpeedLimit_default_instance_);
}
inline const ::NavMessage::SpeedLimit& NewAction::inoutvlimit() const {
  // @@protoc_insertion_point(field_get:NavMessage.NewAction.InOutVLimit)
  return _internal_inoutvlimit();
}
inline void NewAction::unsafe_arena_set_allocated_inoutvlimit(
    ::NavMessage::SpeedLimit* inoutvlimit) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(inoutvlimit_);
  }
  inoutvlimit_ = inoutvlimit;
  if (inoutvlimit) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.NewAction.InOutVLimit)
}
inline ::NavMessage::SpeedLimit* NewAction::release_inoutvlimit() {
  
  ::NavMessage::SpeedLimit* temp = inoutvlimit_;
  inoutvlimit_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::NavMessage::SpeedLimit* NewAction::unsafe_arena_release_inoutvlimit() {
  // @@protoc_insertion_point(field_release:NavMessage.NewAction.InOutVLimit)
  
  ::NavMessage::SpeedLimit* temp = inoutvlimit_;
  inoutvlimit_ = nullptr;
  return temp;
}
inline ::NavMessage::SpeedLimit* NewAction::_internal_mutable_inoutvlimit() {
  
  if (inoutvlimit_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::SpeedLimit>(GetArena());
    inoutvlimit_ = p;
  }
  return inoutvlimit_;
}
inline ::NavMessage::SpeedLimit* NewAction::mutable_inoutvlimit() {
  // @@protoc_insertion_point(field_mutable:NavMessage.NewAction.InOutVLimit)
  return _internal_mutable_inoutvlimit();
}
inline void NewAction::set_allocated_inoutvlimit(::NavMessage::SpeedLimit* inoutvlimit) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete inoutvlimit_;
  }
  if (inoutvlimit) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(inoutvlimit);
    if (message_arena != submessage_arena) {
      inoutvlimit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, inoutvlimit, submessage_arena);
    }
    
  } else {
    
  }
  inoutvlimit_ = inoutvlimit;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NewAction.InOutVLimit)
}

// .NavMessage.SpeedLimit NodeVelocityLimit = 7;
inline bool NewAction::_internal_has_nodevelocitylimit() const {
  return this != internal_default_instance() && nodevelocitylimit_ != nullptr;
}
inline bool NewAction::has_nodevelocitylimit() const {
  return _internal_has_nodevelocitylimit();
}
inline void NewAction::clear_nodevelocitylimit() {
  if (GetArena() == nullptr && nodevelocitylimit_ != nullptr) {
    delete nodevelocitylimit_;
  }
  nodevelocitylimit_ = nullptr;
}
inline const ::NavMessage::SpeedLimit& NewAction::_internal_nodevelocitylimit() const {
  const ::NavMessage::SpeedLimit* p = nodevelocitylimit_;
  return p != nullptr ? *p : *reinterpret_cast<const ::NavMessage::SpeedLimit*>(
      &::NavMessage::_SpeedLimit_default_instance_);
}
inline const ::NavMessage::SpeedLimit& NewAction::nodevelocitylimit() const {
  // @@protoc_insertion_point(field_get:NavMessage.NewAction.NodeVelocityLimit)
  return _internal_nodevelocitylimit();
}
inline void NewAction::unsafe_arena_set_allocated_nodevelocitylimit(
    ::NavMessage::SpeedLimit* nodevelocitylimit) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(nodevelocitylimit_);
  }
  nodevelocitylimit_ = nodevelocitylimit;
  if (nodevelocitylimit) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.NewAction.NodeVelocityLimit)
}
inline ::NavMessage::SpeedLimit* NewAction::release_nodevelocitylimit() {
  
  ::NavMessage::SpeedLimit* temp = nodevelocitylimit_;
  nodevelocitylimit_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::NavMessage::SpeedLimit* NewAction::unsafe_arena_release_nodevelocitylimit() {
  // @@protoc_insertion_point(field_release:NavMessage.NewAction.NodeVelocityLimit)
  
  ::NavMessage::SpeedLimit* temp = nodevelocitylimit_;
  nodevelocitylimit_ = nullptr;
  return temp;
}
inline ::NavMessage::SpeedLimit* NewAction::_internal_mutable_nodevelocitylimit() {
  
  if (nodevelocitylimit_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::SpeedLimit>(GetArena());
    nodevelocitylimit_ = p;
  }
  return nodevelocitylimit_;
}
inline ::NavMessage::SpeedLimit* NewAction::mutable_nodevelocitylimit() {
  // @@protoc_insertion_point(field_mutable:NavMessage.NewAction.NodeVelocityLimit)
  return _internal_mutable_nodevelocitylimit();
}
inline void NewAction::set_allocated_nodevelocitylimit(::NavMessage::SpeedLimit* nodevelocitylimit) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete nodevelocitylimit_;
  }
  if (nodevelocitylimit) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(nodevelocitylimit);
    if (message_arena != submessage_arena) {
      nodevelocitylimit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, nodevelocitylimit, submessage_arena);
    }
    
  } else {
    
  }
  nodevelocitylimit_ = nodevelocitylimit;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NewAction.NodeVelocityLimit)
}

// .NavMessage.SpeedLimit NodeAngularLimit = 8;
inline bool NewAction::_internal_has_nodeangularlimit() const {
  return this != internal_default_instance() && nodeangularlimit_ != nullptr;
}
inline bool NewAction::has_nodeangularlimit() const {
  return _internal_has_nodeangularlimit();
}
inline void NewAction::clear_nodeangularlimit() {
  if (GetArena() == nullptr && nodeangularlimit_ != nullptr) {
    delete nodeangularlimit_;
  }
  nodeangularlimit_ = nullptr;
}
inline const ::NavMessage::SpeedLimit& NewAction::_internal_nodeangularlimit() const {
  const ::NavMessage::SpeedLimit* p = nodeangularlimit_;
  return p != nullptr ? *p : *reinterpret_cast<const ::NavMessage::SpeedLimit*>(
      &::NavMessage::_SpeedLimit_default_instance_);
}
inline const ::NavMessage::SpeedLimit& NewAction::nodeangularlimit() const {
  // @@protoc_insertion_point(field_get:NavMessage.NewAction.NodeAngularLimit)
  return _internal_nodeangularlimit();
}
inline void NewAction::unsafe_arena_set_allocated_nodeangularlimit(
    ::NavMessage::SpeedLimit* nodeangularlimit) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(nodeangularlimit_);
  }
  nodeangularlimit_ = nodeangularlimit;
  if (nodeangularlimit) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.NewAction.NodeAngularLimit)
}
inline ::NavMessage::SpeedLimit* NewAction::release_nodeangularlimit() {
  
  ::NavMessage::SpeedLimit* temp = nodeangularlimit_;
  nodeangularlimit_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::NavMessage::SpeedLimit* NewAction::unsafe_arena_release_nodeangularlimit() {
  // @@protoc_insertion_point(field_release:NavMessage.NewAction.NodeAngularLimit)
  
  ::NavMessage::SpeedLimit* temp = nodeangularlimit_;
  nodeangularlimit_ = nullptr;
  return temp;
}
inline ::NavMessage::SpeedLimit* NewAction::_internal_mutable_nodeangularlimit() {
  
  if (nodeangularlimit_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::SpeedLimit>(GetArena());
    nodeangularlimit_ = p;
  }
  return nodeangularlimit_;
}
inline ::NavMessage::SpeedLimit* NewAction::mutable_nodeangularlimit() {
  // @@protoc_insertion_point(field_mutable:NavMessage.NewAction.NodeAngularLimit)
  return _internal_mutable_nodeangularlimit();
}
inline void NewAction::set_allocated_nodeangularlimit(::NavMessage::SpeedLimit* nodeangularlimit) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete nodeangularlimit_;
  }
  if (nodeangularlimit) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(nodeangularlimit);
    if (message_arena != submessage_arena) {
      nodeangularlimit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, nodeangularlimit, submessage_arena);
    }
    
  } else {
    
  }
  nodeangularlimit_ = nodeangularlimit;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NewAction.NodeAngularLimit)
}

// .NavMessage.SpeedLimit adjustVelocitylimit = 9;
inline bool NewAction::_internal_has_adjustvelocitylimit() const {
  return this != internal_default_instance() && adjustvelocitylimit_ != nullptr;
}
inline bool NewAction::has_adjustvelocitylimit() const {
  return _internal_has_adjustvelocitylimit();
}
inline void NewAction::clear_adjustvelocitylimit() {
  if (GetArena() == nullptr && adjustvelocitylimit_ != nullptr) {
    delete adjustvelocitylimit_;
  }
  adjustvelocitylimit_ = nullptr;
}
inline const ::NavMessage::SpeedLimit& NewAction::_internal_adjustvelocitylimit() const {
  const ::NavMessage::SpeedLimit* p = adjustvelocitylimit_;
  return p != nullptr ? *p : *reinterpret_cast<const ::NavMessage::SpeedLimit*>(
      &::NavMessage::_SpeedLimit_default_instance_);
}
inline const ::NavMessage::SpeedLimit& NewAction::adjustvelocitylimit() const {
  // @@protoc_insertion_point(field_get:NavMessage.NewAction.adjustVelocitylimit)
  return _internal_adjustvelocitylimit();
}
inline void NewAction::unsafe_arena_set_allocated_adjustvelocitylimit(
    ::NavMessage::SpeedLimit* adjustvelocitylimit) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(adjustvelocitylimit_);
  }
  adjustvelocitylimit_ = adjustvelocitylimit;
  if (adjustvelocitylimit) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.NewAction.adjustVelocitylimit)
}
inline ::NavMessage::SpeedLimit* NewAction::release_adjustvelocitylimit() {
  
  ::NavMessage::SpeedLimit* temp = adjustvelocitylimit_;
  adjustvelocitylimit_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::NavMessage::SpeedLimit* NewAction::unsafe_arena_release_adjustvelocitylimit() {
  // @@protoc_insertion_point(field_release:NavMessage.NewAction.adjustVelocitylimit)
  
  ::NavMessage::SpeedLimit* temp = adjustvelocitylimit_;
  adjustvelocitylimit_ = nullptr;
  return temp;
}
inline ::NavMessage::SpeedLimit* NewAction::_internal_mutable_adjustvelocitylimit() {
  
  if (adjustvelocitylimit_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::SpeedLimit>(GetArena());
    adjustvelocitylimit_ = p;
  }
  return adjustvelocitylimit_;
}
inline ::NavMessage::SpeedLimit* NewAction::mutable_adjustvelocitylimit() {
  // @@protoc_insertion_point(field_mutable:NavMessage.NewAction.adjustVelocitylimit)
  return _internal_mutable_adjustvelocitylimit();
}
inline void NewAction::set_allocated_adjustvelocitylimit(::NavMessage::SpeedLimit* adjustvelocitylimit) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete adjustvelocitylimit_;
  }
  if (adjustvelocitylimit) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(adjustvelocitylimit);
    if (message_arena != submessage_arena) {
      adjustvelocitylimit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, adjustvelocitylimit, submessage_arena);
    }
    
  } else {
    
  }
  adjustvelocitylimit_ = adjustvelocitylimit;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NewAction.adjustVelocitylimit)
}

// .NavMessage.SpeedLimit adjustHorizonLimit = 10;
inline bool NewAction::_internal_has_adjusthorizonlimit() const {
  return this != internal_default_instance() && adjusthorizonlimit_ != nullptr;
}
inline bool NewAction::has_adjusthorizonlimit() const {
  return _internal_has_adjusthorizonlimit();
}
inline void NewAction::clear_adjusthorizonlimit() {
  if (GetArena() == nullptr && adjusthorizonlimit_ != nullptr) {
    delete adjusthorizonlimit_;
  }
  adjusthorizonlimit_ = nullptr;
}
inline const ::NavMessage::SpeedLimit& NewAction::_internal_adjusthorizonlimit() const {
  const ::NavMessage::SpeedLimit* p = adjusthorizonlimit_;
  return p != nullptr ? *p : *reinterpret_cast<const ::NavMessage::SpeedLimit*>(
      &::NavMessage::_SpeedLimit_default_instance_);
}
inline const ::NavMessage::SpeedLimit& NewAction::adjusthorizonlimit() const {
  // @@protoc_insertion_point(field_get:NavMessage.NewAction.adjustHorizonLimit)
  return _internal_adjusthorizonlimit();
}
inline void NewAction::unsafe_arena_set_allocated_adjusthorizonlimit(
    ::NavMessage::SpeedLimit* adjusthorizonlimit) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(adjusthorizonlimit_);
  }
  adjusthorizonlimit_ = adjusthorizonlimit;
  if (adjusthorizonlimit) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.NewAction.adjustHorizonLimit)
}
inline ::NavMessage::SpeedLimit* NewAction::release_adjusthorizonlimit() {
  
  ::NavMessage::SpeedLimit* temp = adjusthorizonlimit_;
  adjusthorizonlimit_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::NavMessage::SpeedLimit* NewAction::unsafe_arena_release_adjusthorizonlimit() {
  // @@protoc_insertion_point(field_release:NavMessage.NewAction.adjustHorizonLimit)
  
  ::NavMessage::SpeedLimit* temp = adjusthorizonlimit_;
  adjusthorizonlimit_ = nullptr;
  return temp;
}
inline ::NavMessage::SpeedLimit* NewAction::_internal_mutable_adjusthorizonlimit() {
  
  if (adjusthorizonlimit_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::SpeedLimit>(GetArena());
    adjusthorizonlimit_ = p;
  }
  return adjusthorizonlimit_;
}
inline ::NavMessage::SpeedLimit* NewAction::mutable_adjusthorizonlimit() {
  // @@protoc_insertion_point(field_mutable:NavMessage.NewAction.adjustHorizonLimit)
  return _internal_mutable_adjusthorizonlimit();
}
inline void NewAction::set_allocated_adjusthorizonlimit(::NavMessage::SpeedLimit* adjusthorizonlimit) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete adjusthorizonlimit_;
  }
  if (adjusthorizonlimit) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(adjusthorizonlimit);
    if (message_arena != submessage_arena) {
      adjusthorizonlimit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, adjusthorizonlimit, submessage_arena);
    }
    
  } else {
    
  }
  adjusthorizonlimit_ = adjusthorizonlimit;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NewAction.adjustHorizonLimit)
}

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

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

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

// NavCmd

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

// string key = 2;
inline void NavCmd::clear_key() {
  key_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline const std::string& NavCmd::key() const {
  // @@protoc_insertion_point(field_get:NavMessage.NavCmd.key)
  return _internal_key();
}
inline void NavCmd::set_key(const std::string& value) {
  _internal_set_key(value);
  // @@protoc_insertion_point(field_set:NavMessage.NavCmd.key)
}
inline std::string* NavCmd::mutable_key() {
  // @@protoc_insertion_point(field_mutable:NavMessage.NavCmd.key)
  return _internal_mutable_key();
}
inline const std::string& NavCmd::_internal_key() const {
  return key_.Get();
}
inline void NavCmd::_internal_set_key(const std::string& value) {
  
  key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void NavCmd::set_key(std::string&& value) {
  
  key_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:NavMessage.NavCmd.key)
}
inline void NavCmd::set_key(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:NavMessage.NavCmd.key)
}
inline void NavCmd::set_key(const char* value,
    size_t size) {
  
  key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:NavMessage.NavCmd.key)
}
inline std::string* NavCmd::_internal_mutable_key() {
  
  return key_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* NavCmd::release_key() {
  // @@protoc_insertion_point(field_release:NavMessage.NavCmd.key)
  return key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void NavCmd::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    
  } else {
    
  }
  key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NavCmd.key)
}

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

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

// NavStatu

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

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

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

// string key = 4;
inline void NavStatu::clear_key() {
  key_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline const std::string& NavStatu::key() const {
  // @@protoc_insertion_point(field_get:NavMessage.NavStatu.key)
  return _internal_key();
}
inline void NavStatu::set_key(const std::string& value) {
  _internal_set_key(value);
  // @@protoc_insertion_point(field_set:NavMessage.NavStatu.key)
}
inline std::string* NavStatu::mutable_key() {
  // @@protoc_insertion_point(field_mutable:NavMessage.NavStatu.key)
  return _internal_mutable_key();
}
inline const std::string& NavStatu::_internal_key() const {
  return key_.Get();
}
inline void NavStatu::_internal_set_key(const std::string& value) {
  
  key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void NavStatu::set_key(std::string&& value) {
  
  key_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:NavMessage.NavStatu.key)
}
inline void NavStatu::set_key(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:NavMessage.NavStatu.key)
}
inline void NavStatu::set_key(const char* value,
    size_t size) {
  
  key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:NavMessage.NavStatu.key)
}
inline std::string* NavStatu::_internal_mutable_key() {
  
  return key_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* NavStatu::release_key() {
  // @@protoc_insertion_point(field_release:NavMessage.NavStatu.key)
  return key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void NavStatu::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    
  } else {
    
  }
  key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NavStatu.key)
}

// .NavMessage.Trajectory selected_traj = 6;
inline bool NavStatu::_internal_has_selected_traj() const {
  return this != internal_default_instance() && selected_traj_ != nullptr;
}
inline bool NavStatu::has_selected_traj() const {
  return _internal_has_selected_traj();
}
inline void NavStatu::clear_selected_traj() {
  if (GetArena() == nullptr && selected_traj_ != nullptr) {
    delete selected_traj_;
  }
  selected_traj_ = nullptr;
}
inline const ::NavMessage::Trajectory& NavStatu::_internal_selected_traj() const {
  const ::NavMessage::Trajectory* p = 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 (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(selected_traj_);
  }
  selected_traj_ = selected_traj;
  if (selected_traj) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.NavStatu.selected_traj)
}
inline ::NavMessage::Trajectory* NavStatu::release_selected_traj() {
  
  ::NavMessage::Trajectory* temp = selected_traj_;
  selected_traj_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::NavMessage::Trajectory* NavStatu::unsafe_arena_release_selected_traj() {
  // @@protoc_insertion_point(field_release:NavMessage.NavStatu.selected_traj)
  
  ::NavMessage::Trajectory* temp = selected_traj_;
  selected_traj_ = nullptr;
  return temp;
}
inline ::NavMessage::Trajectory* NavStatu::_internal_mutable_selected_traj() {
  
  if (selected_traj_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::Trajectory>(GetArena());
    selected_traj_ = p;
  }
  return selected_traj_;
}
inline ::NavMessage::Trajectory* NavStatu::mutable_selected_traj() {
  // @@protoc_insertion_point(field_mutable:NavMessage.NavStatu.selected_traj)
  return _internal_mutable_selected_traj();
}
inline void NavStatu::set_allocated_selected_traj(::NavMessage::Trajectory* selected_traj) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete selected_traj_;
  }
  if (selected_traj) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(selected_traj);
    if (message_arena != submessage_arena) {
      selected_traj = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, selected_traj, submessage_arena);
    }
    
  } else {
    
  }
  selected_traj_ = selected_traj;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NavStatu.selected_traj)
}

// .NavMessage.Trajectory predict_traj = 7;
inline bool NavStatu::_internal_has_predict_traj() const {
  return this != internal_default_instance() && predict_traj_ != nullptr;
}
inline bool NavStatu::has_predict_traj() const {
  return _internal_has_predict_traj();
}
inline void NavStatu::clear_predict_traj() {
  if (GetArena() == nullptr && predict_traj_ != nullptr) {
    delete predict_traj_;
  }
  predict_traj_ = nullptr;
}
inline const ::NavMessage::Trajectory& NavStatu::_internal_predict_traj() const {
  const ::NavMessage::Trajectory* p = 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 (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(predict_traj_);
  }
  predict_traj_ = predict_traj;
  if (predict_traj) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.NavStatu.predict_traj)
}
inline ::NavMessage::Trajectory* NavStatu::release_predict_traj() {
  
  ::NavMessage::Trajectory* temp = predict_traj_;
  predict_traj_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::NavMessage::Trajectory* NavStatu::unsafe_arena_release_predict_traj() {
  // @@protoc_insertion_point(field_release:NavMessage.NavStatu.predict_traj)
  
  ::NavMessage::Trajectory* temp = predict_traj_;
  predict_traj_ = nullptr;
  return temp;
}
inline ::NavMessage::Trajectory* NavStatu::_internal_mutable_predict_traj() {
  
  if (predict_traj_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::Trajectory>(GetArena());
    predict_traj_ = p;
  }
  return predict_traj_;
}
inline ::NavMessage::Trajectory* NavStatu::mutable_predict_traj() {
  // @@protoc_insertion_point(field_mutable:NavMessage.NavStatu.predict_traj)
  return _internal_mutable_predict_traj();
}
inline void NavStatu::set_allocated_predict_traj(::NavMessage::Trajectory* predict_traj) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete predict_traj_;
  }
  if (predict_traj) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(predict_traj);
    if (message_arena != submessage_arena) {
      predict_traj = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, predict_traj, submessage_arena);
    }
    
  } else {
    
  }
  predict_traj_ = predict_traj;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NavStatu.predict_traj)
}

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

// RobotStatu

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

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

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

// .NavMessage.AgvStatu agvStatu = 4;
inline bool RobotStatu::_internal_has_agvstatu() const {
  return this != internal_default_instance() && agvstatu_ != nullptr;
}
inline bool RobotStatu::has_agvstatu() const {
  return _internal_has_agvstatu();
}
inline void RobotStatu::clear_agvstatu() {
  if (GetArena() == nullptr && agvstatu_ != nullptr) {
    delete agvstatu_;
  }
  agvstatu_ = nullptr;
}
inline const ::NavMessage::AgvStatu& RobotStatu::_internal_agvstatu() const {
  const ::NavMessage::AgvStatu* p = 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 (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(agvstatu_);
  }
  agvstatu_ = agvstatu;
  if (agvstatu) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.RobotStatu.agvStatu)
}
inline ::NavMessage::AgvStatu* RobotStatu::release_agvstatu() {
  
  ::NavMessage::AgvStatu* temp = agvstatu_;
  agvstatu_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::NavMessage::AgvStatu* RobotStatu::unsafe_arena_release_agvstatu() {
  // @@protoc_insertion_point(field_release:NavMessage.RobotStatu.agvStatu)
  
  ::NavMessage::AgvStatu* temp = agvstatu_;
  agvstatu_ = nullptr;
  return temp;
}
inline ::NavMessage::AgvStatu* RobotStatu::_internal_mutable_agvstatu() {
  
  if (agvstatu_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::AgvStatu>(GetArena());
    agvstatu_ = p;
  }
  return agvstatu_;
}
inline ::NavMessage::AgvStatu* RobotStatu::mutable_agvstatu() {
  // @@protoc_insertion_point(field_mutable:NavMessage.RobotStatu.agvStatu)
  return _internal_mutable_agvstatu();
}
inline void RobotStatu::set_allocated_agvstatu(::NavMessage::AgvStatu* agvstatu) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete agvstatu_;
  }
  if (agvstatu) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(agvstatu);
    if (message_arena != submessage_arena) {
      agvstatu = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, agvstatu, submessage_arena);
    }
    
  } else {
    
  }
  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_GOOGLE_PROTOBUF_INCLUDED_message_2eproto
