2021 0308, wangkang parkspace message修改

message/parkspace_allocation_message.pb.cc

@@ -85,6 +85,11 @@ class Parkspace_allocation_data_msgDefaultTypeInternal {
   ::google::protobuf::internal::ExplicitlyConstructed<Parkspace_allocation_data_msg>
       _instance;
 } _Parkspace_allocation_data_msg_default_instance_;
+class Parkspace_remaining_number_msgDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<Parkspace_remaining_number_msg>
+      _instance;
+} _Parkspace_remaining_number_msg_default_instance_;
 }  // namespace message
 namespace protobuf_parkspace_5fallocation_5fmessage_2eproto {
 void InitDefaultsParkspace_allocation_request_msgImpl() {
@@ -391,7 +396,30 @@ void InitDefaultsParkspace_allocation_data_msg() {
   ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsParkspace_allocation_data_msgImpl);
 }
 
-::google::protobuf::Metadata file_level_metadata[13];
+void InitDefaultsParkspace_remaining_number_msgImpl() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
+  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
+#else
+  ::google::protobuf::internal::InitProtobufDefaults();
+#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
+  protobuf_message_5fbase_2eproto::InitDefaultsBase_info();
+  protobuf_message_5fbase_2eproto::InitDefaultsError_manager();
+  {
+    void* ptr = &::message::_Parkspace_remaining_number_msg_default_instance_;
+    new (ptr) ::message::Parkspace_remaining_number_msg();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::message::Parkspace_remaining_number_msg::InitAsDefaultInstance();
+}
+
+void InitDefaultsParkspace_remaining_number_msg() {
+  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
+  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsParkspace_remaining_number_msgImpl);
+}
+
+::google::protobuf::Metadata file_level_metadata[14];
 const ::google::protobuf::EnumDescriptor* file_level_enum_descriptors[3];
 
 const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
@@ -552,6 +580,23 @@ const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUT
   0,
   1,
   ~0u,
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Parkspace_remaining_number_msg, _has_bits_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Parkspace_remaining_number_msg, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Parkspace_remaining_number_msg, base_info_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Parkspace_remaining_number_msg, error_manager_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Parkspace_remaining_number_msg, small_parkspace_remaining_number_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Parkspace_remaining_number_msg, medium_parkspace_remaining_number_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Parkspace_remaining_number_msg, large_parkspace_remaining_number_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Parkspace_remaining_number_msg, total_parkspace_remaining_number_),
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
 };
 static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
   { 0, 9, sizeof(::message::Parkspace_allocation_request_msg)},
@@ -567,6 +612,7 @@ static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROT
   { 126, 135, sizeof(::message::Parkspace_allocation_status_msg)},
   { 139, 145, sizeof(::message::Parkspace_refresh_request_msg)},
   { 146, 154, sizeof(::message::Parkspace_allocation_data_msg)},
+  { 157, 168, sizeof(::message::Parkspace_remaining_number_msg)},
 };
 
 static ::google::protobuf::Message const * const file_default_instances[] = {
@@ -583,6 +629,7 @@ static ::google::protobuf::Message const * const file_default_instances[] = {
   reinterpret_cast<const ::google::protobuf::Message*>(&::message::_Parkspace_allocation_status_msg_default_instance_),
   reinterpret_cast<const ::google::protobuf::Message*>(&::message::_Parkspace_refresh_request_msg_default_instance_),
   reinterpret_cast<const ::google::protobuf::Message*>(&::message::_Parkspace_allocation_data_msg_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::message::_Parkspace_remaining_number_msg_default_instance_),
 };
 
 void protobuf_AssignDescriptors() {
@@ -601,7 +648,7 @@ void protobuf_AssignDescriptorsOnce() {
 void protobuf_RegisterTypes(const ::std::string&) GOOGLE_PROTOBUF_ATTRIBUTE_COLD;
 void protobuf_RegisterTypes(const ::std::string&) {
   protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::internal::RegisterAllTypes(file_level_metadata, 13);
+  ::google::protobuf::internal::RegisterAllTypes(file_level_metadata, 14);
 }
 
 void AddDescriptorsImpl() {
@@ -667,19 +714,26 @@ void AddDescriptorsImpl() {
       "info\030\001 \002(\0132\022.message.Base_info\022-\n\rerror_"
       "manager\030\002 \002(\0132\026.message.Error_manager\022/\n"
       "\016parkspace_info\030\003 \003(\0132\027.message.Parkspac"
-      "e_info*\225\001\n\016Vehicle_status\022\021\n\reVehicle_id"
-      "le\020\000\022\026\n\022eVehicle_in_garage\020\001\022\024\n\020eVehicle"
-      "_parking\020\002\022\025\n\021eVehicle_fetching\020\003\022\025\n\021eVe"
-      "hicle_reserved\020\004\022\024\n\020eVehicle_unknown\020\005*W"
-      "\n\032Database_controller_status\022\r\n\tE_UNKNOW"
-      "N\020\000\022\013\n\007E_READY\020\001\022\020\n\014E_DISCONNECT\020\002\022\013\n\007E_"
-      "FAULT\020\003*v\n\027Parkspace_manager_satus\022\036\n\032eP"
-      "arkspace_manager_unknown\020\000\022\035\n\031eParkspace"
-      "_manager_normal\020\001\022\034\n\030eParkspace_manager_"
-      "fault\020\002"
+      "e_info\"\237\002\n\036Parkspace_remaining_number_ms"
+      "g\022%\n\tbase_info\030\001 \002(\0132\022.message.Base_info"
+      "\022-\n\rerror_manager\030\002 \002(\0132\026.message.Error_"
+      "manager\022(\n small_parkspace_remaining_num"
+      "ber\030\003 \002(\005\022)\n!medium_parkspace_remaining_"
+      "number\030\004 \002(\005\022(\n large_parkspace_remainin"
+      "g_number\030\005 \002(\005\022(\n total_parkspace_remain"
+      "ing_number\030\006 \002(\005*\225\001\n\016Vehicle_status\022\021\n\re"
+      "Vehicle_idle\020\000\022\026\n\022eVehicle_in_garage\020\001\022\024"
+      "\n\020eVehicle_parking\020\002\022\025\n\021eVehicle_fetchin"
+      "g\020\003\022\025\n\021eVehicle_reserved\020\004\022\024\n\020eVehicle_u"
+      "nknown\020\005*W\n\032Database_controller_status\022\r"
+      "\n\tE_UNKNOWN\020\000\022\013\n\007E_READY\020\001\022\020\n\014E_DISCONNE"
+      "CT\020\002\022\013\n\007E_FAULT\020\003*v\n\027Parkspace_manager_s"
+      "atus\022\036\n\032eParkspace_manager_unknown\020\000\022\035\n\031"
+      "eParkspace_manager_normal\020\001\022\034\n\030eParkspac"
+      "e_manager_fault\020\002"
   };
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
-      descriptor, 2767);
+      descriptor, 3057);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "parkspace_allocation_message.proto", &protobuf_RegisterTypes);
   ::protobuf_message_5fbase_2eproto::AddDescriptors();
@@ -6363,6 +6417,525 @@ void Parkspace_allocation_data_msg::InternalSwap(Parkspace_allocation_data_msg*
 }
 
 
+// ===================================================================
+
+void Parkspace_remaining_number_msg::InitAsDefaultInstance() {
+  ::message::_Parkspace_remaining_number_msg_default_instance_._instance.get_mutable()->base_info_ = const_cast< ::message::Base_info*>(
+      ::message::Base_info::internal_default_instance());
+  ::message::_Parkspace_remaining_number_msg_default_instance_._instance.get_mutable()->error_manager_ = const_cast< ::message::Error_manager*>(
+      ::message::Error_manager::internal_default_instance());
+}
+void Parkspace_remaining_number_msg::clear_base_info() {
+  if (base_info_ != NULL) base_info_->Clear();
+  clear_has_base_info();
+}
+void Parkspace_remaining_number_msg::clear_error_manager() {
+  if (error_manager_ != NULL) error_manager_->Clear();
+  clear_has_error_manager();
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int Parkspace_remaining_number_msg::kBaseInfoFieldNumber;
+const int Parkspace_remaining_number_msg::kErrorManagerFieldNumber;
+const int Parkspace_remaining_number_msg::kSmallParkspaceRemainingNumberFieldNumber;
+const int Parkspace_remaining_number_msg::kMediumParkspaceRemainingNumberFieldNumber;
+const int Parkspace_remaining_number_msg::kLargeParkspaceRemainingNumberFieldNumber;
+const int Parkspace_remaining_number_msg::kTotalParkspaceRemainingNumberFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+Parkspace_remaining_number_msg::Parkspace_remaining_number_msg()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
+    ::protobuf_parkspace_5fallocation_5fmessage_2eproto::InitDefaultsParkspace_remaining_number_msg();
+  }
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:message.Parkspace_remaining_number_msg)
+}
+Parkspace_remaining_number_msg::Parkspace_remaining_number_msg(const Parkspace_remaining_number_msg& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL),
+      _has_bits_(from._has_bits_),
+      _cached_size_(0) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  if (from.has_base_info()) {
+    base_info_ = new ::message::Base_info(*from.base_info_);
+  } else {
+    base_info_ = NULL;
+  }
+  if (from.has_error_manager()) {
+    error_manager_ = new ::message::Error_manager(*from.error_manager_);
+  } else {
+    error_manager_ = NULL;
+  }
+  ::memcpy(&small_parkspace_remaining_number_, &from.small_parkspace_remaining_number_,
+    static_cast<size_t>(reinterpret_cast<char*>(&total_parkspace_remaining_number_) -
+    reinterpret_cast<char*>(&small_parkspace_remaining_number_)) + sizeof(total_parkspace_remaining_number_));
+  // @@protoc_insertion_point(copy_constructor:message.Parkspace_remaining_number_msg)
+}
+
+void Parkspace_remaining_number_msg::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(&base_info_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&total_parkspace_remaining_number_) -
+      reinterpret_cast<char*>(&base_info_)) + sizeof(total_parkspace_remaining_number_));
+}
+
+Parkspace_remaining_number_msg::~Parkspace_remaining_number_msg() {
+  // @@protoc_insertion_point(destructor:message.Parkspace_remaining_number_msg)
+  SharedDtor();
+}
+
+void Parkspace_remaining_number_msg::SharedDtor() {
+  if (this != internal_default_instance()) delete base_info_;
+  if (this != internal_default_instance()) delete error_manager_;
+}
+
+void Parkspace_remaining_number_msg::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Parkspace_remaining_number_msg::descriptor() {
+  ::protobuf_parkspace_5fallocation_5fmessage_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_parkspace_5fallocation_5fmessage_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const Parkspace_remaining_number_msg& Parkspace_remaining_number_msg::default_instance() {
+  ::protobuf_parkspace_5fallocation_5fmessage_2eproto::InitDefaultsParkspace_remaining_number_msg();
+  return *internal_default_instance();
+}
+
+Parkspace_remaining_number_msg* Parkspace_remaining_number_msg::New(::google::protobuf::Arena* arena) const {
+  Parkspace_remaining_number_msg* n = new Parkspace_remaining_number_msg;
+  if (arena != NULL) {
+    arena->Own(n);
+  }
+  return n;
+}
+
+void Parkspace_remaining_number_msg::Clear() {
+// @@protoc_insertion_point(message_clear_start:message.Parkspace_remaining_number_msg)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 3u) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(base_info_ != NULL);
+      base_info_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(error_manager_ != NULL);
+      error_manager_->Clear();
+    }
+  }
+  if (cached_has_bits & 60u) {
+    ::memset(&small_parkspace_remaining_number_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&total_parkspace_remaining_number_) -
+        reinterpret_cast<char*>(&small_parkspace_remaining_number_)) + sizeof(total_parkspace_remaining_number_));
+  }
+  _has_bits_.Clear();
+  _internal_metadata_.Clear();
+}
+
+bool Parkspace_remaining_number_msg::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:message.Parkspace_remaining_number_msg)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .message.Base_info base_info = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
+               input, mutable_base_info()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // required .message.Error_manager error_manager = 2;
+      case 2: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
+               input, mutable_error_manager()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // required int32 small_parkspace_remaining_number = 3;
+      case 3: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
+          set_has_small_parkspace_remaining_number();
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &small_parkspace_remaining_number_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // required int32 medium_parkspace_remaining_number = 4;
+      case 4: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
+          set_has_medium_parkspace_remaining_number();
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &medium_parkspace_remaining_number_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // required int32 large_parkspace_remaining_number = 5;
+      case 5: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {
+          set_has_large_parkspace_remaining_number();
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &large_parkspace_remaining_number_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // required int32 total_parkspace_remaining_number = 6;
+      case 6: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
+          set_has_total_parkspace_remaining_number();
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &total_parkspace_remaining_number_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:message.Parkspace_remaining_number_msg)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:message.Parkspace_remaining_number_msg)
+  return false;
+#undef DO_
+}
+
+void Parkspace_remaining_number_msg::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:message.Parkspace_remaining_number_msg)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  // required .message.Base_info base_info = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, *this->base_info_, output);
+  }
+
+  // required .message.Error_manager error_manager = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, *this->error_manager_, output);
+  }
+
+  // required int32 small_parkspace_remaining_number = 3;
+  if (cached_has_bits & 0x00000004u) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->small_parkspace_remaining_number(), output);
+  }
+
+  // required int32 medium_parkspace_remaining_number = 4;
+  if (cached_has_bits & 0x00000008u) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->medium_parkspace_remaining_number(), output);
+  }
+
+  // required int32 large_parkspace_remaining_number = 5;
+  if (cached_has_bits & 0x00000010u) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->large_parkspace_remaining_number(), output);
+  }
+
+  // required int32 total_parkspace_remaining_number = 6;
+  if (cached_has_bits & 0x00000020u) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->total_parkspace_remaining_number(), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:message.Parkspace_remaining_number_msg)
+}
+
+::google::protobuf::uint8* Parkspace_remaining_number_msg::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:message.Parkspace_remaining_number_msg)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  // required .message.Base_info base_info = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        1, *this->base_info_, deterministic, target);
+  }
+
+  // required .message.Error_manager error_manager = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        2, *this->error_manager_, deterministic, target);
+  }
+
+  // required int32 small_parkspace_remaining_number = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->small_parkspace_remaining_number(), target);
+  }
+
+  // required int32 medium_parkspace_remaining_number = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->medium_parkspace_remaining_number(), target);
+  }
+
+  // required int32 large_parkspace_remaining_number = 5;
+  if (cached_has_bits & 0x00000010u) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->large_parkspace_remaining_number(), target);
+  }
+
+  // required int32 total_parkspace_remaining_number = 6;
+  if (cached_has_bits & 0x00000020u) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->total_parkspace_remaining_number(), target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:message.Parkspace_remaining_number_msg)
+  return target;
+}
+
+size_t Parkspace_remaining_number_msg::RequiredFieldsByteSizeFallback() const {
+// @@protoc_insertion_point(required_fields_byte_size_fallback_start:message.Parkspace_remaining_number_msg)
+  size_t total_size = 0;
+
+  if (has_base_info()) {
+    // required .message.Base_info base_info = 1;
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::MessageSize(
+        *this->base_info_);
+  }
+
+  if (has_error_manager()) {
+    // required .message.Error_manager error_manager = 2;
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::MessageSize(
+        *this->error_manager_);
+  }
+
+  if (has_small_parkspace_remaining_number()) {
+    // required int32 small_parkspace_remaining_number = 3;
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::Int32Size(
+        this->small_parkspace_remaining_number());
+  }
+
+  if (has_medium_parkspace_remaining_number()) {
+    // required int32 medium_parkspace_remaining_number = 4;
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::Int32Size(
+        this->medium_parkspace_remaining_number());
+  }
+
+  if (has_large_parkspace_remaining_number()) {
+    // required int32 large_parkspace_remaining_number = 5;
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::Int32Size(
+        this->large_parkspace_remaining_number());
+  }
+
+  if (has_total_parkspace_remaining_number()) {
+    // required int32 total_parkspace_remaining_number = 6;
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::Int32Size(
+        this->total_parkspace_remaining_number());
+  }
+
+  return total_size;
+}
+size_t Parkspace_remaining_number_msg::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:message.Parkspace_remaining_number_msg)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  if (((_has_bits_[0] & 0x0000003f) ^ 0x0000003f) == 0) {  // All required fields are present.
+    // required .message.Base_info base_info = 1;
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::MessageSize(
+        *this->base_info_);
+
+    // required .message.Error_manager error_manager = 2;
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::MessageSize(
+        *this->error_manager_);
+
+    // required int32 small_parkspace_remaining_number = 3;
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::Int32Size(
+        this->small_parkspace_remaining_number());
+
+    // required int32 medium_parkspace_remaining_number = 4;
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::Int32Size(
+        this->medium_parkspace_remaining_number());
+
+    // required int32 large_parkspace_remaining_number = 5;
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::Int32Size(
+        this->large_parkspace_remaining_number());
+
+    // required int32 total_parkspace_remaining_number = 6;
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::Int32Size(
+        this->total_parkspace_remaining_number());
+
+  } else {
+    total_size += RequiredFieldsByteSizeFallback();
+  }
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = cached_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Parkspace_remaining_number_msg::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:message.Parkspace_remaining_number_msg)
+  GOOGLE_DCHECK_NE(&from, this);
+  const Parkspace_remaining_number_msg* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const Parkspace_remaining_number_msg>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:message.Parkspace_remaining_number_msg)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:message.Parkspace_remaining_number_msg)
+    MergeFrom(*source);
+  }
+}
+
+void Parkspace_remaining_number_msg::MergeFrom(const Parkspace_remaining_number_msg& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:message.Parkspace_remaining_number_msg)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._has_bits_[0];
+  if (cached_has_bits & 63u) {
+    if (cached_has_bits & 0x00000001u) {
+      mutable_base_info()->::message::Base_info::MergeFrom(from.base_info());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      mutable_error_manager()->::message::Error_manager::MergeFrom(from.error_manager());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      small_parkspace_remaining_number_ = from.small_parkspace_remaining_number_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      medium_parkspace_remaining_number_ = from.medium_parkspace_remaining_number_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      large_parkspace_remaining_number_ = from.large_parkspace_remaining_number_;
+    }
+    if (cached_has_bits & 0x00000020u) {
+      total_parkspace_remaining_number_ = from.total_parkspace_remaining_number_;
+    }
+    _has_bits_[0] |= cached_has_bits;
+  }
+}
+
+void Parkspace_remaining_number_msg::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:message.Parkspace_remaining_number_msg)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Parkspace_remaining_number_msg::CopyFrom(const Parkspace_remaining_number_msg& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:message.Parkspace_remaining_number_msg)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Parkspace_remaining_number_msg::IsInitialized() const {
+  if ((_has_bits_[0] & 0x0000003f) != 0x0000003f) return false;
+  if (has_base_info()) {
+    if (!this->base_info_->IsInitialized()) return false;
+  }
+  if (has_error_manager()) {
+    if (!this->error_manager_->IsInitialized()) return false;
+  }
+  return true;
+}
+
+void Parkspace_remaining_number_msg::Swap(Parkspace_remaining_number_msg* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void Parkspace_remaining_number_msg::InternalSwap(Parkspace_remaining_number_msg* other) {
+  using std::swap;
+  swap(base_info_, other->base_info_);
+  swap(error_manager_, other->error_manager_);
+  swap(small_parkspace_remaining_number_, other->small_parkspace_remaining_number_);
+  swap(medium_parkspace_remaining_number_, other->medium_parkspace_remaining_number_);
+  swap(large_parkspace_remaining_number_, other->large_parkspace_remaining_number_);
+  swap(total_parkspace_remaining_number_, other->total_parkspace_remaining_number_);
+  swap(_has_bits_[0], other->_has_bits_[0]);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  swap(_cached_size_, other->_cached_size_);
+}
+
+::google::protobuf::Metadata Parkspace_remaining_number_msg::GetMetadata() const {
+  protobuf_parkspace_5fallocation_5fmessage_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_parkspace_5fallocation_5fmessage_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
 // @@protoc_insertion_point(namespace_scope)
 }  // namespace message
 

message/parkspace_allocation_message.pb.h

@@ -38,7 +38,7 @@ namespace protobuf_parkspace_5fallocation_5fmessage_2eproto {
 struct TableStruct {
   static const ::google::protobuf::internal::ParseTableField entries[];
   static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
-  static const ::google::protobuf::internal::ParseTable schema[13];
+  static const ::google::protobuf::internal::ParseTable schema[14];
   static const ::google::protobuf::internal::FieldMetadata field_metadata[];
   static const ::google::protobuf::internal::SerializationTable serialization_table[];
   static const ::google::protobuf::uint32 offsets[];
@@ -70,6 +70,8 @@ void InitDefaultsParkspace_refresh_request_msgImpl();
 void InitDefaultsParkspace_refresh_request_msg();
 void InitDefaultsParkspace_allocation_data_msgImpl();
 void InitDefaultsParkspace_allocation_data_msg();
+void InitDefaultsParkspace_remaining_number_msgImpl();
+void InitDefaultsParkspace_remaining_number_msg();
 inline void InitDefaults() {
   InitDefaultsParkspace_allocation_request_msg();
   InitDefaultsParkspace_allocation_response_msg();
@@ -84,6 +86,7 @@ inline void InitDefaults() {
   InitDefaultsParkspace_allocation_status_msg();
   InitDefaultsParkspace_refresh_request_msg();
   InitDefaultsParkspace_allocation_data_msg();
+  InitDefaultsParkspace_remaining_number_msg();
 }
 }  // namespace protobuf_parkspace_5fallocation_5fmessage_2eproto
 namespace message {
@@ -120,6 +123,9 @@ extern Parkspace_release_request_msgDefaultTypeInternal _Parkspace_release_reque
 class Parkspace_release_response_msg;
 class Parkspace_release_response_msgDefaultTypeInternal;
 extern Parkspace_release_response_msgDefaultTypeInternal _Parkspace_release_response_msg_default_instance_;
+class Parkspace_remaining_number_msg;
+class Parkspace_remaining_number_msgDefaultTypeInternal;
+extern Parkspace_remaining_number_msgDefaultTypeInternal _Parkspace_remaining_number_msg_default_instance_;
 class Parkspace_search_request_msg;
 class Parkspace_search_request_msgDefaultTypeInternal;
 extern Parkspace_search_request_msgDefaultTypeInternal _Parkspace_search_request_msg_default_instance_;
@@ -2138,6 +2144,173 @@ class Parkspace_allocation_data_msg : public ::google::protobuf::Message /* @@pr
   friend struct ::protobuf_parkspace_5fallocation_5fmessage_2eproto::TableStruct;
   friend void ::protobuf_parkspace_5fallocation_5fmessage_2eproto::InitDefaultsParkspace_allocation_data_msgImpl();
 };
+// -------------------------------------------------------------------
+
+class Parkspace_remaining_number_msg : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Parkspace_remaining_number_msg) */ {
+ public:
+  Parkspace_remaining_number_msg();
+  virtual ~Parkspace_remaining_number_msg();
+
+  Parkspace_remaining_number_msg(const Parkspace_remaining_number_msg& from);
+
+  inline Parkspace_remaining_number_msg& operator=(const Parkspace_remaining_number_msg& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Parkspace_remaining_number_msg(Parkspace_remaining_number_msg&& from) noexcept
+    : Parkspace_remaining_number_msg() {
+    *this = ::std::move(from);
+  }
+
+  inline Parkspace_remaining_number_msg& operator=(Parkspace_remaining_number_msg&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Parkspace_remaining_number_msg& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Parkspace_remaining_number_msg* internal_default_instance() {
+    return reinterpret_cast<const Parkspace_remaining_number_msg*>(
+               &_Parkspace_remaining_number_msg_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    13;
+
+  void Swap(Parkspace_remaining_number_msg* other);
+  friend void swap(Parkspace_remaining_number_msg& a, Parkspace_remaining_number_msg& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Parkspace_remaining_number_msg* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Parkspace_remaining_number_msg* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Parkspace_remaining_number_msg& from);
+  void MergeFrom(const Parkspace_remaining_number_msg& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Parkspace_remaining_number_msg* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required .message.Base_info base_info = 1;
+  bool has_base_info() const;
+  void clear_base_info();
+  static const int kBaseInfoFieldNumber = 1;
+  const ::message::Base_info& base_info() const;
+  ::message::Base_info* release_base_info();
+  ::message::Base_info* mutable_base_info();
+  void set_allocated_base_info(::message::Base_info* base_info);
+
+  // required .message.Error_manager error_manager = 2;
+  bool has_error_manager() const;
+  void clear_error_manager();
+  static const int kErrorManagerFieldNumber = 2;
+  const ::message::Error_manager& error_manager() const;
+  ::message::Error_manager* release_error_manager();
+  ::message::Error_manager* mutable_error_manager();
+  void set_allocated_error_manager(::message::Error_manager* error_manager);
+
+  // required int32 small_parkspace_remaining_number = 3;
+  bool has_small_parkspace_remaining_number() const;
+  void clear_small_parkspace_remaining_number();
+  static const int kSmallParkspaceRemainingNumberFieldNumber = 3;
+  ::google::protobuf::int32 small_parkspace_remaining_number() const;
+  void set_small_parkspace_remaining_number(::google::protobuf::int32 value);
+
+  // required int32 medium_parkspace_remaining_number = 4;
+  bool has_medium_parkspace_remaining_number() const;
+  void clear_medium_parkspace_remaining_number();
+  static const int kMediumParkspaceRemainingNumberFieldNumber = 4;
+  ::google::protobuf::int32 medium_parkspace_remaining_number() const;
+  void set_medium_parkspace_remaining_number(::google::protobuf::int32 value);
+
+  // required int32 large_parkspace_remaining_number = 5;
+  bool has_large_parkspace_remaining_number() const;
+  void clear_large_parkspace_remaining_number();
+  static const int kLargeParkspaceRemainingNumberFieldNumber = 5;
+  ::google::protobuf::int32 large_parkspace_remaining_number() const;
+  void set_large_parkspace_remaining_number(::google::protobuf::int32 value);
+
+  // required int32 total_parkspace_remaining_number = 6;
+  bool has_total_parkspace_remaining_number() const;
+  void clear_total_parkspace_remaining_number();
+  static const int kTotalParkspaceRemainingNumberFieldNumber = 6;
+  ::google::protobuf::int32 total_parkspace_remaining_number() const;
+  void set_total_parkspace_remaining_number(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:message.Parkspace_remaining_number_msg)
+ private:
+  void set_has_base_info();
+  void clear_has_base_info();
+  void set_has_error_manager();
+  void clear_has_error_manager();
+  void set_has_small_parkspace_remaining_number();
+  void clear_has_small_parkspace_remaining_number();
+  void set_has_medium_parkspace_remaining_number();
+  void clear_has_medium_parkspace_remaining_number();
+  void set_has_large_parkspace_remaining_number();
+  void clear_has_large_parkspace_remaining_number();
+  void set_has_total_parkspace_remaining_number();
+  void clear_has_total_parkspace_remaining_number();
+
+  // helper for ByteSizeLong()
+  size_t RequiredFieldsByteSizeFallback() const;
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::message::Base_info* base_info_;
+  ::message::Error_manager* error_manager_;
+  ::google::protobuf::int32 small_parkspace_remaining_number_;
+  ::google::protobuf::int32 medium_parkspace_remaining_number_;
+  ::google::protobuf::int32 large_parkspace_remaining_number_;
+  ::google::protobuf::int32 total_parkspace_remaining_number_;
+  friend struct ::protobuf_parkspace_5fallocation_5fmessage_2eproto::TableStruct;
+  friend void ::protobuf_parkspace_5fallocation_5fmessage_2eproto::InitDefaultsParkspace_remaining_number_msgImpl();
+};
 // ===================================================================
 
 
@@ -4482,6 +4655,206 @@ Parkspace_allocation_data_msg::parkspace_info() const {
   return parkspace_info_;
 }
 
+// -------------------------------------------------------------------
+
+// Parkspace_remaining_number_msg
+
+// required .message.Base_info base_info = 1;
+inline bool Parkspace_remaining_number_msg::has_base_info() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Parkspace_remaining_number_msg::set_has_base_info() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Parkspace_remaining_number_msg::clear_has_base_info() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const ::message::Base_info& Parkspace_remaining_number_msg::base_info() const {
+  const ::message::Base_info* p = base_info_;
+  // @@protoc_insertion_point(field_get:message.Parkspace_remaining_number_msg.base_info)
+  return p != NULL ? *p : *reinterpret_cast<const ::message::Base_info*>(
+      &::message::_Base_info_default_instance_);
+}
+inline ::message::Base_info* Parkspace_remaining_number_msg::release_base_info() {
+  // @@protoc_insertion_point(field_release:message.Parkspace_remaining_number_msg.base_info)
+  clear_has_base_info();
+  ::message::Base_info* temp = base_info_;
+  base_info_ = NULL;
+  return temp;
+}
+inline ::message::Base_info* Parkspace_remaining_number_msg::mutable_base_info() {
+  set_has_base_info();
+  if (base_info_ == NULL) {
+    base_info_ = new ::message::Base_info;
+  }
+  // @@protoc_insertion_point(field_mutable:message.Parkspace_remaining_number_msg.base_info)
+  return base_info_;
+}
+inline void Parkspace_remaining_number_msg::set_allocated_base_info(::message::Base_info* base_info) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(base_info_);
+  }
+  if (base_info) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      base_info = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, base_info, submessage_arena);
+    }
+    set_has_base_info();
+  } else {
+    clear_has_base_info();
+  }
+  base_info_ = base_info;
+  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_remaining_number_msg.base_info)
+}
+
+// required .message.Error_manager error_manager = 2;
+inline bool Parkspace_remaining_number_msg::has_error_manager() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Parkspace_remaining_number_msg::set_has_error_manager() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Parkspace_remaining_number_msg::clear_has_error_manager() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const ::message::Error_manager& Parkspace_remaining_number_msg::error_manager() const {
+  const ::message::Error_manager* p = error_manager_;
+  // @@protoc_insertion_point(field_get:message.Parkspace_remaining_number_msg.error_manager)
+  return p != NULL ? *p : *reinterpret_cast<const ::message::Error_manager*>(
+      &::message::_Error_manager_default_instance_);
+}
+inline ::message::Error_manager* Parkspace_remaining_number_msg::release_error_manager() {
+  // @@protoc_insertion_point(field_release:message.Parkspace_remaining_number_msg.error_manager)
+  clear_has_error_manager();
+  ::message::Error_manager* temp = error_manager_;
+  error_manager_ = NULL;
+  return temp;
+}
+inline ::message::Error_manager* Parkspace_remaining_number_msg::mutable_error_manager() {
+  set_has_error_manager();
+  if (error_manager_ == NULL) {
+    error_manager_ = new ::message::Error_manager;
+  }
+  // @@protoc_insertion_point(field_mutable:message.Parkspace_remaining_number_msg.error_manager)
+  return error_manager_;
+}
+inline void Parkspace_remaining_number_msg::set_allocated_error_manager(::message::Error_manager* error_manager) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(error_manager_);
+  }
+  if (error_manager) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      error_manager = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, error_manager, submessage_arena);
+    }
+    set_has_error_manager();
+  } else {
+    clear_has_error_manager();
+  }
+  error_manager_ = error_manager;
+  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_remaining_number_msg.error_manager)
+}
+
+// required int32 small_parkspace_remaining_number = 3;
+inline bool Parkspace_remaining_number_msg::has_small_parkspace_remaining_number() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void Parkspace_remaining_number_msg::set_has_small_parkspace_remaining_number() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void Parkspace_remaining_number_msg::clear_has_small_parkspace_remaining_number() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void Parkspace_remaining_number_msg::clear_small_parkspace_remaining_number() {
+  small_parkspace_remaining_number_ = 0;
+  clear_has_small_parkspace_remaining_number();
+}
+inline ::google::protobuf::int32 Parkspace_remaining_number_msg::small_parkspace_remaining_number() const {
+  // @@protoc_insertion_point(field_get:message.Parkspace_remaining_number_msg.small_parkspace_remaining_number)
+  return small_parkspace_remaining_number_;
+}
+inline void Parkspace_remaining_number_msg::set_small_parkspace_remaining_number(::google::protobuf::int32 value) {
+  set_has_small_parkspace_remaining_number();
+  small_parkspace_remaining_number_ = value;
+  // @@protoc_insertion_point(field_set:message.Parkspace_remaining_number_msg.small_parkspace_remaining_number)
+}
+
+// required int32 medium_parkspace_remaining_number = 4;
+inline bool Parkspace_remaining_number_msg::has_medium_parkspace_remaining_number() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void Parkspace_remaining_number_msg::set_has_medium_parkspace_remaining_number() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void Parkspace_remaining_number_msg::clear_has_medium_parkspace_remaining_number() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void Parkspace_remaining_number_msg::clear_medium_parkspace_remaining_number() {
+  medium_parkspace_remaining_number_ = 0;
+  clear_has_medium_parkspace_remaining_number();
+}
+inline ::google::protobuf::int32 Parkspace_remaining_number_msg::medium_parkspace_remaining_number() const {
+  // @@protoc_insertion_point(field_get:message.Parkspace_remaining_number_msg.medium_parkspace_remaining_number)
+  return medium_parkspace_remaining_number_;
+}
+inline void Parkspace_remaining_number_msg::set_medium_parkspace_remaining_number(::google::protobuf::int32 value) {
+  set_has_medium_parkspace_remaining_number();
+  medium_parkspace_remaining_number_ = value;
+  // @@protoc_insertion_point(field_set:message.Parkspace_remaining_number_msg.medium_parkspace_remaining_number)
+}
+
+// required int32 large_parkspace_remaining_number = 5;
+inline bool Parkspace_remaining_number_msg::has_large_parkspace_remaining_number() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void Parkspace_remaining_number_msg::set_has_large_parkspace_remaining_number() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void Parkspace_remaining_number_msg::clear_has_large_parkspace_remaining_number() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void Parkspace_remaining_number_msg::clear_large_parkspace_remaining_number() {
+  large_parkspace_remaining_number_ = 0;
+  clear_has_large_parkspace_remaining_number();
+}
+inline ::google::protobuf::int32 Parkspace_remaining_number_msg::large_parkspace_remaining_number() const {
+  // @@protoc_insertion_point(field_get:message.Parkspace_remaining_number_msg.large_parkspace_remaining_number)
+  return large_parkspace_remaining_number_;
+}
+inline void Parkspace_remaining_number_msg::set_large_parkspace_remaining_number(::google::protobuf::int32 value) {
+  set_has_large_parkspace_remaining_number();
+  large_parkspace_remaining_number_ = value;
+  // @@protoc_insertion_point(field_set:message.Parkspace_remaining_number_msg.large_parkspace_remaining_number)
+}
+
+// required int32 total_parkspace_remaining_number = 6;
+inline bool Parkspace_remaining_number_msg::has_total_parkspace_remaining_number() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void Parkspace_remaining_number_msg::set_has_total_parkspace_remaining_number() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void Parkspace_remaining_number_msg::clear_has_total_parkspace_remaining_number() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void Parkspace_remaining_number_msg::clear_total_parkspace_remaining_number() {
+  total_parkspace_remaining_number_ = 0;
+  clear_has_total_parkspace_remaining_number();
+}
+inline ::google::protobuf::int32 Parkspace_remaining_number_msg::total_parkspace_remaining_number() const {
+  // @@protoc_insertion_point(field_get:message.Parkspace_remaining_number_msg.total_parkspace_remaining_number)
+  return total_parkspace_remaining_number_;
+}
+inline void Parkspace_remaining_number_msg::set_total_parkspace_remaining_number(::google::protobuf::int32 value) {
+  set_has_total_parkspace_remaining_number();
+  total_parkspace_remaining_number_ = value;
+  // @@protoc_insertion_point(field_set:message.Parkspace_remaining_number_msg.total_parkspace_remaining_number)
+}
+
 #ifdef __GNUC__
   #pragma GCC diagnostic pop
 #endif  // __GNUC__
@@ -4509,6 +4882,8 @@ Parkspace_allocation_data_msg::parkspace_info() const {
 
 // -------------------------------------------------------------------
 
+// -------------------------------------------------------------------
+
 
 // @@protoc_insertion_point(namespace_scope)
 

message/parkspace_allocation_message.proto

@@ -147,3 +147,13 @@ message Parkspace_allocation_data_msg
     required Error_manager              error_manager=2;
     repeated Parkspace_info             parkspace_info=3;
 }
+//各种车位空闲数量
+message Parkspace_remaining_number_msg
+{
+    required Base_info                  base_info=1;                         //消息类型
+    required Error_manager              error_manager=2;
+    required int32                      small_parkspace_remaining_number=3;    //小型车位剩余数量
+    required int32                      medium_parkspace_remaining_number=4;   //中型车位剩余数量
+    required int32                      large_parkspace_remaining_number=5;    //大型车位剩余数量
+    required int32                      total_parkspace_remaining_number=6;    //所有车位剩余数量
+}

parkspace_allocation/parkspace_manager.cpp

@@ -687,7 +687,11 @@ Error_manager Parkspace_manager::query_the_optimal_parkspace_serverB1(message::P
 		//判断小车车位中间部分(第一优先级)是否有找到合适的空车位   如果找到了  则不需要继续比较  直接返回
 		if ( time_min!=0 && parkingspace_index_id!=-1 )
 		{
+
 			parkspace_info.CopyFrom(all_min_parkspace_data.parkspace_info(parkingspace_index_id));
+			parkspace_info.set_path_estimate_time(time_min);
+			parkspace_info.set_parkspace_path(message::LEFT_PATH);
+
 			return Error_code::SUCCESS;
 		}
 		else
@@ -725,6 +729,8 @@ Error_manager Parkspace_manager::query_the_optimal_parkspace_serverB1(message::P
 			if ( time_min!=0 && parkingspace_index_id!=-1 )
 			{
 				parkspace_info.CopyFrom(all_min_parkspace_data.parkspace_info(parkingspace_index_id));
+				parkspace_info.set_path_estimate_time(time_min);
+				parkspace_info.set_parkspace_path(message::LEFT_PATH);
 				return Error_code::SUCCESS;
 			}
 		}
@@ -773,6 +779,8 @@ Error_manager Parkspace_manager::query_the_optimal_parkspace_serverB1(message::P
 		if ( time_min!=0 && parkingspace_index_id!=-1 )
 		{
 			parkspace_info.CopyFrom(all_mid_parkspace_data.parkspace_info(parkingspace_index_id));
+			parkspace_info.set_path_estimate_time(time_min);
+			parkspace_info.set_parkspace_path(message::LEFT_PATH);
 			return Error_code::SUCCESS;
 		}
 		else
@@ -812,6 +820,8 @@ Error_manager Parkspace_manager::query_the_optimal_parkspace_serverB1(message::P
 			if ( time_min!=0 && parkingspace_index_id!=-1 )
 			{
 				parkspace_info.CopyFrom(all_mid_parkspace_data.parkspace_info(parkingspace_index_id));
+				parkspace_info.set_path_estimate_time(time_min);
+				parkspace_info.set_parkspace_path(message::LEFT_PATH);
 				return Error_code::SUCCESS;
 			}
 		}
@@ -882,6 +892,8 @@ Error_manager Parkspace_manager::query_the_optimal_parkspace_serverB1(message::P
 		if ( time_min!=0 && parkingspace_index_id!=-1 )
 		{
 			parkspace_info.CopyFrom(all_big_parkspace_data.parkspace_info(parkingspace_index_id));
+			parkspace_info.set_path_estimate_time(time_min);
+			parkspace_info.set_parkspace_path(message::LEFT_PATH);
 			return Error_code::SUCCESS;
 		}
 		else
@@ -989,6 +1001,8 @@ Error_manager Parkspace_manager::query_the_optimal_parkspace_serverB2(message::P
 			if ( time_min!=0 && parkingspace_index_id!=-1 )
 			{
 				parkspace_info.CopyFrom(all_min_parkspace_data.parkspace_info(parkingspace_index_id));
+				parkspace_info.set_path_estimate_time(time_min);
+				parkspace_info.set_parkspace_path(message::RIGHT_PATH);
 				return Error_code::SUCCESS;
 			}
 		}
@@ -1037,6 +1051,8 @@ Error_manager Parkspace_manager::query_the_optimal_parkspace_serverB2(message::P
 		if ( time_min!=0 && parkingspace_index_id!=-1 )
 		{
 			parkspace_info.CopyFrom(all_mid_parkspace_data.parkspace_info(parkingspace_index_id));
+			parkspace_info.set_path_estimate_time(time_min);
+			parkspace_info.set_parkspace_path(message::RIGHT_PATH);
 			return Error_code::SUCCESS;
 		}
 		else
@@ -1076,6 +1092,8 @@ Error_manager Parkspace_manager::query_the_optimal_parkspace_serverB2(message::P
 			if ( time_min!=0 && parkingspace_index_id!=-1 )
 			{
 				parkspace_info.CopyFrom(all_mid_parkspace_data.parkspace_info(parkingspace_index_id));
+				parkspace_info.set_path_estimate_time(time_min);
+				parkspace_info.set_parkspace_path(message::RIGHT_PATH);
 				return Error_code::SUCCESS;
 			}
 		}
@@ -1146,6 +1164,8 @@ Error_manager Parkspace_manager::query_the_optimal_parkspace_serverB2(message::P
 		if ( time_min!=0 && parkingspace_index_id!=-1 )
 		{
 			parkspace_info.CopyFrom(all_big_parkspace_data.parkspace_info(parkingspace_index_id));
+			parkspace_info.set_path_estimate_time(time_min);
+			parkspace_info.set_parkspace_path(message::RIGHT_PATH);
 			return Error_code::SUCCESS;
 		}
 		else
@@ -1210,6 +1230,8 @@ Error_manager Parkspace_manager::query_the_optimal_parkspace_serverB3(message::P
 		if ( time_min!=0 && parkingspace_index_id!=-1 )
 		{
 			parkspace_info.CopyFrom(all_mid_parkspace_data.parkspace_info(parkingspace_index_id));
+			parkspace_info.set_path_estimate_time(time_min);
+			parkspace_info.set_parkspace_path(message::TEMPORARY_CACHE_PATH);
 			return Error_code::SUCCESS;
 		}
 	}
@@ -1251,6 +1273,8 @@ Error_manager Parkspace_manager::query_the_optimal_parkspace_serverB3(message::P
 		if ( time_min!=0 && parkingspace_index_id!=-1 )
 		{
 			parkspace_info.CopyFrom(all_big_parkspace_data.parkspace_info(parkingspace_index_id));
+			parkspace_info.set_path_estimate_time(time_min);
+			parkspace_info.set_parkspace_path(message::TEMPORARY_CACHE_PATH);
 			return Error_code::SUCCESS;
 		}
 		else
@@ -1292,20 +1316,52 @@ void Parkspace_manager::execute_for_allocate(message::Car_info car_info, int ter
 	{
 		m_parkspace_lock.lock();
 //		如果车辆不存在 则找到一个最优车位(方案A)----车库分为两个独立部分，左库和右库如果1~3号终端来车 则在左库分配车位，4~号终端来车 则在右库分配车位
-		error=query_the_optimal_parkspace_serverA(t_allocated_space,car_info,terminal_id);
+//		error=query_the_optimal_parkspace_serverA(t_allocated_space,car_info,terminal_id);
 
 //		如果车辆不存在 则找到一个最优车位(方案B)----分配三个车位  左边分配一个 右边分配一个  缓冲区分配一个   最后使用那个由调度决定
-//		message::Parkspace_info t_allocated_space_left;
-//		message::Parkspace_info t_allocated_space_rigth;
-//		message::Parkspace_info t_allocated_space_temporary;
+		message::Parkspace_info t_allocated_space_left;
+		message::Parkspace_info t_allocated_space_rigth;
+		message::Parkspace_info t_allocated_space_temporary;
 //
-//		error=query_the_optimal_parkspace_serverB1(t_allocated_space_left,car_info,terminal_id);
-//		LOG(INFO) << " 左侧车位ID： "<<t_allocated_space_left.parkingspace_index_id();
-//		error=query_the_optimal_parkspace_serverB2(t_allocated_space_rigth,car_info,terminal_id);
-//		LOG(INFO) << " 右侧车位ID： "<<t_allocated_space_rigth.parkingspace_index_id();
-//		error=query_the_optimal_parkspace_serverB3(t_allocated_space_temporary,car_info,terminal_id);
-//		LOG(INFO) << " 缓冲区车位ID： "<<t_allocated_space_temporary.parkingspace_index_id();
+		error=query_the_optimal_parkspace_serverB1(t_allocated_space_left,car_info,terminal_id);
+		if ( error != Error_code::SUCCESS )
+		{
+			t_error.set_error_code(error.get_error_code());
+			t_error.set_error_level((message::Error_level)error.get_error_level());
+			t_error.set_error_description(error.get_error_description());
+			LOG(ERROR) << car_info.license()<<" 获取左侧车位失败  "<<error.to_string();
+		}
+		LOG(INFO) << " 左侧车位ID： "<<t_allocated_space_left.parkingspace_index_id();
+		error=query_the_optimal_parkspace_serverB2(t_allocated_space_rigth,car_info,terminal_id);
+		if ( error != Error_code::SUCCESS )
+		{
+			t_error.set_error_code(error.get_error_code());
+			t_error.set_error_level((message::Error_level)error.get_error_level());
+			t_error.set_error_description(error.get_error_description());
+			LOG(ERROR) << car_info.license()<<" 获取右侧车位失败  "<<error.to_string();
+		}
+		LOG(INFO) << " 右侧车位ID： "<<t_allocated_space_rigth.parkingspace_index_id();
+		error=query_the_optimal_parkspace_serverB3(t_allocated_space_temporary,car_info,terminal_id);
+		if ( error != Error_code::SUCCESS )
+		{
+			t_error.set_error_code(error.get_error_code());
+			t_error.set_error_level((message::Error_level)error.get_error_level());
+			t_error.set_error_description(error.get_error_description());
+			LOG(ERROR) << car_info.license()<<" 获取缓冲区车位失败  "<<error.to_string();
+		}
+		LOG(INFO) << " 缓冲区车位ID： "<<t_allocated_space_temporary.parkingspace_index_id();
+		if ( error != Error_code::SUCCESS )
+		{
+			t_error.set_error_code(error.get_error_code());
+			t_error.set_error_level((message::Error_level)error.get_error_level());
+			t_error.set_error_description(error.get_error_description());
+			LOG(ERROR) << car_info.license()<<" 获取空车位失败  "<<error.to_string();
+		}
+		else
+		{
+
 
+		}
 		//如果车辆不存在则获取一个空车位
 //		error=m_parkspace_operating_function.query_one_empty_parkspace(t_allocated_space);
 
@@ -1369,7 +1425,7 @@ void Parkspace_manager::execute_for_allocate(message::Car_info car_info, int ter
 //查询车位线程函数
 void Parkspace_manager::execute_for_search(message::Car_info car_info,std::string command_key)
 {
-	LOG(INFO) << "查询车位     "<<"牌号:"<<car_info.license()<<"     command_key="<<command_key;  //huli printf command_key
+	LOG(INFO) << "查询车位     "<<"牌号:"<<car_info.license()<<"     command_key="<<command_key;
 	//根据车辆凭证信息查询车辆位置
 	message::Parkspace_search_response_msg response_msg;
 	message::Base_info t_response_header;

setting/communication.prototxt

@@ -10,6 +10,5 @@ communication_parameters
 
     bind_string:"tcp://192.168.2.113:30008"
     connect_string_vector:"tcp://192.168.2.127:30000"
-    connect_string_vector:"tcp://127.0.0.1:7000"
 }