Terminal_process_CT/message/message_base.pb.h

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

#ifndef PROTOBUF_message_5fbase_2eproto__INCLUDED
#define PROTOBUF_message_5fbase_2eproto__INCLUDED

#include <string>

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

#if GOOGLE_PROTOBUF_VERSION < 3005000
#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 3005000 < 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/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)

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[6];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors();
void InitDefaultsBase_infoImpl();
void InitDefaultsBase_info();
void InitDefaultsBase_msgImpl();
void InitDefaultsBase_msg();
void InitDefaultsError_managerImpl();
void InitDefaultsError_manager();
void InitDefaultsLocate_informationImpl();
void InitDefaultsLocate_information();
void InitDefaultsCar_infoImpl();
void InitDefaultsCar_info();
void InitDefaultsParkspace_infoImpl();
void InitDefaultsParkspace_info();
inline void InitDefaults() {
  InitDefaultsBase_info();
  InitDefaultsBase_msg();
  InitDefaultsError_manager();
  InitDefaultsLocate_information();
  InitDefaultsCar_info();
  InitDefaultsParkspace_info();
}
}  // 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 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 message {

enum Message_type {
  eBase_msg = 0,
  eCommand_msg = 1,
  eLocate_status_msg = 17,
  eLocate_request_msg = 18,
  eLocate_response_msg = 19,
  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,
  eStore_command_request_msg = 65,
  eStore_command_response_msg = 66,
  ePickup_command_request_msg = 67,
  ePickup_command_response_msg = 68,
  eStoring_process_statu_msg = 144,
  ePicking_process_statu_msg = 145,
  eCentral_controller_statu_msg = 160,
  eEntrance_manual_operation_msg = 176,
  eProcess_manual_operation_msg = 177
};
bool Message_type_IsValid(int value);
const Message_type Message_type_MIN = eBase_msg;
const Message_type Message_type_MAX = eProcess_manual_operation_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,
  eDispatch = 1024
};
bool Communicator_IsValid(int value);
const Communicator Communicator_MIN = eEmpty;
const Communicator Communicator_MAX = eDispatch;
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_empty = 0,
  eParkspace_occupied = 1,
  eParkspace_reserverd = 2,
  eParkspace_error = 3
};
bool Parkspace_status_IsValid(int value);
const Parkspace_status Parkspace_status_MIN = eParkspace_empty;
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 {
  eForward = 1,
  eBackward = 2
};
bool Direction_IsValid(int value);
const Direction Direction_MIN = eForward;
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 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);
}
// ===================================================================

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 PROTOBUF_CONSTEXPR int const 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 PROTOBUF_FINAL { return New(NULL); }

  Base_info* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const Base_info& from);
  void MergeFrom(const Base_info& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_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 PROTOBUF_FINAL;

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

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

  // required .message.Message_type msg_type = 1;
  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;
  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;
  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;
  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 int _cached_size_;
  int msg_type_;
  ::google::protobuf::int32 timeout_ms_;
  int sender_;
  int receiver_;
  friend struct ::protobuf_message_5fbase_2eproto::TableStruct;
  friend void ::protobuf_message_5fbase_2eproto::InitDefaultsBase_infoImpl();
};
// -------------------------------------------------------------------

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 PROTOBUF_CONSTEXPR int const 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 PROTOBUF_FINAL { return New(NULL); }

  Base_msg* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const Base_msg& from);
  void MergeFrom(const Base_msg& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_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 PROTOBUF_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;
  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 int _cached_size_;
  ::message::Base_info* base_info_;
  friend struct ::protobuf_message_5fbase_2eproto::TableStruct;
  friend void ::protobuf_message_5fbase_2eproto::InitDefaultsBase_msgImpl();
};
// -------------------------------------------------------------------

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 PROTOBUF_CONSTEXPR int const 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 PROTOBUF_FINAL { return New(NULL); }

  Error_manager* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const Error_manager& from);
  void MergeFrom(const Error_manager& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_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 PROTOBUF_FINAL;

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

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

  // optional string error_description = 3;
  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;
  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;
  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 int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr error_description_;
  ::google::protobuf::int32 error_code_;
  int error_level_;
  friend struct ::protobuf_message_5fbase_2eproto::TableStruct;
  friend void ::protobuf_message_5fbase_2eproto::InitDefaultsError_managerImpl();
};
// -------------------------------------------------------------------

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 PROTOBUF_CONSTEXPR int const 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 PROTOBUF_FINAL { return New(NULL); }

  Locate_information* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const Locate_information& from);
  void MergeFrom(const Locate_information& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_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 PROTOBUF_FINAL;

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

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

  // optional float locate_x = 1;
  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;
  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;
  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;
  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;
  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;
  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;
  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;
  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;
  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;
  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);

  // @@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();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  float locate_x_;
  float locate_y_;
  float locate_angle_;
  float locate_length_;
  float locate_width_;
  float locate_height_;
  float locate_wheel_base_;
  float locate_wheel_width_;
  bool locate_correct_;
  float locate_front_theta_;
  friend struct ::protobuf_message_5fbase_2eproto::TableStruct;
  friend void ::protobuf_message_5fbase_2eproto::InitDefaultsLocate_informationImpl();
};
// -------------------------------------------------------------------

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 PROTOBUF_CONSTEXPR int const 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 PROTOBUF_FINAL { return New(NULL); }

  Car_info* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const Car_info& from);
  void MergeFrom(const Car_info& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_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 PROTOBUF_FINAL;

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

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

  // optional string license = 4;
  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 float car_length = 1;
  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;
  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;
  bool has_car_height() const;
  void clear_car_height();
  static const int kCarHeightFieldNumber = 3;
  float car_height() const;
  void set_car_height(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();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr license_;
  float car_length_;
  float car_width_;
  float car_height_;
  friend struct ::protobuf_message_5fbase_2eproto::TableStruct;
  friend void ::protobuf_message_5fbase_2eproto::InitDefaultsCar_infoImpl();
};
// -------------------------------------------------------------------

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 PROTOBUF_CONSTEXPR int const 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 PROTOBUF_FINAL { return New(NULL); }

  Parkspace_info* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const Parkspace_info& from);
  void MergeFrom(const Parkspace_info& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_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 PROTOBUF_FINAL;

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

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

  // optional string entry_time = 10;
  bool has_entry_time() const;
  void clear_entry_time();
  static const int kEntryTimeFieldNumber = 10;
  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 = 11;
  bool has_leave_time() const;
  void clear_leave_time();
  static const int kLeaveTimeFieldNumber = 11;
  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 = 9;
  bool has_car_info() const;
  void clear_car_info();
  static const int kCarInfoFieldNumber = 9;
  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 parkspace_id = 1;
  bool has_parkspace_id() const;
  void clear_parkspace_id();
  static const int kParkspaceIdFieldNumber = 1;
  ::google::protobuf::int32 parkspace_id() const;
  void set_parkspace_id(::google::protobuf::int32 value);

  // optional int32 index = 2;
  bool has_index() const;
  void clear_index();
  static const int kIndexFieldNumber = 2;
  ::google::protobuf::int32 index() const;
  void set_index(::google::protobuf::int32 value);

  // optional int32 floor = 4;
  bool has_floor() const;
  void clear_floor();
  static const int kFloorFieldNumber = 4;
  ::google::protobuf::int32 floor() const;
  void set_floor(::google::protobuf::int32 value);

  // optional float length = 5;
  bool has_length() const;
  void clear_length();
  static const int kLengthFieldNumber = 5;
  float length() const;
  void set_length(float value);

  // optional float width = 6;
  bool has_width() const;
  void clear_width();
  static const int kWidthFieldNumber = 6;
  float width() const;
  void set_width(float value);

  // optional float height = 7;
  bool has_height() const;
  void clear_height();
  static const int kHeightFieldNumber = 7;
  float height() const;
  void set_height(float value);

  // optional .message.Parkspace_status parkspace_status = 8;
  bool has_parkspace_status() const;
  void clear_parkspace_status();
  static const int kParkspaceStatusFieldNumber = 8;
  ::message::Parkspace_status parkspace_status() const;
  void set_parkspace_status(::message::Parkspace_status value);

  // optional .message.Direction direction = 3;
  bool has_direction() const;
  void clear_direction();
  static const int kDirectionFieldNumber = 3;
  ::message::Direction direction() const;
  void set_direction(::message::Direction value);

  // @@protoc_insertion_point(class_scope:message.Parkspace_info)
 private:
  void set_has_parkspace_id();
  void clear_has_parkspace_id();
  void set_has_index();
  void clear_has_index();
  void set_has_direction();
  void clear_has_direction();
  void set_has_floor();
  void clear_has_floor();
  void set_has_length();
  void clear_has_length();
  void set_has_width();
  void clear_has_width();
  void set_has_height();
  void clear_has_height();
  void set_has_parkspace_status();
  void clear_has_parkspace_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();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr entry_time_;
  ::google::protobuf::internal::ArenaStringPtr leave_time_;
  ::message::Car_info* car_info_;
  ::google::protobuf::int32 parkspace_id_;
  ::google::protobuf::int32 index_;
  ::google::protobuf::int32 floor_;
  float length_;
  float width_;
  float height_;
  int parkspace_status_;
  int direction_;
  friend struct ::protobuf_message_5fbase_2eproto::TableStruct;
  friend void ::protobuf_message_5fbase_2eproto::InitDefaultsParkspace_infoImpl();
};
// ===================================================================


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

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

// required .message.Message_type msg_type = 1;
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;
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;
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;
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::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) {
    base_info_ = new ::message::Base_info;
  }
  // @@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;
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;
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;
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)
  clear_has_error_description();
  return error_description_.ReleaseNoArena(&::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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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)
}

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

// Car_info

// optional float car_length = 1;
inline bool Car_info::has_car_length() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Car_info::set_has_car_length() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Car_info::clear_has_car_length() {
  _has_bits_[0] &= ~0x00000002u;
}
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;
inline bool Car_info::has_car_width() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Car_info::set_has_car_width() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Car_info::clear_has_car_width() {
  _has_bits_[0] &= ~0x00000004u;
}
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;
inline bool Car_info::has_car_height() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Car_info::set_has_car_height() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Car_info::clear_has_car_height() {
  _has_bits_[0] &= ~0x00000008u;
}
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;
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)
  clear_has_license();
  return license_.ReleaseNoArena(&::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)
}

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

// Parkspace_info

// optional int32 parkspace_id = 1;
inline bool Parkspace_info::has_parkspace_id() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Parkspace_info::set_has_parkspace_id() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Parkspace_info::clear_has_parkspace_id() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Parkspace_info::clear_parkspace_id() {
  parkspace_id_ = 0;
  clear_has_parkspace_id();
}
inline ::google::protobuf::int32 Parkspace_info::parkspace_id() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.parkspace_id)
  return parkspace_id_;
}
inline void Parkspace_info::set_parkspace_id(::google::protobuf::int32 value) {
  set_has_parkspace_id();
  parkspace_id_ = value;
  // @@protoc_insertion_point(field_set:message.Parkspace_info.parkspace_id)
}

// optional int32 index = 2;
inline bool Parkspace_info::has_index() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Parkspace_info::set_has_index() {
  _has_bits_[0] |= 0x00000010u;
}
inline void Parkspace_info::clear_has_index() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void Parkspace_info::clear_index() {
  index_ = 0;
  clear_has_index();
}
inline ::google::protobuf::int32 Parkspace_info::index() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.index)
  return index_;
}
inline void Parkspace_info::set_index(::google::protobuf::int32 value) {
  set_has_index();
  index_ = value;
  // @@protoc_insertion_point(field_set:message.Parkspace_info.index)
}

// optional .message.Direction direction = 3;
inline bool Parkspace_info::has_direction() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void Parkspace_info::set_has_direction() {
  _has_bits_[0] |= 0x00000400u;
}
inline void Parkspace_info::clear_has_direction() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void Parkspace_info::clear_direction() {
  direction_ = 1;
  clear_has_direction();
}
inline ::message::Direction Parkspace_info::direction() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.direction)
  return static_cast< ::message::Direction >(direction_);
}
inline void Parkspace_info::set_direction(::message::Direction value) {
  assert(::message::Direction_IsValid(value));
  set_has_direction();
  direction_ = value;
  // @@protoc_insertion_point(field_set:message.Parkspace_info.direction)
}

// optional int32 floor = 4;
inline bool Parkspace_info::has_floor() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Parkspace_info::set_has_floor() {
  _has_bits_[0] |= 0x00000020u;
}
inline void Parkspace_info::clear_has_floor() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void Parkspace_info::clear_floor() {
  floor_ = 0;
  clear_has_floor();
}
inline ::google::protobuf::int32 Parkspace_info::floor() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.floor)
  return floor_;
}
inline void Parkspace_info::set_floor(::google::protobuf::int32 value) {
  set_has_floor();
  floor_ = value;
  // @@protoc_insertion_point(field_set:message.Parkspace_info.floor)
}

// optional float length = 5;
inline bool Parkspace_info::has_length() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void Parkspace_info::set_has_length() {
  _has_bits_[0] |= 0x00000040u;
}
inline void Parkspace_info::clear_has_length() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void Parkspace_info::clear_length() {
  length_ = 0;
  clear_has_length();
}
inline float Parkspace_info::length() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.length)
  return length_;
}
inline void Parkspace_info::set_length(float value) {
  set_has_length();
  length_ = value;
  // @@protoc_insertion_point(field_set:message.Parkspace_info.length)
}

// optional float width = 6;
inline bool Parkspace_info::has_width() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void Parkspace_info::set_has_width() {
  _has_bits_[0] |= 0x00000080u;
}
inline void Parkspace_info::clear_has_width() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void Parkspace_info::clear_width() {
  width_ = 0;
  clear_has_width();
}
inline float Parkspace_info::width() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.width)
  return width_;
}
inline void Parkspace_info::set_width(float value) {
  set_has_width();
  width_ = value;
  // @@protoc_insertion_point(field_set:message.Parkspace_info.width)
}

// optional float height = 7;
inline bool Parkspace_info::has_height() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void Parkspace_info::set_has_height() {
  _has_bits_[0] |= 0x00000100u;
}
inline void Parkspace_info::clear_has_height() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void Parkspace_info::clear_height() {
  height_ = 0;
  clear_has_height();
}
inline float Parkspace_info::height() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.height)
  return height_;
}
inline void Parkspace_info::set_height(float value) {
  set_has_height();
  height_ = value;
  // @@protoc_insertion_point(field_set:message.Parkspace_info.height)
}

// optional .message.Parkspace_status parkspace_status = 8;
inline bool Parkspace_info::has_parkspace_status() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void Parkspace_info::set_has_parkspace_status() {
  _has_bits_[0] |= 0x00000200u;
}
inline void Parkspace_info::clear_has_parkspace_status() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void Parkspace_info::clear_parkspace_status() {
  parkspace_status_ = 0;
  clear_has_parkspace_status();
}
inline ::message::Parkspace_status Parkspace_info::parkspace_status() const {
  // @@protoc_insertion_point(field_get:message.Parkspace_info.parkspace_status)
  return static_cast< ::message::Parkspace_status >(parkspace_status_);
}
inline void Parkspace_info::set_parkspace_status(::message::Parkspace_status value) {
  assert(::message::Parkspace_status_IsValid(value));
  set_has_parkspace_status();
  parkspace_status_ = value;
  // @@protoc_insertion_point(field_set:message.Parkspace_info.parkspace_status)
}

// optional .message.Car_info car_info = 9;
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::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) {
    car_info_ = new ::message::Car_info;
  }
  // @@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 = 10;
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)
  clear_has_entry_time();
  return entry_time_.ReleaseNoArena(&::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 = 11;
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)
  clear_has_leave_time();
  return leave_time_.ReleaseNoArena(&::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)
}

#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> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::message::Message_type>() {
  return ::message::Message_type_descriptor();
}
template <> struct is_proto_enum< ::message::Communicator> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::message::Communicator>() {
  return ::message::Communicator_descriptor();
}
template <> struct is_proto_enum< ::message::Process_type> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::message::Process_type>() {
  return ::message::Process_type_descriptor();
}
template <> struct is_proto_enum< ::message::Error_level> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::message::Error_level>() {
  return ::message::Error_level_descriptor();
}
template <> struct is_proto_enum< ::message::Parkspace_status> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::message::Parkspace_status>() {
  return ::message::Parkspace_status_descriptor();
}
template <> struct is_proto_enum< ::message::Direction> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::message::Direction>() {
  return ::message::Direction_descriptor();
}
template <> struct is_proto_enum< ::message::Step_type> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::message::Step_type>() {
  return ::message::Step_type_descriptor();
}
template <> struct is_proto_enum< ::message::Step_statu> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::message::Step_statu>() {
  return ::message::Step_statu_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_message_5fbase_2eproto__INCLUDED