增加手动请求处理，封装外部车位分配模块成为另一个单例

CMakeLists.txt

@@ -42,6 +42,7 @@ aux_source_directory(${CMAKE_CURRENT_LIST_DIR}/task TASK_MANAGER_SRC )
 aux_source_directory(${CMAKE_CURRENT_LIST_DIR}/tool TOOL_SRC )
 aux_source_directory(${CMAKE_CURRENT_LIST_DIR}/communication COMMUNICATION_SRC )
 aux_source_directory(${CMAKE_CURRENT_LIST_DIR}/system SYSTEM_SRC )
+aux_source_directory(${CMAKE_CURRENT_LIST_DIR}/parkspace_allocation PARKSPACE_ALLOC_SRC )
 
 add_executable(terminal
         main.cpp
@@ -123,11 +124,11 @@ target_link_libraries(locate_test
 # 车位分配测试
 add_executable(parkspace_test
         ./test/test_parkspace_sample.cpp
-        ./parkspace_allocation/parkspace_allocation_communicator.cpp
-        ./error_code/error_code.cpp
+        ${error_src}
         ${message_src}
         ${TOOL_SRC}
         ${COMMUNICATION_SRC}
+        ${PARKSPACE_ALLOC_SRC}
         )
 target_link_libraries(parkspace_test
         nnxx
@@ -138,7 +139,7 @@ target_link_libraries(parkspace_test
         )
 add_executable(parkspace_client
         ./test/parkspace_client.cpp
-        ./error_code/error_code.cpp
+        ${error_src}
         ${message_src}
         ${TOOL_SRC}
         ${COMMUNICATION_SRC}

communication/communication_message.h

@@ -40,6 +40,8 @@ public:
 		eParkspace_search_response_msg = 0x35,		//查询车位反馈消息
 		eParkspace_release_request_msg = 0x36,		//释放车位请求消息
 		eParkspace_release_response_msg = 0x37,		//释放车位反馈消息
+		eParkspace_force_update_request_msg = 0x38,	//手动修改车位消息
+		eParkspace_force_update_response_msg = 0x39,//手动修改车位反馈消息
 	};
 
 	//通讯单元

error_code/error_code.h

@@ -287,9 +287,16 @@ enum Error_code
     
     
     //parkspace allocator，车位分配模块
-    PARKSPACE_ALLOCATOR_ERROR_BASE                  = 0x20010000,      
+    PARKSPACE_ALLOCATOR_ERROR_BASE                  = 0x20010000,     
+    PARKSPACE_ALLOCATOR_MSG_REQUEST_TYPE_ERROR,    //反馈车位消息类型错误 
     PARKSPACE_ALLOCATOR_MSG_RESPONSE_TYPE_ERROR,    //反馈车位消息类型错误
-
+    PARKSPACE_ALLOCATOR_MSG_PARSE_ERROR,            //请求消息解析错误
+    PARKSPACE_ALLOCATOR_SPACE_EMPTY,                //空车位异常，车库无车位。或许由模块初始化异常产生
+    PARKSPACE_ALLOCATOR_ALLOCATE_FAILED,            //无合适车位，分配失败
+    PARKSPACE_ALLOCATOR_SEARCH_FAILED,              //未找到车辆对应车位
+    PARKSPACE_ALLOCATOR_RELEASE_FAILED,             //未找到匹配的车位，车位未释放
+    PARKSPACE_ALLOCATOR_FORCE_UPDATE_FAILED,        //手动更新失败，未找到匹配车位
+    PARKSPACE_ALLOCATOR_PARAM_ERROR,                //传入待释放车位参数错误，内部无车辆信息
 };
 
 //错误等级，用来做故障处理

message/message_base.pb.cc

@@ -236,7 +236,7 @@ void AddDescriptorsImpl() {
       "\030\004 \001(\002\022\024\n\014locate_width\030\005 \001(\002\022\025\n\rlocate_h"
       "eight\030\006 \001(\002\022\031\n\021locate_wheel_base\030\007 \001(\002\022\032"
       "\n\022locate_wheel_width\030\010 \001(\002\022\026\n\016locate_cor"
-      "rect\030\t \001(\010*\314\003\n\014Message_type\022\r\n\teBase_msg"
+      "rect\030\t \001(\010*\237\004\n\014Message_type\022\r\n\teBase_msg"
       "\020\000\022\020\n\014eCommand_msg\020\001\022\026\n\022eLocate_status_m"
       "sg\020\021\022\027\n\023eLocate_request_msg\020\022\022\030\n\024eLocate"
       "_response_msg\020\023\022\026\n\022eHarware_statu_msg\020!\022"
@@ -247,16 +247,18 @@ void AddDescriptorsImpl() {
       "nse_msg\0203\022!\n\035eParkspace_search_request_m"
       "sg\0204\022\"\n\036eParkspace_search_response_msg\0205"
       "\022\"\n\036eParkspace_release_request_msg\0206\022#\n\037"
-      "eParkspace_release_response_msg\0207*o\n\014Com"
-      "municator\022\n\n\006eEmpty\020\000\022\t\n\005eMain\020\001\022\016\n\teTer"
-      "minor\020\200\002\022\031\n\024eParkspace_allocator\020\200\004\022\016\n\te"
-      "Measurer\020\200\006\022\r\n\010eProcess\020\200\010*e\n\013Error_leve"
-      "l\022\n\n\006NORMAL\020\000\022\024\n\020NEGLIGIBLE_ERROR\020\001\022\017\n\013M"
-      "INOR_ERROR\020\002\022\017\n\013MAJOR_ERROR\020\003\022\022\n\016CRITICA"
-      "L_ERROR\020\004"
+      "eParkspace_release_response_msg\0207\022\'\n#ePa"
+      "rkspace_force_update_request_msg\0208\022(\n$eP"
+      "arkspace_force_update_response_msg\0209*o\n\014"
+      "Communicator\022\n\n\006eEmpty\020\000\022\t\n\005eMain\020\001\022\016\n\te"
+      "Terminor\020\200\002\022\031\n\024eParkspace_allocator\020\200\004\022\016"
+      "\n\teMeasurer\020\200\006\022\r\n\010eProcess\020\200\010*e\n\013Error_l"
+      "evel\022\n\n\006NORMAL\020\000\022\024\n\020NEGLIGIBLE_ERROR\020\001\022\017"
+      "\n\013MINOR_ERROR\020\002\022\017\n\013MAJOR_ERROR\020\003\022\022\n\016CRIT"
+      "ICAL_ERROR\020\004"
   };
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
-      descriptor, 1249);
+      descriptor, 1332);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "message_base.proto", &protobuf_RegisterTypes);
 }
@@ -294,6 +296,8 @@ bool Message_type_IsValid(int value) {
     case 53:
     case 54:
     case 55:
+    case 56:
+    case 57:
       return true;
     default:
       return false;

message/message_base.pb.h

@@ -89,11 +89,13 @@ enum Message_type {
   eParkspace_search_request_msg = 52,
   eParkspace_search_response_msg = 53,
   eParkspace_release_request_msg = 54,
-  eParkspace_release_response_msg = 55
+  eParkspace_release_response_msg = 55,
+  eParkspace_force_update_request_msg = 56,
+  eParkspace_force_update_response_msg = 57
 };
 bool Message_type_IsValid(int value);
 const Message_type Message_type_MIN = eBase_msg;
-const Message_type Message_type_MAX = eParkspace_release_response_msg;
+const Message_type Message_type_MAX = eParkspace_force_update_response_msg;
 const int Message_type_ARRAYSIZE = Message_type_MAX + 1;
 
 const ::google::protobuf::EnumDescriptor* Message_type_descriptor();

message/message_base.proto

@@ -24,6 +24,8 @@ enum Message_type
     eParkspace_search_response_msg = 0x35;		//查询车位反馈消息
     eParkspace_release_request_msg = 0x36;		//释放车位请求消息
     eParkspace_release_response_msg = 0x37;		//释放车位反馈消息
+    eParkspace_force_update_request_msg = 0x38;	//手动修改车位消息
+    eParkspace_force_update_response_msg = 0x39;//手动修改车位反馈消息
 }
 
 //通讯单元

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[9];
+  static const ::google::protobuf::internal::ParseTable schema[11];
   static const ::google::protobuf::internal::FieldMetadata field_metadata[];
   static const ::google::protobuf::internal::SerializationTable serialization_table[];
   static const ::google::protobuf::uint32 offsets[];
@@ -60,6 +60,10 @@ void InitDefaultsParkspace_release_request_msgImpl();
 void InitDefaultsParkspace_release_request_msg();
 void InitDefaultsParkspace_release_response_msgImpl();
 void InitDefaultsParkspace_release_response_msg();
+void InitDefaultsParkspace_force_update_request_msgImpl();
+void InitDefaultsParkspace_force_update_request_msg();
+void InitDefaultsParkspace_force_update_response_msgImpl();
+void InitDefaultsParkspace_force_update_response_msg();
 void InitDefaultsParkspace_allocation_status_msgImpl();
 void InitDefaultsParkspace_allocation_status_msg();
 inline void InitDefaults() {
@@ -71,6 +75,8 @@ inline void InitDefaults() {
   InitDefaultsParkspace_search_response_msg();
   InitDefaultsParkspace_release_request_msg();
   InitDefaultsParkspace_release_response_msg();
+  InitDefaultsParkspace_force_update_request_msg();
+  InitDefaultsParkspace_force_update_response_msg();
   InitDefaultsParkspace_allocation_status_msg();
 }
 }  // namespace protobuf_parkspace_5fallocation_5fmessage_2eproto
@@ -87,6 +93,12 @@ extern Parkspace_allocation_response_msgDefaultTypeInternal _Parkspace_allocatio
 class Parkspace_allocation_status_msg;
 class Parkspace_allocation_status_msgDefaultTypeInternal;
 extern Parkspace_allocation_status_msgDefaultTypeInternal _Parkspace_allocation_status_msg_default_instance_;
+class Parkspace_force_update_request_msg;
+class Parkspace_force_update_request_msgDefaultTypeInternal;
+extern Parkspace_force_update_request_msgDefaultTypeInternal _Parkspace_force_update_request_msg_default_instance_;
+class Parkspace_force_update_response_msg;
+class Parkspace_force_update_response_msgDefaultTypeInternal;
+extern Parkspace_force_update_response_msgDefaultTypeInternal _Parkspace_force_update_response_msg_default_instance_;
 class Parkspace_info;
 class Parkspace_infoDefaultTypeInternal;
 extern Parkspace_infoDefaultTypeInternal _Parkspace_info_default_instance_;
@@ -1397,6 +1409,292 @@ class Parkspace_release_response_msg : public ::google::protobuf::Message /* @@p
 };
 // -------------------------------------------------------------------
 
+class Parkspace_force_update_request_msg : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Parkspace_force_update_request_msg) */ {
+ public:
+  Parkspace_force_update_request_msg();
+  virtual ~Parkspace_force_update_request_msg();
+
+  Parkspace_force_update_request_msg(const Parkspace_force_update_request_msg& from);
+
+  inline Parkspace_force_update_request_msg& operator=(const Parkspace_force_update_request_msg& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Parkspace_force_update_request_msg(Parkspace_force_update_request_msg&& from) noexcept
+    : Parkspace_force_update_request_msg() {
+    *this = ::std::move(from);
+  }
+
+  inline Parkspace_force_update_request_msg& operator=(Parkspace_force_update_request_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_force_update_request_msg& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Parkspace_force_update_request_msg* internal_default_instance() {
+    return reinterpret_cast<const Parkspace_force_update_request_msg*>(
+               &_Parkspace_force_update_request_msg_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    8;
+
+  void Swap(Parkspace_force_update_request_msg* other);
+  friend void swap(Parkspace_force_update_request_msg& a, Parkspace_force_update_request_msg& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Parkspace_force_update_request_msg* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Parkspace_force_update_request_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_force_update_request_msg& from);
+  void MergeFrom(const Parkspace_force_update_request_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_force_update_request_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.Parkspace_info update_space_info = 3;
+  bool has_update_space_info() const;
+  void clear_update_space_info();
+  static const int kUpdateSpaceInfoFieldNumber = 3;
+  const ::message::Parkspace_info& update_space_info() const;
+  ::message::Parkspace_info* release_update_space_info();
+  ::message::Parkspace_info* mutable_update_space_info();
+  void set_allocated_update_space_info(::message::Parkspace_info* update_space_info);
+
+  // required int32 command_id = 2;
+  bool has_command_id() const;
+  void clear_command_id();
+  static const int kCommandIdFieldNumber = 2;
+  ::google::protobuf::int32 command_id() const;
+  void set_command_id(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:message.Parkspace_force_update_request_msg)
+ private:
+  void set_has_base_info();
+  void clear_has_base_info();
+  void set_has_command_id();
+  void clear_has_command_id();
+  void set_has_update_space_info();
+  void clear_has_update_space_info();
+
+  // 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::Parkspace_info* update_space_info_;
+  ::google::protobuf::int32 command_id_;
+  friend struct ::protobuf_parkspace_5fallocation_5fmessage_2eproto::TableStruct;
+  friend void ::protobuf_parkspace_5fallocation_5fmessage_2eproto::InitDefaultsParkspace_force_update_request_msgImpl();
+};
+// -------------------------------------------------------------------
+
+class Parkspace_force_update_response_msg : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Parkspace_force_update_response_msg) */ {
+ public:
+  Parkspace_force_update_response_msg();
+  virtual ~Parkspace_force_update_response_msg();
+
+  Parkspace_force_update_response_msg(const Parkspace_force_update_response_msg& from);
+
+  inline Parkspace_force_update_response_msg& operator=(const Parkspace_force_update_response_msg& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Parkspace_force_update_response_msg(Parkspace_force_update_response_msg&& from) noexcept
+    : Parkspace_force_update_response_msg() {
+    *this = ::std::move(from);
+  }
+
+  inline Parkspace_force_update_response_msg& operator=(Parkspace_force_update_response_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_force_update_response_msg& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Parkspace_force_update_response_msg* internal_default_instance() {
+    return reinterpret_cast<const Parkspace_force_update_response_msg*>(
+               &_Parkspace_force_update_response_msg_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    9;
+
+  void Swap(Parkspace_force_update_response_msg* other);
+  friend void swap(Parkspace_force_update_response_msg& a, Parkspace_force_update_response_msg& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Parkspace_force_update_response_msg* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Parkspace_force_update_response_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_force_update_response_msg& from);
+  void MergeFrom(const Parkspace_force_update_response_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_force_update_response_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 = 3;
+  bool has_error_manager() const;
+  void clear_error_manager();
+  static const int kErrorManagerFieldNumber = 3;
+  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 .message.Parkspace_info update_space_info = 4;
+  bool has_update_space_info() const;
+  void clear_update_space_info();
+  static const int kUpdateSpaceInfoFieldNumber = 4;
+  const ::message::Parkspace_info& update_space_info() const;
+  ::message::Parkspace_info* release_update_space_info();
+  ::message::Parkspace_info* mutable_update_space_info();
+  void set_allocated_update_space_info(::message::Parkspace_info* update_space_info);
+
+  // required int32 command_id = 2;
+  bool has_command_id() const;
+  void clear_command_id();
+  static const int kCommandIdFieldNumber = 2;
+  ::google::protobuf::int32 command_id() const;
+  void set_command_id(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:message.Parkspace_force_update_response_msg)
+ private:
+  void set_has_base_info();
+  void clear_has_base_info();
+  void set_has_command_id();
+  void clear_has_command_id();
+  void set_has_error_manager();
+  void clear_has_error_manager();
+  void set_has_update_space_info();
+  void clear_has_update_space_info();
+
+  // 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_;
+  ::message::Parkspace_info* update_space_info_;
+  ::google::protobuf::int32 command_id_;
+  friend struct ::protobuf_parkspace_5fallocation_5fmessage_2eproto::TableStruct;
+  friend void ::protobuf_parkspace_5fallocation_5fmessage_2eproto::InitDefaultsParkspace_force_update_response_msgImpl();
+};
+// -------------------------------------------------------------------
+
 class Parkspace_allocation_status_msg : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Parkspace_allocation_status_msg) */ {
  public:
   Parkspace_allocation_status_msg();
@@ -1439,7 +1737,7 @@ class Parkspace_allocation_status_msg : public ::google::protobuf::Message /* @@
                &_Parkspace_allocation_status_msg_default_instance_);
   }
   static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
-    8;
+    10;
 
   void Swap(Parkspace_allocation_status_msg* other);
   friend void swap(Parkspace_allocation_status_msg& a, Parkspace_allocation_status_msg& b) {
@@ -3027,6 +3325,320 @@ inline void Parkspace_release_response_msg::set_allocated_release_space_info(::m
 
 // -------------------------------------------------------------------
 
+// Parkspace_force_update_request_msg
+
+// required .message.Base_info base_info = 1;
+inline bool Parkspace_force_update_request_msg::has_base_info() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Parkspace_force_update_request_msg::set_has_base_info() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Parkspace_force_update_request_msg::clear_has_base_info() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const ::message::Base_info& Parkspace_force_update_request_msg::base_info() const {
+  const ::message::Base_info* p = base_info_;
+  // @@protoc_insertion_point(field_get:message.Parkspace_force_update_request_msg.base_info)
+  return p != NULL ? *p : *reinterpret_cast<const ::message::Base_info*>(
+      &::message::_Base_info_default_instance_);
+}
+inline ::message::Base_info* Parkspace_force_update_request_msg::release_base_info() {
+  // @@protoc_insertion_point(field_release:message.Parkspace_force_update_request_msg.base_info)
+  clear_has_base_info();
+  ::message::Base_info* temp = base_info_;
+  base_info_ = NULL;
+  return temp;
+}
+inline ::message::Base_info* Parkspace_force_update_request_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_force_update_request_msg.base_info)
+  return base_info_;
+}
+inline void Parkspace_force_update_request_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_force_update_request_msg.base_info)
+}
+
+// required int32 command_id = 2;
+inline bool Parkspace_force_update_request_msg::has_command_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void Parkspace_force_update_request_msg::set_has_command_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void Parkspace_force_update_request_msg::clear_has_command_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void Parkspace_force_update_request_msg::clear_command_id() {
+  command_id_ = 0;
+  clear_has_command_id();
+}
+inline ::google::protobuf::int32 Parkspace_force_update_request_msg::command_id() const {
+  // @@protoc_insertion_point(field_get:message.Parkspace_force_update_request_msg.command_id)
+  return command_id_;
+}
+inline void Parkspace_force_update_request_msg::set_command_id(::google::protobuf::int32 value) {
+  set_has_command_id();
+  command_id_ = value;
+  // @@protoc_insertion_point(field_set:message.Parkspace_force_update_request_msg.command_id)
+}
+
+// required .message.Parkspace_info update_space_info = 3;
+inline bool Parkspace_force_update_request_msg::has_update_space_info() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Parkspace_force_update_request_msg::set_has_update_space_info() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Parkspace_force_update_request_msg::clear_has_update_space_info() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Parkspace_force_update_request_msg::clear_update_space_info() {
+  if (update_space_info_ != NULL) update_space_info_->Clear();
+  clear_has_update_space_info();
+}
+inline const ::message::Parkspace_info& Parkspace_force_update_request_msg::update_space_info() const {
+  const ::message::Parkspace_info* p = update_space_info_;
+  // @@protoc_insertion_point(field_get:message.Parkspace_force_update_request_msg.update_space_info)
+  return p != NULL ? *p : *reinterpret_cast<const ::message::Parkspace_info*>(
+      &::message::_Parkspace_info_default_instance_);
+}
+inline ::message::Parkspace_info* Parkspace_force_update_request_msg::release_update_space_info() {
+  // @@protoc_insertion_point(field_release:message.Parkspace_force_update_request_msg.update_space_info)
+  clear_has_update_space_info();
+  ::message::Parkspace_info* temp = update_space_info_;
+  update_space_info_ = NULL;
+  return temp;
+}
+inline ::message::Parkspace_info* Parkspace_force_update_request_msg::mutable_update_space_info() {
+  set_has_update_space_info();
+  if (update_space_info_ == NULL) {
+    update_space_info_ = new ::message::Parkspace_info;
+  }
+  // @@protoc_insertion_point(field_mutable:message.Parkspace_force_update_request_msg.update_space_info)
+  return update_space_info_;
+}
+inline void Parkspace_force_update_request_msg::set_allocated_update_space_info(::message::Parkspace_info* update_space_info) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete update_space_info_;
+  }
+  if (update_space_info) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      update_space_info = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, update_space_info, submessage_arena);
+    }
+    set_has_update_space_info();
+  } else {
+    clear_has_update_space_info();
+  }
+  update_space_info_ = update_space_info;
+  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_force_update_request_msg.update_space_info)
+}
+
+// -------------------------------------------------------------------
+
+// Parkspace_force_update_response_msg
+
+// required .message.Base_info base_info = 1;
+inline bool Parkspace_force_update_response_msg::has_base_info() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Parkspace_force_update_response_msg::set_has_base_info() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Parkspace_force_update_response_msg::clear_has_base_info() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const ::message::Base_info& Parkspace_force_update_response_msg::base_info() const {
+  const ::message::Base_info* p = base_info_;
+  // @@protoc_insertion_point(field_get:message.Parkspace_force_update_response_msg.base_info)
+  return p != NULL ? *p : *reinterpret_cast<const ::message::Base_info*>(
+      &::message::_Base_info_default_instance_);
+}
+inline ::message::Base_info* Parkspace_force_update_response_msg::release_base_info() {
+  // @@protoc_insertion_point(field_release:message.Parkspace_force_update_response_msg.base_info)
+  clear_has_base_info();
+  ::message::Base_info* temp = base_info_;
+  base_info_ = NULL;
+  return temp;
+}
+inline ::message::Base_info* Parkspace_force_update_response_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_force_update_response_msg.base_info)
+  return base_info_;
+}
+inline void Parkspace_force_update_response_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_force_update_response_msg.base_info)
+}
+
+// required int32 command_id = 2;
+inline bool Parkspace_force_update_response_msg::has_command_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void Parkspace_force_update_response_msg::set_has_command_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void Parkspace_force_update_response_msg::clear_has_command_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void Parkspace_force_update_response_msg::clear_command_id() {
+  command_id_ = 0;
+  clear_has_command_id();
+}
+inline ::google::protobuf::int32 Parkspace_force_update_response_msg::command_id() const {
+  // @@protoc_insertion_point(field_get:message.Parkspace_force_update_response_msg.command_id)
+  return command_id_;
+}
+inline void Parkspace_force_update_response_msg::set_command_id(::google::protobuf::int32 value) {
+  set_has_command_id();
+  command_id_ = value;
+  // @@protoc_insertion_point(field_set:message.Parkspace_force_update_response_msg.command_id)
+}
+
+// required .message.Error_manager error_manager = 3;
+inline bool Parkspace_force_update_response_msg::has_error_manager() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Parkspace_force_update_response_msg::set_has_error_manager() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Parkspace_force_update_response_msg::clear_has_error_manager() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const ::message::Error_manager& Parkspace_force_update_response_msg::error_manager() const {
+  const ::message::Error_manager* p = error_manager_;
+  // @@protoc_insertion_point(field_get:message.Parkspace_force_update_response_msg.error_manager)
+  return p != NULL ? *p : *reinterpret_cast<const ::message::Error_manager*>(
+      &::message::_Error_manager_default_instance_);
+}
+inline ::message::Error_manager* Parkspace_force_update_response_msg::release_error_manager() {
+  // @@protoc_insertion_point(field_release:message.Parkspace_force_update_response_msg.error_manager)
+  clear_has_error_manager();
+  ::message::Error_manager* temp = error_manager_;
+  error_manager_ = NULL;
+  return temp;
+}
+inline ::message::Error_manager* Parkspace_force_update_response_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_force_update_response_msg.error_manager)
+  return error_manager_;
+}
+inline void Parkspace_force_update_response_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_force_update_response_msg.error_manager)
+}
+
+// required .message.Parkspace_info update_space_info = 4;
+inline bool Parkspace_force_update_response_msg::has_update_space_info() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void Parkspace_force_update_response_msg::set_has_update_space_info() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void Parkspace_force_update_response_msg::clear_has_update_space_info() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void Parkspace_force_update_response_msg::clear_update_space_info() {
+  if (update_space_info_ != NULL) update_space_info_->Clear();
+  clear_has_update_space_info();
+}
+inline const ::message::Parkspace_info& Parkspace_force_update_response_msg::update_space_info() const {
+  const ::message::Parkspace_info* p = update_space_info_;
+  // @@protoc_insertion_point(field_get:message.Parkspace_force_update_response_msg.update_space_info)
+  return p != NULL ? *p : *reinterpret_cast<const ::message::Parkspace_info*>(
+      &::message::_Parkspace_info_default_instance_);
+}
+inline ::message::Parkspace_info* Parkspace_force_update_response_msg::release_update_space_info() {
+  // @@protoc_insertion_point(field_release:message.Parkspace_force_update_response_msg.update_space_info)
+  clear_has_update_space_info();
+  ::message::Parkspace_info* temp = update_space_info_;
+  update_space_info_ = NULL;
+  return temp;
+}
+inline ::message::Parkspace_info* Parkspace_force_update_response_msg::mutable_update_space_info() {
+  set_has_update_space_info();
+  if (update_space_info_ == NULL) {
+    update_space_info_ = new ::message::Parkspace_info;
+  }
+  // @@protoc_insertion_point(field_mutable:message.Parkspace_force_update_response_msg.update_space_info)
+  return update_space_info_;
+}
+inline void Parkspace_force_update_response_msg::set_allocated_update_space_info(::message::Parkspace_info* update_space_info) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete update_space_info_;
+  }
+  if (update_space_info) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      update_space_info = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, update_space_info, submessage_arena);
+    }
+    set_has_update_space_info();
+  } else {
+    clear_has_update_space_info();
+  }
+  update_space_info_ = update_space_info;
+  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_force_update_response_msg.update_space_info)
+}
+
+// -------------------------------------------------------------------
+
 // Parkspace_allocation_status_msg
 
 // required .message.Base_info base_info = 1;
@@ -3178,6 +3790,10 @@ Parkspace_allocation_status_msg::parkspace_info() const {
 
 // -------------------------------------------------------------------
 
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
 
 // @@protoc_insertion_point(namespace_scope)
 

message/parkspace_allocation_message.proto

@@ -6,6 +6,7 @@ import "message_base.proto";
 // 1.分配车位
 // 2.查询车辆位置
 // 3.解锁车位
+// 4.手动操作修改车位状态
 
 message Car_info
 {
@@ -89,7 +90,7 @@ message Parkspace_release_request_msg
     required Parkspace_info             release_space_info=3;   //待释放车位信息
 }
 
-//查询车辆位置反馈
+//解锁车位反馈
 message Parkspace_release_response_msg
 {
     required Base_info                  base_info=1;            //消息类型
@@ -98,6 +99,24 @@ message Parkspace_release_response_msg
     required Parkspace_info             release_space_info=4;   //待释放车位信息
 }
 
+// 4.手动操作修改车位状态
+message Parkspace_force_update_request_msg
+{
+    required Base_info                  base_info=1;            //消息类型
+    required int32                      command_id=2;           //指令唯一标识符id
+    required Parkspace_info             update_space_info=3;    //待手动修改车位信息，通过id定位
+}
+
+//手动操作反馈
+message Parkspace_force_update_response_msg
+{
+    required Base_info                  base_info=1;            //消息类型
+    required int32                      command_id=2;           //指令唯一标识符id
+    required Error_manager              error_manager=3;        //分配成功与否标志
+    required Parkspace_info             update_space_info=4;    //已修改后的车位信息
+}
+
+
 // 车位心跳状态信息
 message Parkspace_allocation_status_msg
 {

parkspace_allocation/parkspace_allocation_communicator.cpp

@@ -1,8 +1,6 @@
-//
-// Created by zx on 2020/6/18.
-//
 
 #include "parkspace_allocation_communicator.h"
+#include "parkspace_allocator.h"
 
 Parkspace_allocation_communicator::Parkspace_allocation_communicator()
 {
@@ -31,9 +29,9 @@ Error_manager Parkspace_allocation_communicator::update_parkspace_status(message
 Error_manager Parkspace_allocation_communicator::update_parkspace_status(int parkspace_id, message::Parkspace_info parkspace_info)
 {
     std::lock_guard<std::mutex> lck(m_status_mutex);
-    if(m_parkspace_status_msg.parkspace_info_size() >= parkspace_id)
+    if(m_parkspace_status_msg.parkspace_info_size() > parkspace_id)
     {
-        m_parkspace_status_msg.mutable_parkspace_info(parkspace_id-1)->CopyFrom(parkspace_info);
+        m_parkspace_status_msg.mutable_parkspace_info(parkspace_id)->CopyFrom(parkspace_info);
     }
     return SUCCESS;
 }
@@ -73,6 +71,10 @@ Error_manager Parkspace_allocation_communicator::encapsulate_msg(Communication_m
         {
             break;
         }
+        case Communication_message::eParkspace_force_update_response_msg:
+        {
+            break;
+        }
         default:
             return Error_manager(PARKSPACE_ALLOCATOR_MSG_RESPONSE_TYPE_ERROR, NEGLIGIBLE_ERROR, "Parkspace_allocation_communicator::message response type error");
     }
@@ -84,115 +86,7 @@ Error_manager Parkspace_allocation_communicator::encapsulate_msg(Communication_m
 //重载执行消息，父类线程通过check_msg接收到车位分配请求后调用，解析内容并进行相应处理
 Error_manager Parkspace_allocation_communicator::execute_msg(Communication_message *p_msg)
 {
-    if (p_msg == nullptr)
-        return Error_manager(POINTER_IS_NULL, CRITICAL_ERROR, "parkspace allocation response msg pointer is null");
-    //车位分配request消息
-    switch (p_msg->get_message_type())
-    {
-        ///测量结果反馈消息
-        case Communication_message::eParkspace_allocation_request_msg:
-        {
-            message::Parkspace_allocation_request_msg request;
-            request.ParseFromString(p_msg->get_message_buf());
-            std::cout<<"allocation request, car license: "<<request.car_info().license()<<std::endl;
-
-            //根据请求的信息反馈分配的车位,并封装发送
-            //!!!!!此处跳过外部处理与调用的过程，直接在内部调用，发送分配结果用于测试，目前一直发布第一个车位
-            message::Parkspace_allocation_response_msg response_msg;
-            message::Base_info t_response_header;
-            message::Error_manager t_error;
-            message::Parkspace_info t_allocated_space;
-            t_response_header.set_msg_type(message::Message_type::eParkspace_allocation_response_msg);
-            t_response_header.set_timeout_ms(1000);
-            t_response_header.set_sender(message::Communicator::eParkspace_allocator);
-            t_response_header.set_receiver(message::Communicator::eMain);
-            if(m_parkspace_status_msg.parkspace_info_size()>0)
-            {
-                t_error.set_error_code(0);
-                t_error.set_error_level(message::Error_level::NORMAL);
-                t_allocated_space.CopyFrom(m_parkspace_status_msg.parkspace_info(0));
-            } else{
-                t_error.set_error_code(1);
-                t_error.set_error_level(message::Error_level::MAJOR_ERROR);
-            }
-            response_msg.mutable_base_info()->CopyFrom(t_response_header);
-            response_msg.set_command_id(request.command_id());
-            response_msg.mutable_error_manager()->CopyFrom(t_error);
-            response_msg.mutable_allocated_space_info()->CopyFrom(t_allocated_space);
-            Communication_message* response=new Communication_message();
-            response->reset(t_response_header, response_msg.SerializeAsString());
-            return send_response(response);
-            // return SUCCESS;
-        }
-        case Communication_message::eParkspace_search_request_msg:
-        {
-            message::Parkspace_search_request_msg request;
-            request.ParseFromString(p_msg->get_message_buf());
-            std::cout<<"search request, car license: "<<request.car_info().license()<<std::endl;
-
-            //根据车辆凭证信息查询车辆位置
-            //!!!!!此处跳过外部处理与调用的过程，直接在内部调用，发送分配结果用于测试，目前一直发布第一个车位
-            message::Parkspace_search_response_msg response_msg;
-            message::Base_info t_response_header;
-            message::Error_manager t_error;
-            message::Parkspace_info t_car_position;
-            t_response_header.set_msg_type(message::Message_type::eParkspace_search_response_msg);
-            t_response_header.set_timeout_ms(1000);
-            t_response_header.set_sender(message::Communicator::eParkspace_allocator);
-            t_response_header.set_receiver(message::Communicator::eMain);
-            if (m_parkspace_status_msg.parkspace_info_size() > 1)
-            {
-                t_error.set_error_code(0);
-                t_error.set_error_level(message::Error_level::NORMAL);
-                t_car_position.CopyFrom(m_parkspace_status_msg.parkspace_info(1));
-            }
-            else
-            {
-                t_error.set_error_code(1);
-                t_error.set_error_level(message::Error_level::MAJOR_ERROR);
-            }
-            response_msg.mutable_base_info()->CopyFrom(t_response_header);
-            response_msg.set_command_id(request.command_id());
-            response_msg.mutable_error_manager()->CopyFrom(t_error);
-            response_msg.mutable_car_position()->CopyFrom(t_car_position);
-            Communication_message* response=new Communication_message();
-            response->reset(t_response_header, response_msg.SerializeAsString());
-            return send_response(response);
-        }
-        case Communication_message::eParkspace_release_request_msg:
-        {
-            message::Parkspace_release_request_msg request;
-            request.ParseFromString(p_msg->get_message_buf());
-            std::cout<<"release request, parkspace id: "<<request.release_space_info().parkspace_id()<<std::endl;
-
-            //根据车位信息定位待释放车位位置，车辆凭证号用于校验
-            //!!!!!此处跳过外部处理与调用的过程，直接在内部调用，发送分配结果用于测试，目前一直发布第一个车位
-            message::Parkspace_release_response_msg response_msg;
-            message::Base_info t_response_header;
-            message::Error_manager t_error;
-            t_response_header.set_msg_type(message::Message_type::eParkspace_release_response_msg);
-            t_response_header.set_timeout_ms(1000);
-            t_response_header.set_sender(message::Communicator::eParkspace_allocator);
-            t_response_header.set_receiver(message::Communicator::eMain);
-            if (m_parkspace_status_msg.parkspace_info_size() > 0)
-            {
-                t_error.set_error_code(0);
-                t_error.set_error_level(message::Error_level::NORMAL);
-            }
-            else
-            {
-                t_error.set_error_code(1);
-                t_error.set_error_level(message::Error_level::MAJOR_ERROR);
-            }
-            response_msg.mutable_base_info()->CopyFrom(t_response_header);
-            response_msg.set_command_id(request.command_id());
-            response_msg.mutable_error_manager()->CopyFrom(t_error);
-            response_msg.mutable_release_space_info()->CopyFrom(request.release_space_info());
-            Communication_message* response=new Communication_message();
-            response->reset(t_response_header, response_msg.SerializeAsString());
-            return send_response(response);
-        }
-    }
+    return Parkspace_allocator::get_instance_references().execute_msg(p_msg);
     return Error_manager(PARKSPACE_ALLOCATOR_MSG_RESPONSE_TYPE_ERROR, NEGLIGIBLE_ERROR, "parkspace allocation wrong request type");
 }
 
@@ -211,6 +105,8 @@ Error_manager Parkspace_allocation_communicator::check_msg(Communication_message
                 return Error_code::SUCCESS;
             case Communication_message::Message_type::eParkspace_release_request_msg:
                 return Error_code::SUCCESS;
+            case Communication_message::Message_type::eParkspace_force_update_request_msg:
+                return Error_code::SUCCESS;
             default:
                 return Error_code::INVALID_MESSAGE;
         }
@@ -223,33 +119,17 @@ Error_manager Parkspace_allocation_communicator::check_executer(Communication_me
 	//同时也要判断是否超时, 超时返回 COMMUNICATION_ANALYSIS_TIME_OUT
 	//如果处理器正在忙别的, 那么返回 COMMUNICATION_EXCUTER_IS_BUSY
 
+	Error_manager t_error;
 	if ( p_msg->is_over_time() )
 	{
-		std::cout << "Communication_socket_base::check_msg  p_buf =  " << p_msg->get_message_buf() << std::endl;
-		std::cout << "Communication_socket_base::check_msg   size =  " << p_msg->get_message_buf().size() << std::endl;
 		std::cout << "COMMUNICATION_ANALYSIS_TIME_OUT , " << std::endl;
+		//超时:接收方不做处理,发送方会进行超时处理
 		return Error_code::COMMUNICATION_ANALYSIS_TIME_OUT;
 	}
 	else
 	{
-		bool executer_is_ready = true;
-		//通过 p_msg->get_message_type() 和 p_msg->get_receiver() 找到处理模块的实例对象, 查询执行人是否可以处理这条消息
-		//这里子类重载时, 增加判断逻辑, 以后再写.
-		// std::cout << "Communication_socket_base::check_msg  p_buf =  " << p_msg->get_message_buf() << std::endl;
-		// std::cout << "Communication_socket_base::check_msg   size =  " << p_msg->get_message_buf().size() << std::endl;
-
-		if ( executer_is_ready )
-		{
-			// std::cout << "executer_is_ready , " << std::endl;
-			return Error_code::SUCCESS;
-		}
-		else
-		{
-			std::cout << "executer_is_busy , " << std::endl;
-			return Error_code::COMMUNICATION_EXCUTER_IS_BUSY;
-		}
+		return Parkspace_allocator::get_instance_references().check_executer(p_msg);
 	}
-
 	return Error_code::SUCCESS;
 }
 

parkspace_allocation/parkspace_allocation_communicator.h

@@ -12,8 +12,6 @@
 #include "parkspace_allocation_message.pb.h"
 #include "error_code.h"
 
-#include "thread_safe_map.h"
-
 class Parkspace_allocation_communicator: public Singleton<Parkspace_allocation_communicator>, public Communication_socket_base
 {
     friend Singleton<Parkspace_allocation_communicator>;
@@ -23,7 +21,7 @@ public:
     Error_manager send_response(Communication_message* message);
     //更新所有车位状态，现有状态将被全部覆盖，车位数量可能变动
     Error_manager update_parkspace_status(message::Parkspace_allocation_status_msg message);
-    //更新某个车位状态，不修改车位数量，车位按编号从1开始
+    //更新某个车位状态，不修改车位数量，车位按编号从0开始
     Error_manager update_parkspace_status(int parkspace_id, message::Parkspace_info parkspace_info);
     //获取所有车位状态
     message::Parkspace_allocation_status_msg get_status();

parkspace_allocation/parkspace_allocator.cpp

@@ -0,0 +1,382 @@
+/*
+ * @Description: 车位分配算法模块，使用单例模式，接收外部请求并通过调用通信块接口发送反馈
+ * @Author: yct
+ * @Date: 2020-07-10 11:02:40
+ * @LastEditTime: 2020-07-10 16:57:14
+ * @LastEditors: yct
+ */ 
+
+#include "parkspace_allocator.h"
+#include "parkspace_allocation_communicator.h"
+
+Parkspace_allocator::Parkspace_allocator()
+{
+
+}
+
+Parkspace_allocator::~Parkspace_allocator()
+{
+	parkspace_allocator_uninit();
+}
+
+//初始化
+Error_manager Parkspace_allocator::parkspace_allocator_init(int threads_size)
+{
+	m_thread_pool.thread_pool_init(threads_size);
+	m_current_status = eParkspace_allocator_normal;
+	return Error_code::SUCCESS;
+}
+
+//反初始化
+Error_manager Parkspace_allocator::parkspace_allocator_uninit()
+{
+	m_thread_pool.thread_pool_uninit();
+	m_current_status = eParkspace_allocator_unknown;
+	return Error_code::SUCCESS;
+}
+
+//检查执行者的状态, 判断能否处理这条消息,
+Error_manager Parkspace_allocator::check_executer(Communication_message* p_msg)
+{
+	if ( p_msg == NULL )
+	{
+		return Error_manager(Error_code::POINTER_IS_NULL, Error_level::MINOR_ERROR,
+							 "  POINTER IS NULL ");
+	}
+
+	Error_manager t_error = SUCCESS;
+
+	return t_error;
+}
+
+//处理消息的执行函数
+Error_manager Parkspace_allocator::execute_msg(Communication_message* p_msg)
+{
+	if ( p_msg == nullptr )
+	{
+		return Error_manager(Error_code::POINTER_IS_NULL, Error_level::MINOR_ERROR,
+							 "  POINTER IS NULL ");
+	}
+	switch ( p_msg->get_message_type() )
+	{
+		///车位分配请求消息
+        case Communication_message::eParkspace_allocation_request_msg:
+        {
+            message::Parkspace_allocation_request_msg request;
+            bool result = request.ParseFromString(p_msg->get_message_buf());
+            LOG(INFO)<<"allocation request, car license: "<<request.car_info().license();
+            if(!result)
+            {
+                return Error_manager(Error_code::PARKSPACE_ALLOCATOR_MSG_PARSE_ERROR, Error_level::MINOR_ERROR,
+			    					" message::Parkspace_allocation_request_msg  ParseFromString error ");
+            }
+            //往线程池添加执行任务, 之后会唤醒一个线程去执行他.
+            m_thread_pool.enqueue(&Parkspace_allocator::execute_for_allocate, this,
+            request.car_info(), request.terminal_id(), request.command_id());
+            return SUCCESS;
+        }
+        // 车位查询请求消息
+        case Communication_message::eParkspace_search_request_msg:
+        {
+            message::Parkspace_search_request_msg request;
+            bool result = request.ParseFromString(p_msg->get_message_buf());
+            LOG(INFO)<<"search request, car license: "<<request.car_info().license();
+            if(!result)
+            {
+                return Error_manager(Error_code::PARKSPACE_ALLOCATOR_MSG_PARSE_ERROR, Error_level::MINOR_ERROR,
+			    					" message::Parkspace_search_request_msg  ParseFromString error ");
+            }
+            //往线程池添加执行任务, 之后会唤醒一个线程去执行他.
+            m_thread_pool.enqueue(&Parkspace_allocator::execute_for_search, this, request.car_info(), request.command_id());
+            return SUCCESS;
+        }
+        // 车位释放请求消息
+        case Communication_message::eParkspace_release_request_msg:
+        {
+            message::Parkspace_release_request_msg request;
+            bool result = request.ParseFromString(p_msg->get_message_buf());
+            LOG(INFO)<<"release request, parkspace id: "<<request.release_space_info().parkspace_id();
+            if(!result)
+            {
+                return Error_manager(Error_code::PARKSPACE_ALLOCATOR_MSG_PARSE_ERROR, Error_level::MINOR_ERROR,
+			    					" message::Parkspace_release_request_msg  ParseFromString error ");
+            }
+            //往线程池添加执行任务, 之后会唤醒一个线程去执行他.
+            m_thread_pool.enqueue(&Parkspace_allocator::execute_for_release, this, request.release_space_info(), request.command_id());
+            return SUCCESS;
+        }
+        // 车位手动更新请求消息
+        case Communication_message::eParkspace_force_update_request_msg:
+        {
+            message::Parkspace_force_update_request_msg request;
+            bool result = request.ParseFromString(p_msg->get_message_buf());
+            LOG(INFO)<<"force update request, parkspace id: "<<request.update_space_info().parkspace_id();
+            if(!result)
+            {
+                return Error_manager(Error_code::PARKSPACE_ALLOCATOR_MSG_PARSE_ERROR, Error_level::MINOR_ERROR,
+			    					" message::Parkspace_force_update_request_msg  ParseFromString error ");
+            }
+            //往线程池添加执行任务, 之后会唤醒一个线程去执行他.
+            m_thread_pool.enqueue(&Parkspace_allocator::execute_for_force_update, this, request.update_space_info(), request.command_id());
+            return SUCCESS;
+        }
+	}
+	return Error_code::PARKSPACE_ALLOCATOR_MSG_REQUEST_TYPE_ERROR;
+}
+
+//判断是否为待机，如果已经准备好，则可以执行任务。
+bool Parkspace_allocator::is_ready()
+{
+	if ( m_current_status == eParkspace_allocator_normal && m_thread_pool.thread_is_full_load() == false )
+	{
+	    return true;
+	}
+	else
+	{
+		return false;
+	}
+}
+
+Parkspace_allocator::parkspace_allocator_status Parkspace_allocator::get_parkspace_allocator_status()
+{
+	return m_current_status;
+}
+
+//分配车位线程函数
+void Parkspace_allocator::execute_for_allocate(message::Car_info car_info, int terminal_id, int command_id)
+{
+    std::lock_guard<std::mutex> lck(m_mutex);
+    LOG(INFO) << "分配";
+    //根据请求的信息反馈分配的车位,并封装发送
+    message::Parkspace_allocation_response_msg response_msg;
+    message::Base_info t_response_header;
+    t_response_header.set_msg_type(message::Message_type::eParkspace_allocation_response_msg);
+    t_response_header.set_timeout_ms(1000);
+    t_response_header.set_sender(message::Communicator::eParkspace_allocator);
+    t_response_header.set_receiver(message::Communicator::eMain);
+    message::Error_manager t_error;
+    message::Parkspace_info t_allocated_space;
+    //获取当前所有车位状态，分配车位
+    message::Parkspace_allocation_status_msg t_current_parkspace_status = Parkspace_allocation_communicator::get_instance_references().get_status();
+    int index = -1;
+    if(t_current_parkspace_status.parkspace_info_size()<=0)
+    {
+        t_error.set_error_code(PARKSPACE_ALLOCATOR_SPACE_EMPTY);
+        t_error.set_error_level(message::Error_level::MAJOR_ERROR);
+        LOG(ERROR) << "无车位";
+    }
+    else
+    {
+        
+        for (size_t i = 0; i < t_current_parkspace_status.parkspace_info_size(); i++)
+        {
+            // 找到高于车高且空闲车位，则分配
+            if (t_current_parkspace_status.parkspace_info(i).height() > car_info.car_height() 
+            && t_current_parkspace_status.parkspace_info(i).width() > car_info.car_width() 
+            && t_current_parkspace_status.parkspace_info(i).parkspace_status() == message::Parkspace_status::eParkspace_empty)
+            {
+                index = i;
+                break;
+            }
+        }
+        
+        if(index<0){
+            t_error.set_error_code(PARKSPACE_ALLOCATOR_ALLOCATE_FAILED);
+            t_error.set_error_level(message::Error_level::MAJOR_ERROR);
+            t_allocated_space.CopyFrom(t_current_parkspace_status.parkspace_info(0));
+            LOG(WARNING) << "分配车位失败";
+        }else{
+            t_error.set_error_code(SUCCESS);
+            t_error.set_error_level(message::Error_level::NORMAL);
+            message::Parkspace_info t_space_to_lock = t_current_parkspace_status.parkspace_info(index);
+            t_space_to_lock.set_parkspace_status(message::Parkspace_status::eParkspace_occupied);
+            t_space_to_lock.mutable_car_info()->CopyFrom(car_info);
+            t_allocated_space.CopyFrom(t_space_to_lock);
+            // 分配车位后更新车位状态
+            Parkspace_allocation_communicator::get_instance_references().update_parkspace_status(index, t_space_to_lock);
+            LOG(INFO) << "第"<<index<<"号位占用, id: "<<t_space_to_lock.parkspace_id();
+        }
+    }
+    response_msg.mutable_base_info()->CopyFrom(t_response_header);
+    response_msg.set_command_id(command_id);
+    response_msg.mutable_error_manager()->CopyFrom(t_error);
+    response_msg.mutable_allocated_space_info()->CopyFrom(t_allocated_space);
+    Communication_message* response=new Communication_message();
+    response->reset(t_response_header, response_msg.SerializeAsString());
+    Parkspace_allocation_communicator::get_instance_references().send_response(response);
+}
+
+//查询车位线程函数
+void Parkspace_allocator::execute_for_search(message::Car_info car_info, int command_id)
+{
+    std::lock_guard<std::mutex> lck(m_mutex);
+    LOG(INFO) << "查询";
+    //根据车辆凭证信息查询车辆位置
+    //!!!!!此处跳过外部处理与调用的过程，直接在内部调用，发送分配结果用于测试，目前一直发布第一个车位
+    message::Parkspace_search_response_msg response_msg;
+    message::Base_info t_response_header;
+    message::Error_manager t_error;
+    message::Parkspace_info t_car_position;
+    t_response_header.set_msg_type(message::Message_type::eParkspace_search_response_msg);
+    t_response_header.set_timeout_ms(1000);
+    t_response_header.set_sender(message::Communicator::eParkspace_allocator);
+    t_response_header.set_receiver(message::Communicator::eMain);
+    //获取当前所有车位状态，查询车辆位置
+    message::Parkspace_allocation_status_msg t_current_parkspace_status = Parkspace_allocation_communicator::get_instance_references().get_status();
+    int index = -1;
+    if(t_current_parkspace_status.parkspace_info_size()<=0)
+    {
+        t_error.set_error_code(PARKSPACE_ALLOCATOR_SPACE_EMPTY);
+        t_error.set_error_level(message::Error_level::MAJOR_ERROR);
+        LOG(ERROR) << "无车位";
+    }
+    else
+    {
+        for (size_t i = 0; i < t_current_parkspace_status.parkspace_info_size(); i++)
+        {
+            // 找到凭证号/号牌对应车位，记录
+            if (t_current_parkspace_status.parkspace_info(i).has_car_info() 
+            && t_current_parkspace_status.parkspace_info(i).car_info().license() == car_info.license() 
+            && t_current_parkspace_status.parkspace_info(i).parkspace_status() == message::Parkspace_status::eParkspace_occupied)
+            {
+                index = i;
+                break;
+            }
+        }
+        if(index<0){
+            t_error.set_error_code(PARKSPACE_ALLOCATOR_SEARCH_FAILED);
+            t_error.set_error_level(message::Error_level::MAJOR_ERROR);
+            LOG(INFO) << "查询车位失败";
+        }else{
+            t_error.set_error_code(SUCCESS);
+            t_error.set_error_level(message::Error_level::NORMAL);
+            message::Parkspace_info t_space_searching = t_current_parkspace_status.parkspace_info(index);
+            t_car_position.CopyFrom(t_space_searching);
+            LOG(INFO) << "车辆"<<car_info.license() <<"在第"<<index<<"号位, id: "<<t_space_searching.parkspace_id();
+        }
+    }
+    response_msg.mutable_base_info()->CopyFrom(t_response_header);
+    response_msg.set_command_id(command_id);
+    response_msg.mutable_error_manager()->CopyFrom(t_error);
+    response_msg.mutable_car_position()->CopyFrom(t_car_position);
+    Communication_message* response=new Communication_message();
+    response->reset(t_response_header, response_msg.SerializeAsString());
+    Parkspace_allocation_communicator::get_instance_references().send_response(response);
+}
+
+//释放车位线程函数
+void Parkspace_allocator::execute_for_release(message::Parkspace_info space_info, int command_id)
+{
+    std::lock_guard<std::mutex> lck(m_mutex);
+    LOG(INFO) << "释放";
+    //根据车位信息定位待释放车位位置，车辆凭证号用于校验
+    //!!!!!此处跳过外部处理与调用的过程，直接在内部调用，发送分配结果用于测试，目前一直发布第一个车位
+    message::Parkspace_release_response_msg response_msg;
+    message::Base_info t_response_header;
+    message::Error_manager t_error;
+    message::Parkspace_info t_release_space;
+    //获取当前所有车位状态，找到待释放的车位
+    message::Parkspace_allocation_status_msg t_current_parkspace_status = Parkspace_allocation_communicator::get_instance_references().get_status();
+    int index = -1;
+    if(t_current_parkspace_status.parkspace_info_size()<=0)
+    {
+        t_error.set_error_code(PARKSPACE_ALLOCATOR_SPACE_EMPTY);
+        t_error.set_error_level(message::Error_level::MAJOR_ERROR);
+        LOG(ERROR) << "无车位";
+    }
+    else if (!space_info.has_car_info())
+    {
+        t_error.set_error_code(PARKSPACE_ALLOCATOR_RELEASE_FAILED);
+        t_error.set_error_level(message::Error_level::MAJOR_ERROR);
+        LOG(WARNING) << "传入待释放车位无车辆信息";
+    }
+    else
+    {
+        for (size_t i = 0; i < t_current_parkspace_status.parkspace_info_size(); i++)
+        {
+            // 找到高于车高且空闲车位，则分配
+            if (t_current_parkspace_status.parkspace_info(i).parkspace_id() == space_info.parkspace_id()
+            && t_current_parkspace_status.parkspace_info(i).parkspace_status() == message::Parkspace_status::eParkspace_occupied
+            && t_current_parkspace_status.parkspace_info(i).has_car_info()
+            && t_current_parkspace_status.parkspace_info(i).car_info().license() == space_info.car_info().license())
+            {
+                index = i;
+                break;
+            }
+        }
+        if(index<0){
+            t_error.set_error_code(PARKSPACE_ALLOCATOR_RELEASE_FAILED);
+            t_error.set_error_level(message::Error_level::MAJOR_ERROR);
+            LOG(WARNING) << "释放车位失败";
+        }else{
+            t_error.set_error_code(SUCCESS);
+            t_error.set_error_level(message::Error_level::NORMAL);
+            message::Parkspace_info t_space_to_release = t_current_parkspace_status.parkspace_info(index);
+            t_space_to_release.set_parkspace_status(message::Parkspace_status::eParkspace_empty);
+            t_release_space.CopyFrom(t_space_to_release);
+            // 分配车位后更新车位状态
+            Parkspace_allocation_communicator::get_instance_references().update_parkspace_status(index, t_space_to_release);
+            LOG(INFO) << "第"<<index<<"号位释放, id: "<<t_space_to_release.parkspace_id();
+        }
+    }
+    response_msg.mutable_base_info()->CopyFrom(t_response_header);
+    response_msg.set_command_id(command_id);
+    response_msg.mutable_error_manager()->CopyFrom(t_error);
+    response_msg.mutable_release_space_info()->CopyFrom(t_release_space);
+    Communication_message* response=new Communication_message();
+    response->reset(t_response_header, response_msg.SerializeAsString());
+    Parkspace_allocation_communicator::get_instance_references().send_response(response);
+}
+
+//强制更新车位信息线程函数
+void Parkspace_allocator::execute_for_force_update(message::Parkspace_info space_info, int command_id)
+{
+    std::lock_guard<std::mutex> lck(m_mutex);
+    LOG(INFO) << "手动";
+    //根据车位信息定位待释放车位位置，车辆凭证号用于校验
+    //!!!!!此处跳过外部处理与调用的过程，直接在内部调用，发送分配结果用于测试，目前一直发布第一个车位
+    message::Parkspace_force_update_response_msg response_msg;
+    message::Base_info t_response_header;
+    message::Error_manager t_error;
+    message::Parkspace_info t_update_space;
+    //获取当前所有车位状态，找到待释放的车位
+    message::Parkspace_allocation_status_msg t_current_parkspace_status = Parkspace_allocation_communicator::get_instance_references().get_status();
+    int index = -1;
+    if(t_current_parkspace_status.parkspace_info_size()<=0)
+    {
+        t_error.set_error_code(PARKSPACE_ALLOCATOR_SPACE_EMPTY);
+        t_error.set_error_level(message::Error_level::MAJOR_ERROR);
+        LOG(ERROR) << "无车位";
+    }
+    else
+    {
+        for (size_t i = 0; i < t_current_parkspace_status.parkspace_info_size(); i++)
+        {
+            // 找到高于车高且空闲车位，则分配
+            if (t_current_parkspace_status.parkspace_info(i).parkspace_id() == space_info.parkspace_id())
+            {
+                index = i;
+                break;
+            }
+        }
+        if(index<0){
+            t_error.set_error_code(PARKSPACE_ALLOCATOR_FORCE_UPDATE_FAILED);
+            t_error.set_error_level(message::Error_level::MAJOR_ERROR);
+            LOG(WARNING) << "手动更新车位失败";
+        }else{
+            t_error.set_error_code(SUCCESS);
+            t_error.set_error_level(message::Error_level::NORMAL);
+            t_update_space.CopyFrom(space_info);
+            // 分配车位后更新车位状态
+            Parkspace_allocation_communicator::get_instance_references().update_parkspace_status(index, t_update_space);
+            LOG(INFO) << "第"<<index<<"号位已手动更新, id: "<<t_update_space.parkspace_id();
+        }
+    }
+    response_msg.mutable_base_info()->CopyFrom(t_response_header);
+    response_msg.set_command_id(command_id);
+    response_msg.mutable_error_manager()->CopyFrom(t_error);
+    response_msg.mutable_update_space_info()->CopyFrom(t_update_space);
+    Communication_message* response=new Communication_message();
+    response->reset(t_response_header, response_msg.SerializeAsString());
+    Parkspace_allocation_communicator::get_instance_references().send_response(response);
+}

parkspace_allocation/parkspace_allocator.h

@@ -0,0 +1,70 @@
+/*
+ * @Description: 车位分配算法模块，使用单例模式，接收外部请求并通过调用通信块接口发送反馈
+ * @Author: yct
+ * @Date: 2020-07-10 09:25:56
+ * @LastEditTime: 2020-07-10 15:24:08
+ * @LastEditors: yct
+ */ 
+
+#ifndef PARKSPACE_ALLOCATOR_HH
+#define PARKSPACE_ALLOCATOR_HH
+
+#include "../tool/thread_pool.h"
+#include "../tool/singleton.h"
+#include "../error_code/error_code.h"
+#include "../communication/communication_message.h"
+#include "../message/parkspace_allocation_message.pb.h"
+
+class Parkspace_allocator : public Singleton<Parkspace_allocator>
+{
+    friend class Singleton<Parkspace_allocator>;
+public:
+    enum parkspace_allocator_status
+    {
+        eParkspace_allocator_unknown,
+        eParkspace_allocator_normal,
+        eParkspace_allocator_fault
+    };
+
+private:
+    // 父类的构造函数必须保护，子类的构造函数必须私有。
+    Parkspace_allocator();
+public:
+    // 必须关闭拷贝构造和赋值构造，只能通过 get_instance 函数来进行操作唯一的实例。
+    Parkspace_allocator(const Parkspace_allocator &) = delete;
+    Parkspace_allocator &operator=(const Parkspace_allocator &) = delete;
+    ~Parkspace_allocator();
+public://API functions
+	//初始化
+	Error_manager parkspace_allocator_init(int threads_size);
+	//反初始化
+	Error_manager parkspace_allocator_uninit();
+
+	//检查执行者的状态, 判断能否处理这条消息,
+	Error_manager check_executer(Communication_message* p_msg);
+	//处理消息的执行函数
+	Error_manager execute_msg(Communication_message* p_msg);
+
+	//判断是否为待机，如果已经准备好，则可以执行任务。
+	bool is_ready();
+
+    // 获取模块状态
+    parkspace_allocator_status get_parkspace_allocator_status();
+
+public://execute_msg创建各线程进行处理
+	//分配车位线程函数
+    void execute_for_allocate(message::Car_info car_info, int terminal_id, int command_id);
+    //查询车位线程函数
+    void execute_for_search(message::Car_info car_info, int command_id);
+    //释放车位线程函数
+    void execute_for_release(message::Parkspace_info space_info, int command_id);
+    //强制更新车位信息线程函数
+    void execute_for_force_update(message::Parkspace_info space_info, int command_id);
+
+private:
+    parkspace_allocator_status  m_current_status;               //分配器当前状态
+	Thread_pool 				m_thread_pool;					//执行多任务的线程池
+    std::mutex                  m_mutex;                        //车位变动锁
+};
+
+#endif // !PARKSPACE_ALLOCATOR_HH

test/parkspace_client.cpp

@@ -2,7 +2,7 @@
  * @Description: 模拟主程序发送车位分配请求，并监听状态信息
  * @Author: yct
  * @Date: 2020-07-08 15:44:43
- * @LastEditTime: 2020-07-09 17:32:55
+ * @LastEditTime: 2020-07-10 17:06:26
  * @LastEditors: yct
  */
 
@@ -40,7 +40,7 @@ std::string send_allocation_request(int n)
     return request.SerializeAsString();
 }
 
-std::string send_search_requests(int n)
+std::string send_search_requests(int n, std::string license="鄂A12345")
 {
     // 发送车位查询请求
     message::Error_manager error_code;
@@ -54,7 +54,7 @@ std::string send_search_requests(int n)
     base_info.set_timeout_ms(2000);
     car_info.set_car_height(2.0);
     car_info.set_car_width(2.0);
-    car_info.set_license("鄂A23456");
+    car_info.set_license(license);
 
     request.mutable_base_info()->CopyFrom(base_info);
     request.set_command_id(n);
@@ -79,7 +79,7 @@ std::string send_release_request(int n)
     base_info.set_timeout_ms(2000);
     car_info.set_car_height(1.5);
     car_info.set_car_width(1.85);
-    car_info.set_license("鄂A34567");
+    car_info.set_license("鄂A12345");
     space_info.set_parkspace_id(1);
     space_info.set_index(1);
     space_info.set_direction(message::Direction::eForward);
@@ -87,6 +87,7 @@ std::string send_release_request(int n)
     space_info.set_width(1.5);
     space_info.set_height(1.5);
     space_info.set_parkspace_status(message::Parkspace_status::eParkspace_occupied);
+    space_info.mutable_car_info()->CopyFrom(car_info);
 
     request.mutable_base_info()->CopyFrom(base_info);
     request.set_command_id(n);
@@ -100,26 +101,48 @@ int main()
 {
     nnxx::socket socket{nnxx::SP, nnxx::BUS};
     // socket.bind("tcp://127.0.0.1:7000");
-    socket.connect("tcp://127.0.0.1:7001");
+    socket.connect("tcp://192.168.2.108:7001");
     int n = 0;
     message::Base_msg base_msg;
 
-    usleep(1000*3000);
+    usleep(1000 * 3000);
+
+    std::string alloc_req = send_allocation_request(1);
+    socket.send(alloc_req);
+    alloc_req = send_allocation_request(1);
+    socket.send(alloc_req);
+    // std::string alloc_req = send_allocation_request(2);
+    // socket.send(alloc_req);
+    // std::string alloc_req = send_allocation_request(3);
+    // socket.send(alloc_req);
+    // std::string alloc_req = send_allocation_request(4);
+    // socket.send(alloc_req);
+    
+    std::string search_req = send_search_requests(2);
+    socket.send(search_req);
+    std::string release_req = send_release_request(2);
+    socket.send(release_req);
+
+    usleep(1000*200);
+    search_req = send_search_requests(3);
+    socket.send(search_req);
+    release_req = send_release_request(3);
+    socket.send(release_req);
 
     while (1)
     {
         // std::string alloc_req = send_allocation_request(n);
         // std::string search_req = send_search_requests(n);
 
-        std::string alloc_req = send_allocation_request(n);
-        socket.send(alloc_req);
-        usleep(1000*2000);
-        std::string search_req = send_search_requests(n);
-        socket.send(search_req);
-        usleep(1000*2000);
-        std::string release_req = send_release_request(n);
-        socket.send(release_req);
-        usleep(1000*2000);
+        // std::string alloc_req = send_allocation_request(n);
+        // socket.send(alloc_req);
+        // usleep(1000*2000);
+        // std::string search_req = send_search_requests(n);
+        // socket.send(search_req);
+        // // usleep(1000*2000);
+        // std::string release_req = send_release_request(n);
+        // socket.send(release_req);
+        // usleep(1000*2000);
 
         for (size_t i = 0; i < 5; i++)
         {
@@ -165,6 +188,6 @@ int main()
 
         // std::this_thread::yield();
         n++;
-        usleep(1000 * 5000);
+        usleep(1000 * 1000);
     }
 }

test/test_parkspace_sample.cpp

@@ -2,10 +2,11 @@
  * @Description: 测试车位分配模块通信情况
  * @Author: yct
  * @Date: 2020-07-08 15:51:46
- * @LastEditTime: 2020-07-09 17:24:24
+ * @LastEditTime: 2020-07-10 17:14:16
  * @LastEditors: yct
  */ 
 #include "../parkspace_allocation/parkspace_allocation_communicator.h"
+#include "../parkspace_allocation/parkspace_allocator.h"
 
 int main()
 {
@@ -14,24 +15,26 @@ int main()
     google::InstallFailureSignalHandler();
     FLAGS_colorlogtostderr = true; 
 
-    Parkspace_allocation_communicator *p_parkspace_allocator = Parkspace_allocation_communicator::get_instance_pointer();
-    
-    p_parkspace_allocator->communication_bind("tcp://127.0.0.1:7001");
-    // p_parkspace_allocator->communication_connect("tcp://127.0.0.1:7000");
-    p_parkspace_allocator->communication_run();
+    Parkspace_allocation_communicator *p_parkspace_allocation_communicater = Parkspace_allocation_communicator::get_instance_pointer();
+    Parkspace_allocator *p_parkspace_allocator = Parkspace_allocator::get_instance_pointer();
+
+    p_parkspace_allocator->parkspace_allocator_init(4);
+    p_parkspace_allocation_communicater->communication_bind("tcp://192.168.2.139:7001");
+    // p_parkspace_allocation_communicater->communication_connect("tcp://127.0.0.1:7000");
+    p_parkspace_allocation_communicater->communication_run();
 
     // 初始化车位，创建三个车位
     message::Parkspace_allocation_status_msg parkspace_status;
-    for (size_t i = 1; i < 4; i++)
+    for (size_t i = 1; i < 1000; i++)
     {
         message::Parkspace_info* space = parkspace_status.add_parkspace_info();
         space->set_parkspace_id(i);
         space->set_index(i);
         space->set_direction(message::Direction::eForward);
         space->set_floor(2+i);
-        space->set_length(5500);
-        space->set_width(2200);
-        space->set_height(1750);
+        space->set_length(5.5);
+        space->set_width(2.2);
+        space->set_height(1.75);
         space->set_parkspace_status(message::Parkspace_status::eParkspace_empty);
     }
     message::Base_info base_msg;
@@ -43,24 +46,23 @@ int main()
     error.set_error_code(0);
     parkspace_status.mutable_base_info()->CopyFrom(base_msg);
     parkspace_status.mutable_error_manager()->CopyFrom(error);
-    p_parkspace_allocator->update_parkspace_status(parkspace_status);
-
+    p_parkspace_allocation_communicater->update_parkspace_status(parkspace_status);
     int k=1;
 
     while(1) {
-        message::Parkspace_info space;
-        space.set_parkspace_id(3);
-        space.set_index(k);
-        space.set_direction(message::Direction::eForward);
-        space.set_floor(k*3);
-        space.set_length(5500);
-        space.set_width(2200);
-        space.set_height(k*400);
-        space.set_parkspace_status(message::Parkspace_status::eParkspace_occupied);
-        p_parkspace_allocator->update_parkspace_status(3, space);
+        // message::Parkspace_info space;
+        // space.set_parkspace_id(3);
+        // space.set_index(k);
+        // space.set_direction(message::Direction::eForward);
+        // space.set_floor(k*3);
+        // space.set_length(5500);
+        // space.set_width(2200);
+        // space.set_height(k*400);
+        // space.set_parkspace_status(message::Parkspace_status::eParkspace_occupied);
+        // p_parkspace_allocator->update_parkspace_status(3, space);
         usleep(1000*1000);
         k++;
     }
-
+    p_parkspace_allocator->parkspace_allocator_uninit();
     return 0;
 }