Terminal_process_CT/message/message_base.pb.h

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_message_5fbase_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_message_5fbase_2eproto

#include <limits>
#include <string>

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

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_message_5fbase_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

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

enum Message_type : int {
  eBase_msg = 0,
  eCommand_msg = 1,
  eLocate_status_msg = 17,
  eLocate_request_msg = 18,
  eLocate_response_msg = 19,
  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);
constexpr Message_type Message_type_MIN = eBase_msg;
constexpr Message_type Message_type_MAX = eProcess_manual_operation_msg;
constexpr int Message_type_ARRAYSIZE = Message_type_MAX + 1;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  public:

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

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

  enum : int {
    kEntryTimeFieldNumber = 10,
    kLeaveTimeFieldNumber = 11,
    kCarInfoFieldNumber = 9,
    kParkspaceIdFieldNumber = 1,
    kIndexFieldNumber = 2,
    kFloorFieldNumber = 4,
    kLengthFieldNumber = 5,
    kWidthFieldNumber = 6,
    kHeightFieldNumber = 7,
    kParkspaceStatusFieldNumber = 8,
    kDirectionFieldNumber = 3,
  };
  // optional string entry_time = 10;
  bool has_entry_time() const;
  private:
  bool _internal_has_entry_time() const;
  public:
  void clear_entry_time();
  const std::string& entry_time() const;
  void set_entry_time(const std::string& value);
  void set_entry_time(std::string&& value);
  void set_entry_time(const char* value);
  void set_entry_time(const char* value, size_t size);
  std::string* mutable_entry_time();
  std::string* release_entry_time();
  void set_allocated_entry_time(std::string* entry_time);
  private:
  const std::string& _internal_entry_time() const;
  void _internal_set_entry_time(const std::string& value);
  std::string* _internal_mutable_entry_time();
  public:

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

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

  // optional int32 parkspace_id = 1;
  bool has_parkspace_id() const;
  private:
  bool _internal_has_parkspace_id() const;
  public:
  void clear_parkspace_id();
  ::PROTOBUF_NAMESPACE_ID::int32 parkspace_id() const;
  void set_parkspace_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_parkspace_id() const;
  void _internal_set_parkspace_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 index = 2;
  bool has_index() const;
  private:
  bool _internal_has_index() const;
  public:
  void clear_index();
  ::PROTOBUF_NAMESPACE_ID::int32 index() const;
  void set_index(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_index() const;
  void _internal_set_index(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 floor = 4;
  bool has_floor() const;
  private:
  bool _internal_has_floor() const;
  public:
  void clear_floor();
  ::PROTOBUF_NAMESPACE_ID::int32 floor() const;
  void set_floor(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_floor() const;
  void _internal_set_floor(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional float length = 5;
  bool has_length() const;
  private:
  bool _internal_has_length() const;
  public:
  void clear_length();
  float length() const;
  void set_length(float value);
  private:
  float _internal_length() const;
  void _internal_set_length(float value);
  public:

  // optional float width = 6;
  bool has_width() const;
  private:
  bool _internal_has_width() const;
  public:
  void clear_width();
  float width() const;
  void set_width(float value);
  private:
  float _internal_width() const;
  void _internal_set_width(float value);
  public:

  // optional float height = 7;
  bool has_height() const;
  private:
  bool _internal_has_height() const;
  public:
  void clear_height();
  float height() const;
  void set_height(float value);
  private:
  float _internal_height() const;
  void _internal_set_height(float value);
  public:

  // optional .message.Parkspace_status parkspace_status = 8;
  bool has_parkspace_status() const;
  private:
  bool _internal_has_parkspace_status() const;
  public:
  void clear_parkspace_status();
  ::message::Parkspace_status parkspace_status() const;
  void set_parkspace_status(::message::Parkspace_status value);
  private:
  ::message::Parkspace_status _internal_parkspace_status() const;
  void _internal_set_parkspace_status(::message::Parkspace_status value);
  public:

  // optional .message.Direction direction = 3;
  bool has_direction() const;
  private:
  bool _internal_has_direction() const;
  public:
  void clear_direction();
  ::message::Direction direction() const;
  void set_direction(::message::Direction value);
  private:
  ::message::Direction _internal_direction() const;
  void _internal_set_direction(::message::Direction value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr entry_time_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr leave_time_;
  ::message::Car_info* car_info_;
  ::PROTOBUF_NAMESPACE_ID::int32 parkspace_id_;
  ::PROTOBUF_NAMESPACE_ID::int32 index_;
  ::PROTOBUF_NAMESPACE_ID::int32 floor_;
  float length_;
  float width_;
  float height_;
  int parkspace_status_;
  int direction_;
  friend struct ::TableStruct_message_5fbase_2eproto;
};
// ===================================================================


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

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

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

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

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

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

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

// Base_msg

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

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

// Error_manager

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

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

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

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

// Locate_information

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

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

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

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

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

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

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

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

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

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

// Car_info

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

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

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

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

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

// Parkspace_info

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace message

PROTOBUF_NAMESPACE_OPEN

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

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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