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

#ifndef PROTOBUF_INCLUDED_message_5fbase_2eproto
#define PROTOBUF_INCLUDED_message_5fbase_2eproto

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3006001
#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 3006001 < GOOGLE_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/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.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)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_message_5fbase_2eproto 

namespace protobuf_message_5fbase_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[7];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors();
}  // namespace protobuf_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 Id_struct;
class Id_structDefaultTypeInternal;
extern Id_structDefaultTypeInternal _Id_struct_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
namespace google {
namespace protobuf {
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::Id_struct* Arena::CreateMaybeMessage<::message::Id_struct>(Arena*);
template<> ::message::Locate_information* Arena::CreateMaybeMessage<::message::Locate_information>(Arena*);
template<> ::message::Parkspace_info* Arena::CreateMaybeMessage<::message::Parkspace_info>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace message {

enum Message_type {
  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,
  eParkspace_allocation_data_response_msg = 61,
  eParkspace_manual_search_request_msg = 62,
  eParkspace_manual_search_response_msg = 63,
  eStore_command_request_msg = 65,
  eStore_command_response_msg = 66,
  ePickup_command_request_msg = 67,
  ePickup_command_response_msg = 68,
  eTerminal_status_msg = 80,
  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,
  eNotify_request_msg = 192,
  eNotify_response_msg = 193,
  eNotify_status_msg = 194,
  eUnNormalized_module_statu_msg = 208,
  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,
  eGround_detect_request_msg = 240,
  eGround_detect_response_msg = 241,
  eGround_status_msg = 242
};
bool Message_type_IsValid(int value);
const Message_type Message_type_MIN = eBase_msg;
const Message_type Message_type_MAX = eGround_status_msg;
const int Message_type_ARRAYSIZE = Message_type_MAX + 1;

const ::google::protobuf::EnumDescriptor* Message_type_descriptor();
inline const ::std::string& Message_type_Name(Message_type value) {
  return ::google::protobuf::internal::NameOfEnum(
    Message_type_descriptor(), value);
}
inline bool Message_type_Parse(
    const ::std::string& name, Message_type* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Message_type>(
    Message_type_descriptor(), name, value);
}
enum Communicator {
  eEmpty = 0,
  eMain = 1,
  eTerminor = 256,
  eParkspace = 512,
  eMeasurer = 768,
  eMeasurer_sift_server = 769,
  eDispatch_manager = 1024,
  eDispatch_control = 1025,
  eNotify = 1281,
  eGround_measurer = 3840
};
bool Communicator_IsValid(int value);
const Communicator Communicator_MIN = eEmpty;
const Communicator Communicator_MAX = eGround_measurer;
const int Communicator_ARRAYSIZE = Communicator_MAX + 1;

const ::google::protobuf::EnumDescriptor* Communicator_descriptor();
inline const ::std::string& Communicator_Name(Communicator value) {
  return ::google::protobuf::internal::NameOfEnum(
    Communicator_descriptor(), value);
}
inline bool Communicator_Parse(
    const ::std::string& name, Communicator* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Communicator>(
    Communicator_descriptor(), name, value);
}
enum Process_type {
  eStoring = 1,
  ePicking = 2
};
bool Process_type_IsValid(int value);
const Process_type Process_type_MIN = eStoring;
const Process_type Process_type_MAX = ePicking;
const int Process_type_ARRAYSIZE = Process_type_MAX + 1;

const ::google::protobuf::EnumDescriptor* Process_type_descriptor();
inline const ::std::string& Process_type_Name(Process_type value) {
  return ::google::protobuf::internal::NameOfEnum(
    Process_type_descriptor(), value);
}
inline bool Process_type_Parse(
    const ::std::string& name, Process_type* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Process_type>(
    Process_type_descriptor(), name, value);
}
enum Error_level {
  NORMAL = 0,
  NEGLIGIBLE_ERROR = 1,
  MINOR_ERROR = 2,
  MAJOR_ERROR = 3,
  CRITICAL_ERROR = 4
};
bool Error_level_IsValid(int value);
const Error_level Error_level_MIN = NORMAL;
const Error_level Error_level_MAX = CRITICAL_ERROR;
const int Error_level_ARRAYSIZE = Error_level_MAX + 1;

const ::google::protobuf::EnumDescriptor* Error_level_descriptor();
inline const ::std::string& Error_level_Name(Error_level value) {
  return ::google::protobuf::internal::NameOfEnum(
    Error_level_descriptor(), value);
}
inline bool Error_level_Parse(
    const ::std::string& name, Error_level* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Error_level>(
    Error_level_descriptor(), name, value);
}
enum Parkspace_status {
  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);
const Parkspace_status Parkspace_status_MIN = eParkspace_status_unknow;
const Parkspace_status Parkspace_status_MAX = eParkspace_error;
const int Parkspace_status_ARRAYSIZE = Parkspace_status_MAX + 1;

const ::google::protobuf::EnumDescriptor* Parkspace_status_descriptor();
inline const ::std::string& Parkspace_status_Name(Parkspace_status value) {
  return ::google::protobuf::internal::NameOfEnum(
    Parkspace_status_descriptor(), value);
}
inline bool Parkspace_status_Parse(
    const ::std::string& name, Parkspace_status* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Parkspace_status>(
    Parkspace_status_descriptor(), name, value);
}
enum Direction {
  eDirection_unknow = 0,
  eForward = 1,
  eBackward = 2
};
bool Direction_IsValid(int value);
const Direction Direction_MIN = eDirection_unknow;
const Direction Direction_MAX = eBackward;
const int Direction_ARRAYSIZE = Direction_MAX + 1;

const ::google::protobuf::EnumDescriptor* Direction_descriptor();
inline const ::std::string& Direction_Name(Direction value) {
  return ::google::protobuf::internal::NameOfEnum(
    Direction_descriptor(), value);
}
inline bool Direction_Parse(
    const ::std::string& name, Direction* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Direction>(
    Direction_descriptor(), name, value);
}
enum Parkspace_path {
  UNKNOW_PATH = 0,
  OPTIMAL_PATH = 1,
  LEFT_PATH = 2,
  RIGHT_PATH = 3,
  TEMPORARY_CACHE_PATH = 4
};
bool Parkspace_path_IsValid(int value);
const Parkspace_path Parkspace_path_MIN = UNKNOW_PATH;
const Parkspace_path Parkspace_path_MAX = TEMPORARY_CACHE_PATH;
const int Parkspace_path_ARRAYSIZE = Parkspace_path_MAX + 1;

const ::google::protobuf::EnumDescriptor* Parkspace_path_descriptor();
inline const ::std::string& Parkspace_path_Name(Parkspace_path value) {
  return ::google::protobuf::internal::NameOfEnum(
    Parkspace_path_descriptor(), value);
}
inline bool Parkspace_path_Parse(
    const ::std::string& name, Parkspace_path* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Parkspace_path>(
    Parkspace_path_descriptor(), name, value);
}
enum Parkspace_type {
  UNKNOW_PARKSPACE_TYPE = 0,
  MIN_PARKINGSPACE = 1,
  MID_PARKINGSPACE = 2,
  BIG_PARKINGSPACE = 3
};
bool Parkspace_type_IsValid(int value);
const Parkspace_type Parkspace_type_MIN = UNKNOW_PARKSPACE_TYPE;
const Parkspace_type Parkspace_type_MAX = BIG_PARKINGSPACE;
const int Parkspace_type_ARRAYSIZE = Parkspace_type_MAX + 1;

const ::google::protobuf::EnumDescriptor* Parkspace_type_descriptor();
inline const ::std::string& Parkspace_type_Name(Parkspace_type value) {
  return ::google::protobuf::internal::NameOfEnum(
    Parkspace_type_descriptor(), value);
}
inline bool Parkspace_type_Parse(
    const ::std::string& name, Parkspace_type* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Parkspace_type>(
    Parkspace_type_descriptor(), name, value);
}
enum Car_type {
  UNKNOW_CAR_TYPE = 0,
  MIN_CAR = 1,
  MID_CAR = 2,
  BIG_CAR = 3
};
bool Car_type_IsValid(int value);
const Car_type Car_type_MIN = UNKNOW_CAR_TYPE;
const Car_type Car_type_MAX = BIG_CAR;
const int Car_type_ARRAYSIZE = Car_type_MAX + 1;

const ::google::protobuf::EnumDescriptor* Car_type_descriptor();
inline const ::std::string& Car_type_Name(Car_type value) {
  return ::google::protobuf::internal::NameOfEnum(
    Car_type_descriptor(), value);
}
inline bool Car_type_Parse(
    const ::std::string& name, Car_type* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Car_type>(
    Car_type_descriptor(), name, value);
}
enum Step_type {
  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);
const Step_type Step_type_MIN = eAlloc_step;
const Step_type Step_type_MAX = eBackComplete;
const int Step_type_ARRAYSIZE = Step_type_MAX + 1;

const ::google::protobuf::EnumDescriptor* Step_type_descriptor();
inline const ::std::string& Step_type_Name(Step_type value) {
  return ::google::protobuf::internal::NameOfEnum(
    Step_type_descriptor(), value);
}
inline bool Step_type_Parse(
    const ::std::string& name, Step_type* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Step_type>(
    Step_type_descriptor(), name, value);
}
enum Step_statu {
  eWaiting = 0,
  eWorking = 1,
  eError = 2,
  eFinished = 3
};
bool Step_statu_IsValid(int value);
const Step_statu Step_statu_MIN = eWaiting;
const Step_statu Step_statu_MAX = eFinished;
const int Step_statu_ARRAYSIZE = Step_statu_MAX + 1;

const ::google::protobuf::EnumDescriptor* Step_statu_descriptor();
inline const ::std::string& Step_statu_Name(Step_statu value) {
  return ::google::protobuf::internal::NameOfEnum(
    Step_statu_descriptor(), value);
}
inline bool Step_statu_Parse(
    const ::std::string& name, Step_statu* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Step_statu>(
    Step_statu_descriptor(), name, value);
}
enum Dispatch_device_type {
  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);
const Dispatch_device_type Dispatch_device_type_MIN = ROBOT_1;
const Dispatch_device_type Dispatch_device_type_MAX = PASSAGEWAY_7;
const int Dispatch_device_type_ARRAYSIZE = Dispatch_device_type_MAX + 1;

const ::google::protobuf::EnumDescriptor* Dispatch_device_type_descriptor();
inline const ::std::string& Dispatch_device_type_Name(Dispatch_device_type value) {
  return ::google::protobuf::internal::NameOfEnum(
    Dispatch_device_type_descriptor(), value);
}
inline bool Dispatch_device_type_Parse(
    const ::std::string& name, Dispatch_device_type* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Dispatch_device_type>(
    Dispatch_device_type_descriptor(), name, value);
}
// ===================================================================

class Base_info : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Base_info) */ {
 public:
  Base_info();
  virtual ~Base_info();

  Base_info(const Base_info& from);

  inline Base_info& operator=(const Base_info& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Base_info(Base_info&& from) noexcept
    : Base_info() {
    *this = ::std::move(from);
  }

  inline Base_info& operator=(Base_info&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  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;

  void Swap(Base_info* other);
  friend void swap(Base_info& a, Base_info& b) {
    a.Swap(&b);
  }

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

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

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

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Base_info* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // required .message.Message_type msg_type = 1 [default = eBase_msg];
  bool has_msg_type() const;
  void clear_msg_type();
  static const int kMsgTypeFieldNumber = 1;
  ::message::Message_type msg_type() const;
  void set_msg_type(::message::Message_type value);

  // optional int32 timeout_ms = 2 [default = 0];
  bool has_timeout_ms() const;
  void clear_timeout_ms();
  static const int kTimeoutMsFieldNumber = 2;
  ::google::protobuf::int32 timeout_ms() const;
  void set_timeout_ms(::google::protobuf::int32 value);

  // required .message.Communicator sender = 3 [default = eEmpty];
  bool has_sender() const;
  void clear_sender();
  static const int kSenderFieldNumber = 3;
  ::message::Communicator sender() const;
  void set_sender(::message::Communicator value);

  // required .message.Communicator receiver = 4 [default = eEmpty];
  bool has_receiver() const;
  void clear_receiver();
  static const int kReceiverFieldNumber = 4;
  ::message::Communicator receiver() const;
  void set_receiver(::message::Communicator value);

  // @@protoc_insertion_point(class_scope:message.Base_info)
 private:
  void set_has_msg_type();
  void clear_has_msg_type();
  void set_has_timeout_ms();
  void clear_has_timeout_ms();
  void set_has_sender();
  void clear_has_sender();
  void set_has_receiver();
  void clear_has_receiver();

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

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  int msg_type_;
  ::google::protobuf::int32 timeout_ms_;
  int sender_;
  int receiver_;
  friend struct ::protobuf_message_5fbase_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Base_msg : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Base_msg) */ {
 public:
  Base_msg();
  virtual ~Base_msg();

  Base_msg(const Base_msg& from);

  inline Base_msg& operator=(const Base_msg& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Base_msg(Base_msg&& from) noexcept
    : Base_msg() {
    *this = ::std::move(from);
  }

  inline Base_msg& operator=(Base_msg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  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;

  void Swap(Base_msg* other);
  friend void swap(Base_msg& a, Base_msg& b) {
    a.Swap(&b);
  }

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

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

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

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Base_msg* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // required .message.Base_info base_info = 1;
  bool has_base_info() const;
  void clear_base_info();
  static const int kBaseInfoFieldNumber = 1;
  private:
  const ::message::Base_info& _internal_base_info() const;
  public:
  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);

  // @@protoc_insertion_point(class_scope:message.Base_msg)
 private:
  void set_has_base_info();
  void clear_has_base_info();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::message::Base_info* base_info_;
  friend struct ::protobuf_message_5fbase_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Error_manager : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Error_manager) */ {
 public:
  Error_manager();
  virtual ~Error_manager();

  Error_manager(const Error_manager& from);

  inline Error_manager& operator=(const Error_manager& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Error_manager(Error_manager&& from) noexcept
    : Error_manager() {
    *this = ::std::move(from);
  }

  inline Error_manager& operator=(Error_manager&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  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;

  void Swap(Error_manager* other);
  friend void swap(Error_manager& a, Error_manager& b) {
    a.Swap(&b);
  }

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

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

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

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Error_manager* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // optional string error_description = 3 [default = ""];
  bool has_error_description() const;
  void clear_error_description();
  static const int kErrorDescriptionFieldNumber = 3;
  const ::std::string& error_description() const;
  void set_error_description(const ::std::string& value);
  #if LANG_CXX11
  void set_error_description(::std::string&& value);
  #endif
  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);

  // required int32 error_code = 1 [default = 0];
  bool has_error_code() const;
  void clear_error_code();
  static const int kErrorCodeFieldNumber = 1;
  ::google::protobuf::int32 error_code() const;
  void set_error_code(::google::protobuf::int32 value);

  // optional .message.Error_level error_level = 2 [default = NORMAL];
  bool has_error_level() const;
  void clear_error_level();
  static const int kErrorLevelFieldNumber = 2;
  ::message::Error_level error_level() const;
  void set_error_level(::message::Error_level value);

  // @@protoc_insertion_point(class_scope:message.Error_manager)
 private:
  void set_has_error_code();
  void clear_has_error_code();
  void set_has_error_level();
  void clear_has_error_level();
  void set_has_error_description();
  void clear_has_error_description();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr error_description_;
  ::google::protobuf::int32 error_code_;
  int error_level_;
  friend struct ::protobuf_message_5fbase_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Locate_information : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Locate_information) */ {
 public:
  Locate_information();
  virtual ~Locate_information();

  Locate_information(const Locate_information& from);

  inline Locate_information& operator=(const Locate_information& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Locate_information(Locate_information&& from) noexcept
    : Locate_information() {
    *this = ::std::move(from);
  }

  inline Locate_information& operator=(Locate_information&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  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;

  void Swap(Locate_information* other);
  friend void swap(Locate_information& a, Locate_information& b) {
    a.Swap(&b);
  }

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

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

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

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Locate_information* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // optional float locate_x = 1 [default = 0];
  bool has_locate_x() const;
  void clear_locate_x();
  static const int kLocateXFieldNumber = 1;
  float locate_x() const;
  void set_locate_x(float value);

  // optional float locate_y = 2 [default = 0];
  bool has_locate_y() const;
  void clear_locate_y();
  static const int kLocateYFieldNumber = 2;
  float locate_y() const;
  void set_locate_y(float value);

  // optional float locate_angle = 3 [default = 0];
  bool has_locate_angle() const;
  void clear_locate_angle();
  static const int kLocateAngleFieldNumber = 3;
  float locate_angle() const;
  void set_locate_angle(float value);

  // optional float locate_length = 4 [default = 0];
  bool has_locate_length() const;
  void clear_locate_length();
  static const int kLocateLengthFieldNumber = 4;
  float locate_length() const;
  void set_locate_length(float value);

  // optional float locate_width = 5 [default = 0];
  bool has_locate_width() const;
  void clear_locate_width();
  static const int kLocateWidthFieldNumber = 5;
  float locate_width() const;
  void set_locate_width(float value);

  // optional float locate_height = 6 [default = 0];
  bool has_locate_height() const;
  void clear_locate_height();
  static const int kLocateHeightFieldNumber = 6;
  float locate_height() const;
  void set_locate_height(float value);

  // optional float locate_wheel_base = 7 [default = 0];
  bool has_locate_wheel_base() const;
  void clear_locate_wheel_base();
  static const int kLocateWheelBaseFieldNumber = 7;
  float locate_wheel_base() const;
  void set_locate_wheel_base(float value);

  // optional float locate_wheel_width = 8 [default = 0];
  bool has_locate_wheel_width() const;
  void clear_locate_wheel_width();
  static const int kLocateWheelWidthFieldNumber = 8;
  float locate_wheel_width() const;
  void set_locate_wheel_width(float value);

  // optional bool locate_correct = 9 [default = false];
  bool has_locate_correct() const;
  void clear_locate_correct();
  static const int kLocateCorrectFieldNumber = 9;
  bool locate_correct() const;
  void set_locate_correct(bool value);

  // optional float locate_front_theta = 10 [default = 0];
  bool has_locate_front_theta() const;
  void clear_locate_front_theta();
  static const int kLocateFrontThetaFieldNumber = 10;
  float locate_front_theta() const;
  void set_locate_front_theta(float value);

  // optional float uniformed_car_x = 11;
  bool has_uniformed_car_x() const;
  void clear_uniformed_car_x();
  static const int kUniformedCarXFieldNumber = 11;
  float uniformed_car_x() const;
  void set_uniformed_car_x(float value);

  // optional float uniformed_car_y = 12;
  bool has_uniformed_car_y() const;
  void clear_uniformed_car_y();
  static const int kUniformedCarYFieldNumber = 12;
  float uniformed_car_y() const;
  void set_uniformed_car_y(float value);

  // @@protoc_insertion_point(class_scope:message.Locate_information)
 private:
  void set_has_locate_x();
  void clear_has_locate_x();
  void set_has_locate_y();
  void clear_has_locate_y();
  void set_has_locate_angle();
  void clear_has_locate_angle();
  void set_has_locate_length();
  void clear_has_locate_length();
  void set_has_locate_width();
  void clear_has_locate_width();
  void set_has_locate_height();
  void clear_has_locate_height();
  void set_has_locate_wheel_base();
  void clear_has_locate_wheel_base();
  void set_has_locate_wheel_width();
  void clear_has_locate_wheel_width();
  void set_has_locate_correct();
  void clear_has_locate_correct();
  void set_has_locate_front_theta();
  void clear_has_locate_front_theta();
  void set_has_uniformed_car_x();
  void clear_has_uniformed_car_x();
  void set_has_uniformed_car_y();
  void clear_has_uniformed_car_y();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::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_;
  float uniformed_car_x_;
  float uniformed_car_y_;
  friend struct ::protobuf_message_5fbase_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Car_info : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Car_info) */ {
 public:
  Car_info();
  virtual ~Car_info();

  Car_info(const Car_info& from);

  inline Car_info& operator=(const Car_info& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Car_info(Car_info&& from) noexcept
    : Car_info() {
    *this = ::std::move(from);
  }

  inline Car_info& operator=(Car_info&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  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;

  void Swap(Car_info* other);
  friend void swap(Car_info& a, Car_info& b) {
    a.Swap(&b);
  }

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

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

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

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Car_info* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // optional string license = 4 [default = ""];
  bool has_license() const;
  void clear_license();
  static const int kLicenseFieldNumber = 4;
  const ::std::string& license() const;
  void set_license(const ::std::string& value);
  #if LANG_CXX11
  void set_license(::std::string&& value);
  #endif
  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);

  // optional string car_numberPlate = 5 [default = ""];
  bool has_car_numberplate() const;
  void clear_car_numberplate();
  static const int kCarNumberPlateFieldNumber = 5;
  const ::std::string& car_numberplate() const;
  void set_car_numberplate(const ::std::string& value);
  #if LANG_CXX11
  void set_car_numberplate(::std::string&& value);
  #endif
  void set_car_numberplate(const char* value);
  void set_car_numberplate(const char* value, size_t size);
  ::std::string* mutable_car_numberplate();
  ::std::string* release_car_numberplate();
  void set_allocated_car_numberplate(::std::string* car_numberplate);

  // optional float car_length = 1 [default = 0];
  bool has_car_length() const;
  void clear_car_length();
  static const int kCarLengthFieldNumber = 1;
  float car_length() const;
  void set_car_length(float value);

  // optional float car_width = 2 [default = 0];
  bool has_car_width() const;
  void clear_car_width();
  static const int kCarWidthFieldNumber = 2;
  float car_width() const;
  void set_car_width(float value);

  // optional float car_height = 3 [default = 0];
  bool has_car_height() const;
  void clear_car_height();
  static const int kCarHeightFieldNumber = 3;
  float car_height() const;
  void set_car_height(float value);

  // optional float car_wheel_base = 6 [default = 0];
  bool has_car_wheel_base() const;
  void clear_car_wheel_base();
  static const int kCarWheelBaseFieldNumber = 6;
  float car_wheel_base() const;
  void set_car_wheel_base(float value);

  // optional float car_wheel_width = 7 [default = 0];
  bool has_car_wheel_width() const;
  void clear_car_wheel_width();
  static const int kCarWheelWidthFieldNumber = 7;
  float car_wheel_width() const;
  void set_car_wheel_width(float value);

  // @@protoc_insertion_point(class_scope:message.Car_info)
 private:
  void set_has_car_length();
  void clear_has_car_length();
  void set_has_car_width();
  void clear_has_car_width();
  void set_has_car_height();
  void clear_has_car_height();
  void set_has_license();
  void clear_has_license();
  void set_has_car_numberplate();
  void clear_has_car_numberplate();
  void set_has_car_wheel_base();
  void clear_has_car_wheel_base();
  void set_has_car_wheel_width();
  void clear_has_car_wheel_width();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr license_;
  ::google::protobuf::internal::ArenaStringPtr car_numberplate_;
  float car_length_;
  float car_width_;
  float car_height_;
  float car_wheel_base_;
  float car_wheel_width_;
  friend struct ::protobuf_message_5fbase_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Parkspace_info : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Parkspace_info) */ {
 public:
  Parkspace_info();
  virtual ~Parkspace_info();

  Parkspace_info(const Parkspace_info& from);

  inline Parkspace_info& operator=(const Parkspace_info& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Parkspace_info(Parkspace_info&& from) noexcept
    : Parkspace_info() {
    *this = ::std::move(from);
  }

  inline Parkspace_info& operator=(Parkspace_info&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  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;

  void Swap(Parkspace_info* other);
  friend void swap(Parkspace_info& a, Parkspace_info& b) {
    a.Swap(&b);
  }

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

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

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

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Parkspace_info* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // optional string entry_time = 12;
  bool has_entry_time() const;
  void clear_entry_time();
  static const int kEntryTimeFieldNumber = 12;
  const ::std::string& entry_time() const;
  void set_entry_time(const ::std::string& value);
  #if LANG_CXX11
  void set_entry_time(::std::string&& value);
  #endif
  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);

  // optional string leave_time = 13;
  bool has_leave_time() const;
  void clear_leave_time();
  static const int kLeaveTimeFieldNumber = 13;
  const ::std::string& leave_time() const;
  void set_leave_time(const ::std::string& value);
  #if LANG_CXX11
  void set_leave_time(::std::string&& value);
  #endif
  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);

  // optional .message.Car_info car_info = 11;
  bool has_car_info() const;
  void clear_car_info();
  static const int kCarInfoFieldNumber = 11;
  private:
  const ::message::Car_info& _internal_car_info() const;
  public:
  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);

  // optional int32 parkingspace_index_id = 1;
  bool has_parkingspace_index_id() const;
  void clear_parkingspace_index_id();
  static const int kParkingspaceIndexIdFieldNumber = 1;
  ::google::protobuf::int32 parkingspace_index_id() const;
  void set_parkingspace_index_id(::google::protobuf::int32 value);

  // optional .message.Parkspace_type parkingspace_type = 2;
  bool has_parkingspace_type() const;
  void clear_parkingspace_type();
  static const int kParkingspaceTypeFieldNumber = 2;
  ::message::Parkspace_type parkingspace_type() const;
  void set_parkingspace_type(::message::Parkspace_type value);

  // optional int32 parkingspace_unit_id = 3;
  bool has_parkingspace_unit_id() const;
  void clear_parkingspace_unit_id();
  static const int kParkingspaceUnitIdFieldNumber = 3;
  ::google::protobuf::int32 parkingspace_unit_id() const;
  void set_parkingspace_unit_id(::google::protobuf::int32 value);

  // optional int32 parkingspace_label_id = 4;
  bool has_parkingspace_label_id() const;
  void clear_parkingspace_label_id();
  static const int kParkingspaceLabelIdFieldNumber = 4;
  ::google::protobuf::int32 parkingspace_label_id() const;
  void set_parkingspace_label_id(::google::protobuf::int32 value);

  // optional int32 parkingspace_room_id = 5;
  bool has_parkingspace_room_id() const;
  void clear_parkingspace_room_id();
  static const int kParkingspaceRoomIdFieldNumber = 5;
  ::google::protobuf::int32 parkingspace_room_id() const;
  void set_parkingspace_room_id(::google::protobuf::int32 value);

  // optional .message.Direction parkingspace_direction = 6;
  bool has_parkingspace_direction() const;
  void clear_parkingspace_direction();
  static const int kParkingspaceDirectionFieldNumber = 6;
  ::message::Direction parkingspace_direction() const;
  void set_parkingspace_direction(::message::Direction value);

  // optional int32 parkingspace_floor_id = 7;
  bool has_parkingspace_floor_id() const;
  void clear_parkingspace_floor_id();
  static const int kParkingspaceFloorIdFieldNumber = 7;
  ::google::protobuf::int32 parkingspace_floor_id() const;
  void set_parkingspace_floor_id(::google::protobuf::int32 value);

  // optional float parkingspace_width = 8;
  bool has_parkingspace_width() const;
  void clear_parkingspace_width();
  static const int kParkingspaceWidthFieldNumber = 8;
  float parkingspace_width() const;
  void set_parkingspace_width(float value);

  // optional float parkingspace_height = 9;
  bool has_parkingspace_height() const;
  void clear_parkingspace_height();
  static const int kParkingspaceHeightFieldNumber = 9;
  float parkingspace_height() const;
  void set_parkingspace_height(float value);

  // optional .message.Parkspace_status parkingspace_status = 10;
  bool has_parkingspace_status() const;
  void clear_parkingspace_status();
  static const int kParkingspaceStatusFieldNumber = 10;
  ::message::Parkspace_status parkingspace_status() const;
  void set_parkingspace_status(::message::Parkspace_status value);

  // optional .message.Parkspace_path parkspace_path = 14;
  bool has_parkspace_path() const;
  void clear_parkspace_path();
  static const int kParkspacePathFieldNumber = 14;
  ::message::Parkspace_path parkspace_path() const;
  void set_parkspace_path(::message::Parkspace_path value);

  // optional float path_estimate_time = 15;
  bool has_path_estimate_time() const;
  void clear_path_estimate_time();
  static const int kPathEstimateTimeFieldNumber = 15;
  float path_estimate_time() const;
  void set_path_estimate_time(float value);

  // optional .message.Parkspace_status parkspace_status_target = 16;
  bool has_parkspace_status_target() const;
  void clear_parkspace_status_target();
  static const int kParkspaceStatusTargetFieldNumber = 16;
  ::message::Parkspace_status parkspace_status_target() const;
  void set_parkspace_status_target(::message::Parkspace_status value);

  // optional .message.Car_type car_type = 17;
  bool has_car_type() const;
  void clear_car_type();
  static const int kCarTypeFieldNumber = 17;
  ::message::Car_type car_type() const;
  void set_car_type(::message::Car_type value);

  // @@protoc_insertion_point(class_scope:message.Parkspace_info)
 private:
  void set_has_parkingspace_index_id();
  void clear_has_parkingspace_index_id();
  void set_has_parkingspace_type();
  void clear_has_parkingspace_type();
  void set_has_parkingspace_unit_id();
  void clear_has_parkingspace_unit_id();
  void set_has_parkingspace_label_id();
  void clear_has_parkingspace_label_id();
  void set_has_parkingspace_room_id();
  void clear_has_parkingspace_room_id();
  void set_has_parkingspace_direction();
  void clear_has_parkingspace_direction();
  void set_has_parkingspace_floor_id();
  void clear_has_parkingspace_floor_id();
  void set_has_parkingspace_width();
  void clear_has_parkingspace_width();
  void set_has_parkingspace_height();
  void clear_has_parkingspace_height();
  void set_has_parkingspace_status();
  void clear_has_parkingspace_status();
  void set_has_car_info();
  void clear_has_car_info();
  void set_has_entry_time();
  void clear_has_entry_time();
  void set_has_leave_time();
  void clear_has_leave_time();
  void set_has_parkspace_path();
  void clear_has_parkspace_path();
  void set_has_path_estimate_time();
  void clear_has_path_estimate_time();
  void set_has_parkspace_status_target();
  void clear_has_parkspace_status_target();
  void set_has_car_type();
  void clear_has_car_type();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr entry_time_;
  ::google::protobuf::internal::ArenaStringPtr leave_time_;
  ::message::Car_info* car_info_;
  ::google::protobuf::int32 parkingspace_index_id_;
  int parkingspace_type_;
  ::google::protobuf::int32 parkingspace_unit_id_;
  ::google::protobuf::int32 parkingspace_label_id_;
  ::google::protobuf::int32 parkingspace_room_id_;
  int parkingspace_direction_;
  ::google::protobuf::int32 parkingspace_floor_id_;
  float parkingspace_width_;
  float parkingspace_height_;
  int parkingspace_status_;
  int parkspace_path_;
  float path_estimate_time_;
  int parkspace_status_target_;
  int car_type_;
  friend struct ::protobuf_message_5fbase_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Id_struct : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Id_struct) */ {
 public:
  Id_struct();
  virtual ~Id_struct();

  Id_struct(const Id_struct& from);

  inline Id_struct& operator=(const Id_struct& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Id_struct(Id_struct&& from) noexcept
    : Id_struct() {
    *this = ::std::move(from);
  }

  inline Id_struct& operator=(Id_struct&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Id_struct& default_instance();

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

  void Swap(Id_struct* other);
  friend void swap(Id_struct& a, Id_struct& b) {
    a.Swap(&b);
  }

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

  inline Id_struct* New() const final {
    return CreateMaybeMessage<Id_struct>(NULL);
  }

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

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Id_struct* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // optional int32 terminal_id = 1;
  bool has_terminal_id() const;
  void clear_terminal_id();
  static const int kTerminalIdFieldNumber = 1;
  ::google::protobuf::int32 terminal_id() const;
  void set_terminal_id(::google::protobuf::int32 value);

  // optional int32 unit_id = 2;
  bool has_unit_id() const;
  void clear_unit_id();
  static const int kUnitIdFieldNumber = 2;
  ::google::protobuf::int32 unit_id() const;
  void set_unit_id(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:message.Id_struct)
 private:
  void set_has_terminal_id();
  void clear_has_terminal_id();
  void set_has_unit_id();
  void clear_has_unit_id();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 terminal_id_;
  ::google::protobuf::int32 unit_id_;
  friend struct ::protobuf_message_5fbase_2eproto::TableStruct;
};
// ===================================================================


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

#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::has_msg_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Base_info::set_has_msg_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Base_info::clear_has_msg_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Base_info::clear_msg_type() {
  msg_type_ = 0;
  clear_has_msg_type();
}
inline ::message::Message_type Base_info::msg_type() const {
  // @@protoc_insertion_point(field_get:message.Base_info.msg_type)
  return static_cast< ::message::Message_type >(msg_type_);
}
inline void Base_info::set_msg_type(::message::Message_type value) {
  assert(::message::Message_type_IsValid(value));
  set_has_msg_type();
  msg_type_ = value;
  // @@protoc_insertion_point(field_set:message.Base_info.msg_type)
}

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

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

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

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

// Base_msg

// required .message.Base_info base_info = 1;
inline bool Base_msg::has_base_info() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Base_msg::set_has_base_info() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Base_msg::clear_has_base_info() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Base_msg::clear_base_info() {
  if (base_info_ != NULL) base_info_->Clear();
  clear_has_base_info();
}
inline const ::message::Base_info& Base_msg::_internal_base_info() const {
  return *base_info_;
}
inline const ::message::Base_info& Base_msg::base_info() const {
  const ::message::Base_info* p = base_info_;
  // @@protoc_insertion_point(field_get:message.Base_msg.base_info)
  return p != NULL ? *p : *reinterpret_cast<const ::message::Base_info*>(
      &::message::_Base_info_default_instance_);
}
inline ::message::Base_info* Base_msg::release_base_info() {
  // @@protoc_insertion_point(field_release:message.Base_msg.base_info)
  clear_has_base_info();
  ::message::Base_info* temp = base_info_;
  base_info_ = NULL;
  return temp;
}
inline ::message::Base_info* Base_msg::mutable_base_info() {
  set_has_base_info();
  if (base_info_ == NULL) {
    auto* p = CreateMaybeMessage<::message::Base_info>(GetArenaNoVirtual());
    base_info_ = p;
  }
  // @@protoc_insertion_point(field_mutable:message.Base_msg.base_info)
  return base_info_;
}
inline void Base_msg::set_allocated_base_info(::message::Base_info* base_info) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete base_info_;
  }
  if (base_info) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      base_info = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, base_info, submessage_arena);
    }
    set_has_base_info();
  } else {
    clear_has_base_info();
  }
  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::has_error_code() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Error_manager::set_has_error_code() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Error_manager::clear_has_error_code() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Error_manager::clear_error_code() {
  error_code_ = 0;
  clear_has_error_code();
}
inline ::google::protobuf::int32 Error_manager::error_code() const {
  // @@protoc_insertion_point(field_get:message.Error_manager.error_code)
  return error_code_;
}
inline void Error_manager::set_error_code(::google::protobuf::int32 value) {
  set_has_error_code();
  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::has_error_level() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Error_manager::set_has_error_level() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Error_manager::clear_has_error_level() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Error_manager::clear_error_level() {
  error_level_ = 0;
  clear_has_error_level();
}
inline ::message::Error_level Error_manager::error_level() const {
  // @@protoc_insertion_point(field_get:message.Error_manager.error_level)
  return static_cast< ::message::Error_level >(error_level_);
}
inline void Error_manager::set_error_level(::message::Error_level value) {
  assert(::message::Error_level_IsValid(value));
  set_has_error_level();
  error_level_ = value;
  // @@protoc_insertion_point(field_set:message.Error_manager.error_level)
}

// optional string error_description = 3 [default = ""];
inline bool Error_manager::has_error_description() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Error_manager::set_has_error_description() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Error_manager::clear_has_error_description() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Error_manager::clear_error_description() {
  error_description_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_error_description();
}
inline const ::std::string& Error_manager::error_description() const {
  // @@protoc_insertion_point(field_get:message.Error_manager.error_description)
  return error_description_.GetNoArena();
}
inline void Error_manager::set_error_description(const ::std::string& value) {
  set_has_error_description();
  error_description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:message.Error_manager.error_description)
}
#if LANG_CXX11
inline void Error_manager::set_error_description(::std::string&& value) {
  set_has_error_description();
  error_description_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:message.Error_manager.error_description)
}
#endif
inline void Error_manager::set_error_description(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_error_description();
  error_description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:message.Error_manager.error_description)
}
inline void Error_manager::set_error_description(const char* value, size_t size) {
  set_has_error_description();
  error_description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:message.Error_manager.error_description)
}
inline ::std::string* Error_manager::mutable_error_description() {
  set_has_error_description();
  // @@protoc_insertion_point(field_mutable:message.Error_manager.error_description)
  return error_description_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Error_manager::release_error_description() {
  // @@protoc_insertion_point(field_release:message.Error_manager.error_description)
  if (!has_error_description()) {
    return NULL;
  }
  clear_has_error_description();
  return error_description_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Error_manager::set_allocated_error_description(::std::string* error_description) {
  if (error_description != NULL) {
    set_has_error_description();
  } else {
    clear_has_error_description();
  }
  error_description_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), error_description);
  // @@protoc_insertion_point(field_set_allocated:message.Error_manager.error_description)
}

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

// Locate_information

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

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

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

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

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

// optional float locate_height = 6 [default = 0];
inline bool Locate_information::has_locate_height() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Locate_information::set_has_locate_height() {
  _has_bits_[0] |= 0x00000020u;
}
inline void Locate_information::clear_has_locate_height() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void Locate_information::clear_locate_height() {
  locate_height_ = 0;
  clear_has_locate_height();
}
inline float Locate_information::locate_height() const {
  // @@protoc_insertion_point(field_get:message.Locate_information.locate_height)
  return locate_height_;
}
inline void Locate_information::set_locate_height(float value) {
  set_has_locate_height();
  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::has_locate_wheel_base() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void Locate_information::set_has_locate_wheel_base() {
  _has_bits_[0] |= 0x00000040u;
}
inline void Locate_information::clear_has_locate_wheel_base() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void Locate_information::clear_locate_wheel_base() {
  locate_wheel_base_ = 0;
  clear_has_locate_wheel_base();
}
inline float Locate_information::locate_wheel_base() const {
  // @@protoc_insertion_point(field_get:message.Locate_information.locate_wheel_base)
  return locate_wheel_base_;
}
inline void Locate_information::set_locate_wheel_base(float value) {
  set_has_locate_wheel_base();
  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::has_locate_wheel_width() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void Locate_information::set_has_locate_wheel_width() {
  _has_bits_[0] |= 0x00000080u;
}
inline void Locate_information::clear_has_locate_wheel_width() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void Locate_information::clear_locate_wheel_width() {
  locate_wheel_width_ = 0;
  clear_has_locate_wheel_width();
}
inline float Locate_information::locate_wheel_width() const {
  // @@protoc_insertion_point(field_get:message.Locate_information.locate_wheel_width)
  return locate_wheel_width_;
}
inline void Locate_information::set_locate_wheel_width(float value) {
  set_has_locate_wheel_width();
  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::has_locate_correct() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void Locate_information::set_has_locate_correct() {
  _has_bits_[0] |= 0x00000100u;
}
inline void Locate_information::clear_has_locate_correct() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void Locate_information::clear_locate_correct() {
  locate_correct_ = false;
  clear_has_locate_correct();
}
inline bool Locate_information::locate_correct() const {
  // @@protoc_insertion_point(field_get:message.Locate_information.locate_correct)
  return locate_correct_;
}
inline void Locate_information::set_locate_correct(bool value) {
  set_has_locate_correct();
  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::has_locate_front_theta() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void Locate_information::set_has_locate_front_theta() {
  _has_bits_[0] |= 0x00000200u;
}
inline void Locate_information::clear_has_locate_front_theta() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void Locate_information::clear_locate_front_theta() {
  locate_front_theta_ = 0;
  clear_has_locate_front_theta();
}
inline float Locate_information::locate_front_theta() const {
  // @@protoc_insertion_point(field_get:message.Locate_information.locate_front_theta)
  return locate_front_theta_;
}
inline void Locate_information::set_locate_front_theta(float value) {
  set_has_locate_front_theta();
  locate_front_theta_ = value;
  // @@protoc_insertion_point(field_set:message.Locate_information.locate_front_theta)
}

// optional float uniformed_car_x = 11;
inline bool Locate_information::has_uniformed_car_x() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void Locate_information::set_has_uniformed_car_x() {
  _has_bits_[0] |= 0x00000400u;
}
inline void Locate_information::clear_has_uniformed_car_x() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void Locate_information::clear_uniformed_car_x() {
  uniformed_car_x_ = 0;
  clear_has_uniformed_car_x();
}
inline float Locate_information::uniformed_car_x() const {
  // @@protoc_insertion_point(field_get:message.Locate_information.uniformed_car_x)
  return uniformed_car_x_;
}
inline void Locate_information::set_uniformed_car_x(float value) {
  set_has_uniformed_car_x();
  uniformed_car_x_ = value;
  // @@protoc_insertion_point(field_set:message.Locate_information.uniformed_car_x)
}

// optional float uniformed_car_y = 12;
inline bool Locate_information::has_uniformed_car_y() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void Locate_information::set_has_uniformed_car_y() {
  _has_bits_[0] |= 0x00000800u;
}
inline void Locate_information::clear_has_uniformed_car_y() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void Locate_information::clear_uniformed_car_y() {
  uniformed_car_y_ = 0;
  clear_has_uniformed_car_y();
}
inline float Locate_information::uniformed_car_y() const {
  // @@protoc_insertion_point(field_get:message.Locate_information.uniformed_car_y)
  return uniformed_car_y_;
}
inline void Locate_information::set_uniformed_car_y(float value) {
  set_has_uniformed_car_y();
  uniformed_car_y_ = value;
  // @@protoc_insertion_point(field_set:message.Locate_information.uniformed_car_y)
}

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

// Car_info

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

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

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

// optional string license = 4 [default = ""];
inline bool Car_info::has_license() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Car_info::set_has_license() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Car_info::clear_has_license() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Car_info::clear_license() {
  license_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_license();
}
inline const ::std::string& Car_info::license() const {
  // @@protoc_insertion_point(field_get:message.Car_info.license)
  return license_.GetNoArena();
}
inline void Car_info::set_license(const ::std::string& value) {
  set_has_license();
  license_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:message.Car_info.license)
}
#if LANG_CXX11
inline void Car_info::set_license(::std::string&& value) {
  set_has_license();
  license_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:message.Car_info.license)
}
#endif
inline void Car_info::set_license(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_license();
  license_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:message.Car_info.license)
}
inline void Car_info::set_license(const char* value, size_t size) {
  set_has_license();
  license_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:message.Car_info.license)
}
inline ::std::string* Car_info::mutable_license() {
  set_has_license();
  // @@protoc_insertion_point(field_mutable:message.Car_info.license)
  return license_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Car_info::release_license() {
  // @@protoc_insertion_point(field_release:message.Car_info.license)
  if (!has_license()) {
    return NULL;
  }
  clear_has_license();
  return license_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Car_info::set_allocated_license(::std::string* license) {
  if (license != NULL) {
    set_has_license();
  } else {
    clear_has_license();
  }
  license_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), license);
  // @@protoc_insertion_point(field_set_allocated:message.Car_info.license)
}

// optional string car_numberPlate = 5 [default = ""];
inline bool Car_info::has_car_numberplate() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Car_info::set_has_car_numberplate() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Car_info::clear_has_car_numberplate() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Car_info::clear_car_numberplate() {
  car_numberplate_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_car_numberplate();
}
inline const ::std::string& Car_info::car_numberplate() const {
  // @@protoc_insertion_point(field_get:message.Car_info.car_numberPlate)
  return car_numberplate_.GetNoArena();
}
inline void Car_info::set_car_numberplate(const ::std::string& value) {
  set_has_car_numberplate();
  car_numberplate_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:message.Car_info.car_numberPlate)
}
#if LANG_CXX11
inline void Car_info::set_car_numberplate(::std::string&& value) {
  set_has_car_numberplate();
  car_numberplate_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:message.Car_info.car_numberPlate)
}
#endif
inline void Car_info::set_car_numberplate(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_car_numberplate();
  car_numberplate_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:message.Car_info.car_numberPlate)
}
inline void Car_info::set_car_numberplate(const char* value, size_t size) {
  set_has_car_numberplate();
  car_numberplate_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:message.Car_info.car_numberPlate)
}
inline ::std::string* Car_info::mutable_car_numberplate() {
  set_has_car_numberplate();
  // @@protoc_insertion_point(field_mutable:message.Car_info.car_numberPlate)
  return car_numberplate_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Car_info::release_car_numberplate() {
  // @@protoc_insertion_point(field_release:message.Car_info.car_numberPlate)
  if (!has_car_numberplate()) {
    return NULL;
  }
  clear_has_car_numberplate();
  return car_numberplate_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Car_info::set_allocated_car_numberplate(::std::string* car_numberplate) {
  if (car_numberplate != NULL) {
    set_has_car_numberplate();
  } else {
    clear_has_car_numberplate();
  }
  car_numberplate_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), car_numberplate);
  // @@protoc_insertion_point(field_set_allocated:message.Car_info.car_numberPlate)
}

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

// optional float car_wheel_width = 7 [default = 0];
inline bool Car_info::has_car_wheel_width() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void Car_info::set_has_car_wheel_width() {
  _has_bits_[0] |= 0x00000040u;
}
inline void Car_info::clear_has_car_wheel_width() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void Car_info::clear_car_wheel_width() {
  car_wheel_width_ = 0;
  clear_has_car_wheel_width();
}
inline float Car_info::car_wheel_width() const {
  // @@protoc_insertion_point(field_get:message.Car_info.car_wheel_width)
  return car_wheel_width_;
}
inline void Car_info::set_car_wheel_width(float value) {
  set_has_car_wheel_width();
  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::has_parkingspace_index_id() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Parkspace_info::set_has_parkingspace_index_id() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Parkspace_info::clear_has_parkingspace_index_id() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Parkspace_info::clear_parkingspace_index_id() {
  parkingspace_index_id_ = 0;
  clear_has_parkingspace_index_id();
}
inline ::google::protobuf::int32 Parkspace_info::parkingspace_index_id() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.parkingspace_index_id)
  return parkingspace_index_id_;
}
inline void Parkspace_info::set_parkingspace_index_id(::google::protobuf::int32 value) {
  set_has_parkingspace_index_id();
  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::has_parkingspace_type() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Parkspace_info::set_has_parkingspace_type() {
  _has_bits_[0] |= 0x00000010u;
}
inline void Parkspace_info::clear_has_parkingspace_type() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void Parkspace_info::clear_parkingspace_type() {
  parkingspace_type_ = 0;
  clear_has_parkingspace_type();
}
inline ::message::Parkspace_type Parkspace_info::parkingspace_type() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.parkingspace_type)
  return static_cast< ::message::Parkspace_type >(parkingspace_type_);
}
inline void Parkspace_info::set_parkingspace_type(::message::Parkspace_type value) {
  assert(::message::Parkspace_type_IsValid(value));
  set_has_parkingspace_type();
  parkingspace_type_ = value;
  // @@protoc_insertion_point(field_set:message.Parkspace_info.parkingspace_type)
}

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

// optional int32 parkingspace_label_id = 4;
inline bool Parkspace_info::has_parkingspace_label_id() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void Parkspace_info::set_has_parkingspace_label_id() {
  _has_bits_[0] |= 0x00000040u;
}
inline void Parkspace_info::clear_has_parkingspace_label_id() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void Parkspace_info::clear_parkingspace_label_id() {
  parkingspace_label_id_ = 0;
  clear_has_parkingspace_label_id();
}
inline ::google::protobuf::int32 Parkspace_info::parkingspace_label_id() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.parkingspace_label_id)
  return parkingspace_label_id_;
}
inline void Parkspace_info::set_parkingspace_label_id(::google::protobuf::int32 value) {
  set_has_parkingspace_label_id();
  parkingspace_label_id_ = value;
  // @@protoc_insertion_point(field_set:message.Parkspace_info.parkingspace_label_id)
}

// optional int32 parkingspace_room_id = 5;
inline bool Parkspace_info::has_parkingspace_room_id() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void Parkspace_info::set_has_parkingspace_room_id() {
  _has_bits_[0] |= 0x00000080u;
}
inline void Parkspace_info::clear_has_parkingspace_room_id() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void Parkspace_info::clear_parkingspace_room_id() {
  parkingspace_room_id_ = 0;
  clear_has_parkingspace_room_id();
}
inline ::google::protobuf::int32 Parkspace_info::parkingspace_room_id() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.parkingspace_room_id)
  return parkingspace_room_id_;
}
inline void Parkspace_info::set_parkingspace_room_id(::google::protobuf::int32 value) {
  set_has_parkingspace_room_id();
  parkingspace_room_id_ = value;
  // @@protoc_insertion_point(field_set:message.Parkspace_info.parkingspace_room_id)
}

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

// optional int32 parkingspace_floor_id = 7;
inline bool Parkspace_info::has_parkingspace_floor_id() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void Parkspace_info::set_has_parkingspace_floor_id() {
  _has_bits_[0] |= 0x00000200u;
}
inline void Parkspace_info::clear_has_parkingspace_floor_id() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void Parkspace_info::clear_parkingspace_floor_id() {
  parkingspace_floor_id_ = 0;
  clear_has_parkingspace_floor_id();
}
inline ::google::protobuf::int32 Parkspace_info::parkingspace_floor_id() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.parkingspace_floor_id)
  return parkingspace_floor_id_;
}
inline void Parkspace_info::set_parkingspace_floor_id(::google::protobuf::int32 value) {
  set_has_parkingspace_floor_id();
  parkingspace_floor_id_ = value;
  // @@protoc_insertion_point(field_set:message.Parkspace_info.parkingspace_floor_id)
}

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

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

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

// optional .message.Car_info car_info = 11;
inline bool Parkspace_info::has_car_info() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Parkspace_info::set_has_car_info() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Parkspace_info::clear_has_car_info() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Parkspace_info::clear_car_info() {
  if (car_info_ != NULL) car_info_->Clear();
  clear_has_car_info();
}
inline const ::message::Car_info& Parkspace_info::_internal_car_info() const {
  return *car_info_;
}
inline const ::message::Car_info& Parkspace_info::car_info() const {
  const ::message::Car_info* p = car_info_;
  // @@protoc_insertion_point(field_get:message.Parkspace_info.car_info)
  return p != NULL ? *p : *reinterpret_cast<const ::message::Car_info*>(
      &::message::_Car_info_default_instance_);
}
inline ::message::Car_info* Parkspace_info::release_car_info() {
  // @@protoc_insertion_point(field_release:message.Parkspace_info.car_info)
  clear_has_car_info();
  ::message::Car_info* temp = car_info_;
  car_info_ = NULL;
  return temp;
}
inline ::message::Car_info* Parkspace_info::mutable_car_info() {
  set_has_car_info();
  if (car_info_ == NULL) {
    auto* p = CreateMaybeMessage<::message::Car_info>(GetArenaNoVirtual());
    car_info_ = p;
  }
  // @@protoc_insertion_point(field_mutable:message.Parkspace_info.car_info)
  return car_info_;
}
inline void Parkspace_info::set_allocated_car_info(::message::Car_info* car_info) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete car_info_;
  }
  if (car_info) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      car_info = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, car_info, submessage_arena);
    }
    set_has_car_info();
  } else {
    clear_has_car_info();
  }
  car_info_ = car_info;
  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_info.car_info)
}

// optional string entry_time = 12;
inline bool Parkspace_info::has_entry_time() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Parkspace_info::set_has_entry_time() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Parkspace_info::clear_has_entry_time() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Parkspace_info::clear_entry_time() {
  entry_time_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_entry_time();
}
inline const ::std::string& Parkspace_info::entry_time() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.entry_time)
  return entry_time_.GetNoArena();
}
inline void Parkspace_info::set_entry_time(const ::std::string& value) {
  set_has_entry_time();
  entry_time_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:message.Parkspace_info.entry_time)
}
#if LANG_CXX11
inline void Parkspace_info::set_entry_time(::std::string&& value) {
  set_has_entry_time();
  entry_time_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:message.Parkspace_info.entry_time)
}
#endif
inline void Parkspace_info::set_entry_time(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_entry_time();
  entry_time_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:message.Parkspace_info.entry_time)
}
inline void Parkspace_info::set_entry_time(const char* value, size_t size) {
  set_has_entry_time();
  entry_time_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:message.Parkspace_info.entry_time)
}
inline ::std::string* Parkspace_info::mutable_entry_time() {
  set_has_entry_time();
  // @@protoc_insertion_point(field_mutable:message.Parkspace_info.entry_time)
  return entry_time_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Parkspace_info::release_entry_time() {
  // @@protoc_insertion_point(field_release:message.Parkspace_info.entry_time)
  if (!has_entry_time()) {
    return NULL;
  }
  clear_has_entry_time();
  return entry_time_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Parkspace_info::set_allocated_entry_time(::std::string* entry_time) {
  if (entry_time != NULL) {
    set_has_entry_time();
  } else {
    clear_has_entry_time();
  }
  entry_time_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), entry_time);
  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_info.entry_time)
}

// optional string leave_time = 13;
inline bool Parkspace_info::has_leave_time() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Parkspace_info::set_has_leave_time() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Parkspace_info::clear_has_leave_time() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Parkspace_info::clear_leave_time() {
  leave_time_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_leave_time();
}
inline const ::std::string& Parkspace_info::leave_time() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.leave_time)
  return leave_time_.GetNoArena();
}
inline void Parkspace_info::set_leave_time(const ::std::string& value) {
  set_has_leave_time();
  leave_time_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:message.Parkspace_info.leave_time)
}
#if LANG_CXX11
inline void Parkspace_info::set_leave_time(::std::string&& value) {
  set_has_leave_time();
  leave_time_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:message.Parkspace_info.leave_time)
}
#endif
inline void Parkspace_info::set_leave_time(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_leave_time();
  leave_time_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:message.Parkspace_info.leave_time)
}
inline void Parkspace_info::set_leave_time(const char* value, size_t size) {
  set_has_leave_time();
  leave_time_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:message.Parkspace_info.leave_time)
}
inline ::std::string* Parkspace_info::mutable_leave_time() {
  set_has_leave_time();
  // @@protoc_insertion_point(field_mutable:message.Parkspace_info.leave_time)
  return leave_time_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Parkspace_info::release_leave_time() {
  // @@protoc_insertion_point(field_release:message.Parkspace_info.leave_time)
  if (!has_leave_time()) {
    return NULL;
  }
  clear_has_leave_time();
  return leave_time_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Parkspace_info::set_allocated_leave_time(::std::string* leave_time) {
  if (leave_time != NULL) {
    set_has_leave_time();
  } else {
    clear_has_leave_time();
  }
  leave_time_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), leave_time);
  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_info.leave_time)
}

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

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

// optional .message.Parkspace_status parkspace_status_target = 16;
inline bool Parkspace_info::has_parkspace_status_target() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void Parkspace_info::set_has_parkspace_status_target() {
  _has_bits_[0] |= 0x00008000u;
}
inline void Parkspace_info::clear_has_parkspace_status_target() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void Parkspace_info::clear_parkspace_status_target() {
  parkspace_status_target_ = 0;
  clear_has_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 static_cast< ::message::Parkspace_status >(parkspace_status_target_);
}
inline void Parkspace_info::set_parkspace_status_target(::message::Parkspace_status value) {
  assert(::message::Parkspace_status_IsValid(value));
  set_has_parkspace_status_target();
  parkspace_status_target_ = value;
  // @@protoc_insertion_point(field_set:message.Parkspace_info.parkspace_status_target)
}

// optional .message.Car_type car_type = 17;
inline bool Parkspace_info::has_car_type() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void Parkspace_info::set_has_car_type() {
  _has_bits_[0] |= 0x00010000u;
}
inline void Parkspace_info::clear_has_car_type() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void Parkspace_info::clear_car_type() {
  car_type_ = 0;
  clear_has_car_type();
}
inline ::message::Car_type Parkspace_info::car_type() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.car_type)
  return static_cast< ::message::Car_type >(car_type_);
}
inline void Parkspace_info::set_car_type(::message::Car_type value) {
  assert(::message::Car_type_IsValid(value));
  set_has_car_type();
  car_type_ = value;
  // @@protoc_insertion_point(field_set:message.Parkspace_info.car_type)
}

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

// Id_struct

// optional int32 terminal_id = 1;
inline bool Id_struct::has_terminal_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Id_struct::set_has_terminal_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Id_struct::clear_has_terminal_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Id_struct::clear_terminal_id() {
  terminal_id_ = 0;
  clear_has_terminal_id();
}
inline ::google::protobuf::int32 Id_struct::terminal_id() const {
  // @@protoc_insertion_point(field_get:message.Id_struct.terminal_id)
  return terminal_id_;
}
inline void Id_struct::set_terminal_id(::google::protobuf::int32 value) {
  set_has_terminal_id();
  terminal_id_ = value;
  // @@protoc_insertion_point(field_set:message.Id_struct.terminal_id)
}

// optional int32 unit_id = 2;
inline bool Id_struct::has_unit_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Id_struct::set_has_unit_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Id_struct::clear_has_unit_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Id_struct::clear_unit_id() {
  unit_id_ = 0;
  clear_has_unit_id();
}
inline ::google::protobuf::int32 Id_struct::unit_id() const {
  // @@protoc_insertion_point(field_get:message.Id_struct.unit_id)
  return unit_id_;
}
inline void Id_struct::set_unit_id(::google::protobuf::int32 value) {
  set_has_unit_id();
  unit_id_ = value;
  // @@protoc_insertion_point(field_set:message.Id_struct.unit_id)
}

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace message

namespace google {
namespace protobuf {

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();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_INCLUDED_message_5fbase_2eproto
