移动基类线程销毁到子类，解决因调用纯虚函数导致的崩溃问题。

message/terminal_message.pb.cc

@@ -127,9 +127,11 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_terminal_5fmessage_2eproto::of
   PROTOBUF_FIELD_OFFSET(::message::Store_command_response_msg, base_info_),
   PROTOBUF_FIELD_OFFSET(::message::Store_command_response_msg, terminal_id_),
   PROTOBUF_FIELD_OFFSET(::message::Store_command_response_msg, code_),
-  0,
-  2,
+  PROTOBUF_FIELD_OFFSET(::message::Store_command_response_msg, license_),
   1,
+  3,
+  2,
+  0,
   PROTOBUF_FIELD_OFFSET(::message::Pickup_command_request_msg, _has_bits_),
   PROTOBUF_FIELD_OFFSET(::message::Pickup_command_request_msg, _internal_metadata_),
   ~0u,  // no _extensions_
@@ -149,15 +151,17 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_terminal_5fmessage_2eproto::of
   PROTOBUF_FIELD_OFFSET(::message::Pickup_command_response_msg, base_info_),
   PROTOBUF_FIELD_OFFSET(::message::Pickup_command_response_msg, terminal_id_),
   PROTOBUF_FIELD_OFFSET(::message::Pickup_command_response_msg, code_),
-  0,
-  2,
+  PROTOBUF_FIELD_OFFSET(::message::Pickup_command_response_msg, license_),
   1,
+  3,
+  2,
+  0,
 };
 static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
   { 0, 9, sizeof(::message::Store_command_request_msg)},
-  { 13, 21, sizeof(::message::Store_command_response_msg)},
-  { 24, 32, sizeof(::message::Pickup_command_request_msg)},
-  { 35, 43, sizeof(::message::Pickup_command_response_msg)},
+  { 13, 22, sizeof(::message::Store_command_response_msg)},
+  { 26, 34, sizeof(::message::Pickup_command_request_msg)},
+  { 37, 46, sizeof(::message::Pickup_command_response_msg)},
 };
 
 static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
@@ -173,17 +177,18 @@ const char descriptor_table_protodef_terminal_5fmessage_2eproto[] PROTOBUF_SECTI
   "msg\022%\n\tbase_info\030\001 \002(\0132\022.message.Base_in"
   "fo\022\023\n\013terminal_id\030\002 \002(\005\0227\n\022locate_inform"
   "ation\030\003 \002(\0132\033.message.Locate_information"
-  "\022#\n\010car_info\030\004 \002(\0132\021.message.Car_info\"~\n"
-  "\032Store_command_response_msg\022%\n\tbase_info"
-  "\030\001 \002(\0132\022.message.Base_info\022\023\n\013terminal_i"
-  "d\030\002 \002(\005\022$\n\004code\030\003 \002(\0132\026.message.Error_ma"
-  "nager\"}\n\032Pickup_command_request_msg\022%\n\tb"
-  "ase_info\030\001 \002(\0132\022.message.Base_info\022\023\n\013te"
-  "rminal_id\030\002 \002(\005\022#\n\010car_info\030\004 \002(\0132\021.mess"
-  "age.Car_info\"\177\n\033Pickup_command_response_"
-  "msg\022%\n\tbase_info\030\001 \002(\0132\022.message.Base_in"
-  "fo\022\023\n\013terminal_id\030\002 \002(\005\022$\n\004code\030\003 \002(\0132\026."
-  "message.Error_manager"
+  "\022#\n\010car_info\030\004 \002(\0132\021.message.Car_info\"\217\001"
+  "\n\032Store_command_response_msg\022%\n\tbase_inf"
+  "o\030\001 \002(\0132\022.message.Base_info\022\023\n\013terminal_"
+  "id\030\002 \002(\005\022$\n\004code\030\003 \002(\0132\026.message.Error_m"
+  "anager\022\017\n\007license\030\004 \001(\t\"}\n\032Pickup_comman"
+  "d_request_msg\022%\n\tbase_info\030\001 \002(\0132\022.messa"
+  "ge.Base_info\022\023\n\013terminal_id\030\002 \002(\005\022#\n\010car"
+  "_info\030\004 \002(\0132\021.message.Car_info\"\220\001\n\033Picku"
+  "p_command_response_msg\022%\n\tbase_info\030\001 \002("
+  "\0132\022.message.Base_info\022\023\n\013terminal_id\030\002 \002"
+  "(\005\022$\n\004code\030\003 \002(\0132\026.message.Error_manager"
+  "\022\017\n\007license\030\004 \001(\t"
   ;
 static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_terminal_5fmessage_2eproto_deps[1] = {
   &::descriptor_table_message_5fbase_2eproto,
@@ -196,7 +201,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_ter
 };
 static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_terminal_5fmessage_2eproto_once;
 const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_terminal_5fmessage_2eproto = {
-  false, false, descriptor_table_protodef_terminal_5fmessage_2eproto, "terminal_message.proto", 621,
+  false, false, descriptor_table_protodef_terminal_5fmessage_2eproto, "terminal_message.proto", 657,
   &descriptor_table_terminal_5fmessage_2eproto_once, descriptor_table_terminal_5fmessage_2eproto_sccs, descriptor_table_terminal_5fmessage_2eproto_deps, 4, 1,
   schemas, file_default_instances, TableStruct_terminal_5fmessage_2eproto::offsets,
   file_level_metadata_terminal_5fmessage_2eproto, 4, file_level_enum_descriptors_terminal_5fmessage_2eproto, file_level_service_descriptors_terminal_5fmessage_2eproto,
@@ -626,17 +631,20 @@ class Store_command_response_msg::_Internal {
   using HasBits = decltype(std::declval<Store_command_response_msg>()._has_bits_);
   static const ::message::Base_info& base_info(const Store_command_response_msg* msg);
   static void set_has_base_info(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
+    (*has_bits)[0] |= 2u;
   }
   static void set_has_terminal_id(HasBits* has_bits) {
-    (*has_bits)[0] |= 4u;
+    (*has_bits)[0] |= 8u;
   }
   static const ::message::Error_manager& code(const Store_command_response_msg* msg);
   static void set_has_code(HasBits* has_bits) {
-    (*has_bits)[0] |= 2u;
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_license(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
   }
   static bool MissingRequiredFields(const HasBits& has_bits) {
-    return ((has_bits[0] & 0x00000007) ^ 0x00000007) != 0;
+    return ((has_bits[0] & 0x0000000e) ^ 0x0000000e) != 0;
   }
 };
 
@@ -650,11 +658,11 @@ Store_command_response_msg::_Internal::code(const Store_command_response_msg* ms
 }
 void Store_command_response_msg::clear_base_info() {
   if (base_info_ != nullptr) base_info_->Clear();
-  _has_bits_[0] &= ~0x00000001u;
+  _has_bits_[0] &= ~0x00000002u;
 }
 void Store_command_response_msg::clear_code() {
   if (code_ != nullptr) code_->Clear();
-  _has_bits_[0] &= ~0x00000002u;
+  _has_bits_[0] &= ~0x00000004u;
 }
 Store_command_response_msg::Store_command_response_msg(::PROTOBUF_NAMESPACE_ID::Arena* arena)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
@@ -666,6 +674,11 @@ Store_command_response_msg::Store_command_response_msg(const Store_command_respo
   : ::PROTOBUF_NAMESPACE_ID::Message(),
       _has_bits_(from._has_bits_) {
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  license_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (from._internal_has_license()) {
+    license_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_license(),
+      GetArena());
+  }
   if (from._internal_has_base_info()) {
     base_info_ = new ::message::Base_info(*from.base_info_);
   } else {
@@ -682,6 +695,7 @@ Store_command_response_msg::Store_command_response_msg(const Store_command_respo
 
 void Store_command_response_msg::SharedCtor() {
   ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Store_command_response_msg_terminal_5fmessage_2eproto.base);
+  license_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
   ::memset(&base_info_, 0, static_cast<size_t>(
       reinterpret_cast<char*>(&terminal_id_) -
       reinterpret_cast<char*>(&base_info_)) + sizeof(terminal_id_));
@@ -695,6 +709,7 @@ Store_command_response_msg::~Store_command_response_msg() {
 
 void Store_command_response_msg::SharedDtor() {
   GOOGLE_DCHECK(GetArena() == nullptr);
+  license_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
   if (this != internal_default_instance()) delete base_info_;
   if (this != internal_default_instance()) delete code_;
 }
@@ -721,12 +736,15 @@ void Store_command_response_msg::Clear() {
   (void) cached_has_bits;
 
   cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
+  if (cached_has_bits & 0x00000007u) {
     if (cached_has_bits & 0x00000001u) {
+      license_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
       GOOGLE_DCHECK(base_info_ != nullptr);
       base_info_->Clear();
     }
-    if (cached_has_bits & 0x00000002u) {
+    if (cached_has_bits & 0x00000004u) {
       GOOGLE_DCHECK(code_ != nullptr);
       code_->Clear();
     }
@@ -767,6 +785,17 @@ const char* Store_command_response_msg::_InternalParse(const char* ptr, ::PROTOB
           CHK_(ptr);
         } else goto handle_unusual;
         continue;
+      // optional string license = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
+          auto str = _internal_mutable_license();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          #ifndef NDEBUG
+          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "message.Store_command_response_msg.license");
+          #endif  // !NDEBUG
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
       default: {
       handle_unusual:
         if ((tag & 7) == 4 || tag == 0) {
@@ -798,7 +827,7 @@ failure:
 
   cached_has_bits = _has_bits_[0];
   // required .message.Base_info base_info = 1;
-  if (cached_has_bits & 0x00000001u) {
+  if (cached_has_bits & 0x00000002u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
       InternalWriteMessage(
@@ -806,19 +835,29 @@ failure:
   }
 
   // required int32 terminal_id = 2;
-  if (cached_has_bits & 0x00000004u) {
+  if (cached_has_bits & 0x00000008u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_terminal_id(), target);
   }
 
   // required .message.Error_manager code = 3;
-  if (cached_has_bits & 0x00000002u) {
+  if (cached_has_bits & 0x00000004u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
       InternalWriteMessage(
         3, _Internal::code(this), target, stream);
   }
 
+  // optional string license = 4;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_license().data(), static_cast<int>(this->_internal_license().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "message.Store_command_response_msg.license");
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_license(), target);
+  }
+
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
@@ -858,7 +897,7 @@ size_t Store_command_response_msg::ByteSizeLong() const {
 // @@protoc_insertion_point(message_byte_size_start:message.Store_command_response_msg)
   size_t total_size = 0;
 
-  if (((_has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) {  // All required fields are present.
+  if (((_has_bits_[0] & 0x0000000e) ^ 0x0000000e) == 0) {  // All required fields are present.
     // required .message.Base_info base_info = 1;
     total_size += 1 +
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
@@ -881,6 +920,14 @@ size_t Store_command_response_msg::ByteSizeLong() const {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
+  // optional string license = 4;
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_license());
+  }
+
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
     return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
         _internal_metadata_, total_size, &_cached_size_);
@@ -913,14 +960,17 @@ void Store_command_response_msg::MergeFrom(const Store_command_response_msg& fro
   (void) cached_has_bits;
 
   cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 0x00000007u) {
+  if (cached_has_bits & 0x0000000fu) {
     if (cached_has_bits & 0x00000001u) {
-      _internal_mutable_base_info()->::message::Base_info::MergeFrom(from._internal_base_info());
+      _internal_set_license(from._internal_license());
     }
     if (cached_has_bits & 0x00000002u) {
-      _internal_mutable_code()->::message::Error_manager::MergeFrom(from._internal_code());
+      _internal_mutable_base_info()->::message::Base_info::MergeFrom(from._internal_base_info());
     }
     if (cached_has_bits & 0x00000004u) {
+      _internal_mutable_code()->::message::Error_manager::MergeFrom(from._internal_code());
+    }
+    if (cached_has_bits & 0x00000008u) {
       terminal_id_ = from.terminal_id_;
     }
     _has_bits_[0] |= cached_has_bits;
@@ -956,6 +1006,7 @@ void Store_command_response_msg::InternalSwap(Store_command_response_msg* other)
   using std::swap;
   _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
   swap(_has_bits_[0], other->_has_bits_[0]);
+  license_.Swap(&other->license_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
       PROTOBUF_FIELD_OFFSET(Store_command_response_msg, terminal_id_)
       + sizeof(Store_command_response_msg::terminal_id_)
@@ -1335,17 +1386,20 @@ class Pickup_command_response_msg::_Internal {
   using HasBits = decltype(std::declval<Pickup_command_response_msg>()._has_bits_);
   static const ::message::Base_info& base_info(const Pickup_command_response_msg* msg);
   static void set_has_base_info(HasBits* has_bits) {
-    (*has_bits)[0] |= 1u;
+    (*has_bits)[0] |= 2u;
   }
   static void set_has_terminal_id(HasBits* has_bits) {
-    (*has_bits)[0] |= 4u;
+    (*has_bits)[0] |= 8u;
   }
   static const ::message::Error_manager& code(const Pickup_command_response_msg* msg);
   static void set_has_code(HasBits* has_bits) {
-    (*has_bits)[0] |= 2u;
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_license(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
   }
   static bool MissingRequiredFields(const HasBits& has_bits) {
-    return ((has_bits[0] & 0x00000007) ^ 0x00000007) != 0;
+    return ((has_bits[0] & 0x0000000e) ^ 0x0000000e) != 0;
   }
 };
 
@@ -1359,11 +1413,11 @@ Pickup_command_response_msg::_Internal::code(const Pickup_command_response_msg*
 }
 void Pickup_command_response_msg::clear_base_info() {
   if (base_info_ != nullptr) base_info_->Clear();
-  _has_bits_[0] &= ~0x00000001u;
+  _has_bits_[0] &= ~0x00000002u;
 }
 void Pickup_command_response_msg::clear_code() {
   if (code_ != nullptr) code_->Clear();
-  _has_bits_[0] &= ~0x00000002u;
+  _has_bits_[0] &= ~0x00000004u;
 }
 Pickup_command_response_msg::Pickup_command_response_msg(::PROTOBUF_NAMESPACE_ID::Arena* arena)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
@@ -1375,6 +1429,11 @@ Pickup_command_response_msg::Pickup_command_response_msg(const Pickup_command_re
   : ::PROTOBUF_NAMESPACE_ID::Message(),
       _has_bits_(from._has_bits_) {
   _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  license_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (from._internal_has_license()) {
+    license_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_license(),
+      GetArena());
+  }
   if (from._internal_has_base_info()) {
     base_info_ = new ::message::Base_info(*from.base_info_);
   } else {
@@ -1391,6 +1450,7 @@ Pickup_command_response_msg::Pickup_command_response_msg(const Pickup_command_re
 
 void Pickup_command_response_msg::SharedCtor() {
   ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Pickup_command_response_msg_terminal_5fmessage_2eproto.base);
+  license_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
   ::memset(&base_info_, 0, static_cast<size_t>(
       reinterpret_cast<char*>(&terminal_id_) -
       reinterpret_cast<char*>(&base_info_)) + sizeof(terminal_id_));
@@ -1404,6 +1464,7 @@ Pickup_command_response_msg::~Pickup_command_response_msg() {
 
 void Pickup_command_response_msg::SharedDtor() {
   GOOGLE_DCHECK(GetArena() == nullptr);
+  license_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
   if (this != internal_default_instance()) delete base_info_;
   if (this != internal_default_instance()) delete code_;
 }
@@ -1430,12 +1491,15 @@ void Pickup_command_response_msg::Clear() {
   (void) cached_has_bits;
 
   cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 0x00000003u) {
+  if (cached_has_bits & 0x00000007u) {
     if (cached_has_bits & 0x00000001u) {
+      license_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
       GOOGLE_DCHECK(base_info_ != nullptr);
       base_info_->Clear();
     }
-    if (cached_has_bits & 0x00000002u) {
+    if (cached_has_bits & 0x00000004u) {
       GOOGLE_DCHECK(code_ != nullptr);
       code_->Clear();
     }
@@ -1476,6 +1540,17 @@ const char* Pickup_command_response_msg::_InternalParse(const char* ptr, ::PROTO
           CHK_(ptr);
         } else goto handle_unusual;
         continue;
+      // optional string license = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
+          auto str = _internal_mutable_license();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          #ifndef NDEBUG
+          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "message.Pickup_command_response_msg.license");
+          #endif  // !NDEBUG
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
       default: {
       handle_unusual:
         if ((tag & 7) == 4 || tag == 0) {
@@ -1507,7 +1582,7 @@ failure:
 
   cached_has_bits = _has_bits_[0];
   // required .message.Base_info base_info = 1;
-  if (cached_has_bits & 0x00000001u) {
+  if (cached_has_bits & 0x00000002u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
       InternalWriteMessage(
@@ -1515,19 +1590,29 @@ failure:
   }
 
   // required int32 terminal_id = 2;
-  if (cached_has_bits & 0x00000004u) {
+  if (cached_has_bits & 0x00000008u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_terminal_id(), target);
   }
 
   // required .message.Error_manager code = 3;
-  if (cached_has_bits & 0x00000002u) {
+  if (cached_has_bits & 0x00000004u) {
     target = stream->EnsureSpace(target);
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
       InternalWriteMessage(
         3, _Internal::code(this), target, stream);
   }
 
+  // optional string license = 4;
+  if (cached_has_bits & 0x00000001u) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_license().data(), static_cast<int>(this->_internal_license().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
+      "message.Pickup_command_response_msg.license");
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_license(), target);
+  }
+
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
@@ -1567,7 +1652,7 @@ size_t Pickup_command_response_msg::ByteSizeLong() const {
 // @@protoc_insertion_point(message_byte_size_start:message.Pickup_command_response_msg)
   size_t total_size = 0;
 
-  if (((_has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) {  // All required fields are present.
+  if (((_has_bits_[0] & 0x0000000e) ^ 0x0000000e) == 0) {  // All required fields are present.
     // required .message.Base_info base_info = 1;
     total_size += 1 +
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
@@ -1590,6 +1675,14 @@ size_t Pickup_command_response_msg::ByteSizeLong() const {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
+  // optional string license = 4;
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_license());
+  }
+
   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
     return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
         _internal_metadata_, total_size, &_cached_size_);
@@ -1622,14 +1715,17 @@ void Pickup_command_response_msg::MergeFrom(const Pickup_command_response_msg& f
   (void) cached_has_bits;
 
   cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 0x00000007u) {
+  if (cached_has_bits & 0x0000000fu) {
     if (cached_has_bits & 0x00000001u) {
-      _internal_mutable_base_info()->::message::Base_info::MergeFrom(from._internal_base_info());
+      _internal_set_license(from._internal_license());
     }
     if (cached_has_bits & 0x00000002u) {
-      _internal_mutable_code()->::message::Error_manager::MergeFrom(from._internal_code());
+      _internal_mutable_base_info()->::message::Base_info::MergeFrom(from._internal_base_info());
     }
     if (cached_has_bits & 0x00000004u) {
+      _internal_mutable_code()->::message::Error_manager::MergeFrom(from._internal_code());
+    }
+    if (cached_has_bits & 0x00000008u) {
       terminal_id_ = from.terminal_id_;
     }
     _has_bits_[0] |= cached_has_bits;
@@ -1665,6 +1761,7 @@ void Pickup_command_response_msg::InternalSwap(Pickup_command_response_msg* othe
   using std::swap;
   _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
   swap(_has_bits_[0], other->_has_bits_[0]);
+  license_.Swap(&other->license_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
       PROTOBUF_FIELD_OFFSET(Pickup_command_response_msg, terminal_id_)
       + sizeof(Pickup_command_response_msg::terminal_id_)

message/terminal_message.pb.h

@@ -411,10 +411,31 @@ class Store_command_response_msg PROTOBUF_FINAL :
   // accessors -------------------------------------------------------
 
   enum : int {
+    kLicenseFieldNumber = 4,
     kBaseInfoFieldNumber = 1,
     kCodeFieldNumber = 3,
     kTerminalIdFieldNumber = 2,
   };
+  // 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:
+
   // required .message.Base_info base_info = 1;
   bool has_base_info() const;
   private:
@@ -476,6 +497,7 @@ class Store_command_response_msg PROTOBUF_FINAL :
   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_;
   ::message::Base_info* base_info_;
   ::message::Error_manager* code_;
   ::PROTOBUF_NAMESPACE_ID::int32 terminal_id_;
@@ -795,10 +817,31 @@ class Pickup_command_response_msg PROTOBUF_FINAL :
   // accessors -------------------------------------------------------
 
   enum : int {
+    kLicenseFieldNumber = 4,
     kBaseInfoFieldNumber = 1,
     kCodeFieldNumber = 3,
     kTerminalIdFieldNumber = 2,
   };
+  // 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:
+
   // required .message.Base_info base_info = 1;
   bool has_base_info() const;
   private:
@@ -860,6 +903,7 @@ class Pickup_command_response_msg PROTOBUF_FINAL :
   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_;
   ::message::Base_info* base_info_;
   ::message::Error_manager* code_;
   ::PROTOBUF_NAMESPACE_ID::int32 terminal_id_;
@@ -1147,7 +1191,7 @@ inline void Store_command_request_msg::set_allocated_car_info(::message::Car_inf
 
 // required .message.Base_info base_info = 1;
 inline bool Store_command_response_msg::_internal_has_base_info() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
   PROTOBUF_ASSUME(!value || base_info_ != nullptr);
   return value;
 }
@@ -1170,14 +1214,14 @@ inline void Store_command_response_msg::unsafe_arena_set_allocated_base_info(
   }
   base_info_ = base_info;
   if (base_info) {
-    _has_bits_[0] |= 0x00000001u;
+    _has_bits_[0] |= 0x00000002u;
   } else {
-    _has_bits_[0] &= ~0x00000001u;
+    _has_bits_[0] &= ~0x00000002u;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Store_command_response_msg.base_info)
 }
 inline ::message::Base_info* Store_command_response_msg::release_base_info() {
-  _has_bits_[0] &= ~0x00000001u;
+  _has_bits_[0] &= ~0x00000002u;
   ::message::Base_info* temp = base_info_;
   base_info_ = nullptr;
   if (GetArena() != nullptr) {
@@ -1187,13 +1231,13 @@ inline ::message::Base_info* Store_command_response_msg::release_base_info() {
 }
 inline ::message::Base_info* Store_command_response_msg::unsafe_arena_release_base_info() {
   // @@protoc_insertion_point(field_release:message.Store_command_response_msg.base_info)
-  _has_bits_[0] &= ~0x00000001u;
+  _has_bits_[0] &= ~0x00000002u;
   ::message::Base_info* temp = base_info_;
   base_info_ = nullptr;
   return temp;
 }
 inline ::message::Base_info* Store_command_response_msg::_internal_mutable_base_info() {
-  _has_bits_[0] |= 0x00000001u;
+  _has_bits_[0] |= 0x00000002u;
   if (base_info_ == nullptr) {
     auto* p = CreateMaybeMessage<::message::Base_info>(GetArena());
     base_info_ = p;
@@ -1216,9 +1260,9 @@ inline void Store_command_response_msg::set_allocated_base_info(::message::Base_
       base_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
           message_arena, base_info, submessage_arena);
     }
-    _has_bits_[0] |= 0x00000001u;
+    _has_bits_[0] |= 0x00000002u;
   } else {
-    _has_bits_[0] &= ~0x00000001u;
+    _has_bits_[0] &= ~0x00000002u;
   }
   base_info_ = base_info;
   // @@protoc_insertion_point(field_set_allocated:message.Store_command_response_msg.base_info)
@@ -1226,7 +1270,7 @@ inline void Store_command_response_msg::set_allocated_base_info(::message::Base_
 
 // required int32 terminal_id = 2;
 inline bool Store_command_response_msg::_internal_has_terminal_id() const {
-  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
   return value;
 }
 inline bool Store_command_response_msg::has_terminal_id() const {
@@ -1234,7 +1278,7 @@ inline bool Store_command_response_msg::has_terminal_id() const {
 }
 inline void Store_command_response_msg::clear_terminal_id() {
   terminal_id_ = 0;
-  _has_bits_[0] &= ~0x00000004u;
+  _has_bits_[0] &= ~0x00000008u;
 }
 inline ::PROTOBUF_NAMESPACE_ID::int32 Store_command_response_msg::_internal_terminal_id() const {
   return terminal_id_;
@@ -1244,7 +1288,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int32 Store_command_response_msg::terminal_id()
   return _internal_terminal_id();
 }
 inline void Store_command_response_msg::_internal_set_terminal_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _has_bits_[0] |= 0x00000004u;
+  _has_bits_[0] |= 0x00000008u;
   terminal_id_ = value;
 }
 inline void Store_command_response_msg::set_terminal_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
@@ -1254,7 +1298,7 @@ inline void Store_command_response_msg::set_terminal_id(::PROTOBUF_NAMESPACE_ID:
 
 // required .message.Error_manager code = 3;
 inline bool Store_command_response_msg::_internal_has_code() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
   PROTOBUF_ASSUME(!value || code_ != nullptr);
   return value;
 }
@@ -1277,14 +1321,14 @@ inline void Store_command_response_msg::unsafe_arena_set_allocated_code(
   }
   code_ = code;
   if (code) {
-    _has_bits_[0] |= 0x00000002u;
+    _has_bits_[0] |= 0x00000004u;
   } else {
-    _has_bits_[0] &= ~0x00000002u;
+    _has_bits_[0] &= ~0x00000004u;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Store_command_response_msg.code)
 }
 inline ::message::Error_manager* Store_command_response_msg::release_code() {
-  _has_bits_[0] &= ~0x00000002u;
+  _has_bits_[0] &= ~0x00000004u;
   ::message::Error_manager* temp = code_;
   code_ = nullptr;
   if (GetArena() != nullptr) {
@@ -1294,13 +1338,13 @@ inline ::message::Error_manager* Store_command_response_msg::release_code() {
 }
 inline ::message::Error_manager* Store_command_response_msg::unsafe_arena_release_code() {
   // @@protoc_insertion_point(field_release:message.Store_command_response_msg.code)
-  _has_bits_[0] &= ~0x00000002u;
+  _has_bits_[0] &= ~0x00000004u;
   ::message::Error_manager* temp = code_;
   code_ = nullptr;
   return temp;
 }
 inline ::message::Error_manager* Store_command_response_msg::_internal_mutable_code() {
-  _has_bits_[0] |= 0x00000002u;
+  _has_bits_[0] |= 0x00000004u;
   if (code_ == nullptr) {
     auto* p = CreateMaybeMessage<::message::Error_manager>(GetArena());
     code_ = p;
@@ -1323,14 +1367,88 @@ inline void Store_command_response_msg::set_allocated_code(::message::Error_mana
       code = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
           message_arena, code, submessage_arena);
     }
-    _has_bits_[0] |= 0x00000002u;
+    _has_bits_[0] |= 0x00000004u;
   } else {
-    _has_bits_[0] &= ~0x00000002u;
+    _has_bits_[0] &= ~0x00000004u;
   }
   code_ = code;
   // @@protoc_insertion_point(field_set_allocated:message.Store_command_response_msg.code)
 }
 
+// optional string license = 4;
+inline bool Store_command_response_msg::_internal_has_license() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Store_command_response_msg::has_license() const {
+  return _internal_has_license();
+}
+inline void Store_command_response_msg::clear_license() {
+  license_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Store_command_response_msg::license() const {
+  // @@protoc_insertion_point(field_get:message.Store_command_response_msg.license)
+  return _internal_license();
+}
+inline void Store_command_response_msg::set_license(const std::string& value) {
+  _internal_set_license(value);
+  // @@protoc_insertion_point(field_set:message.Store_command_response_msg.license)
+}
+inline std::string* Store_command_response_msg::mutable_license() {
+  // @@protoc_insertion_point(field_mutable:message.Store_command_response_msg.license)
+  return _internal_mutable_license();
+}
+inline const std::string& Store_command_response_msg::_internal_license() const {
+  return license_.Get();
+}
+inline void Store_command_response_msg::_internal_set_license(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  license_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
+}
+inline void Store_command_response_msg::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.Store_command_response_msg.license)
+}
+inline void Store_command_response_msg::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.Store_command_response_msg.license)
+}
+inline void Store_command_response_msg::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.Store_command_response_msg.license)
+}
+inline std::string* Store_command_response_msg::_internal_mutable_license() {
+  _has_bits_[0] |= 0x00000001u;
+  return license_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline std::string* Store_command_response_msg::release_license() {
+  // @@protoc_insertion_point(field_release:message.Store_command_response_msg.license)
+  if (!_internal_has_license()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return license_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void Store_command_response_msg::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.Store_command_response_msg.license)
+}
+
 // -------------------------------------------------------------------
 
 // Pickup_command_request_msg
@@ -1527,7 +1645,7 @@ inline void Pickup_command_request_msg::set_allocated_car_info(::message::Car_in
 
 // required .message.Base_info base_info = 1;
 inline bool Pickup_command_response_msg::_internal_has_base_info() const {
-  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
   PROTOBUF_ASSUME(!value || base_info_ != nullptr);
   return value;
 }
@@ -1550,14 +1668,14 @@ inline void Pickup_command_response_msg::unsafe_arena_set_allocated_base_info(
   }
   base_info_ = base_info;
   if (base_info) {
-    _has_bits_[0] |= 0x00000001u;
+    _has_bits_[0] |= 0x00000002u;
   } else {
-    _has_bits_[0] &= ~0x00000001u;
+    _has_bits_[0] &= ~0x00000002u;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Pickup_command_response_msg.base_info)
 }
 inline ::message::Base_info* Pickup_command_response_msg::release_base_info() {
-  _has_bits_[0] &= ~0x00000001u;
+  _has_bits_[0] &= ~0x00000002u;
   ::message::Base_info* temp = base_info_;
   base_info_ = nullptr;
   if (GetArena() != nullptr) {
@@ -1567,13 +1685,13 @@ inline ::message::Base_info* Pickup_command_response_msg::release_base_info() {
 }
 inline ::message::Base_info* Pickup_command_response_msg::unsafe_arena_release_base_info() {
   // @@protoc_insertion_point(field_release:message.Pickup_command_response_msg.base_info)
-  _has_bits_[0] &= ~0x00000001u;
+  _has_bits_[0] &= ~0x00000002u;
   ::message::Base_info* temp = base_info_;
   base_info_ = nullptr;
   return temp;
 }
 inline ::message::Base_info* Pickup_command_response_msg::_internal_mutable_base_info() {
-  _has_bits_[0] |= 0x00000001u;
+  _has_bits_[0] |= 0x00000002u;
   if (base_info_ == nullptr) {
     auto* p = CreateMaybeMessage<::message::Base_info>(GetArena());
     base_info_ = p;
@@ -1596,9 +1714,9 @@ inline void Pickup_command_response_msg::set_allocated_base_info(::message::Base
       base_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
           message_arena, base_info, submessage_arena);
     }
-    _has_bits_[0] |= 0x00000001u;
+    _has_bits_[0] |= 0x00000002u;
   } else {
-    _has_bits_[0] &= ~0x00000001u;
+    _has_bits_[0] &= ~0x00000002u;
   }
   base_info_ = base_info;
   // @@protoc_insertion_point(field_set_allocated:message.Pickup_command_response_msg.base_info)
@@ -1606,7 +1724,7 @@ inline void Pickup_command_response_msg::set_allocated_base_info(::message::Base
 
 // required int32 terminal_id = 2;
 inline bool Pickup_command_response_msg::_internal_has_terminal_id() const {
-  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
   return value;
 }
 inline bool Pickup_command_response_msg::has_terminal_id() const {
@@ -1614,7 +1732,7 @@ inline bool Pickup_command_response_msg::has_terminal_id() const {
 }
 inline void Pickup_command_response_msg::clear_terminal_id() {
   terminal_id_ = 0;
-  _has_bits_[0] &= ~0x00000004u;
+  _has_bits_[0] &= ~0x00000008u;
 }
 inline ::PROTOBUF_NAMESPACE_ID::int32 Pickup_command_response_msg::_internal_terminal_id() const {
   return terminal_id_;
@@ -1624,7 +1742,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int32 Pickup_command_response_msg::terminal_id()
   return _internal_terminal_id();
 }
 inline void Pickup_command_response_msg::_internal_set_terminal_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _has_bits_[0] |= 0x00000004u;
+  _has_bits_[0] |= 0x00000008u;
   terminal_id_ = value;
 }
 inline void Pickup_command_response_msg::set_terminal_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
@@ -1634,7 +1752,7 @@ inline void Pickup_command_response_msg::set_terminal_id(::PROTOBUF_NAMESPACE_ID
 
 // required .message.Error_manager code = 3;
 inline bool Pickup_command_response_msg::_internal_has_code() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
   PROTOBUF_ASSUME(!value || code_ != nullptr);
   return value;
 }
@@ -1657,14 +1775,14 @@ inline void Pickup_command_response_msg::unsafe_arena_set_allocated_code(
   }
   code_ = code;
   if (code) {
-    _has_bits_[0] |= 0x00000002u;
+    _has_bits_[0] |= 0x00000004u;
   } else {
-    _has_bits_[0] &= ~0x00000002u;
+    _has_bits_[0] &= ~0x00000004u;
   }
   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:message.Pickup_command_response_msg.code)
 }
 inline ::message::Error_manager* Pickup_command_response_msg::release_code() {
-  _has_bits_[0] &= ~0x00000002u;
+  _has_bits_[0] &= ~0x00000004u;
   ::message::Error_manager* temp = code_;
   code_ = nullptr;
   if (GetArena() != nullptr) {
@@ -1674,13 +1792,13 @@ inline ::message::Error_manager* Pickup_command_response_msg::release_code() {
 }
 inline ::message::Error_manager* Pickup_command_response_msg::unsafe_arena_release_code() {
   // @@protoc_insertion_point(field_release:message.Pickup_command_response_msg.code)
-  _has_bits_[0] &= ~0x00000002u;
+  _has_bits_[0] &= ~0x00000004u;
   ::message::Error_manager* temp = code_;
   code_ = nullptr;
   return temp;
 }
 inline ::message::Error_manager* Pickup_command_response_msg::_internal_mutable_code() {
-  _has_bits_[0] |= 0x00000002u;
+  _has_bits_[0] |= 0x00000004u;
   if (code_ == nullptr) {
     auto* p = CreateMaybeMessage<::message::Error_manager>(GetArena());
     code_ = p;
@@ -1703,14 +1821,88 @@ inline void Pickup_command_response_msg::set_allocated_code(::message::Error_man
       code = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
           message_arena, code, submessage_arena);
     }
-    _has_bits_[0] |= 0x00000002u;
+    _has_bits_[0] |= 0x00000004u;
   } else {
-    _has_bits_[0] &= ~0x00000002u;
+    _has_bits_[0] &= ~0x00000004u;
   }
   code_ = code;
   // @@protoc_insertion_point(field_set_allocated:message.Pickup_command_response_msg.code)
 }
 
+// optional string license = 4;
+inline bool Pickup_command_response_msg::_internal_has_license() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Pickup_command_response_msg::has_license() const {
+  return _internal_has_license();
+}
+inline void Pickup_command_response_msg::clear_license() {
+  license_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Pickup_command_response_msg::license() const {
+  // @@protoc_insertion_point(field_get:message.Pickup_command_response_msg.license)
+  return _internal_license();
+}
+inline void Pickup_command_response_msg::set_license(const std::string& value) {
+  _internal_set_license(value);
+  // @@protoc_insertion_point(field_set:message.Pickup_command_response_msg.license)
+}
+inline std::string* Pickup_command_response_msg::mutable_license() {
+  // @@protoc_insertion_point(field_mutable:message.Pickup_command_response_msg.license)
+  return _internal_mutable_license();
+}
+inline const std::string& Pickup_command_response_msg::_internal_license() const {
+  return license_.Get();
+}
+inline void Pickup_command_response_msg::_internal_set_license(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  license_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
+}
+inline void Pickup_command_response_msg::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.Pickup_command_response_msg.license)
+}
+inline void Pickup_command_response_msg::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.Pickup_command_response_msg.license)
+}
+inline void Pickup_command_response_msg::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.Pickup_command_response_msg.license)
+}
+inline std::string* Pickup_command_response_msg::_internal_mutable_license() {
+  _has_bits_[0] |= 0x00000001u;
+  return license_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline std::string* Pickup_command_response_msg::release_license() {
+  // @@protoc_insertion_point(field_release:message.Pickup_command_response_msg.license)
+  if (!_internal_has_license()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return license_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void Pickup_command_response_msg::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.Pickup_command_response_msg.license)
+}
+
 #ifdef __GNUC__
   #pragma GCC diagnostic pop
 #endif  // __GNUC__

message/terminal_message.proto

@@ -17,6 +17,7 @@ message Store_command_response_msg
     required Base_info                  base_info=1;                 //消息类型
     required int32                      terminal_id=2;              //终端id
     required Error_manager              code=3;            //请求结果码
+    optional string                     license=4;
 }
 
 
@@ -25,6 +26,7 @@ message Pickup_command_request_msg
     required Base_info                  base_info=1;                 //消息类型
     required int32                      terminal_id=2;              //终端id
     required Car_info                    car_info=4;                  //车辆信息
+
 }
 
 
@@ -33,4 +35,5 @@ message Pickup_command_response_msg
     required Base_info                  base_info=1;                 //消息类型
     required int32                      terminal_id=2;              //终端id
     required Error_manager              code=3;            //请求结果码
+        optional string                     license=4;
 }

system/PickupProcessTask.cpp

@@ -18,6 +18,17 @@ PickupProcessTask::PickupProcessTask(unsigned int terminal_id,message::Car_info
 }
 PickupProcessTask::~PickupProcessTask()
 {
+    //退出线程
+    m_publish_exit_condition.set_pass_ever(true);
+    if(m_publish_statu_thread!= nullptr)
+    {
+        if(m_publish_statu_thread->joinable())
+        {
+            m_publish_statu_thread->join();
+        }
+        delete m_publish_statu_thread;
+        m_publish_statu_thread=nullptr;
+    }
 }
 Error_manager PickupProcessTask::init_task(const ::google::protobuf::Message& parameter)
 {
@@ -63,6 +74,7 @@ Error_manager PickupProcessTask::search_space_step()
     base_info_response.set_receiver(message::eTerminor);
     m_command_response_msg.mutable_base_info()->CopyFrom(base_info_response);
     m_command_response_msg.set_terminal_id(m_terminor_id);
+    m_command_response_msg.set_license(m_car_info.license());
 
     if(Command_manager::get_instance_pointer()->is_paused()==true)
     {
@@ -201,7 +213,6 @@ void PickupProcessTask::Main()
         {
             updata_step_statu(message::eWorking);
             code=dispatch_step();
-            usleep(1000*500);
             code!=SUCCESS?updata_step_statu(message::eError):updata_step_statu(message::eFinished);
             LOG_IF(ERROR, code != SUCCESS) << "-------  取  -------取车调度失败,取车终端:"<<m_terminor_id
                                            <<", 车位id:"<<m_search_response_msg.query_parkspace_info_ex(0).parkingspace_room_id()
@@ -405,7 +416,7 @@ Error_manager PickupProcessTask::back_dispatch_step()
  */
 Error_manager PickupProcessTask::wait_for_leave_step()
 {
-    usleep(1000*200);
+    usleep(1000*100);
     /*int k=rand()%10;
     if(k==0)
         return Error_manager(ERROR,MINOR_ERROR,"手动制造错误");*/

system/StoreProcessTask.cpp

@@ -21,6 +21,17 @@ StoreProcessTask::StoreProcessTask(unsigned int terminor_id,message::Car_info ca
 
 StoreProcessTask::~StoreProcessTask()
 {
+    //退出线程
+    m_publish_exit_condition.set_pass_ever(true);
+    if(m_publish_statu_thread!= nullptr)
+    {
+        if(m_publish_statu_thread->joinable())
+        {
+            m_publish_statu_thread->join();
+        }
+        delete m_publish_statu_thread;
+        m_publish_statu_thread=nullptr;
+    }
 }
 
 Error_manager StoreProcessTask::init_task(const ::google::protobuf::Message& parameter)
@@ -147,12 +158,15 @@ Error_manager StoreProcessTask::back_dispatch_step()
      */
 Error_manager StoreProcessTask::alloc_space_step()
 {
+
     message::Base_info base_info_response;
     base_info_response.set_msg_type(message::eStore_command_response_msg);
     base_info_response.set_sender(message::eMain);
     base_info_response.set_receiver(message::eTerminor);
     m_command_response_msg.mutable_base_info()->CopyFrom(base_info_response);
     m_command_response_msg.set_terminal_id(m_terminor_id);
+    m_command_response_msg.set_license(m_car_info.license());
+
 
     if(Command_manager::get_instance_pointer()->is_paused()==true)
     {
@@ -437,7 +451,6 @@ void StoreProcessTask::Main()
         {
             updata_step_statu(message::eWorking);
             code=compare_step();
-            usleep(500*1000);
             //ALOG_IF(WARNING, code != SUCCESS) << "------  停  ------- 检验失败:"<<m_car_info.license() << code.get_error_description();
             LOG_IF(WARNING, code != SUCCESS) << "------  停  ------- 检验失败:"<<m_car_info.license() << code.get_error_description();
         }
@@ -447,7 +460,6 @@ void StoreProcessTask::Main()
             //开始调度
             updata_step_statu(message::eWorking);
             code = dispatch_step();
-            usleep(1000 * 500 );
             //ALOG_IF(WARNING, code != SUCCESS) << "------  停  ------- 调度失败:"<<m_car_info.license() << code.get_error_description();
             LOG_IF(WARNING, code != SUCCESS) << "------  停  ------- 调度失败:"<<m_car_info.license() << code.get_error_description();
         }

system/process_task.cpp

@@ -6,6 +6,7 @@
 #include <google/protobuf/text_format.h>
 #include "process_task.h"
 #include "pathcreator.h"
+#include "command_accepter.h"
 
 Process_task::Process_task(unsigned int terminal_id,message::Car_info car_info)
         :m_publish_statu_thread(nullptr)
@@ -16,17 +17,7 @@ Process_task::Process_task(unsigned int terminal_id,message::Car_info car_info)
 }
 Process_task::~Process_task()
 {
-    //退出线程
-    m_publish_exit_condition.set_pass_ever(true);
-    if(m_publish_statu_thread!= nullptr)
-    {
-        if(m_publish_statu_thread->joinable())
-        {
-            m_publish_statu_thread->join();
-        }
-        delete m_publish_statu_thread;
-        m_publish_statu_thread=nullptr;
-    }
+
 }
 
 Error_manager Process_task::init_task(const ::google::protobuf::Message& parameter)

system/process_task.h

@@ -35,8 +35,11 @@ public:
     message::Step_type current_step_type(){return m_current_step_type;}
     message::Step_statu current_step_statu(){return m_current_step_statu;}
     // 获取任务类型
-    virtual message::Process_type get_process_type() const=0;
-
+    virtual message::Process_type get_process_type() const
+    {
+        LOG(ERROR) << "xxxxxxxxxxxxxxxxxxxxxxxxxxx        xxxxxxxxxxxxxxxprocess base virtual called:get_process_type";
+        exit(0);
+    };
 
     /*
      * 取消任务
@@ -55,7 +58,11 @@ public:
         LOG(ERROR)<<"process base virtual called";
         return ERROR;};
 
-    virtual void updata_step_statu(message::Step_statu statu)=0;
+    virtual void updata_step_statu(message::Step_statu statu)
+    {
+        LOG(ERROR)<<"xxxxxxxxxxxxxxxxxxxxxxxxxxx        xxxxxxxxxxxxxxxprocess base virtual called:updata_step_statu";
+        exit(0);
+    };
 
     /*
      * 记录流程信息
@@ -71,7 +78,11 @@ protected:
      * 发布进度消息
      */
     static void publish_thread_func(Process_task* ptask);
-    virtual void publish_step_status()=0;
+    virtual void publish_step_status()
+    {
+        LOG(ERROR)<<"   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    xxxxxxxxxxxxxxxxprocess base virtual called:publish_step_status";
+        exit(0);
+    };
 
     /*
      * 添加日志相关

test/Terminal_communication.cpp

@@ -28,8 +28,7 @@ Error_manager Terminal_communication::encapsulate_msg(Communication_message* mes
         {
             message::Store_command_request_msg request;
             request.ParseFromString(message->get_message_buf());
-            //清空记录
-            m_store_response_msg=message::Store_command_response_msg();
+
             //发送请求
             code= Communication_socket_base::encapsulate_msg(message);
             break;
@@ -39,8 +38,7 @@ Error_manager Terminal_communication::encapsulate_msg(Communication_message* mes
         {
             message::Pickup_command_request_msg request;
             request.ParseFromString(message->get_message_buf());
-            //清空记录
-            m_pickup_response_msg=message::Pickup_command_response_msg();
+
             //发送请求
             code= Communication_socket_base::encapsulate_msg(message);
             break;
@@ -53,7 +51,6 @@ Error_manager Terminal_communication::encapsulate_msg(Communication_message* mes
 }
 Error_manager Terminal_communication::execute_msg(Communication_message* p_msg)
 {
-
     if(p_msg->get_message_type()==Communication_message::eStore_command_response_msg)
     {
         message::Store_command_response_msg response;
@@ -65,7 +62,7 @@ Error_manager Terminal_communication::execute_msg(Communication_message* p_msg)
         if(base_info.sender()==message::eMain && base_info.receiver()==message::eTerminor)
         {
             message::Error_manager error_code=response.code();
-            m_store_response_msg=response;
+            m_store_response_msg_table[response.license()]=response;
             return SUCCESS;
         }
     }
@@ -77,11 +74,12 @@ Error_manager Terminal_communication::execute_msg(Communication_message* p_msg)
         {
             return Error_manager(ERROR,CRITICAL_ERROR,"停车指令反馈信息解析错误");
         }
+        LOG(INFO)<<" 取车反馈："<<response.license();
         message::Base_info base_info=response.base_info();
         if(base_info.sender()==message::eMain && base_info.receiver()==message::eTerminor)
         {
             message::Error_manager error_code=response.code();
-            m_pickup_response_msg=response;
+            m_pickup_response_msg_table[response.license()]=response;
             return SUCCESS;
         }
     }
@@ -96,13 +94,13 @@ Error_manager Terminal_communication::execute_msg(Communication_message* p_msg)
         message::Base_info base_info=msg.base_info();
         if(base_info.sender()==message::eMain)
         {
-            if(m_storing_statu_map.find(msg.license())==false)
+            if(m_storing_process_statu_map.find(msg.license())==false)
             {
                 m_storing_license_queue.push(msg.license());
             }
-            m_storing_statu_map[msg.license()]=msg;
+            m_storing_process_statu_map[msg.license()]=msg;
             std::chrono::system_clock::time_point time_point=std::chrono::system_clock::now();
-            m_storing_statu_time_point_map[msg.license()]=time_point;
+            m_storing_statu_process_time_point_map[msg.license()]=time_point;
 
 
         }
@@ -118,13 +116,13 @@ Error_manager Terminal_communication::execute_msg(Communication_message* p_msg)
         message::Base_info base_info=msg.base_info();
         if(base_info.sender()==message::eMain)
         {
-            if(m_picking_statu_map.find(msg.license())==false)
+            if(m_picking_statu_process_map.find(msg.license())==false)
             {
                 m_picking_license_queue.push(msg.license());
             }
-            m_picking_statu_map[msg.license()]=msg;
+            m_picking_statu_process_map[msg.license()]=msg;
             std::chrono::system_clock::time_point time_point=std::chrono::system_clock::now();
-            m_picking_statu_time_point_map[msg.license()]=time_point;
+            m_picking_statu_process_time_point_map[msg.license()]=time_point;
         }
     }
 
@@ -144,7 +142,6 @@ Error_manager Terminal_communication::execute_msg(Communication_message* p_msg)
 
     return SUCCESS;
 
-    return Error_manager(FAILED,MINOR_ERROR,"terminal communication 未知消息");
 }
 /*
  * 检测消息是否可被处理
@@ -170,7 +167,7 @@ Error_manager Terminal_communication::check_executer(Communication_message* p_ms
 /*
     * 发送停车指令请求
     */
-Error_manager Terminal_communication::store_request(message::Store_command_request_msg& request,message::Store_command_response_msg& response)
+Error_manager Terminal_communication::store_request(message::Store_command_request_msg& request,message::Store_command_response_msg& result)
 {
 
     if(request.has_locate_information()==false ||
@@ -187,49 +184,61 @@ Error_manager Terminal_communication::store_request(message::Store_command_reque
     code=encapsulate_msg(&message);
     if(code!=SUCCESS)
         return code;
-
     //循环查询请求是否被处理
     auto start_time=std::chrono::system_clock::now();
     double time=0;
     do {
-        //查询到记录
+
         ///查询是否存在,并且删除该记录,
-        //判断是否接收到回应,若回应信息被赋值则证明有回应
-        if (m_store_response_msg.has_base_info() && m_store_response_msg.has_code()) {
-            message::Base_info response_base = m_store_response_msg.base_info();
-            //检查类型是否匹配
-            if (response_base.msg_type() != message::eStore_command_response_msg) {
-                return Error_manager(ERROR, CRITICAL_ERROR,
-                                     "停车指令反馈消息 response msg type error");
-            }
-            //检查基本信息是否匹配
-            if (response_base.sender() != message::eMain ||
-                response_base.receiver() != message::eTerminor ) {
-                return Error_manager(PARKSPACE_RELEASE_RESPONSE_INFO_ERROR, MAJOR_ERROR,
-                                     "parkspace store response msg info error");
-            }
-            response.CopyFrom(m_store_response_msg);
-            m_store_response_msg.clear_base_info();
-            return SUCCESS;
+        message::Store_command_response_msg response;
+        if(m_store_response_msg_table.find(request.car_info().license(),response))
+        {
+            //判断是否接收到回应,若回应信息被赋值则证明有回应
+            if (response.has_base_info() && response.has_code())
+            {
+                message::Base_info response_base = response.base_info();
+                //检查类型是否匹配
+                if (response_base.msg_type() != message::eStore_command_response_msg) {
+                    return Error_manager(ERROR, CRITICAL_ERROR,
+                                         "停车指令反馈消息 response msg type error");
+                }
+                //检查基本信息是否匹配
+                if (response_base.sender() != message::eMain ||
+                        response_base.receiver() != message::eTerminor ) {
+                    return Error_manager(PARKSPACE_RELEASE_RESPONSE_INFO_ERROR, MAJOR_ERROR,
+                                         "parkspace store response msg info error");
+                }
+                result = response;
+                m_store_response_msg_table.erase(request.car_info().license());
+                if(response.has_code())
+                {
+                    if(response.code().error_code()==0)
+                        return SUCCESS;
+                }
+                return Error_manager(FAILED,MINOR_ERROR,"车位查询返回错误码");
 
+            }
         }
 
-        auto end_time = std::chrono::system_clock::now();
+        auto end_time=std::chrono::system_clock::now();
         auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);
-        time = 1000.0 * double(duration.count()) * std::chrono::microseconds::period::num /
-               std::chrono::microseconds::period::den;
-        std::this_thread::yield();
+        time=1000.0*double(duration.count()) * std::chrono::microseconds::period::num / std::chrono::microseconds::period::den;
+        if(time>double(timeout))
+        {
+            m_store_response_msg_table.erase(request.car_info().license());
+            return Error_manager(RESPONSE_TIMEOUT,MINOR_ERROR,"storing terminal request timeout");
+        }
         usleep(1000);
-    }while(time<double(timeout));
-    //超时,删除记录,返回错误
-    return Error_manager(RESPONSE_TIMEOUT,MINOR_ERROR,"parkspace store request timeout");
+    }while(1);
+
+
 
 }
 
 /*
  * 发送取车指令请求
  */
-Error_manager Terminal_communication::pickup_request(message::Pickup_command_request_msg& request,message::Pickup_command_response_msg& response)
+Error_manager Terminal_communication::pickup_request(message::Pickup_command_request_msg& request,message::Pickup_command_response_msg& result)
 {
     if(request.has_car_info()==false)
     {
@@ -251,39 +260,47 @@ Error_manager Terminal_communication::pickup_request(message::Pickup_command_req
     auto start_time=std::chrono::system_clock::now();
     double time=0;
     do {
-        //查询到记录
         ///查询是否存在,并且删除该记录,
-        //判断是否接收到回应,若回应信息被赋值则证明有回应
-        if (m_pickup_response_msg.has_base_info() && m_pickup_response_msg.has_code())
+        message::Pickup_command_response_msg response;
+        if(m_pickup_response_msg_table.find(request.car_info().license(),response))
         {
-            message::Base_info response_base = m_pickup_response_msg.base_info();
-            //检查类型是否匹配
-            if (response_base.msg_type() != message::ePickup_command_response_msg) {
-                return Error_manager(ERROR, CRITICAL_ERROR,
-                                     "停车指令反馈消息 response msg type error");
-            }
-            //检查基本信息是否匹配
-            if (response_base.sender() != message::eMain ||
-                response_base.receiver() != message::eTerminor ) {
-                return Error_manager(PARKSPACE_RELEASE_RESPONSE_INFO_ERROR, MAJOR_ERROR,
-                                     "parkspace release response msg info error");
-            }
-            response.CopyFrom(m_pickup_response_msg);
-            m_pickup_response_msg.clear_base_info();
-            //m_pickup_response_msg=message::Pickup_command_response_msg();
-            return SUCCESS;
+            //判断是否接收到回应,若回应信息被赋值则证明有回应
+            if (response.has_base_info() && response.has_code())
+            {
+                message::Base_info response_base = response.base_info();
+                //检查类型是否匹配
+                if (response_base.msg_type() != message::ePickup_command_response_msg) {
+                    return Error_manager(ERROR, CRITICAL_ERROR,
+                                         "停车指令反馈消息 response msg type error");
+                }
+                //检查基本信息是否匹配
+                if (response_base.sender() != message::eMain ||
+                        response_base.receiver() != message::eTerminor ) {
+                    return Error_manager(PARKSPACE_RELEASE_RESPONSE_INFO_ERROR, MAJOR_ERROR,
+                                         "parkspace release response msg info error");
+                }
+                result = response;
+                m_pickup_response_msg_table.erase(request.car_info().license());
+                if(response.has_code())
+                {
+                    if(response.code().error_code()==0)
+                        return SUCCESS;
+                }
+                return Error_manager(FAILED,MINOR_ERROR,"车位查询返回错误码");
 
+            }
         }
 
-        auto end_time = std::chrono::system_clock::now();
+        auto end_time=std::chrono::system_clock::now();
         auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);
-        time = 1000.0 * double(duration.count()) * std::chrono::microseconds::period::num /
-               std::chrono::microseconds::period::den;
-        std::this_thread::yield();
+        time=1000.0*double(duration.count()) * std::chrono::microseconds::period::num / std::chrono::microseconds::period::den;
+        if(time>double(timeout))
+        {
+            m_pickup_response_msg_table.erase(request.car_info().license());
+            return Error_manager(RESPONSE_TIMEOUT,MINOR_ERROR,"picking terminal request timeout");
+        }
         usleep(1000);
-    }while(time<double(timeout));
-    //超时,删除记录,返回错误
-    return Error_manager(RESPONSE_TIMEOUT,MINOR_ERROR,"parkspace release request timeout");
+    }while(1);
 
 }
 
@@ -293,7 +310,7 @@ Error_manager Terminal_communication::pickup_request(message::Pickup_command_req
      */
 Error_manager Terminal_communication::get_storing_statu(std::string car_license,message::Storing_process_statu_msg& msg)
 {
-    if(m_storing_statu_map.find(car_license,msg)) {
+    if(m_storing_process_statu_map.find(car_license,msg)) {
         return SUCCESS;
     }
     return FAILED;
@@ -304,7 +321,7 @@ Error_manager Terminal_communication::get_storing_statu(std::string car_license,
  */
 Error_manager Terminal_communication::get_picking_statu(std::string car_license,message::Picking_process_statu_msg& msg)
 {
-    if(m_picking_statu_map.find(car_license,msg))
+    if(m_picking_statu_process_map.find(car_license,msg))
         return SUCCESS;
     return FAILED;
 }
@@ -317,14 +334,15 @@ void Terminal_communication::update_map()
         if (m_storing_license_queue.try_pop(license))
         {
             std::chrono::system_clock::time_point t1 = std::chrono::system_clock::now();
-            std::chrono::system_clock::time_point start = m_storing_statu_time_point_map[license];
+            std::chrono::system_clock::time_point start = m_storing_statu_process_time_point_map[license];
             auto duration = std::chrono::duration_cast<std::chrono::microseconds>(t1 - start);
             double time = 1000.0 * double(duration.count()) * std::chrono::microseconds::period::num /
                           std::chrono::microseconds::period::den;
 
-            if (time > 3000) {
-                m_storing_statu_time_point_map.erase(license);
-                m_storing_statu_map.erase(license);
+            if (time > 300)
+            {
+                m_storing_statu_process_time_point_map.erase(license);
+                m_storing_process_statu_map.erase(license);
 
             }
             else
@@ -336,14 +354,15 @@ void Terminal_communication::update_map()
         if (m_picking_license_queue.try_pop(license))
         {
             std::chrono::system_clock::time_point t1 = std::chrono::system_clock::now();
-            std::chrono::system_clock::time_point start = m_picking_statu_time_point_map[license];
+            std::chrono::system_clock::time_point start = m_picking_statu_process_time_point_map[license];
             auto duration = std::chrono::duration_cast<std::chrono::microseconds>(t1 - start);
             double time = 1000.0 * double(duration.count()) * std::chrono::microseconds::period::num /
                           std::chrono::microseconds::period::den;
 
-            if (time > 3000) {
-                m_picking_statu_time_point_map.erase(license);
-                m_picking_statu_map.erase(license);
+            if (time > 300)
+            {
+                m_picking_statu_process_time_point_map.erase(license);
+                m_picking_statu_process_map.erase(license);
 
             }
             else
@@ -352,6 +371,8 @@ void Terminal_communication::update_map()
             }
         }
 
+
+
     }
 }
 

test/Terminal_communication.h

@@ -67,19 +67,23 @@ protected:
     void update_map();
 
 private:
-    message::Store_command_response_msg             m_store_response_msg;
-    message::Pickup_command_response_msg            m_pickup_response_msg;
+    thread_safe_map<std::string,message::Store_command_response_msg>            m_store_response_msg_table;
+    thread_safe_map<std::string,message::Pickup_command_response_msg>            m_pickup_response_msg_table;
 
-    thread_safe_map<std::string ,message::Storing_process_statu_msg>        m_storing_statu_map;
-    thread_safe_map<std::string ,std::chrono::system_clock::time_point>     m_storing_statu_time_point_map;
+    thread_safe_map<std::string ,message::Storing_process_statu_msg>        m_storing_process_statu_map;
+    thread_safe_map<std::string ,std::chrono::system_clock::time_point>     m_storing_statu_process_time_point_map;
     Thread_safe_queue<std::string>                                                m_storing_license_queue;
-    thread_safe_map<std::string ,message::Picking_process_statu_msg>        m_picking_statu_map;
-    thread_safe_map<std::string ,std::chrono::system_clock::time_point>     m_picking_statu_time_point_map;
+    thread_safe_map<std::string ,message::Picking_process_statu_msg>        m_picking_statu_process_map;
+    thread_safe_map<std::string ,std::chrono::system_clock::time_point>     m_picking_statu_process_time_point_map;
     Thread_safe_queue<std::string>                                                m_picking_license_queue;
 
+    thread_safe_map<int,int>                m_terminal_storing_count;
+    thread_safe_map<int,int>                m_terminal_picking_count;
+
     std::thread*                    m_update_msg_map_thread;
     Thread_condition				m_publish_exit_condition;
 
+
 };
 
 

test/pickup_terminal.cpp

@@ -5,36 +5,21 @@
 #include "pickup_terminal.h"
 
 #include "Terminal_communication.h"
-pickup_terminal::pickup_terminal(int terminal_id)
+pickup_terminal::pickup_terminal(message::Car_info car_info)
 {
-    m_terminal_id=terminal_id;
-    m_thread_safe_queue= nullptr;
+  m_car_info=car_info;
 
 }
 
 
-Error_manager pickup_terminal::init(threadsafe_queue<message::Car_info>* queue)
-{
-    m_thread_safe_queue=queue;
-    m_exit_cond.reset(false,false,false);
-    m_pthread=new std::thread(pickup_thread,this);
-    return SUCCESS;
-}
-
 pickup_terminal::~pickup_terminal()
 {
     m_exit_cond.set_pass_ever(true);
-    if(m_pthread)
-    {
-        if(m_pthread->joinable())
-            m_pthread->join();
-        delete m_pthread;
-        m_pthread=nullptr;
-    }
+
 }
 
 
-Error_manager pickup_terminal::pickup(message::Car_info& car_info)
+Error_manager pickup_terminal::pickup(int terminal_id)
 {
     message::Pickup_command_request_msg request;
     message::Base_info base_info;
@@ -42,8 +27,8 @@ Error_manager pickup_terminal::pickup(message::Car_info& car_info)
     base_info.set_sender(message::eTerminor);
     base_info.set_receiver(message::eMain);
     request.mutable_base_info()->CopyFrom(base_info);
-    request.mutable_car_info()->CopyFrom(car_info);
-    request.set_terminal_id(m_terminal_id);
+    request.mutable_car_info()->CopyFrom(m_car_info);
+    request.set_terminal_id(terminal_id);
     //发送停车请求
     Error_manager code;
     message::Pickup_command_response_msg response;
@@ -56,39 +41,22 @@ Error_manager pickup_terminal::pickup(message::Car_info& car_info)
     //等待停车完成
 
     bool last_signal=false;
+    message::Picking_process_statu_msg last_msg;
     while(m_exit_cond.wait_for_millisecond(200)==false)
     {
         message::Picking_process_statu_msg msg;
-        code = Terminal_communication::get_instance_pointer()->get_picking_statu(car_info.license(), msg);
-        if (code != SUCCESS) {
-           if(last_signal==true)
-           {
-               return SUCCESS;
-           }
-        }
-        else
+        code = Terminal_communication::get_instance_pointer()->get_picking_statu(m_car_info.license(), msg);
+        if (code == SUCCESS)
         {
             last_signal=true;
+            last_msg=msg;
+        }
+        if(last_signal==true&&(last_msg.completed()==true||last_msg.back_completed()==true))
+        {
+            //取车完成
+            return SUCCESS;
         }
 
     }
     return FAILED;
 }
-
-
-void pickup_terminal::pickup_thread(pickup_terminal* picker)
-{
-    while(picker->m_exit_cond.wait_for_millisecond(200)==false)
-    {
-        message::Car_info car_info;
-        if(picker->m_thread_safe_queue== nullptr)
-            continue;
-        if(picker->m_thread_safe_queue->try_pop(car_info)==true)
-        {
-            /*LOG(WARNING)<<"取车终端:"<<picker->m_terminal_id<<",车辆:"<<car_info.license().c_str()
-                        <<",开始取车,剩余out:"<<picker->m_thread_safe_queue->size();*/
-            Error_manager code=picker->pickup(car_info);
-
-        }
-    }
-}

test/pickup_terminal.h

@@ -12,16 +12,13 @@
 
 class pickup_terminal {
 public:
-    pickup_terminal(int terminal_id);
+    pickup_terminal(message::Car_info);
     ~pickup_terminal();
-    Error_manager init(threadsafe_queue<message::Car_info>* queue);
-    Error_manager pickup(message::Car_info& msg);
+
+    Error_manager pickup(int terminal_id);
 protected:
-    static void pickup_thread(pickup_terminal* pPickup);
-    std::thread*                m_pthread;
-    int                         m_terminal_id;
 
-    threadsafe_queue<message::Car_info>*           m_thread_safe_queue;
+    message::Car_info           m_car_info;
     Thread_condition                                m_exit_cond;
 };
 

test/store_terminal.cpp

@@ -4,35 +4,21 @@
 
 #include "store_terminal.h"
 #include "Terminal_communication.h"
-store_terminal::store_terminal(int terminal_id)
+
+threadsafe_queue<message::Car_info>* store_command::p_command_queue=new threadsafe_queue<message::Car_info>;
+store_command::store_command(message::Car_info msg)
 {
-    m_terminal_id=terminal_id;
-    m_thread_safe_queue= nullptr;
-    m_thread_safe_output_queue=nullptr;
+    m_car_info=msg;
 }
-store_terminal::~store_terminal()
+store_command::~store_command()
 {
     m_exit_cond.set_pass_ever(true);
-    if(m_pthread)
-    {
-        if(m_pthread->joinable())
-            m_pthread->join();
-        delete m_pthread;
-        m_pthread=nullptr;
-    }
-}
 
-Error_manager store_terminal::init(threadsafe_queue<message::Car_info>* input,
-                                   threadsafe_queue<message::Car_info>* output)
-{
-    m_thread_safe_queue=input;
-    m_thread_safe_output_queue=output;
-    m_exit_cond.reset(false,false,false);
-    m_pthread=new std::thread(storing_thread,this);
-    return SUCCESS;
 }
 
-Error_manager store_terminal::storing(message::Car_info& car_info)
+
+
+Error_manager store_command::storing(int terminal_id)
 {
     message::Store_command_request_msg request;
     message::Base_info base_info;
@@ -40,19 +26,19 @@ Error_manager store_terminal::storing(message::Car_info& car_info)
     base_info.set_sender(message::eTerminor);
     base_info.set_receiver(message::eMain);
     request.mutable_base_info()->CopyFrom(base_info);
-    request.mutable_car_info()->CopyFrom(car_info);
+    request.mutable_car_info()->CopyFrom(m_car_info);
 
     message::Locate_information locate_info;
     locate_info.set_locate_x(0.9);
     locate_info.set_locate_y(2.25);
     locate_info.set_locate_angle(90.0);
     locate_info.set_locate_wheel_base(2.7);
-    locate_info.set_locate_width(car_info.car_width());
-    locate_info.set_locate_height(car_info.car_height());
+    locate_info.set_locate_width(m_car_info.car_width());
+    locate_info.set_locate_height(m_car_info.car_height());
     locate_info.set_locate_correct(true);
     request.mutable_locate_information()->CopyFrom(locate_info);
 
-    request.set_terminal_id(m_terminal_id);
+    request.set_terminal_id(terminal_id);
     //发送停车请求
     Error_manager code;
     message::Store_command_response_msg response;
@@ -74,48 +60,19 @@ Error_manager store_terminal::storing(message::Car_info& car_info)
     while(m_exit_cond.wait_for_millisecond(50)==false)
     {
         message::Storing_process_statu_msg msg;
-        code = Terminal_communication::get_instance_pointer()->get_storing_statu(car_info.license(), msg);
-        //未找到
-        if (code != SUCCESS) {
-            if(last_signal==true )
-            {
-                if(last_msg.completed()==true) {
-                    if (m_thread_safe_output_queue)
-                        m_thread_safe_output_queue->push(car_info);
-                }
-                return SUCCESS;
-            }
-        }
-        else
+        code = Terminal_communication::get_instance_pointer()->get_storing_statu(m_car_info.license(), msg);
+        if (code == SUCCESS)
         {
-            last_msg=msg;
             last_signal=true;
+            last_msg=msg;
+        }
+        if(last_signal==true&&(last_msg.completed()==true||last_msg.back_completed()==true))
+        {
+            //停车完成
+            p_command_queue->push(m_car_info);
+            return SUCCESS;
         }
 
     }
     return FAILED;
 }
-
-
-void store_terminal::storing_thread(store_terminal* pStore)
-{
-    while(pStore->m_exit_cond.wait_for_millisecond(1)==false)
-    {
-        message::Car_info car_info;
-        if(pStore->m_thread_safe_queue== nullptr)
-            continue;
-
-        if(pStore->m_thread_safe_queue->try_pop(car_info)==true)
-        {
-            LOG(INFO)<<"车辆:"<<car_info.license().c_str()<<",停车开始---"<<pStore->m_terminal_id<<"---,剩余in:"
-                  <<pStore->m_thread_safe_queue->size();
-            Error_manager code=pStore->storing(car_info);
-
-            LOG_IF(INFO,code==SUCCESS)<<"车辆:"<<car_info.license().c_str()<<",停车结束---"<<pStore->m_terminal_id<<"----------,剩余in:"
-                                      <<pStore->m_thread_safe_queue->size();
-            LOG_IF(ERROR,code!=SUCCESS)<<"车辆:"<<car_info.license().c_str()<<",停车结束---"<<pStore->m_terminal_id<<"---------,剩余in:"
-                                       <<pStore->m_thread_safe_queue->size();
-
-        }
-    }
-}

test/store_terminal.h

@@ -5,33 +5,29 @@
 #ifndef NNXX_TESTS_STORE_TERMINAL_H
 #define NNXX_TESTS_STORE_TERMINAL_H
 #include <thread>
-#include "threadSafeQueue.h"
 #include "thread_condition.h"
 #include "error_code.h"
 #include "terminal_message.pb.h"
+#include "threadSafeQueue.h"
 
 
-
-class store_terminal {
+class store_command
+{
 
 public:
-    store_terminal(int terminal_id);
-    ~store_terminal();
+    store_command(message::Car_info);
+    ~store_command();
 
-    Error_manager init(threadsafe_queue<message::Car_info>* input,
-                       threadsafe_queue<message::Car_info>* output);
-    Error_manager storing(message::Car_info& msg);
+    Error_manager storing(int terminal_id);
 
 protected:
-    static void storing_thread(store_terminal* pStore);
 
-    std::thread*                m_pthread;
-    int                         m_terminal_id;
 
-    threadsafe_queue<message::Car_info>*           m_thread_safe_queue;
+    message::Car_info          m_car_info;
     Thread_condition                                m_exit_cond;
+ public:
+    static threadsafe_queue<message::Car_info>*        p_command_queue;
 
-    threadsafe_queue<message::Car_info>*           m_thread_safe_output_queue;
 };
 
 

test/terminal_client.cpp

@@ -78,30 +78,75 @@ void init_glog()
     FLAGS_stop_logging_if_full_disk = true;
 }
 
+threadsafe_queue<message::Car_info> car_info_queue;
+
+void storing(int terminal_id)
+{
+    while(1)
+    {
+        message::Car_info car_info;
+        if(car_info_queue.try_pop(car_info))
+        {
+            LOG(INFO)<<"    begin   执行停车："<<car_info.license()<<" , 剩余待取："<<store_command::p_command_queue->size();
+            store_command command(car_info);
+            Error_manager code=command.storing(terminal_id);
+            if(code==SUCCESS)
+                LOG(INFO)<<" completed  停车完成 :"<<car_info.license();
+            else
+                LOG(INFO)<<"  停车失败："<<car_info.license()<<code.get_error_description();
+        }
+        usleep(1000*10);
+        std::this_thread::yield();
+    }
+}
+
+void picking(int terminal_id)
+{
+    while(1)
+    {
+        if(store_command::p_command_queue->size()>0)
+        {
+            message::Car_info car_info;
+            store_command::p_command_queue->wait_and_pop(car_info);
+
+            LOG(WARNING) << "    ---------     begin   执行取车：" << car_info.license();
+            pickup_terminal command(car_info);
+            Error_manager code = command.pickup(terminal_id);
+            if (code == SUCCESS)
+                LOG(WARNING) << " ---------     completed  取车完成 :" << car_info.license();
+            else
+                LOG(INFO) << "  取车失败：" << car_info.license() << code.get_error_description();
+
+
+        }
+
+        std::this_thread::yield();
+    }
+}
+
 int main() {
     init_glog();
-    Terminal_communication::get_instance_pointer()->communication_connect("tcp://192.168.2.185:30000");
+    Terminal_communication::get_instance_pointer()->communication_connect("tcp://192.168.3.14:30000");
     Terminal_communication::get_instance_pointer()->communication_run();
     usleep(2000*1000);
-    threadsafe_queue<message::Car_info> input_queue;
-    threadsafe_queue<message::Car_info> output_queue;
+
 
     const int n_input=6;
     const int n_output=6;
-    std::vector<store_terminal*> input_terminals;
-    std::vector<pickup_terminal*> output_terminals;
+
+    std::thread** storing_thread_vec=0;
+    std::thread** picking_thread_vec=0;
+
+    storing_thread_vec=new std::thread*[n_input];
+    picking_thread_vec=new std::thread*[n_output];
+
     for(int i=0;i<n_input;++i)
     {
-        store_terminal* store=new store_terminal(i);
-        store->init(&input_queue,&output_queue);
-        input_terminals.push_back(store);
+        storing_thread_vec[i]=new std::thread(storing,i);
     }
-
     for(int i=0;i<n_output;++i)
     {
-        pickup_terminal* picker=new pickup_terminal(i);
-        picker->init(&output_queue);
-        output_terminals.push_back(picker);
+        picking_thread_vec[i]=new std::thread(picking,i);
     }
 
     int n = 0;
@@ -109,8 +154,14 @@ int main() {
     Error_manager code;
     char c=0;
     int license_id = rand()%90000+10000;
-    while (c!='q') {
-
+    while (c!='q')
+    {
+        if(car_info_queue.size()>100)
+        {
+            usleep(1000*100);
+            std::this_thread::yield();
+            continue;
+        }
         char C=rand()%10+'A';
         char license[255] = {0};
         sprintf(license, "鄂%c%d",C, license_id++);
@@ -118,24 +169,14 @@ int main() {
         car_info.set_license(license);
         car_info.set_car_height(1.5);
         car_info.set_car_width(1.7);
-        input_queue.push(car_info);
-
+        car_info_queue.push(car_info);
         n++;
+        usleep(1000*100);
+        std::this_thread::yield();
 
-        int in_count=input_queue.size();
-        int out_count=output_queue.size();
-
-       {
-
-            usleep(1000*500*in_count);
-            std::this_thread::yield();
-        }
-
-        if(n%20==0)
-        {
-            std::cout << " press any key to send command" << std::endl;
-            std::cin >> c;
-        }
+        LOG_EVERY_N(WARNING,100)<<"----队列指令："<<car_info_queue.size()<<"   总停车数："<<n;
     }
+
+    return 0;
 }