Terminal_process_CT/message/message_base.pb.h

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_message_5fbase_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_message_5fbase_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/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_message_5fbase_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_message_5fbase_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[6]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_message_5fbase_2eproto;
namespace message {
class Base_info;
class Base_infoDefaultTypeInternal;
extern Base_infoDefaultTypeInternal _Base_info_default_instance_;
class Base_msg;
class Base_msgDefaultTypeInternal;
extern Base_msgDefaultTypeInternal _Base_msg_default_instance_;
class Car_info;
class Car_infoDefaultTypeInternal;
extern Car_infoDefaultTypeInternal _Car_info_default_instance_;
class Error_manager;
class Error_managerDefaultTypeInternal;
extern Error_managerDefaultTypeInternal _Error_manager_default_instance_;
class Locate_information;
class Locate_informationDefaultTypeInternal;
extern Locate_informationDefaultTypeInternal _Locate_information_default_instance_;
class Parkspace_info;
class Parkspace_infoDefaultTypeInternal;
extern Parkspace_infoDefaultTypeInternal _Parkspace_info_default_instance_;
}  // namespace message
PROTOBUF_NAMESPACE_OPEN
template<> ::message::Base_info* Arena::CreateMaybeMessage<::message::Base_info>(Arena*);
template<> ::message::Base_msg* Arena::CreateMaybeMessage<::message::Base_msg>(Arena*);
template<> ::message::Car_info* Arena::CreateMaybeMessage<::message::Car_info>(Arena*);
template<> ::message::Error_manager* Arena::CreateMaybeMessage<::message::Error_manager>(Arena*);
template<> ::message::Locate_information* Arena::CreateMaybeMessage<::message::Locate_information>(Arena*);
template<> ::message::Parkspace_info* Arena::CreateMaybeMessage<::message::Parkspace_info>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace message {

enum Message_type : int {
  eBase_msg = 0,
  eCommand_msg = 1,
  eLocate_status_msg = 17,
  eLocate_request_msg = 18,
  eLocate_response_msg = 19,
  eLocate_sift_request_msg = 20,
  eLocate_sift_response_msg = 21,
  eDispatch_status_msg = 33,
  eDispatch_request_msg = 34,
  eDispatch_response_msg = 35,
  eParkspace_allocation_status_msg = 49,
  eParkspace_allocation_request_msg = 50,
  eParkspace_allocation_response_msg = 51,
  eParkspace_search_request_msg = 52,
  eParkspace_search_response_msg = 53,
  eParkspace_release_request_msg = 54,
  eParkspace_release_response_msg = 55,
  eParkspace_force_update_request_msg = 56,
  eParkspace_force_update_response_msg = 57,
  eParkspace_confirm_alloc_request_msg = 58,
  eParkspace_confirm_alloc_response_msg = 59,
  eParkspace_allocation_data_msg = 60,
  eStore_command_request_msg = 65,
  eStore_command_response_msg = 66,
  ePickup_command_request_msg = 67,
  ePickup_command_response_msg = 68,
  eStoring_process_statu_msg = 144,
  ePicking_process_statu_msg = 145,
  eCentral_controller_statu_msg = 160,
  eEntrance_manual_operation_msg = 176,
  eProcess_manual_operation_msg = 177,
  eDispatch_plan_request_msg = 224,
  eDispatch_plan_response_msg = 225,
  eDispatch_control_request_msg = 226,
  eDispatch_control_response_msg = 227,
  eDispatch_manager_status_msg = 234,
  eDispatch_manager_data_msg = 235
};
bool Message_type_IsValid(int value);
constexpr Message_type Message_type_MIN = eBase_msg;
constexpr Message_type Message_type_MAX = eDispatch_manager_data_msg;
constexpr int Message_type_ARRAYSIZE = Message_type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_type_descriptor();
template<typename T>
inline const std::string& Message_type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_type_descriptor(), enum_t_value);
}
inline bool Message_type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_type>(
    Message_type_descriptor(), name, value);
}
enum Communicator : int {
  eEmpty = 0,
  eMain = 1,
  eTerminor = 256,
  eParkspace = 512,
  eMeasurer = 768,
  eMeasurer_sift_server = 769,
  eDispatch_manager = 1024,
  eDispatch_control = 1025
};
bool Communicator_IsValid(int value);
constexpr Communicator Communicator_MIN = eEmpty;
constexpr Communicator Communicator_MAX = eDispatch_control;
constexpr int Communicator_ARRAYSIZE = Communicator_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Communicator_descriptor();
template<typename T>
inline const std::string& Communicator_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Communicator>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Communicator_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Communicator_descriptor(), enum_t_value);
}
inline bool Communicator_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Communicator* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Communicator>(
    Communicator_descriptor(), name, value);
}
enum Process_type : int {
  eStoring = 1,
  ePicking = 2
};
bool Process_type_IsValid(int value);
constexpr Process_type Process_type_MIN = eStoring;
constexpr Process_type Process_type_MAX = ePicking;
constexpr int Process_type_ARRAYSIZE = Process_type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Process_type_descriptor();
template<typename T>
inline const std::string& Process_type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Process_type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Process_type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Process_type_descriptor(), enum_t_value);
}
inline bool Process_type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Process_type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Process_type>(
    Process_type_descriptor(), name, value);
}
enum Error_level : int {
  NORMAL = 0,
  NEGLIGIBLE_ERROR = 1,
  MINOR_ERROR = 2,
  MAJOR_ERROR = 3,
  CRITICAL_ERROR = 4
};
bool Error_level_IsValid(int value);
constexpr Error_level Error_level_MIN = NORMAL;
constexpr Error_level Error_level_MAX = CRITICAL_ERROR;
constexpr int Error_level_ARRAYSIZE = Error_level_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Error_level_descriptor();
template<typename T>
inline const std::string& Error_level_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Error_level>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Error_level_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Error_level_descriptor(), enum_t_value);
}
inline bool Error_level_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Error_level* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Error_level>(
    Error_level_descriptor(), name, value);
}
enum Parkspace_status : int {
  eParkspace_status_unknow = 0,
  eParkspace_empty = 1,
  eParkspace_occupied = 2,
  eParkspace_reserved = 3,
  eParkspace_locked = 4,
  eParkspace_error = 5
};
bool Parkspace_status_IsValid(int value);
constexpr Parkspace_status Parkspace_status_MIN = eParkspace_status_unknow;
constexpr Parkspace_status Parkspace_status_MAX = eParkspace_error;
constexpr int Parkspace_status_ARRAYSIZE = Parkspace_status_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Parkspace_status_descriptor();
template<typename T>
inline const std::string& Parkspace_status_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Parkspace_status>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Parkspace_status_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Parkspace_status_descriptor(), enum_t_value);
}
inline bool Parkspace_status_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Parkspace_status* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Parkspace_status>(
    Parkspace_status_descriptor(), name, value);
}
enum Direction : int {
  eDirection_unknow = 0,
  eForward = 1,
  eBackward = 2
};
bool Direction_IsValid(int value);
constexpr Direction Direction_MIN = eDirection_unknow;
constexpr Direction Direction_MAX = eBackward;
constexpr int Direction_ARRAYSIZE = Direction_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Direction_descriptor();
template<typename T>
inline const std::string& Direction_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Direction>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Direction_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Direction_descriptor(), enum_t_value);
}
inline bool Direction_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Direction* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Direction>(
    Direction_descriptor(), name, value);
}
enum Parkspace_path : int {
  UNKNOW_PATH = 0,
  OPTIMAL_PATH = 1,
  LEFT_PATH = 2,
  RIGHT_PATH = 3,
  TEMPORARY_CACHE_PATH = 4
};
bool Parkspace_path_IsValid(int value);
constexpr Parkspace_path Parkspace_path_MIN = UNKNOW_PATH;
constexpr Parkspace_path Parkspace_path_MAX = TEMPORARY_CACHE_PATH;
constexpr int Parkspace_path_ARRAYSIZE = Parkspace_path_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Parkspace_path_descriptor();
template<typename T>
inline const std::string& Parkspace_path_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Parkspace_path>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Parkspace_path_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Parkspace_path_descriptor(), enum_t_value);
}
inline bool Parkspace_path_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Parkspace_path* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Parkspace_path>(
    Parkspace_path_descriptor(), name, value);
}
enum Parkspace_type : int {
  UNKNOW_PARKSPACE_TYPE = 0,
  MIN_PARKINGSPACE = 1,
  MID_PARKINGSPACE = 2,
  BIG_PARKINGSPACE = 3
};
bool Parkspace_type_IsValid(int value);
constexpr Parkspace_type Parkspace_type_MIN = UNKNOW_PARKSPACE_TYPE;
constexpr Parkspace_type Parkspace_type_MAX = BIG_PARKINGSPACE;
constexpr int Parkspace_type_ARRAYSIZE = Parkspace_type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Parkspace_type_descriptor();
template<typename T>
inline const std::string& Parkspace_type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Parkspace_type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Parkspace_type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Parkspace_type_descriptor(), enum_t_value);
}
inline bool Parkspace_type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Parkspace_type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Parkspace_type>(
    Parkspace_type_descriptor(), name, value);
}
enum Car_type : int {
  UNKNOW_CAR_TYPE = 0,
  MIN_CAR = 1,
  MID_CAR = 2,
  BIG_CAR = 3
};
bool Car_type_IsValid(int value);
constexpr Car_type Car_type_MIN = UNKNOW_CAR_TYPE;
constexpr Car_type Car_type_MAX = BIG_CAR;
constexpr int Car_type_ARRAYSIZE = Car_type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Car_type_descriptor();
template<typename T>
inline const std::string& Car_type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Car_type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Car_type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Car_type_descriptor(), enum_t_value);
}
inline bool Car_type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Car_type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Car_type>(
    Car_type_descriptor(), name, value);
}
enum Step_type : int {
  eAlloc_step = 0,
  eMeasure_step = 1,
  eCompare_step = 2,
  eDispatch_step = 3,
  eConfirm_step = 4,
  eSearch_step = 5,
  eWait_step = 6,
  eRelease_step = 7,
  eComplete = 8,
  eBackConfirm_step = 9,
  eBack_compare_step = 10,
  eBackMeasure_step = 11,
  eBackAlloc_step = 12,
  eBackWait_step = 13,
  eBackDispatch_step = 14,
  eBackSearch_step = 15,
  eBackComplete = 16
};
bool Step_type_IsValid(int value);
constexpr Step_type Step_type_MIN = eAlloc_step;
constexpr Step_type Step_type_MAX = eBackComplete;
constexpr int Step_type_ARRAYSIZE = Step_type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Step_type_descriptor();
template<typename T>
inline const std::string& Step_type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Step_type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Step_type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Step_type_descriptor(), enum_t_value);
}
inline bool Step_type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Step_type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Step_type>(
    Step_type_descriptor(), name, value);
}
enum Step_statu : int {
  eWaiting = 0,
  eWorking = 1,
  eError = 2,
  eFinished = 3
};
bool Step_statu_IsValid(int value);
constexpr Step_statu Step_statu_MIN = eWaiting;
constexpr Step_statu Step_statu_MAX = eFinished;
constexpr int Step_statu_ARRAYSIZE = Step_statu_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Step_statu_descriptor();
template<typename T>
inline const std::string& Step_statu_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Step_statu>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Step_statu_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Step_statu_descriptor(), enum_t_value);
}
inline bool Step_statu_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Step_statu* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Step_statu>(
    Step_statu_descriptor(), name, value);
}
enum Dispatch_device_type : int {
  ROBOT_1 = 101,
  ROBOT_2 = 102,
  CARRIER_1 = 200,
  CARRIER_2 = 207,
  CARRIER_3 = 203,
  PASSAGEWAY_0 = 300,
  PASSAGEWAY_1 = 301,
  PASSAGEWAY_2 = 302,
  PASSAGEWAY_3 = 303,
  PASSAGEWAY_4 = 304,
  PASSAGEWAY_5 = 305,
  PASSAGEWAY_6 = 306,
  PASSAGEWAY_7 = 307
};
bool Dispatch_device_type_IsValid(int value);
constexpr Dispatch_device_type Dispatch_device_type_MIN = ROBOT_1;
constexpr Dispatch_device_type Dispatch_device_type_MAX = PASSAGEWAY_7;
constexpr int Dispatch_device_type_ARRAYSIZE = Dispatch_device_type_MAX + 1;

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

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

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

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

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

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

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

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

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

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

  Base_info* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Base_info>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Base_info& from);
  void MergeFrom(const Base_info& 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(Base_info* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "message.Base_info";
  }
  protected:
  explicit Base_info(::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_5fbase_2eproto);
    return ::descriptor_table_message_5fbase_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kMsgTypeFieldNumber = 1,
    kTimeoutMsFieldNumber = 2,
    kSenderFieldNumber = 3,
    kReceiverFieldNumber = 4,
  };
  // required .message.Message_type msg_type = 1 [default = eBase_msg];
  bool has_msg_type() const;
  private:
  bool _internal_has_msg_type() const;
  public:
  void clear_msg_type();
  ::message::Message_type msg_type() const;
  void set_msg_type(::message::Message_type value);
  private:
  ::message::Message_type _internal_msg_type() const;
  void _internal_set_msg_type(::message::Message_type value);
  public:

  // optional int32 timeout_ms = 2 [default = 0];
  bool has_timeout_ms() const;
  private:
  bool _internal_has_timeout_ms() const;
  public:
  void clear_timeout_ms();
  ::PROTOBUF_NAMESPACE_ID::int32 timeout_ms() const;
  void set_timeout_ms(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_timeout_ms() const;
  void _internal_set_timeout_ms(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // required .message.Communicator sender = 3 [default = eEmpty];
  bool has_sender() const;
  private:
  bool _internal_has_sender() const;
  public:
  void clear_sender();
  ::message::Communicator sender() const;
  void set_sender(::message::Communicator value);
  private:
  ::message::Communicator _internal_sender() const;
  void _internal_set_sender(::message::Communicator value);
  public:

  // required .message.Communicator receiver = 4 [default = eEmpty];
  bool has_receiver() const;
  private:
  bool _internal_has_receiver() const;
  public:
  void clear_receiver();
  ::message::Communicator receiver() const;
  void set_receiver(::message::Communicator value);
  private:
  ::message::Communicator _internal_receiver() const;
  void _internal_set_receiver(::message::Communicator value);
  public:

  // @@protoc_insertion_point(class_scope:message.Base_info)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  int msg_type_;
  ::PROTOBUF_NAMESPACE_ID::int32 timeout_ms_;
  int sender_;
  int receiver_;
  friend struct ::TableStruct_message_5fbase_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

  Base_msg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Base_msg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Base_msg& from);
  void MergeFrom(const Base_msg& 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(Base_msg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "message.Base_msg";
  }
  protected:
  explicit Base_msg(::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_5fbase_2eproto);
    return ::descriptor_table_message_5fbase_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kBaseInfoFieldNumber = 1,
  };
  // required .message.Base_info base_info = 1;
  bool has_base_info() const;
  private:
  bool _internal_has_base_info() const;
  public:
  void clear_base_info();
  const ::message::Base_info& base_info() const;
  ::message::Base_info* release_base_info();
  ::message::Base_info* mutable_base_info();
  void set_allocated_base_info(::message::Base_info* base_info);
  private:
  const ::message::Base_info& _internal_base_info() const;
  ::message::Base_info* _internal_mutable_base_info();
  public:
  void unsafe_arena_set_allocated_base_info(
      ::message::Base_info* base_info);
  ::message::Base_info* unsafe_arena_release_base_info();

  // @@protoc_insertion_point(class_scope:message.Base_msg)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::message::Base_info* base_info_;
  friend struct ::TableStruct_message_5fbase_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

  Error_manager* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Error_manager>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Error_manager& from);
  void MergeFrom(const Error_manager& 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(Error_manager* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "message.Error_manager";
  }
  protected:
  explicit Error_manager(::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_5fbase_2eproto);
    return ::descriptor_table_message_5fbase_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kErrorDescriptionFieldNumber = 3,
    kErrorCodeFieldNumber = 1,
    kErrorLevelFieldNumber = 2,
  };
  // optional string error_description = 3 [default = ""];
  bool has_error_description() const;
  private:
  bool _internal_has_error_description() const;
  public:
  void clear_error_description();
  const std::string& error_description() const;
  void set_error_description(const std::string& value);
  void set_error_description(std::string&& value);
  void set_error_description(const char* value);
  void set_error_description(const char* value, size_t size);
  std::string* mutable_error_description();
  std::string* release_error_description();
  void set_allocated_error_description(std::string* error_description);
  private:
  const std::string& _internal_error_description() const;
  void _internal_set_error_description(const std::string& value);
  std::string* _internal_mutable_error_description();
  public:

  // required int32 error_code = 1 [default = 0];
  bool has_error_code() const;
  private:
  bool _internal_has_error_code() const;
  public:
  void clear_error_code();
  ::PROTOBUF_NAMESPACE_ID::int32 error_code() const;
  void set_error_code(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_error_code() const;
  void _internal_set_error_code(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional .message.Error_level error_level = 2 [default = NORMAL];
  bool has_error_level() const;
  private:
  bool _internal_has_error_level() const;
  public:
  void clear_error_level();
  ::message::Error_level error_level() const;
  void set_error_level(::message::Error_level value);
  private:
  ::message::Error_level _internal_error_level() const;
  void _internal_set_error_level(::message::Error_level value);
  public:

  // @@protoc_insertion_point(class_scope:message.Error_manager)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr error_description_;
  ::PROTOBUF_NAMESPACE_ID::int32 error_code_;
  int error_level_;
  friend struct ::TableStruct_message_5fbase_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

  Locate_information* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Locate_information>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Locate_information& from);
  void MergeFrom(const Locate_information& 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(Locate_information* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "message.Locate_information";
  }
  protected:
  explicit Locate_information(::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_5fbase_2eproto);
    return ::descriptor_table_message_5fbase_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kLocateXFieldNumber = 1,
    kLocateYFieldNumber = 2,
    kLocateAngleFieldNumber = 3,
    kLocateLengthFieldNumber = 4,
    kLocateWidthFieldNumber = 5,
    kLocateHeightFieldNumber = 6,
    kLocateWheelBaseFieldNumber = 7,
    kLocateWheelWidthFieldNumber = 8,
    kLocateCorrectFieldNumber = 9,
    kLocateFrontThetaFieldNumber = 10,
  };
  // optional float locate_x = 1 [default = 0];
  bool has_locate_x() const;
  private:
  bool _internal_has_locate_x() const;
  public:
  void clear_locate_x();
  float locate_x() const;
  void set_locate_x(float value);
  private:
  float _internal_locate_x() const;
  void _internal_set_locate_x(float value);
  public:

  // optional float locate_y = 2 [default = 0];
  bool has_locate_y() const;
  private:
  bool _internal_has_locate_y() const;
  public:
  void clear_locate_y();
  float locate_y() const;
  void set_locate_y(float value);
  private:
  float _internal_locate_y() const;
  void _internal_set_locate_y(float value);
  public:

  // optional float locate_angle = 3 [default = 0];
  bool has_locate_angle() const;
  private:
  bool _internal_has_locate_angle() const;
  public:
  void clear_locate_angle();
  float locate_angle() const;
  void set_locate_angle(float value);
  private:
  float _internal_locate_angle() const;
  void _internal_set_locate_angle(float value);
  public:

  // optional float locate_length = 4 [default = 0];
  bool has_locate_length() const;
  private:
  bool _internal_has_locate_length() const;
  public:
  void clear_locate_length();
  float locate_length() const;
  void set_locate_length(float value);
  private:
  float _internal_locate_length() const;
  void _internal_set_locate_length(float value);
  public:

  // optional float locate_width = 5 [default = 0];
  bool has_locate_width() const;
  private:
  bool _internal_has_locate_width() const;
  public:
  void clear_locate_width();
  float locate_width() const;
  void set_locate_width(float value);
  private:
  float _internal_locate_width() const;
  void _internal_set_locate_width(float value);
  public:

  // optional float locate_height = 6 [default = 0];
  bool has_locate_height() const;
  private:
  bool _internal_has_locate_height() const;
  public:
  void clear_locate_height();
  float locate_height() const;
  void set_locate_height(float value);
  private:
  float _internal_locate_height() const;
  void _internal_set_locate_height(float value);
  public:

  // optional float locate_wheel_base = 7 [default = 0];
  bool has_locate_wheel_base() const;
  private:
  bool _internal_has_locate_wheel_base() const;
  public:
  void clear_locate_wheel_base();
  float locate_wheel_base() const;
  void set_locate_wheel_base(float value);
  private:
  float _internal_locate_wheel_base() const;
  void _internal_set_locate_wheel_base(float value);
  public:

  // optional float locate_wheel_width = 8 [default = 0];
  bool has_locate_wheel_width() const;
  private:
  bool _internal_has_locate_wheel_width() const;
  public:
  void clear_locate_wheel_width();
  float locate_wheel_width() const;
  void set_locate_wheel_width(float value);
  private:
  float _internal_locate_wheel_width() const;
  void _internal_set_locate_wheel_width(float value);
  public:

  // optional bool locate_correct = 9 [default = false];
  bool has_locate_correct() const;
  private:
  bool _internal_has_locate_correct() const;
  public:
  void clear_locate_correct();
  bool locate_correct() const;
  void set_locate_correct(bool value);
  private:
  bool _internal_locate_correct() const;
  void _internal_set_locate_correct(bool value);
  public:

  // optional float locate_front_theta = 10 [default = 0];
  bool has_locate_front_theta() const;
  private:
  bool _internal_has_locate_front_theta() const;
  public:
  void clear_locate_front_theta();
  float locate_front_theta() const;
  void set_locate_front_theta(float value);
  private:
  float _internal_locate_front_theta() const;
  void _internal_set_locate_front_theta(float value);
  public:

  // @@protoc_insertion_point(class_scope:message.Locate_information)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  float locate_x_;
  float locate_y_;
  float locate_angle_;
  float locate_length_;
  float locate_width_;
  float locate_height_;
  float locate_wheel_base_;
  float locate_wheel_width_;
  bool locate_correct_;
  float locate_front_theta_;
  friend struct ::TableStruct_message_5fbase_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

  Car_info* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Car_info>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Car_info& from);
  void MergeFrom(const Car_info& 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(Car_info* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "message.Car_info";
  }
  protected:
  explicit Car_info(::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_5fbase_2eproto);
    return ::descriptor_table_message_5fbase_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kLicenseFieldNumber = 4,
    kCarLengthFieldNumber = 1,
    kCarWidthFieldNumber = 2,
    kCarHeightFieldNumber = 3,
    kCarWheelBaseFieldNumber = 5,
    kCarWheelWidthFieldNumber = 6,
  };
  // optional string license = 4 [default = ""];
  bool has_license() const;
  private:
  bool _internal_has_license() const;
  public:
  void clear_license();
  const std::string& license() const;
  void set_license(const std::string& value);
  void set_license(std::string&& value);
  void set_license(const char* value);
  void set_license(const char* value, size_t size);
  std::string* mutable_license();
  std::string* release_license();
  void set_allocated_license(std::string* license);
  private:
  const std::string& _internal_license() const;
  void _internal_set_license(const std::string& value);
  std::string* _internal_mutable_license();
  public:

  // optional float car_length = 1 [default = 0];
  bool has_car_length() const;
  private:
  bool _internal_has_car_length() const;
  public:
  void clear_car_length();
  float car_length() const;
  void set_car_length(float value);
  private:
  float _internal_car_length() const;
  void _internal_set_car_length(float value);
  public:

  // optional float car_width = 2 [default = 0];
  bool has_car_width() const;
  private:
  bool _internal_has_car_width() const;
  public:
  void clear_car_width();
  float car_width() const;
  void set_car_width(float value);
  private:
  float _internal_car_width() const;
  void _internal_set_car_width(float value);
  public:

  // optional float car_height = 3 [default = 0];
  bool has_car_height() const;
  private:
  bool _internal_has_car_height() const;
  public:
  void clear_car_height();
  float car_height() const;
  void set_car_height(float value);
  private:
  float _internal_car_height() const;
  void _internal_set_car_height(float value);
  public:

  // optional float car_wheel_base = 5 [default = 0];
  bool has_car_wheel_base() const;
  private:
  bool _internal_has_car_wheel_base() const;
  public:
  void clear_car_wheel_base();
  float car_wheel_base() const;
  void set_car_wheel_base(float value);
  private:
  float _internal_car_wheel_base() const;
  void _internal_set_car_wheel_base(float value);
  public:

  // optional float car_wheel_width = 6 [default = 0];
  bool has_car_wheel_width() const;
  private:
  bool _internal_has_car_wheel_width() const;
  public:
  void clear_car_wheel_width();
  float car_wheel_width() const;
  void set_car_wheel_width(float value);
  private:
  float _internal_car_wheel_width() const;
  void _internal_set_car_wheel_width(float value);
  public:

  // @@protoc_insertion_point(class_scope:message.Car_info)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr license_;
  float car_length_;
  float car_width_;
  float car_height_;
  float car_wheel_base_;
  float car_wheel_width_;
  friend struct ::TableStruct_message_5fbase_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

  Parkspace_info* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Parkspace_info>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Parkspace_info& from);
  void MergeFrom(const Parkspace_info& 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(Parkspace_info* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "message.Parkspace_info";
  }
  protected:
  explicit Parkspace_info(::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_5fbase_2eproto);
    return ::descriptor_table_message_5fbase_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kEntryTimeFieldNumber = 11,
    kLeaveTimeFieldNumber = 12,
    kCarInfoFieldNumber = 10,
    kParkingspaceIndexIdFieldNumber = 1,
    kParkingspaceTypeFieldNumber = 2,
    kParkingspaceUnitIdFieldNumber = 3,
    kParkingspaceRoomIdFieldNumber = 4,
    kParkingspaceDirectionFieldNumber = 5,
    kParkingspaceFloorIdFieldNumber = 6,
    kParkingspaceWidthFieldNumber = 7,
    kParkingspaceHeightFieldNumber = 8,
    kParkingspaceStatusFieldNumber = 9,
    kParkspacePathFieldNumber = 13,
    kPathEstimateTimeFieldNumber = 14,
    kParkspaceStatusTargetFieldNumber = 15,
  };
  // optional string entry_time = 11;
  bool has_entry_time() const;
  private:
  bool _internal_has_entry_time() const;
  public:
  void clear_entry_time();
  const std::string& entry_time() const;
  void set_entry_time(const std::string& value);
  void set_entry_time(std::string&& value);
  void set_entry_time(const char* value);
  void set_entry_time(const char* value, size_t size);
  std::string* mutable_entry_time();
  std::string* release_entry_time();
  void set_allocated_entry_time(std::string* entry_time);
  private:
  const std::string& _internal_entry_time() const;
  void _internal_set_entry_time(const std::string& value);
  std::string* _internal_mutable_entry_time();
  public:

  // optional string leave_time = 12;
  bool has_leave_time() const;
  private:
  bool _internal_has_leave_time() const;
  public:
  void clear_leave_time();
  const std::string& leave_time() const;
  void set_leave_time(const std::string& value);
  void set_leave_time(std::string&& value);
  void set_leave_time(const char* value);
  void set_leave_time(const char* value, size_t size);
  std::string* mutable_leave_time();
  std::string* release_leave_time();
  void set_allocated_leave_time(std::string* leave_time);
  private:
  const std::string& _internal_leave_time() const;
  void _internal_set_leave_time(const std::string& value);
  std::string* _internal_mutable_leave_time();
  public:

  // optional .message.Car_info car_info = 10;
  bool has_car_info() const;
  private:
  bool _internal_has_car_info() const;
  public:
  void clear_car_info();
  const ::message::Car_info& car_info() const;
  ::message::Car_info* release_car_info();
  ::message::Car_info* mutable_car_info();
  void set_allocated_car_info(::message::Car_info* car_info);
  private:
  const ::message::Car_info& _internal_car_info() const;
  ::message::Car_info* _internal_mutable_car_info();
  public:
  void unsafe_arena_set_allocated_car_info(
      ::message::Car_info* car_info);
  ::message::Car_info* unsafe_arena_release_car_info();

  // optional int32 parkingspace_index_id = 1;
  bool has_parkingspace_index_id() const;
  private:
  bool _internal_has_parkingspace_index_id() const;
  public:
  void clear_parkingspace_index_id();
  ::PROTOBUF_NAMESPACE_ID::int32 parkingspace_index_id() const;
  void set_parkingspace_index_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_parkingspace_index_id() const;
  void _internal_set_parkingspace_index_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional .message.Parkspace_type parkingspace_type = 2;
  bool has_parkingspace_type() const;
  private:
  bool _internal_has_parkingspace_type() const;
  public:
  void clear_parkingspace_type();
  ::message::Parkspace_type parkingspace_type() const;
  void set_parkingspace_type(::message::Parkspace_type value);
  private:
  ::message::Parkspace_type _internal_parkingspace_type() const;
  void _internal_set_parkingspace_type(::message::Parkspace_type value);
  public:

  // optional int32 parkingspace_unit_id = 3;
  bool has_parkingspace_unit_id() const;
  private:
  bool _internal_has_parkingspace_unit_id() const;
  public:
  void clear_parkingspace_unit_id();
  ::PROTOBUF_NAMESPACE_ID::int32 parkingspace_unit_id() const;
  void set_parkingspace_unit_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_parkingspace_unit_id() const;
  void _internal_set_parkingspace_unit_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 parkingspace_room_id = 4;
  bool has_parkingspace_room_id() const;
  private:
  bool _internal_has_parkingspace_room_id() const;
  public:
  void clear_parkingspace_room_id();
  ::PROTOBUF_NAMESPACE_ID::int32 parkingspace_room_id() const;
  void set_parkingspace_room_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_parkingspace_room_id() const;
  void _internal_set_parkingspace_room_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional .message.Direction parkingspace_direction = 5;
  bool has_parkingspace_direction() const;
  private:
  bool _internal_has_parkingspace_direction() const;
  public:
  void clear_parkingspace_direction();
  ::message::Direction parkingspace_direction() const;
  void set_parkingspace_direction(::message::Direction value);
  private:
  ::message::Direction _internal_parkingspace_direction() const;
  void _internal_set_parkingspace_direction(::message::Direction value);
  public:

  // optional int32 parkingspace_floor_id = 6;
  bool has_parkingspace_floor_id() const;
  private:
  bool _internal_has_parkingspace_floor_id() const;
  public:
  void clear_parkingspace_floor_id();
  ::PROTOBUF_NAMESPACE_ID::int32 parkingspace_floor_id() const;
  void set_parkingspace_floor_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_parkingspace_floor_id() const;
  void _internal_set_parkingspace_floor_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional float parkingspace_width = 7;
  bool has_parkingspace_width() const;
  private:
  bool _internal_has_parkingspace_width() const;
  public:
  void clear_parkingspace_width();
  float parkingspace_width() const;
  void set_parkingspace_width(float value);
  private:
  float _internal_parkingspace_width() const;
  void _internal_set_parkingspace_width(float value);
  public:

  // optional float parkingspace_height = 8;
  bool has_parkingspace_height() const;
  private:
  bool _internal_has_parkingspace_height() const;
  public:
  void clear_parkingspace_height();
  float parkingspace_height() const;
  void set_parkingspace_height(float value);
  private:
  float _internal_parkingspace_height() const;
  void _internal_set_parkingspace_height(float value);
  public:

  // optional .message.Parkspace_status parkingspace_status = 9;
  bool has_parkingspace_status() const;
  private:
  bool _internal_has_parkingspace_status() const;
  public:
  void clear_parkingspace_status();
  ::message::Parkspace_status parkingspace_status() const;
  void set_parkingspace_status(::message::Parkspace_status value);
  private:
  ::message::Parkspace_status _internal_parkingspace_status() const;
  void _internal_set_parkingspace_status(::message::Parkspace_status value);
  public:

  // optional .message.Parkspace_path parkspace_path = 13;
  bool has_parkspace_path() const;
  private:
  bool _internal_has_parkspace_path() const;
  public:
  void clear_parkspace_path();
  ::message::Parkspace_path parkspace_path() const;
  void set_parkspace_path(::message::Parkspace_path value);
  private:
  ::message::Parkspace_path _internal_parkspace_path() const;
  void _internal_set_parkspace_path(::message::Parkspace_path value);
  public:

  // optional float path_estimate_time = 14;
  bool has_path_estimate_time() const;
  private:
  bool _internal_has_path_estimate_time() const;
  public:
  void clear_path_estimate_time();
  float path_estimate_time() const;
  void set_path_estimate_time(float value);
  private:
  float _internal_path_estimate_time() const;
  void _internal_set_path_estimate_time(float value);
  public:

  // optional .message.Parkspace_status parkspace_status_target = 15;
  bool has_parkspace_status_target() const;
  private:
  bool _internal_has_parkspace_status_target() const;
  public:
  void clear_parkspace_status_target();
  ::message::Parkspace_status parkspace_status_target() const;
  void set_parkspace_status_target(::message::Parkspace_status value);
  private:
  ::message::Parkspace_status _internal_parkspace_status_target() const;
  void _internal_set_parkspace_status_target(::message::Parkspace_status value);
  public:

  // @@protoc_insertion_point(class_scope:message.Parkspace_info)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr entry_time_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr leave_time_;
  ::message::Car_info* car_info_;
  ::PROTOBUF_NAMESPACE_ID::int32 parkingspace_index_id_;
  int parkingspace_type_;
  ::PROTOBUF_NAMESPACE_ID::int32 parkingspace_unit_id_;
  ::PROTOBUF_NAMESPACE_ID::int32 parkingspace_room_id_;
  int parkingspace_direction_;
  ::PROTOBUF_NAMESPACE_ID::int32 parkingspace_floor_id_;
  float parkingspace_width_;
  float parkingspace_height_;
  int parkingspace_status_;
  int parkspace_path_;
  float path_estimate_time_;
  int parkspace_status_target_;
  friend struct ::TableStruct_message_5fbase_2eproto;
};
// ===================================================================


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

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

// required .message.Message_type msg_type = 1 [default = eBase_msg];
inline bool Base_info::_internal_has_msg_type() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Base_info::has_msg_type() const {
  return _internal_has_msg_type();
}
inline void Base_info::clear_msg_type() {
  msg_type_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::message::Message_type Base_info::_internal_msg_type() const {
  return static_cast< ::message::Message_type >(msg_type_);
}
inline ::message::Message_type Base_info::msg_type() const {
  // @@protoc_insertion_point(field_get:message.Base_info.msg_type)
  return _internal_msg_type();
}
inline void Base_info::_internal_set_msg_type(::message::Message_type value) {
  assert(::message::Message_type_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  msg_type_ = value;
}
inline void Base_info::set_msg_type(::message::Message_type value) {
  _internal_set_msg_type(value);
  // @@protoc_insertion_point(field_set:message.Base_info.msg_type)
}

// optional int32 timeout_ms = 2 [default = 0];
inline bool Base_info::_internal_has_timeout_ms() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Base_info::has_timeout_ms() const {
  return _internal_has_timeout_ms();
}
inline void Base_info::clear_timeout_ms() {
  timeout_ms_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Base_info::_internal_timeout_ms() const {
  return timeout_ms_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Base_info::timeout_ms() const {
  // @@protoc_insertion_point(field_get:message.Base_info.timeout_ms)
  return _internal_timeout_ms();
}
inline void Base_info::_internal_set_timeout_ms(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000002u;
  timeout_ms_ = value;
}
inline void Base_info::set_timeout_ms(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_timeout_ms(value);
  // @@protoc_insertion_point(field_set:message.Base_info.timeout_ms)
}

// required .message.Communicator sender = 3 [default = eEmpty];
inline bool Base_info::_internal_has_sender() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Base_info::has_sender() const {
  return _internal_has_sender();
}
inline void Base_info::clear_sender() {
  sender_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::message::Communicator Base_info::_internal_sender() const {
  return static_cast< ::message::Communicator >(sender_);
}
inline ::message::Communicator Base_info::sender() const {
  // @@protoc_insertion_point(field_get:message.Base_info.sender)
  return _internal_sender();
}
inline void Base_info::_internal_set_sender(::message::Communicator value) {
  assert(::message::Communicator_IsValid(value));
  _has_bits_[0] |= 0x00000004u;
  sender_ = value;
}
inline void Base_info::set_sender(::message::Communicator value) {
  _internal_set_sender(value);
  // @@protoc_insertion_point(field_set:message.Base_info.sender)
}

// required .message.Communicator receiver = 4 [default = eEmpty];
inline bool Base_info::_internal_has_receiver() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Base_info::has_receiver() const {
  return _internal_has_receiver();
}
inline void Base_info::clear_receiver() {
  receiver_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::message::Communicator Base_info::_internal_receiver() const {
  return static_cast< ::message::Communicator >(receiver_);
}
inline ::message::Communicator Base_info::receiver() const {
  // @@protoc_insertion_point(field_get:message.Base_info.receiver)
  return _internal_receiver();
}
inline void Base_info::_internal_set_receiver(::message::Communicator value) {
  assert(::message::Communicator_IsValid(value));
  _has_bits_[0] |= 0x00000008u;
  receiver_ = value;
}
inline void Base_info::set_receiver(::message::Communicator value) {
  _internal_set_receiver(value);
  // @@protoc_insertion_point(field_set:message.Base_info.receiver)
}

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

// Base_msg

// required .message.Base_info base_info = 1;
inline bool Base_msg::_internal_has_base_info() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || base_info_ != nullptr);
  return value;
}
inline bool Base_msg::has_base_info() const {
  return _internal_has_base_info();
}
inline void Base_msg::clear_base_info() {
  if (base_info_ != nullptr) base_info_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::message::Base_info& Base_msg::_internal_base_info() const {
  const ::message::Base_info* p = base_info_;
  return p != nullptr ? *p : *reinterpret_cast<const ::message::Base_info*>(
      &::message::_Base_info_default_instance_);
}
inline const ::message::Base_info& Base_msg::base_info() const {
  // @@protoc_insertion_point(field_get:message.Base_msg.base_info)
  return _internal_base_info();
}
inline void Base_msg::unsafe_arena_set_allocated_base_info(
    ::message::Base_info* base_info) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_info_);
  }
  base_info_ = base_info;
  if (base_info) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Base_msg.base_info)
}
inline ::message::Base_info* Base_msg::release_base_info() {
  _has_bits_[0] &= ~0x00000001u;
  ::message::Base_info* temp = base_info_;
  base_info_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::message::Base_info* Base_msg::unsafe_arena_release_base_info() {
  // @@protoc_insertion_point(field_release:message.Base_msg.base_info)
  _has_bits_[0] &= ~0x00000001u;
  ::message::Base_info* temp = base_info_;
  base_info_ = nullptr;
  return temp;
}
inline ::message::Base_info* Base_msg::_internal_mutable_base_info() {
  _has_bits_[0] |= 0x00000001u;
  if (base_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::message::Base_info>(GetArena());
    base_info_ = p;
  }
  return base_info_;
}
inline ::message::Base_info* Base_msg::mutable_base_info() {
  // @@protoc_insertion_point(field_mutable:message.Base_msg.base_info)
  return _internal_mutable_base_info();
}
inline void Base_msg::set_allocated_base_info(::message::Base_info* base_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete base_info_;
  }
  if (base_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(base_info);
    if (message_arena != submessage_arena) {
      base_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, base_info, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  base_info_ = base_info;
  // @@protoc_insertion_point(field_set_allocated:message.Base_msg.base_info)
}

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

// Error_manager

// required int32 error_code = 1 [default = 0];
inline bool Error_manager::_internal_has_error_code() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Error_manager::has_error_code() const {
  return _internal_has_error_code();
}
inline void Error_manager::clear_error_code() {
  error_code_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Error_manager::_internal_error_code() const {
  return error_code_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Error_manager::error_code() const {
  // @@protoc_insertion_point(field_get:message.Error_manager.error_code)
  return _internal_error_code();
}
inline void Error_manager::_internal_set_error_code(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000002u;
  error_code_ = value;
}
inline void Error_manager::set_error_code(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_error_code(value);
  // @@protoc_insertion_point(field_set:message.Error_manager.error_code)
}

// optional .message.Error_level error_level = 2 [default = NORMAL];
inline bool Error_manager::_internal_has_error_level() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Error_manager::has_error_level() const {
  return _internal_has_error_level();
}
inline void Error_manager::clear_error_level() {
  error_level_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::message::Error_level Error_manager::_internal_error_level() const {
  return static_cast< ::message::Error_level >(error_level_);
}
inline ::message::Error_level Error_manager::error_level() const {
  // @@protoc_insertion_point(field_get:message.Error_manager.error_level)
  return _internal_error_level();
}
inline void Error_manager::_internal_set_error_level(::message::Error_level value) {
  assert(::message::Error_level_IsValid(value));
  _has_bits_[0] |= 0x00000004u;
  error_level_ = value;
}
inline void Error_manager::set_error_level(::message::Error_level value) {
  _internal_set_error_level(value);
  // @@protoc_insertion_point(field_set:message.Error_manager.error_level)
}

// optional string error_description = 3 [default = ""];
inline bool Error_manager::_internal_has_error_description() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Error_manager::has_error_description() const {
  return _internal_has_error_description();
}
inline void Error_manager::clear_error_description() {
  error_description_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Error_manager::error_description() const {
  // @@protoc_insertion_point(field_get:message.Error_manager.error_description)
  return _internal_error_description();
}
inline void Error_manager::set_error_description(const std::string& value) {
  _internal_set_error_description(value);
  // @@protoc_insertion_point(field_set:message.Error_manager.error_description)
}
inline std::string* Error_manager::mutable_error_description() {
  // @@protoc_insertion_point(field_mutable:message.Error_manager.error_description)
  return _internal_mutable_error_description();
}
inline const std::string& Error_manager::_internal_error_description() const {
  return error_description_.Get();
}
inline void Error_manager::_internal_set_error_description(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  error_description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Error_manager::set_error_description(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  error_description_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:message.Error_manager.error_description)
}
inline void Error_manager::set_error_description(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  error_description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:message.Error_manager.error_description)
}
inline void Error_manager::set_error_description(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  error_description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:message.Error_manager.error_description)
}
inline std::string* Error_manager::_internal_mutable_error_description() {
  _has_bits_[0] |= 0x00000001u;
  return error_description_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Error_manager::release_error_description() {
  // @@protoc_insertion_point(field_release:message.Error_manager.error_description)
  if (!_internal_has_error_description()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return error_description_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Error_manager::set_allocated_error_description(std::string* error_description) {
  if (error_description != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  error_description_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), error_description,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:message.Error_manager.error_description)
}

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

// Locate_information

// optional float locate_x = 1 [default = 0];
inline bool Locate_information::_internal_has_locate_x() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Locate_information::has_locate_x() const {
  return _internal_has_locate_x();
}
inline void Locate_information::clear_locate_x() {
  locate_x_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline float Locate_information::_internal_locate_x() const {
  return locate_x_;
}
inline float Locate_information::locate_x() const {
  // @@protoc_insertion_point(field_get:message.Locate_information.locate_x)
  return _internal_locate_x();
}
inline void Locate_information::_internal_set_locate_x(float value) {
  _has_bits_[0] |= 0x00000001u;
  locate_x_ = value;
}
inline void Locate_information::set_locate_x(float value) {
  _internal_set_locate_x(value);
  // @@protoc_insertion_point(field_set:message.Locate_information.locate_x)
}

// optional float locate_y = 2 [default = 0];
inline bool Locate_information::_internal_has_locate_y() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Locate_information::has_locate_y() const {
  return _internal_has_locate_y();
}
inline void Locate_information::clear_locate_y() {
  locate_y_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline float Locate_information::_internal_locate_y() const {
  return locate_y_;
}
inline float Locate_information::locate_y() const {
  // @@protoc_insertion_point(field_get:message.Locate_information.locate_y)
  return _internal_locate_y();
}
inline void Locate_information::_internal_set_locate_y(float value) {
  _has_bits_[0] |= 0x00000002u;
  locate_y_ = value;
}
inline void Locate_information::set_locate_y(float value) {
  _internal_set_locate_y(value);
  // @@protoc_insertion_point(field_set:message.Locate_information.locate_y)
}

// optional float locate_angle = 3 [default = 0];
inline bool Locate_information::_internal_has_locate_angle() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Locate_information::has_locate_angle() const {
  return _internal_has_locate_angle();
}
inline void Locate_information::clear_locate_angle() {
  locate_angle_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline float Locate_information::_internal_locate_angle() const {
  return locate_angle_;
}
inline float Locate_information::locate_angle() const {
  // @@protoc_insertion_point(field_get:message.Locate_information.locate_angle)
  return _internal_locate_angle();
}
inline void Locate_information::_internal_set_locate_angle(float value) {
  _has_bits_[0] |= 0x00000004u;
  locate_angle_ = value;
}
inline void Locate_information::set_locate_angle(float value) {
  _internal_set_locate_angle(value);
  // @@protoc_insertion_point(field_set:message.Locate_information.locate_angle)
}

// optional float locate_length = 4 [default = 0];
inline bool Locate_information::_internal_has_locate_length() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Locate_information::has_locate_length() const {
  return _internal_has_locate_length();
}
inline void Locate_information::clear_locate_length() {
  locate_length_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline float Locate_information::_internal_locate_length() const {
  return locate_length_;
}
inline float Locate_information::locate_length() const {
  // @@protoc_insertion_point(field_get:message.Locate_information.locate_length)
  return _internal_locate_length();
}
inline void Locate_information::_internal_set_locate_length(float value) {
  _has_bits_[0] |= 0x00000008u;
  locate_length_ = value;
}
inline void Locate_information::set_locate_length(float value) {
  _internal_set_locate_length(value);
  // @@protoc_insertion_point(field_set:message.Locate_information.locate_length)
}

// optional float locate_width = 5 [default = 0];
inline bool Locate_information::_internal_has_locate_width() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Locate_information::has_locate_width() const {
  return _internal_has_locate_width();
}
inline void Locate_information::clear_locate_width() {
  locate_width_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline float Locate_information::_internal_locate_width() const {
  return locate_width_;
}
inline float Locate_information::locate_width() const {
  // @@protoc_insertion_point(field_get:message.Locate_information.locate_width)
  return _internal_locate_width();
}
inline void Locate_information::_internal_set_locate_width(float value) {
  _has_bits_[0] |= 0x00000010u;
  locate_width_ = value;
}
inline void Locate_information::set_locate_width(float value) {
  _internal_set_locate_width(value);
  // @@protoc_insertion_point(field_set:message.Locate_information.locate_width)
}

// optional float locate_height = 6 [default = 0];
inline bool Locate_information::_internal_has_locate_height() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Locate_information::has_locate_height() const {
  return _internal_has_locate_height();
}
inline void Locate_information::clear_locate_height() {
  locate_height_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline float Locate_information::_internal_locate_height() const {
  return locate_height_;
}
inline float Locate_information::locate_height() const {
  // @@protoc_insertion_point(field_get:message.Locate_information.locate_height)
  return _internal_locate_height();
}
inline void Locate_information::_internal_set_locate_height(float value) {
  _has_bits_[0] |= 0x00000020u;
  locate_height_ = value;
}
inline void Locate_information::set_locate_height(float value) {
  _internal_set_locate_height(value);
  // @@protoc_insertion_point(field_set:message.Locate_information.locate_height)
}

// optional float locate_wheel_base = 7 [default = 0];
inline bool Locate_information::_internal_has_locate_wheel_base() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Locate_information::has_locate_wheel_base() const {
  return _internal_has_locate_wheel_base();
}
inline void Locate_information::clear_locate_wheel_base() {
  locate_wheel_base_ = 0;
  _has_bits_[0] &= ~0x00000040u;
}
inline float Locate_information::_internal_locate_wheel_base() const {
  return locate_wheel_base_;
}
inline float Locate_information::locate_wheel_base() const {
  // @@protoc_insertion_point(field_get:message.Locate_information.locate_wheel_base)
  return _internal_locate_wheel_base();
}
inline void Locate_information::_internal_set_locate_wheel_base(float value) {
  _has_bits_[0] |= 0x00000040u;
  locate_wheel_base_ = value;
}
inline void Locate_information::set_locate_wheel_base(float value) {
  _internal_set_locate_wheel_base(value);
  // @@protoc_insertion_point(field_set:message.Locate_information.locate_wheel_base)
}

// optional float locate_wheel_width = 8 [default = 0];
inline bool Locate_information::_internal_has_locate_wheel_width() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Locate_information::has_locate_wheel_width() const {
  return _internal_has_locate_wheel_width();
}
inline void Locate_information::clear_locate_wheel_width() {
  locate_wheel_width_ = 0;
  _has_bits_[0] &= ~0x00000080u;
}
inline float Locate_information::_internal_locate_wheel_width() const {
  return locate_wheel_width_;
}
inline float Locate_information::locate_wheel_width() const {
  // @@protoc_insertion_point(field_get:message.Locate_information.locate_wheel_width)
  return _internal_locate_wheel_width();
}
inline void Locate_information::_internal_set_locate_wheel_width(float value) {
  _has_bits_[0] |= 0x00000080u;
  locate_wheel_width_ = value;
}
inline void Locate_information::set_locate_wheel_width(float value) {
  _internal_set_locate_wheel_width(value);
  // @@protoc_insertion_point(field_set:message.Locate_information.locate_wheel_width)
}

// optional bool locate_correct = 9 [default = false];
inline bool Locate_information::_internal_has_locate_correct() const {
  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Locate_information::has_locate_correct() const {
  return _internal_has_locate_correct();
}
inline void Locate_information::clear_locate_correct() {
  locate_correct_ = false;
  _has_bits_[0] &= ~0x00000100u;
}
inline bool Locate_information::_internal_locate_correct() const {
  return locate_correct_;
}
inline bool Locate_information::locate_correct() const {
  // @@protoc_insertion_point(field_get:message.Locate_information.locate_correct)
  return _internal_locate_correct();
}
inline void Locate_information::_internal_set_locate_correct(bool value) {
  _has_bits_[0] |= 0x00000100u;
  locate_correct_ = value;
}
inline void Locate_information::set_locate_correct(bool value) {
  _internal_set_locate_correct(value);
  // @@protoc_insertion_point(field_set:message.Locate_information.locate_correct)
}

// optional float locate_front_theta = 10 [default = 0];
inline bool Locate_information::_internal_has_locate_front_theta() const {
  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Locate_information::has_locate_front_theta() const {
  return _internal_has_locate_front_theta();
}
inline void Locate_information::clear_locate_front_theta() {
  locate_front_theta_ = 0;
  _has_bits_[0] &= ~0x00000200u;
}
inline float Locate_information::_internal_locate_front_theta() const {
  return locate_front_theta_;
}
inline float Locate_information::locate_front_theta() const {
  // @@protoc_insertion_point(field_get:message.Locate_information.locate_front_theta)
  return _internal_locate_front_theta();
}
inline void Locate_information::_internal_set_locate_front_theta(float value) {
  _has_bits_[0] |= 0x00000200u;
  locate_front_theta_ = value;
}
inline void Locate_information::set_locate_front_theta(float value) {
  _internal_set_locate_front_theta(value);
  // @@protoc_insertion_point(field_set:message.Locate_information.locate_front_theta)
}

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

// Car_info

// optional float car_length = 1 [default = 0];
inline bool Car_info::_internal_has_car_length() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Car_info::has_car_length() const {
  return _internal_has_car_length();
}
inline void Car_info::clear_car_length() {
  car_length_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline float Car_info::_internal_car_length() const {
  return car_length_;
}
inline float Car_info::car_length() const {
  // @@protoc_insertion_point(field_get:message.Car_info.car_length)
  return _internal_car_length();
}
inline void Car_info::_internal_set_car_length(float value) {
  _has_bits_[0] |= 0x00000002u;
  car_length_ = value;
}
inline void Car_info::set_car_length(float value) {
  _internal_set_car_length(value);
  // @@protoc_insertion_point(field_set:message.Car_info.car_length)
}

// optional float car_width = 2 [default = 0];
inline bool Car_info::_internal_has_car_width() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Car_info::has_car_width() const {
  return _internal_has_car_width();
}
inline void Car_info::clear_car_width() {
  car_width_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline float Car_info::_internal_car_width() const {
  return car_width_;
}
inline float Car_info::car_width() const {
  // @@protoc_insertion_point(field_get:message.Car_info.car_width)
  return _internal_car_width();
}
inline void Car_info::_internal_set_car_width(float value) {
  _has_bits_[0] |= 0x00000004u;
  car_width_ = value;
}
inline void Car_info::set_car_width(float value) {
  _internal_set_car_width(value);
  // @@protoc_insertion_point(field_set:message.Car_info.car_width)
}

// optional float car_height = 3 [default = 0];
inline bool Car_info::_internal_has_car_height() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Car_info::has_car_height() const {
  return _internal_has_car_height();
}
inline void Car_info::clear_car_height() {
  car_height_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline float Car_info::_internal_car_height() const {
  return car_height_;
}
inline float Car_info::car_height() const {
  // @@protoc_insertion_point(field_get:message.Car_info.car_height)
  return _internal_car_height();
}
inline void Car_info::_internal_set_car_height(float value) {
  _has_bits_[0] |= 0x00000008u;
  car_height_ = value;
}
inline void Car_info::set_car_height(float value) {
  _internal_set_car_height(value);
  // @@protoc_insertion_point(field_set:message.Car_info.car_height)
}

// optional string license = 4 [default = ""];
inline bool Car_info::_internal_has_license() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Car_info::has_license() const {
  return _internal_has_license();
}
inline void Car_info::clear_license() {
  license_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Car_info::license() const {
  // @@protoc_insertion_point(field_get:message.Car_info.license)
  return _internal_license();
}
inline void Car_info::set_license(const std::string& value) {
  _internal_set_license(value);
  // @@protoc_insertion_point(field_set:message.Car_info.license)
}
inline std::string* Car_info::mutable_license() {
  // @@protoc_insertion_point(field_mutable:message.Car_info.license)
  return _internal_mutable_license();
}
inline const std::string& Car_info::_internal_license() const {
  return license_.Get();
}
inline void Car_info::_internal_set_license(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  license_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Car_info::set_license(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  license_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:message.Car_info.license)
}
inline void Car_info::set_license(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  license_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:message.Car_info.license)
}
inline void Car_info::set_license(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  license_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:message.Car_info.license)
}
inline std::string* Car_info::_internal_mutable_license() {
  _has_bits_[0] |= 0x00000001u;
  return license_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Car_info::release_license() {
  // @@protoc_insertion_point(field_release:message.Car_info.license)
  if (!_internal_has_license()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return license_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Car_info::set_allocated_license(std::string* license) {
  if (license != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  license_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), license,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:message.Car_info.license)
}

// optional float car_wheel_base = 5 [default = 0];
inline bool Car_info::_internal_has_car_wheel_base() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Car_info::has_car_wheel_base() const {
  return _internal_has_car_wheel_base();
}
inline void Car_info::clear_car_wheel_base() {
  car_wheel_base_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline float Car_info::_internal_car_wheel_base() const {
  return car_wheel_base_;
}
inline float Car_info::car_wheel_base() const {
  // @@protoc_insertion_point(field_get:message.Car_info.car_wheel_base)
  return _internal_car_wheel_base();
}
inline void Car_info::_internal_set_car_wheel_base(float value) {
  _has_bits_[0] |= 0x00000010u;
  car_wheel_base_ = value;
}
inline void Car_info::set_car_wheel_base(float value) {
  _internal_set_car_wheel_base(value);
  // @@protoc_insertion_point(field_set:message.Car_info.car_wheel_base)
}

// optional float car_wheel_width = 6 [default = 0];
inline bool Car_info::_internal_has_car_wheel_width() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Car_info::has_car_wheel_width() const {
  return _internal_has_car_wheel_width();
}
inline void Car_info::clear_car_wheel_width() {
  car_wheel_width_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline float Car_info::_internal_car_wheel_width() const {
  return car_wheel_width_;
}
inline float Car_info::car_wheel_width() const {
  // @@protoc_insertion_point(field_get:message.Car_info.car_wheel_width)
  return _internal_car_wheel_width();
}
inline void Car_info::_internal_set_car_wheel_width(float value) {
  _has_bits_[0] |= 0x00000020u;
  car_wheel_width_ = value;
}
inline void Car_info::set_car_wheel_width(float value) {
  _internal_set_car_wheel_width(value);
  // @@protoc_insertion_point(field_set:message.Car_info.car_wheel_width)
}

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

// Parkspace_info

// optional int32 parkingspace_index_id = 1;
inline bool Parkspace_info::_internal_has_parkingspace_index_id() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Parkspace_info::has_parkingspace_index_id() const {
  return _internal_has_parkingspace_index_id();
}
inline void Parkspace_info::clear_parkingspace_index_id() {
  parkingspace_index_id_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Parkspace_info::_internal_parkingspace_index_id() const {
  return parkingspace_index_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Parkspace_info::parkingspace_index_id() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.parkingspace_index_id)
  return _internal_parkingspace_index_id();
}
inline void Parkspace_info::_internal_set_parkingspace_index_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000008u;
  parkingspace_index_id_ = value;
}
inline void Parkspace_info::set_parkingspace_index_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_parkingspace_index_id(value);
  // @@protoc_insertion_point(field_set:message.Parkspace_info.parkingspace_index_id)
}

// optional .message.Parkspace_type parkingspace_type = 2;
inline bool Parkspace_info::_internal_has_parkingspace_type() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Parkspace_info::has_parkingspace_type() const {
  return _internal_has_parkingspace_type();
}
inline void Parkspace_info::clear_parkingspace_type() {
  parkingspace_type_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::message::Parkspace_type Parkspace_info::_internal_parkingspace_type() const {
  return static_cast< ::message::Parkspace_type >(parkingspace_type_);
}
inline ::message::Parkspace_type Parkspace_info::parkingspace_type() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.parkingspace_type)
  return _internal_parkingspace_type();
}
inline void Parkspace_info::_internal_set_parkingspace_type(::message::Parkspace_type value) {
  assert(::message::Parkspace_type_IsValid(value));
  _has_bits_[0] |= 0x00000010u;
  parkingspace_type_ = value;
}
inline void Parkspace_info::set_parkingspace_type(::message::Parkspace_type value) {
  _internal_set_parkingspace_type(value);
  // @@protoc_insertion_point(field_set:message.Parkspace_info.parkingspace_type)
}

// optional int32 parkingspace_unit_id = 3;
inline bool Parkspace_info::_internal_has_parkingspace_unit_id() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Parkspace_info::has_parkingspace_unit_id() const {
  return _internal_has_parkingspace_unit_id();
}
inline void Parkspace_info::clear_parkingspace_unit_id() {
  parkingspace_unit_id_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Parkspace_info::_internal_parkingspace_unit_id() const {
  return parkingspace_unit_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Parkspace_info::parkingspace_unit_id() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.parkingspace_unit_id)
  return _internal_parkingspace_unit_id();
}
inline void Parkspace_info::_internal_set_parkingspace_unit_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000020u;
  parkingspace_unit_id_ = value;
}
inline void Parkspace_info::set_parkingspace_unit_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_parkingspace_unit_id(value);
  // @@protoc_insertion_point(field_set:message.Parkspace_info.parkingspace_unit_id)
}

// optional int32 parkingspace_room_id = 4;
inline bool Parkspace_info::_internal_has_parkingspace_room_id() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Parkspace_info::has_parkingspace_room_id() const {
  return _internal_has_parkingspace_room_id();
}
inline void Parkspace_info::clear_parkingspace_room_id() {
  parkingspace_room_id_ = 0;
  _has_bits_[0] &= ~0x00000040u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Parkspace_info::_internal_parkingspace_room_id() const {
  return parkingspace_room_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Parkspace_info::parkingspace_room_id() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.parkingspace_room_id)
  return _internal_parkingspace_room_id();
}
inline void Parkspace_info::_internal_set_parkingspace_room_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000040u;
  parkingspace_room_id_ = value;
}
inline void Parkspace_info::set_parkingspace_room_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_parkingspace_room_id(value);
  // @@protoc_insertion_point(field_set:message.Parkspace_info.parkingspace_room_id)
}

// optional .message.Direction parkingspace_direction = 5;
inline bool Parkspace_info::_internal_has_parkingspace_direction() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Parkspace_info::has_parkingspace_direction() const {
  return _internal_has_parkingspace_direction();
}
inline void Parkspace_info::clear_parkingspace_direction() {
  parkingspace_direction_ = 0;
  _has_bits_[0] &= ~0x00000080u;
}
inline ::message::Direction Parkspace_info::_internal_parkingspace_direction() const {
  return static_cast< ::message::Direction >(parkingspace_direction_);
}
inline ::message::Direction Parkspace_info::parkingspace_direction() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.parkingspace_direction)
  return _internal_parkingspace_direction();
}
inline void Parkspace_info::_internal_set_parkingspace_direction(::message::Direction value) {
  assert(::message::Direction_IsValid(value));
  _has_bits_[0] |= 0x00000080u;
  parkingspace_direction_ = value;
}
inline void Parkspace_info::set_parkingspace_direction(::message::Direction value) {
  _internal_set_parkingspace_direction(value);
  // @@protoc_insertion_point(field_set:message.Parkspace_info.parkingspace_direction)
}

// optional int32 parkingspace_floor_id = 6;
inline bool Parkspace_info::_internal_has_parkingspace_floor_id() const {
  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Parkspace_info::has_parkingspace_floor_id() const {
  return _internal_has_parkingspace_floor_id();
}
inline void Parkspace_info::clear_parkingspace_floor_id() {
  parkingspace_floor_id_ = 0;
  _has_bits_[0] &= ~0x00000100u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Parkspace_info::_internal_parkingspace_floor_id() const {
  return parkingspace_floor_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Parkspace_info::parkingspace_floor_id() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.parkingspace_floor_id)
  return _internal_parkingspace_floor_id();
}
inline void Parkspace_info::_internal_set_parkingspace_floor_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000100u;
  parkingspace_floor_id_ = value;
}
inline void Parkspace_info::set_parkingspace_floor_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_parkingspace_floor_id(value);
  // @@protoc_insertion_point(field_set:message.Parkspace_info.parkingspace_floor_id)
}

// optional float parkingspace_width = 7;
inline bool Parkspace_info::_internal_has_parkingspace_width() const {
  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Parkspace_info::has_parkingspace_width() const {
  return _internal_has_parkingspace_width();
}
inline void Parkspace_info::clear_parkingspace_width() {
  parkingspace_width_ = 0;
  _has_bits_[0] &= ~0x00000200u;
}
inline float Parkspace_info::_internal_parkingspace_width() const {
  return parkingspace_width_;
}
inline float Parkspace_info::parkingspace_width() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.parkingspace_width)
  return _internal_parkingspace_width();
}
inline void Parkspace_info::_internal_set_parkingspace_width(float value) {
  _has_bits_[0] |= 0x00000200u;
  parkingspace_width_ = value;
}
inline void Parkspace_info::set_parkingspace_width(float value) {
  _internal_set_parkingspace_width(value);
  // @@protoc_insertion_point(field_set:message.Parkspace_info.parkingspace_width)
}

// optional float parkingspace_height = 8;
inline bool Parkspace_info::_internal_has_parkingspace_height() const {
  bool value = (_has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Parkspace_info::has_parkingspace_height() const {
  return _internal_has_parkingspace_height();
}
inline void Parkspace_info::clear_parkingspace_height() {
  parkingspace_height_ = 0;
  _has_bits_[0] &= ~0x00000400u;
}
inline float Parkspace_info::_internal_parkingspace_height() const {
  return parkingspace_height_;
}
inline float Parkspace_info::parkingspace_height() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.parkingspace_height)
  return _internal_parkingspace_height();
}
inline void Parkspace_info::_internal_set_parkingspace_height(float value) {
  _has_bits_[0] |= 0x00000400u;
  parkingspace_height_ = value;
}
inline void Parkspace_info::set_parkingspace_height(float value) {
  _internal_set_parkingspace_height(value);
  // @@protoc_insertion_point(field_set:message.Parkspace_info.parkingspace_height)
}

// optional .message.Parkspace_status parkingspace_status = 9;
inline bool Parkspace_info::_internal_has_parkingspace_status() const {
  bool value = (_has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool Parkspace_info::has_parkingspace_status() const {
  return _internal_has_parkingspace_status();
}
inline void Parkspace_info::clear_parkingspace_status() {
  parkingspace_status_ = 0;
  _has_bits_[0] &= ~0x00000800u;
}
inline ::message::Parkspace_status Parkspace_info::_internal_parkingspace_status() const {
  return static_cast< ::message::Parkspace_status >(parkingspace_status_);
}
inline ::message::Parkspace_status Parkspace_info::parkingspace_status() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.parkingspace_status)
  return _internal_parkingspace_status();
}
inline void Parkspace_info::_internal_set_parkingspace_status(::message::Parkspace_status value) {
  assert(::message::Parkspace_status_IsValid(value));
  _has_bits_[0] |= 0x00000800u;
  parkingspace_status_ = value;
}
inline void Parkspace_info::set_parkingspace_status(::message::Parkspace_status value) {
  _internal_set_parkingspace_status(value);
  // @@protoc_insertion_point(field_set:message.Parkspace_info.parkingspace_status)
}

// optional .message.Car_info car_info = 10;
inline bool Parkspace_info::_internal_has_car_info() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || car_info_ != nullptr);
  return value;
}
inline bool Parkspace_info::has_car_info() const {
  return _internal_has_car_info();
}
inline void Parkspace_info::clear_car_info() {
  if (car_info_ != nullptr) car_info_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::message::Car_info& Parkspace_info::_internal_car_info() const {
  const ::message::Car_info* p = car_info_;
  return p != nullptr ? *p : *reinterpret_cast<const ::message::Car_info*>(
      &::message::_Car_info_default_instance_);
}
inline const ::message::Car_info& Parkspace_info::car_info() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.car_info)
  return _internal_car_info();
}
inline void Parkspace_info::unsafe_arena_set_allocated_car_info(
    ::message::Car_info* car_info) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(car_info_);
  }
  car_info_ = car_info;
  if (car_info) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Parkspace_info.car_info)
}
inline ::message::Car_info* Parkspace_info::release_car_info() {
  _has_bits_[0] &= ~0x00000004u;
  ::message::Car_info* temp = car_info_;
  car_info_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::message::Car_info* Parkspace_info::unsafe_arena_release_car_info() {
  // @@protoc_insertion_point(field_release:message.Parkspace_info.car_info)
  _has_bits_[0] &= ~0x00000004u;
  ::message::Car_info* temp = car_info_;
  car_info_ = nullptr;
  return temp;
}
inline ::message::Car_info* Parkspace_info::_internal_mutable_car_info() {
  _has_bits_[0] |= 0x00000004u;
  if (car_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::message::Car_info>(GetArena());
    car_info_ = p;
  }
  return car_info_;
}
inline ::message::Car_info* Parkspace_info::mutable_car_info() {
  // @@protoc_insertion_point(field_mutable:message.Parkspace_info.car_info)
  return _internal_mutable_car_info();
}
inline void Parkspace_info::set_allocated_car_info(::message::Car_info* car_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete car_info_;
  }
  if (car_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(car_info);
    if (message_arena != submessage_arena) {
      car_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, car_info, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  car_info_ = car_info;
  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_info.car_info)
}

// optional string entry_time = 11;
inline bool Parkspace_info::_internal_has_entry_time() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Parkspace_info::has_entry_time() const {
  return _internal_has_entry_time();
}
inline void Parkspace_info::clear_entry_time() {
  entry_time_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Parkspace_info::entry_time() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.entry_time)
  return _internal_entry_time();
}
inline void Parkspace_info::set_entry_time(const std::string& value) {
  _internal_set_entry_time(value);
  // @@protoc_insertion_point(field_set:message.Parkspace_info.entry_time)
}
inline std::string* Parkspace_info::mutable_entry_time() {
  // @@protoc_insertion_point(field_mutable:message.Parkspace_info.entry_time)
  return _internal_mutable_entry_time();
}
inline const std::string& Parkspace_info::_internal_entry_time() const {
  return entry_time_.Get();
}
inline void Parkspace_info::_internal_set_entry_time(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  entry_time_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Parkspace_info::set_entry_time(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  entry_time_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:message.Parkspace_info.entry_time)
}
inline void Parkspace_info::set_entry_time(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  entry_time_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:message.Parkspace_info.entry_time)
}
inline void Parkspace_info::set_entry_time(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  entry_time_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:message.Parkspace_info.entry_time)
}
inline std::string* Parkspace_info::_internal_mutable_entry_time() {
  _has_bits_[0] |= 0x00000001u;
  return entry_time_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Parkspace_info::release_entry_time() {
  // @@protoc_insertion_point(field_release:message.Parkspace_info.entry_time)
  if (!_internal_has_entry_time()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return entry_time_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Parkspace_info::set_allocated_entry_time(std::string* entry_time) {
  if (entry_time != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  entry_time_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), entry_time,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_info.entry_time)
}

// optional string leave_time = 12;
inline bool Parkspace_info::_internal_has_leave_time() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Parkspace_info::has_leave_time() const {
  return _internal_has_leave_time();
}
inline void Parkspace_info::clear_leave_time() {
  leave_time_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Parkspace_info::leave_time() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.leave_time)
  return _internal_leave_time();
}
inline void Parkspace_info::set_leave_time(const std::string& value) {
  _internal_set_leave_time(value);
  // @@protoc_insertion_point(field_set:message.Parkspace_info.leave_time)
}
inline std::string* Parkspace_info::mutable_leave_time() {
  // @@protoc_insertion_point(field_mutable:message.Parkspace_info.leave_time)
  return _internal_mutable_leave_time();
}
inline const std::string& Parkspace_info::_internal_leave_time() const {
  return leave_time_.Get();
}
inline void Parkspace_info::_internal_set_leave_time(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  leave_time_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Parkspace_info::set_leave_time(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  leave_time_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:message.Parkspace_info.leave_time)
}
inline void Parkspace_info::set_leave_time(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  leave_time_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:message.Parkspace_info.leave_time)
}
inline void Parkspace_info::set_leave_time(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  leave_time_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:message.Parkspace_info.leave_time)
}
inline std::string* Parkspace_info::_internal_mutable_leave_time() {
  _has_bits_[0] |= 0x00000002u;
  return leave_time_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Parkspace_info::release_leave_time() {
  // @@protoc_insertion_point(field_release:message.Parkspace_info.leave_time)
  if (!_internal_has_leave_time()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return leave_time_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Parkspace_info::set_allocated_leave_time(std::string* leave_time) {
  if (leave_time != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  leave_time_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), leave_time,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_info.leave_time)
}

// optional .message.Parkspace_path parkspace_path = 13;
inline bool Parkspace_info::_internal_has_parkspace_path() const {
  bool value = (_has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool Parkspace_info::has_parkspace_path() const {
  return _internal_has_parkspace_path();
}
inline void Parkspace_info::clear_parkspace_path() {
  parkspace_path_ = 0;
  _has_bits_[0] &= ~0x00001000u;
}
inline ::message::Parkspace_path Parkspace_info::_internal_parkspace_path() const {
  return static_cast< ::message::Parkspace_path >(parkspace_path_);
}
inline ::message::Parkspace_path Parkspace_info::parkspace_path() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.parkspace_path)
  return _internal_parkspace_path();
}
inline void Parkspace_info::_internal_set_parkspace_path(::message::Parkspace_path value) {
  assert(::message::Parkspace_path_IsValid(value));
  _has_bits_[0] |= 0x00001000u;
  parkspace_path_ = value;
}
inline void Parkspace_info::set_parkspace_path(::message::Parkspace_path value) {
  _internal_set_parkspace_path(value);
  // @@protoc_insertion_point(field_set:message.Parkspace_info.parkspace_path)
}

// optional float path_estimate_time = 14;
inline bool Parkspace_info::_internal_has_path_estimate_time() const {
  bool value = (_has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool Parkspace_info::has_path_estimate_time() const {
  return _internal_has_path_estimate_time();
}
inline void Parkspace_info::clear_path_estimate_time() {
  path_estimate_time_ = 0;
  _has_bits_[0] &= ~0x00002000u;
}
inline float Parkspace_info::_internal_path_estimate_time() const {
  return path_estimate_time_;
}
inline float Parkspace_info::path_estimate_time() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.path_estimate_time)
  return _internal_path_estimate_time();
}
inline void Parkspace_info::_internal_set_path_estimate_time(float value) {
  _has_bits_[0] |= 0x00002000u;
  path_estimate_time_ = value;
}
inline void Parkspace_info::set_path_estimate_time(float value) {
  _internal_set_path_estimate_time(value);
  // @@protoc_insertion_point(field_set:message.Parkspace_info.path_estimate_time)
}

// optional .message.Parkspace_status parkspace_status_target = 15;
inline bool Parkspace_info::_internal_has_parkspace_status_target() const {
  bool value = (_has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool Parkspace_info::has_parkspace_status_target() const {
  return _internal_has_parkspace_status_target();
}
inline void Parkspace_info::clear_parkspace_status_target() {
  parkspace_status_target_ = 0;
  _has_bits_[0] &= ~0x00004000u;
}
inline ::message::Parkspace_status Parkspace_info::_internal_parkspace_status_target() const {
  return static_cast< ::message::Parkspace_status >(parkspace_status_target_);
}
inline ::message::Parkspace_status Parkspace_info::parkspace_status_target() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.parkspace_status_target)
  return _internal_parkspace_status_target();
}
inline void Parkspace_info::_internal_set_parkspace_status_target(::message::Parkspace_status value) {
  assert(::message::Parkspace_status_IsValid(value));
  _has_bits_[0] |= 0x00004000u;
  parkspace_status_target_ = value;
}
inline void Parkspace_info::set_parkspace_status_target(::message::Parkspace_status value) {
  _internal_set_parkspace_status_target(value);
  // @@protoc_insertion_point(field_set:message.Parkspace_info.parkspace_status_target)
}

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace message

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::message::Message_type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::message::Message_type>() {
  return ::message::Message_type_descriptor();
}
template <> struct is_proto_enum< ::message::Communicator> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::message::Communicator>() {
  return ::message::Communicator_descriptor();
}
template <> struct is_proto_enum< ::message::Process_type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::message::Process_type>() {
  return ::message::Process_type_descriptor();
}
template <> struct is_proto_enum< ::message::Error_level> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::message::Error_level>() {
  return ::message::Error_level_descriptor();
}
template <> struct is_proto_enum< ::message::Parkspace_status> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::message::Parkspace_status>() {
  return ::message::Parkspace_status_descriptor();
}
template <> struct is_proto_enum< ::message::Direction> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::message::Direction>() {
  return ::message::Direction_descriptor();
}
template <> struct is_proto_enum< ::message::Parkspace_path> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::message::Parkspace_path>() {
  return ::message::Parkspace_path_descriptor();
}
template <> struct is_proto_enum< ::message::Parkspace_type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::message::Parkspace_type>() {
  return ::message::Parkspace_type_descriptor();
}
template <> struct is_proto_enum< ::message::Car_type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::message::Car_type>() {
  return ::message::Car_type_descriptor();
}
template <> struct is_proto_enum< ::message::Step_type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::message::Step_type>() {
  return ::message::Step_type_descriptor();
}
template <> struct is_proto_enum< ::message::Step_statu> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::message::Step_statu>() {
  return ::message::Step_statu_descriptor();
}
template <> struct is_proto_enum< ::message::Dispatch_device_type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::message::Dispatch_device_type>() {
  return ::message::Dispatch_device_type_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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