修改手动消息名称, 与中控状态消息合并到一个文件

communication/communication_message.h

@@ -55,8 +55,9 @@ public:
 
         eCentral_controller_statu_msg=0xa0,                 //中控状态消息
 
-        eManual_operation_msg=0xb0,                         //中控手动操作消息
-	};
+        eEntrance_manual_operation_msg=0xb0,            //针对出入口状态操作的手动消息
+        eProcess_manual_operation_msg=0xb1,
+    };
 
 //通讯单元
 	enum Communicator

message/central_control_message.pb.h

@@ -38,7 +38,7 @@ namespace protobuf_central_5fcontrol_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[1];
+  static const ::google::protobuf::internal::ParseTable schema[3];
   static const ::google::protobuf::internal::FieldMetadata field_metadata[];
   static const ::google::protobuf::internal::SerializationTable serialization_table[];
   static const ::google::protobuf::uint32 offsets[];
@@ -46,14 +46,26 @@ struct TableStruct {
 void AddDescriptors();
 void InitDefaultsCentral_controller_statu_msgImpl();
 void InitDefaultsCentral_controller_statu_msg();
+void InitDefaultsEntrance_manual_operation_msgImpl();
+void InitDefaultsEntrance_manual_operation_msg();
+void InitDefaultsProcess_manual_operation_msgImpl();
+void InitDefaultsProcess_manual_operation_msg();
 inline void InitDefaults() {
   InitDefaultsCentral_controller_statu_msg();
+  InitDefaultsEntrance_manual_operation_msg();
+  InitDefaultsProcess_manual_operation_msg();
 }
 }  // namespace protobuf_central_5fcontrol_5fmessage_2eproto
 namespace message {
 class Central_controller_statu_msg;
 class Central_controller_statu_msgDefaultTypeInternal;
 extern Central_controller_statu_msgDefaultTypeInternal _Central_controller_statu_msg_default_instance_;
+class Entrance_manual_operation_msg;
+class Entrance_manual_operation_msgDefaultTypeInternal;
+extern Entrance_manual_operation_msgDefaultTypeInternal _Entrance_manual_operation_msg_default_instance_;
+class Process_manual_operation_msg;
+class Process_manual_operation_msgDefaultTypeInternal;
+extern Process_manual_operation_msgDefaultTypeInternal _Process_manual_operation_msg_default_instance_;
 }  // namespace message
 namespace message {
 
@@ -77,6 +89,59 @@ inline bool Entrance_statu_Parse(
   return ::google::protobuf::internal::ParseNamedEnum<Entrance_statu>(
     Entrance_statu_descriptor(), name, value);
 }
+enum Step_type {
+  eAlloc_step = 0,
+  eMeasure_step = 1,
+  eCompare_step = 2,
+  eDispatch_step = 3,
+  eConfirm_step = 4,
+  eSearch_step = 5,
+  eWait_step = 6,
+  eRelease_step = 7,
+  eComplete = 8,
+  eBackConfirm_step = 9,
+  eBack_compare_step = 10,
+  eBackMeasure_step = 11,
+  eBackAlloc_step = 12,
+  eBackWait_step = 13,
+  eBackDispatch_step = 14,
+  eBackSearch_step = 15,
+  eBackComplete = 16
+};
+bool Step_type_IsValid(int value);
+const Step_type Step_type_MIN = eAlloc_step;
+const Step_type Step_type_MAX = eBackComplete;
+const int Step_type_ARRAYSIZE = Step_type_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* Step_type_descriptor();
+inline const ::std::string& Step_type_Name(Step_type value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    Step_type_descriptor(), value);
+}
+inline bool Step_type_Parse(
+    const ::std::string& name, Step_type* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<Step_type>(
+    Step_type_descriptor(), name, value);
+}
+enum Process_operation_type {
+  eManual_cancel = 0,
+  eManual_retry = 1
+};
+bool Process_operation_type_IsValid(int value);
+const Process_operation_type Process_operation_type_MIN = eManual_cancel;
+const Process_operation_type Process_operation_type_MAX = eManual_retry;
+const int Process_operation_type_ARRAYSIZE = Process_operation_type_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* Process_operation_type_descriptor();
+inline const ::std::string& Process_operation_type_Name(Process_operation_type value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    Process_operation_type_descriptor(), value);
+}
+inline bool Process_operation_type_Parse(
+    const ::std::string& name, Process_operation_type* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<Process_operation_type>(
+    Process_operation_type_descriptor(), name, value);
+}
 // ===================================================================
 
 class Central_controller_statu_msg : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Central_controller_statu_msg) */ {
@@ -211,6 +276,304 @@ class Central_controller_statu_msg : public ::google::protobuf::Message /* @@pro
   friend struct ::protobuf_central_5fcontrol_5fmessage_2eproto::TableStruct;
   friend void ::protobuf_central_5fcontrol_5fmessage_2eproto::InitDefaultsCentral_controller_statu_msgImpl();
 };
+// -------------------------------------------------------------------
+
+class Entrance_manual_operation_msg : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Entrance_manual_operation_msg) */ {
+ public:
+  Entrance_manual_operation_msg();
+  virtual ~Entrance_manual_operation_msg();
+
+  Entrance_manual_operation_msg(const Entrance_manual_operation_msg& from);
+
+  inline Entrance_manual_operation_msg& operator=(const Entrance_manual_operation_msg& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Entrance_manual_operation_msg(Entrance_manual_operation_msg&& from) noexcept
+    : Entrance_manual_operation_msg() {
+    *this = ::std::move(from);
+  }
+
+  inline Entrance_manual_operation_msg& operator=(Entrance_manual_operation_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 Entrance_manual_operation_msg& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Entrance_manual_operation_msg* internal_default_instance() {
+    return reinterpret_cast<const Entrance_manual_operation_msg*>(
+               &_Entrance_manual_operation_msg_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void Swap(Entrance_manual_operation_msg* other);
+  friend void swap(Entrance_manual_operation_msg& a, Entrance_manual_operation_msg& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Entrance_manual_operation_msg* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Entrance_manual_operation_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 Entrance_manual_operation_msg& from);
+  void MergeFrom(const Entrance_manual_operation_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(Entrance_manual_operation_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 int32 terminal_id = 2;
+  bool has_terminal_id() const;
+  void clear_terminal_id();
+  static const int kTerminalIdFieldNumber = 2;
+  ::google::protobuf::int32 terminal_id() const;
+  void set_terminal_id(::google::protobuf::int32 value);
+
+  // required .message.Entrance_statu entrance_statu = 4;
+  bool has_entrance_statu() const;
+  void clear_entrance_statu();
+  static const int kEntranceStatuFieldNumber = 4;
+  ::message::Entrance_statu entrance_statu() const;
+  void set_entrance_statu(::message::Entrance_statu value);
+
+  // required .message.Process_type process_type = 3;
+  bool has_process_type() const;
+  void clear_process_type();
+  static const int kProcessTypeFieldNumber = 3;
+  ::message::Process_type process_type() const;
+  void set_process_type(::message::Process_type value);
+
+  // @@protoc_insertion_point(class_scope:message.Entrance_manual_operation_msg)
+ private:
+  void set_has_base_info();
+  void clear_has_base_info();
+  void set_has_terminal_id();
+  void clear_has_terminal_id();
+  void set_has_process_type();
+  void clear_has_process_type();
+  void set_has_entrance_statu();
+  void clear_has_entrance_statu();
+
+  // 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_;
+  ::google::protobuf::int32 terminal_id_;
+  int entrance_statu_;
+  int process_type_;
+  friend struct ::protobuf_central_5fcontrol_5fmessage_2eproto::TableStruct;
+  friend void ::protobuf_central_5fcontrol_5fmessage_2eproto::InitDefaultsEntrance_manual_operation_msgImpl();
+};
+// -------------------------------------------------------------------
+
+class Process_manual_operation_msg : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Process_manual_operation_msg) */ {
+ public:
+  Process_manual_operation_msg();
+  virtual ~Process_manual_operation_msg();
+
+  Process_manual_operation_msg(const Process_manual_operation_msg& from);
+
+  inline Process_manual_operation_msg& operator=(const Process_manual_operation_msg& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Process_manual_operation_msg(Process_manual_operation_msg&& from) noexcept
+    : Process_manual_operation_msg() {
+    *this = ::std::move(from);
+  }
+
+  inline Process_manual_operation_msg& operator=(Process_manual_operation_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 Process_manual_operation_msg& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Process_manual_operation_msg* internal_default_instance() {
+    return reinterpret_cast<const Process_manual_operation_msg*>(
+               &_Process_manual_operation_msg_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    2;
+
+  void Swap(Process_manual_operation_msg* other);
+  friend void swap(Process_manual_operation_msg& a, Process_manual_operation_msg& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Process_manual_operation_msg* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Process_manual_operation_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 Process_manual_operation_msg& from);
+  void MergeFrom(const Process_manual_operation_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(Process_manual_operation_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 string license = 2;
+  bool has_license() const;
+  void clear_license();
+  static const int kLicenseFieldNumber = 2;
+  const ::std::string& license() const;
+  void set_license(const ::std::string& value);
+  #if LANG_CXX11
+  void set_license(::std::string&& value);
+  #endif
+  void set_license(const char* value);
+  void set_license(const char* value, size_t size);
+  ::std::string* mutable_license();
+  ::std::string* release_license();
+  void set_allocated_license(::std::string* license);
+
+  // 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.Step_type step_type = 3;
+  bool has_step_type() const;
+  void clear_step_type();
+  static const int kStepTypeFieldNumber = 3;
+  ::message::Step_type step_type() const;
+  void set_step_type(::message::Step_type value);
+
+  // required .message.Process_operation_type operate_type = 4;
+  bool has_operate_type() const;
+  void clear_operate_type();
+  static const int kOperateTypeFieldNumber = 4;
+  ::message::Process_operation_type operate_type() const;
+  void set_operate_type(::message::Process_operation_type value);
+
+  // @@protoc_insertion_point(class_scope:message.Process_manual_operation_msg)
+ private:
+  void set_has_base_info();
+  void clear_has_base_info();
+  void set_has_license();
+  void clear_has_license();
+  void set_has_step_type();
+  void clear_has_step_type();
+  void set_has_operate_type();
+  void clear_has_operate_type();
+
+  // helper for ByteSizeLong()
+  size_t RequiredFieldsByteSizeFallback() const;
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::internal::ArenaStringPtr license_;
+  ::message::Base_info* base_info_;
+  int step_type_;
+  int operate_type_;
+  friend struct ::protobuf_central_5fcontrol_5fmessage_2eproto::TableStruct;
+  friend void ::protobuf_central_5fcontrol_5fmessage_2eproto::InitDefaultsProcess_manual_operation_msgImpl();
+};
 // ===================================================================
 
 
@@ -336,9 +699,308 @@ Central_controller_statu_msg::mutable_export_statu_vector() {
   return &export_statu_vector_;
 }
 
+// -------------------------------------------------------------------
+
+// Entrance_manual_operation_msg
+
+// required .message.Base_info base_info = 1;
+inline bool Entrance_manual_operation_msg::has_base_info() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Entrance_manual_operation_msg::set_has_base_info() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Entrance_manual_operation_msg::clear_has_base_info() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const ::message::Base_info& Entrance_manual_operation_msg::base_info() const {
+  const ::message::Base_info* p = base_info_;
+  // @@protoc_insertion_point(field_get:message.Entrance_manual_operation_msg.base_info)
+  return p != NULL ? *p : *reinterpret_cast<const ::message::Base_info*>(
+      &::message::_Base_info_default_instance_);
+}
+inline ::message::Base_info* Entrance_manual_operation_msg::release_base_info() {
+  // @@protoc_insertion_point(field_release:message.Entrance_manual_operation_msg.base_info)
+  clear_has_base_info();
+  ::message::Base_info* temp = base_info_;
+  base_info_ = NULL;
+  return temp;
+}
+inline ::message::Base_info* Entrance_manual_operation_msg::mutable_base_info() {
+  set_has_base_info();
+  if (base_info_ == NULL) {
+    base_info_ = new ::message::Base_info;
+  }
+  // @@protoc_insertion_point(field_mutable:message.Entrance_manual_operation_msg.base_info)
+  return base_info_;
+}
+inline void Entrance_manual_operation_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.Entrance_manual_operation_msg.base_info)
+}
+
+// required int32 terminal_id = 2;
+inline bool Entrance_manual_operation_msg::has_terminal_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Entrance_manual_operation_msg::set_has_terminal_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Entrance_manual_operation_msg::clear_has_terminal_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Entrance_manual_operation_msg::clear_terminal_id() {
+  terminal_id_ = 0;
+  clear_has_terminal_id();
+}
+inline ::google::protobuf::int32 Entrance_manual_operation_msg::terminal_id() const {
+  // @@protoc_insertion_point(field_get:message.Entrance_manual_operation_msg.terminal_id)
+  return terminal_id_;
+}
+inline void Entrance_manual_operation_msg::set_terminal_id(::google::protobuf::int32 value) {
+  set_has_terminal_id();
+  terminal_id_ = value;
+  // @@protoc_insertion_point(field_set:message.Entrance_manual_operation_msg.terminal_id)
+}
+
+// required .message.Process_type process_type = 3;
+inline bool Entrance_manual_operation_msg::has_process_type() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void Entrance_manual_operation_msg::set_has_process_type() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void Entrance_manual_operation_msg::clear_has_process_type() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void Entrance_manual_operation_msg::clear_process_type() {
+  process_type_ = 1;
+  clear_has_process_type();
+}
+inline ::message::Process_type Entrance_manual_operation_msg::process_type() const {
+  // @@protoc_insertion_point(field_get:message.Entrance_manual_operation_msg.process_type)
+  return static_cast< ::message::Process_type >(process_type_);
+}
+inline void Entrance_manual_operation_msg::set_process_type(::message::Process_type value) {
+  assert(::message::Process_type_IsValid(value));
+  set_has_process_type();
+  process_type_ = value;
+  // @@protoc_insertion_point(field_set:message.Entrance_manual_operation_msg.process_type)
+}
+
+// required .message.Entrance_statu entrance_statu = 4;
+inline bool Entrance_manual_operation_msg::has_entrance_statu() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void Entrance_manual_operation_msg::set_has_entrance_statu() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void Entrance_manual_operation_msg::clear_has_entrance_statu() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void Entrance_manual_operation_msg::clear_entrance_statu() {
+  entrance_statu_ = 0;
+  clear_has_entrance_statu();
+}
+inline ::message::Entrance_statu Entrance_manual_operation_msg::entrance_statu() const {
+  // @@protoc_insertion_point(field_get:message.Entrance_manual_operation_msg.entrance_statu)
+  return static_cast< ::message::Entrance_statu >(entrance_statu_);
+}
+inline void Entrance_manual_operation_msg::set_entrance_statu(::message::Entrance_statu value) {
+  assert(::message::Entrance_statu_IsValid(value));
+  set_has_entrance_statu();
+  entrance_statu_ = value;
+  // @@protoc_insertion_point(field_set:message.Entrance_manual_operation_msg.entrance_statu)
+}
+
+// -------------------------------------------------------------------
+
+// Process_manual_operation_msg
+
+// required .message.Base_info base_info = 1;
+inline bool Process_manual_operation_msg::has_base_info() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Process_manual_operation_msg::set_has_base_info() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Process_manual_operation_msg::clear_has_base_info() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const ::message::Base_info& Process_manual_operation_msg::base_info() const {
+  const ::message::Base_info* p = base_info_;
+  // @@protoc_insertion_point(field_get:message.Process_manual_operation_msg.base_info)
+  return p != NULL ? *p : *reinterpret_cast<const ::message::Base_info*>(
+      &::message::_Base_info_default_instance_);
+}
+inline ::message::Base_info* Process_manual_operation_msg::release_base_info() {
+  // @@protoc_insertion_point(field_release:message.Process_manual_operation_msg.base_info)
+  clear_has_base_info();
+  ::message::Base_info* temp = base_info_;
+  base_info_ = NULL;
+  return temp;
+}
+inline ::message::Base_info* Process_manual_operation_msg::mutable_base_info() {
+  set_has_base_info();
+  if (base_info_ == NULL) {
+    base_info_ = new ::message::Base_info;
+  }
+  // @@protoc_insertion_point(field_mutable:message.Process_manual_operation_msg.base_info)
+  return base_info_;
+}
+inline void Process_manual_operation_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.Process_manual_operation_msg.base_info)
+}
+
+// required string license = 2;
+inline bool Process_manual_operation_msg::has_license() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Process_manual_operation_msg::set_has_license() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Process_manual_operation_msg::clear_has_license() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Process_manual_operation_msg::clear_license() {
+  license_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  clear_has_license();
+}
+inline const ::std::string& Process_manual_operation_msg::license() const {
+  // @@protoc_insertion_point(field_get:message.Process_manual_operation_msg.license)
+  return license_.GetNoArena();
+}
+inline void Process_manual_operation_msg::set_license(const ::std::string& value) {
+  set_has_license();
+  license_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:message.Process_manual_operation_msg.license)
+}
+#if LANG_CXX11
+inline void Process_manual_operation_msg::set_license(::std::string&& value) {
+  set_has_license();
+  license_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:message.Process_manual_operation_msg.license)
+}
+#endif
+inline void Process_manual_operation_msg::set_license(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_license();
+  license_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:message.Process_manual_operation_msg.license)
+}
+inline void Process_manual_operation_msg::set_license(const char* value, size_t size) {
+  set_has_license();
+  license_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:message.Process_manual_operation_msg.license)
+}
+inline ::std::string* Process_manual_operation_msg::mutable_license() {
+  set_has_license();
+  // @@protoc_insertion_point(field_mutable:message.Process_manual_operation_msg.license)
+  return license_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Process_manual_operation_msg::release_license() {
+  // @@protoc_insertion_point(field_release:message.Process_manual_operation_msg.license)
+  clear_has_license();
+  return license_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Process_manual_operation_msg::set_allocated_license(::std::string* license) {
+  if (license != NULL) {
+    set_has_license();
+  } else {
+    clear_has_license();
+  }
+  license_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), license);
+  // @@protoc_insertion_point(field_set_allocated:message.Process_manual_operation_msg.license)
+}
+
+// required .message.Step_type step_type = 3;
+inline bool Process_manual_operation_msg::has_step_type() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void Process_manual_operation_msg::set_has_step_type() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void Process_manual_operation_msg::clear_has_step_type() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void Process_manual_operation_msg::clear_step_type() {
+  step_type_ = 0;
+  clear_has_step_type();
+}
+inline ::message::Step_type Process_manual_operation_msg::step_type() const {
+  // @@protoc_insertion_point(field_get:message.Process_manual_operation_msg.step_type)
+  return static_cast< ::message::Step_type >(step_type_);
+}
+inline void Process_manual_operation_msg::set_step_type(::message::Step_type value) {
+  assert(::message::Step_type_IsValid(value));
+  set_has_step_type();
+  step_type_ = value;
+  // @@protoc_insertion_point(field_set:message.Process_manual_operation_msg.step_type)
+}
+
+// required .message.Process_operation_type operate_type = 4;
+inline bool Process_manual_operation_msg::has_operate_type() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void Process_manual_operation_msg::set_has_operate_type() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void Process_manual_operation_msg::clear_has_operate_type() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void Process_manual_operation_msg::clear_operate_type() {
+  operate_type_ = 0;
+  clear_has_operate_type();
+}
+inline ::message::Process_operation_type Process_manual_operation_msg::operate_type() const {
+  // @@protoc_insertion_point(field_get:message.Process_manual_operation_msg.operate_type)
+  return static_cast< ::message::Process_operation_type >(operate_type_);
+}
+inline void Process_manual_operation_msg::set_operate_type(::message::Process_operation_type value) {
+  assert(::message::Process_operation_type_IsValid(value));
+  set_has_operate_type();
+  operate_type_ = value;
+  // @@protoc_insertion_point(field_set:message.Process_manual_operation_msg.operate_type)
+}
+
 #ifdef __GNUC__
   #pragma GCC diagnostic pop
 #endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
 
 // @@protoc_insertion_point(namespace_scope)
 
@@ -352,6 +1014,16 @@ template <>
 inline const EnumDescriptor* GetEnumDescriptor< ::message::Entrance_statu>() {
   return ::message::Entrance_statu_descriptor();
 }
+template <> struct is_proto_enum< ::message::Step_type> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::message::Step_type>() {
+  return ::message::Step_type_descriptor();
+}
+template <> struct is_proto_enum< ::message::Process_operation_type> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::message::Process_operation_type>() {
+  return ::message::Process_operation_type_descriptor();
+}
 
 }  // namespace protobuf
 }  // namespace google

message/central_control_message.proto

@@ -10,6 +10,41 @@ enum Entrance_statu
     ePaused=2;                          //急停
 }
 
+//流程中的步骤类型
+enum Step_type
+{
+    eAlloc_step=0;
+    eMeasure_step=1;
+    eCompare_step=2;
+    eDispatch_step=3;
+    eConfirm_step=4;
+
+    eSearch_step=5;        //查询数据库
+    eWait_step=6;             //等待车辆离开
+    eRelease_step=7;          //释放车位
+
+    eComplete=8;              //完成
+
+    eBackConfirm_step=9;
+    eBack_compare_step=10;
+    eBackMeasure_step=11;
+    eBackAlloc_step=12;
+
+    eBackWait_step=13;
+    eBackDispatch_step=14;
+    eBackSearch_step=15;
+
+    eBackComplete=16;
+}
+
+//针对流程的手动操作类型
+enum Process_operation_type
+{
+    eManual_cancel=0;                   //取消流程
+    eManual_retry=1;                    //重试
+}
+
+
 //中控状态消息
 message Central_controller_statu_msg
 {
@@ -18,3 +53,23 @@ message Central_controller_statu_msg
     repeated Entrance_statu             export_statu_vector=3;      //出口状态
 }
 
+//出入口手动操作消息
+message Entrance_manual_operation_msg
+{
+    required Base_info                  base_info=1;
+    required int32                      terminal_id=2;
+    required Process_type               process_type=3;
+    required Entrance_statu             entrance_statu=4;           //要修改的出入口状态
+}
+
+
+//流程手动操作消息
+message Process_manual_operation_msg
+{
+    required Base_info                  base_info=1;
+    required string                     license=2;
+    required Step_type                  step_type=3;
+    required Process_operation_type     operate_type=4;
+}
+
+

message/manual_operation_message.pb.cc

@@ -1,636 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: manual_operation_message.proto
-
-#include "manual_operation_message.pb.h"
-
-#include <algorithm>
-
-#include <google/protobuf/stubs/common.h>
-#include <google/protobuf/stubs/port.h>
-#include <google/protobuf/stubs/once.h>
-#include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/wire_format_lite_inl.h>
-#include <google/protobuf/descriptor.h>
-#include <google/protobuf/generated_message_reflection.h>
-#include <google/protobuf/reflection_ops.h>
-#include <google/protobuf/wire_format.h>
-// This is a temporary google only hack
-#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
-#include "third_party/protobuf/version.h"
-#endif
-// @@protoc_insertion_point(includes)
-namespace message {
-class Manual_operation_msgDefaultTypeInternal {
- public:
-  ::google::protobuf::internal::ExplicitlyConstructed<Manual_operation_msg>
-      _instance;
-} _Manual_operation_msg_default_instance_;
-}  // namespace message
-namespace protobuf_manual_5foperation_5fmessage_2eproto {
-void InitDefaultsManual_operation_msgImpl() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
-  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
-#else
-  ::google::protobuf::internal::InitProtobufDefaults();
-#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
-  protobuf_message_5fbase_2eproto::InitDefaultsBase_info();
-  {
-    void* ptr = &::message::_Manual_operation_msg_default_instance_;
-    new (ptr) ::message::Manual_operation_msg();
-    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
-  }
-  ::message::Manual_operation_msg::InitAsDefaultInstance();
-}
-
-void InitDefaultsManual_operation_msg() {
-  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
-  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsManual_operation_msgImpl);
-}
-
-::google::protobuf::Metadata file_level_metadata[1];
-const ::google::protobuf::EnumDescriptor* file_level_enum_descriptors[2];
-
-const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
-  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Manual_operation_msg, _has_bits_),
-  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Manual_operation_msg, _internal_metadata_),
-  ~0u,  // no _extensions_
-  ~0u,  // no _oneof_case_
-  ~0u,  // no _weak_field_map_
-  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Manual_operation_msg, base_info_),
-  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Manual_operation_msg, license_),
-  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Manual_operation_msg, step_type_),
-  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Manual_operation_msg, operate_type_),
-  1,
-  0,
-  2,
-  3,
-};
-static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
-  { 0, 9, sizeof(::message::Manual_operation_msg)},
-};
-
-static ::google::protobuf::Message const * const file_default_instances[] = {
-  reinterpret_cast<const ::google::protobuf::Message*>(&::message::_Manual_operation_msg_default_instance_),
-};
-
-void protobuf_AssignDescriptors() {
-  AddDescriptors();
-  ::google::protobuf::MessageFactory* factory = NULL;
-  AssignDescriptors(
-      "manual_operation_message.proto", schemas, file_default_instances, TableStruct::offsets, factory,
-      file_level_metadata, file_level_enum_descriptors, NULL);
-}
-
-void protobuf_AssignDescriptorsOnce() {
-  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
-  ::google::protobuf::GoogleOnceInit(&once, &protobuf_AssignDescriptors);
-}
-
-void protobuf_RegisterTypes(const ::std::string&) GOOGLE_PROTOBUF_ATTRIBUTE_COLD;
-void protobuf_RegisterTypes(const ::std::string&) {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::internal::RegisterAllTypes(file_level_metadata, 1);
-}
-
-void AddDescriptorsImpl() {
-  InitDefaults();
-  static const char descriptor[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
-      "\n\036manual_operation_message.proto\022\007messag"
-      "e\032\022message_base.proto\"\244\001\n\024Manual_operati"
-      "on_msg\022%\n\tbase_info\030\001 \002(\0132\022.message.Base"
-      "_info\022\017\n\007license\030\002 \002(\t\022%\n\tstep_type\030\003 \002("
-      "\0162\022.message.Step_type\022-\n\014operate_type\030\004 "
-      "\002(\0162\027.message.Operation_type*\335\002\n\tStep_ty"
-      "pe\022\017\n\013eAlloc_step\020\000\022\021\n\reMeasure_step\020\001\022\021"
-      "\n\reCompare_step\020\002\022\022\n\016eDispatch_step\020\003\022\021\n"
-      "\reConfirm_step\020\004\022\020\n\014eSearch_step\020\005\022\016\n\neW"
-      "ait_step\020\006\022\021\n\reRelease_step\020\007\022\r\n\teComple"
-      "te\020\010\022\025\n\021eBackConfirm_step\020\t\022\026\n\022eBack_com"
-      "pare_step\020\n\022\025\n\021eBackMeasure_step\020\013\022\023\n\017eB"
-      "ackAlloc_step\020\014\022\022\n\016eBackWait_step\020\r\022\026\n\022e"
-      "BackDispatch_step\020\016\022\024\n\020eBackSearch_step\020"
-      "\017\022\021\n\reBackComplete\020\020*7\n\016Operation_type\022\022"
-      "\n\016eManual_cancel\020\000\022\021\n\reManual_retry\020\001"
-  };
-  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
-      descriptor, 637);
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
-    "manual_operation_message.proto", &protobuf_RegisterTypes);
-  ::protobuf_message_5fbase_2eproto::AddDescriptors();
-}
-
-void AddDescriptors() {
-  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
-  ::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);
-}
-// Force AddDescriptors() to be called at dynamic initialization time.
-struct StaticDescriptorInitializer {
-  StaticDescriptorInitializer() {
-    AddDescriptors();
-  }
-} static_descriptor_initializer;
-}  // namespace protobuf_manual_5foperation_5fmessage_2eproto
-namespace message {
-const ::google::protobuf::EnumDescriptor* Step_type_descriptor() {
-  protobuf_manual_5foperation_5fmessage_2eproto::protobuf_AssignDescriptorsOnce();
-  return protobuf_manual_5foperation_5fmessage_2eproto::file_level_enum_descriptors[0];
-}
-bool Step_type_IsValid(int value) {
-  switch (value) {
-    case 0:
-    case 1:
-    case 2:
-    case 3:
-    case 4:
-    case 5:
-    case 6:
-    case 7:
-    case 8:
-    case 9:
-    case 10:
-    case 11:
-    case 12:
-    case 13:
-    case 14:
-    case 15:
-    case 16:
-      return true;
-    default:
-      return false;
-  }
-}
-
-const ::google::protobuf::EnumDescriptor* Operation_type_descriptor() {
-  protobuf_manual_5foperation_5fmessage_2eproto::protobuf_AssignDescriptorsOnce();
-  return protobuf_manual_5foperation_5fmessage_2eproto::file_level_enum_descriptors[1];
-}
-bool Operation_type_IsValid(int value) {
-  switch (value) {
-    case 0:
-    case 1:
-      return true;
-    default:
-      return false;
-  }
-}
-
-
-// ===================================================================
-
-void Manual_operation_msg::InitAsDefaultInstance() {
-  ::message::_Manual_operation_msg_default_instance_._instance.get_mutable()->base_info_ = const_cast< ::message::Base_info*>(
-      ::message::Base_info::internal_default_instance());
-}
-void Manual_operation_msg::clear_base_info() {
-  if (base_info_ != NULL) base_info_->Clear();
-  clear_has_base_info();
-}
-#if !defined(_MSC_VER) || _MSC_VER >= 1900
-const int Manual_operation_msg::kBaseInfoFieldNumber;
-const int Manual_operation_msg::kLicenseFieldNumber;
-const int Manual_operation_msg::kStepTypeFieldNumber;
-const int Manual_operation_msg::kOperateTypeFieldNumber;
-#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
-
-Manual_operation_msg::Manual_operation_msg()
-  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
-  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
-    ::protobuf_manual_5foperation_5fmessage_2eproto::InitDefaultsManual_operation_msg();
-  }
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:message.Manual_operation_msg)
-}
-Manual_operation_msg::Manual_operation_msg(const Manual_operation_msg& from)
-  : ::google::protobuf::Message(),
-      _internal_metadata_(NULL),
-      _has_bits_(from._has_bits_),
-      _cached_size_(0) {
-  _internal_metadata_.MergeFrom(from._internal_metadata_);
-  license_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  if (from.has_license()) {
-    license_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.license_);
-  }
-  if (from.has_base_info()) {
-    base_info_ = new ::message::Base_info(*from.base_info_);
-  } else {
-    base_info_ = NULL;
-  }
-  ::memcpy(&step_type_, &from.step_type_,
-    static_cast<size_t>(reinterpret_cast<char*>(&operate_type_) -
-    reinterpret_cast<char*>(&step_type_)) + sizeof(operate_type_));
-  // @@protoc_insertion_point(copy_constructor:message.Manual_operation_msg)
-}
-
-void Manual_operation_msg::SharedCtor() {
-  _cached_size_ = 0;
-  license_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  ::memset(&base_info_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&operate_type_) -
-      reinterpret_cast<char*>(&base_info_)) + sizeof(operate_type_));
-}
-
-Manual_operation_msg::~Manual_operation_msg() {
-  // @@protoc_insertion_point(destructor:message.Manual_operation_msg)
-  SharedDtor();
-}
-
-void Manual_operation_msg::SharedDtor() {
-  license_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  if (this != internal_default_instance()) delete base_info_;
-}
-
-void Manual_operation_msg::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* Manual_operation_msg::descriptor() {
-  ::protobuf_manual_5foperation_5fmessage_2eproto::protobuf_AssignDescriptorsOnce();
-  return ::protobuf_manual_5foperation_5fmessage_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
-}
-
-const Manual_operation_msg& Manual_operation_msg::default_instance() {
-  ::protobuf_manual_5foperation_5fmessage_2eproto::InitDefaultsManual_operation_msg();
-  return *internal_default_instance();
-}
-
-Manual_operation_msg* Manual_operation_msg::New(::google::protobuf::Arena* arena) const {
-  Manual_operation_msg* n = new Manual_operation_msg;
-  if (arena != NULL) {
-    arena->Own(n);
-  }
-  return n;
-}
-
-void Manual_operation_msg::Clear() {
-// @@protoc_insertion_point(message_clear_start:message.Manual_operation_msg)
-  ::google::protobuf::uint32 cached_has_bits = 0;
-  // Prevent compiler warnings about cached_has_bits being unused
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 3u) {
-    if (cached_has_bits & 0x00000001u) {
-      GOOGLE_DCHECK(!license_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
-      (*license_.UnsafeRawStringPointer())->clear();
-    }
-    if (cached_has_bits & 0x00000002u) {
-      GOOGLE_DCHECK(base_info_ != NULL);
-      base_info_->Clear();
-    }
-  }
-  if (cached_has_bits & 12u) {
-    ::memset(&step_type_, 0, static_cast<size_t>(
-        reinterpret_cast<char*>(&operate_type_) -
-        reinterpret_cast<char*>(&step_type_)) + sizeof(operate_type_));
-  }
-  _has_bits_.Clear();
-  _internal_metadata_.Clear();
-}
-
-bool Manual_operation_msg::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:message.Manual_operation_msg)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // required .message.Base_info base_info = 1;
-      case 1: {
-        if (static_cast< ::google::protobuf::uint8>(tag) ==
-            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
-               input, mutable_base_info()));
-        } else {
-          goto handle_unusual;
-        }
-        break;
-      }
-
-      // required string license = 2;
-      case 2: {
-        if (static_cast< ::google::protobuf::uint8>(tag) ==
-            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_license()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->license().data(), static_cast<int>(this->license().length()),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "message.Manual_operation_msg.license");
-        } else {
-          goto handle_unusual;
-        }
-        break;
-      }
-
-      // required .message.Step_type step_type = 3;
-      case 3: {
-        if (static_cast< ::google::protobuf::uint8>(tag) ==
-            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
-          int value;
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
-                 input, &value)));
-          if (::message::Step_type_IsValid(value)) {
-            set_step_type(static_cast< ::message::Step_type >(value));
-          } else {
-            mutable_unknown_fields()->AddVarint(
-                3, static_cast< ::google::protobuf::uint64>(value));
-          }
-        } else {
-          goto handle_unusual;
-        }
-        break;
-      }
-
-      // required .message.Operation_type operate_type = 4;
-      case 4: {
-        if (static_cast< ::google::protobuf::uint8>(tag) ==
-            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
-          int value;
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
-                 input, &value)));
-          if (::message::Operation_type_IsValid(value)) {
-            set_operate_type(static_cast< ::message::Operation_type >(value));
-          } else {
-            mutable_unknown_fields()->AddVarint(
-                4, static_cast< ::google::protobuf::uint64>(value));
-          }
-        } else {
-          goto handle_unusual;
-        }
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, _internal_metadata_.mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:message.Manual_operation_msg)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:message.Manual_operation_msg)
-  return false;
-#undef DO_
-}
-
-void Manual_operation_msg::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:message.Manual_operation_msg)
-  ::google::protobuf::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // required .message.Base_info base_info = 1;
-  if (cached_has_bits & 0x00000002u) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, *this->base_info_, output);
-  }
-
-  // required string license = 2;
-  if (cached_has_bits & 0x00000001u) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->license().data(), static_cast<int>(this->license().length()),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "message.Manual_operation_msg.license");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      2, this->license(), output);
-  }
-
-  // required .message.Step_type step_type = 3;
-  if (cached_has_bits & 0x00000004u) {
-    ::google::protobuf::internal::WireFormatLite::WriteEnum(
-      3, this->step_type(), output);
-  }
-
-  // required .message.Operation_type operate_type = 4;
-  if (cached_has_bits & 0x00000008u) {
-    ::google::protobuf::internal::WireFormatLite::WriteEnum(
-      4, this->operate_type(), output);
-  }
-
-  if (_internal_metadata_.have_unknown_fields()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        _internal_metadata_.unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:message.Manual_operation_msg)
-}
-
-::google::protobuf::uint8* Manual_operation_msg::InternalSerializeWithCachedSizesToArray(
-    bool deterministic, ::google::protobuf::uint8* target) const {
-  (void)deterministic; // Unused
-  // @@protoc_insertion_point(serialize_to_array_start:message.Manual_operation_msg)
-  ::google::protobuf::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // required .message.Base_info base_info = 1;
-  if (cached_has_bits & 0x00000002u) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      InternalWriteMessageToArray(
-        1, *this->base_info_, deterministic, target);
-  }
-
-  // required string license = 2;
-  if (cached_has_bits & 0x00000001u) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->license().data(), static_cast<int>(this->license().length()),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "message.Manual_operation_msg.license");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        2, this->license(), target);
-  }
-
-  // required .message.Step_type step_type = 3;
-  if (cached_has_bits & 0x00000004u) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
-      3, this->step_type(), target);
-  }
-
-  // required .message.Operation_type operate_type = 4;
-  if (cached_has_bits & 0x00000008u) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
-      4, this->operate_type(), target);
-  }
-
-  if (_internal_metadata_.have_unknown_fields()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        _internal_metadata_.unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:message.Manual_operation_msg)
-  return target;
-}
-
-size_t Manual_operation_msg::RequiredFieldsByteSizeFallback() const {
-// @@protoc_insertion_point(required_fields_byte_size_fallback_start:message.Manual_operation_msg)
-  size_t total_size = 0;
-
-  if (has_license()) {
-    // required string license = 2;
-    total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::StringSize(
-        this->license());
-  }
-
-  if (has_base_info()) {
-    // required .message.Base_info base_info = 1;
-    total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::MessageSize(
-        *this->base_info_);
-  }
-
-  if (has_step_type()) {
-    // required .message.Step_type step_type = 3;
-    total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::EnumSize(this->step_type());
-  }
-
-  if (has_operate_type()) {
-    // required .message.Operation_type operate_type = 4;
-    total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::EnumSize(this->operate_type());
-  }
-
-  return total_size;
-}
-size_t Manual_operation_msg::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:message.Manual_operation_msg)
-  size_t total_size = 0;
-
-  if (_internal_metadata_.have_unknown_fields()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        _internal_metadata_.unknown_fields());
-  }
-  if (((_has_bits_[0] & 0x0000000f) ^ 0x0000000f) == 0) {  // All required fields are present.
-    // required string license = 2;
-    total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::StringSize(
-        this->license());
-
-    // required .message.Base_info base_info = 1;
-    total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::MessageSize(
-        *this->base_info_);
-
-    // required .message.Step_type step_type = 3;
-    total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::EnumSize(this->step_type());
-
-    // required .message.Operation_type operate_type = 4;
-    total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::EnumSize(this->operate_type());
-
-  } else {
-    total_size += RequiredFieldsByteSizeFallback();
-  }
-  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = cached_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void Manual_operation_msg::MergeFrom(const ::google::protobuf::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:message.Manual_operation_msg)
-  GOOGLE_DCHECK_NE(&from, this);
-  const Manual_operation_msg* source =
-      ::google::protobuf::internal::DynamicCastToGenerated<const Manual_operation_msg>(
-          &from);
-  if (source == NULL) {
-  // @@protoc_insertion_point(generalized_merge_from_cast_fail:message.Manual_operation_msg)
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-  // @@protoc_insertion_point(generalized_merge_from_cast_success:message.Manual_operation_msg)
-    MergeFrom(*source);
-  }
-}
-
-void Manual_operation_msg::MergeFrom(const Manual_operation_msg& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:message.Manual_operation_msg)
-  GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom(from._internal_metadata_);
-  ::google::protobuf::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 15u) {
-    if (cached_has_bits & 0x00000001u) {
-      set_has_license();
-      license_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.license_);
-    }
-    if (cached_has_bits & 0x00000002u) {
-      mutable_base_info()->::message::Base_info::MergeFrom(from.base_info());
-    }
-    if (cached_has_bits & 0x00000004u) {
-      step_type_ = from.step_type_;
-    }
-    if (cached_has_bits & 0x00000008u) {
-      operate_type_ = from.operate_type_;
-    }
-    _has_bits_[0] |= cached_has_bits;
-  }
-}
-
-void Manual_operation_msg::CopyFrom(const ::google::protobuf::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:message.Manual_operation_msg)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void Manual_operation_msg::CopyFrom(const Manual_operation_msg& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:message.Manual_operation_msg)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool Manual_operation_msg::IsInitialized() const {
-  if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;
-  if (has_base_info()) {
-    if (!this->base_info_->IsInitialized()) return false;
-  }
-  return true;
-}
-
-void Manual_operation_msg::Swap(Manual_operation_msg* other) {
-  if (other == this) return;
-  InternalSwap(other);
-}
-void Manual_operation_msg::InternalSwap(Manual_operation_msg* other) {
-  using std::swap;
-  license_.Swap(&other->license_);
-  swap(base_info_, other->base_info_);
-  swap(step_type_, other->step_type_);
-  swap(operate_type_, other->operate_type_);
-  swap(_has_bits_[0], other->_has_bits_[0]);
-  _internal_metadata_.Swap(&other->_internal_metadata_);
-  swap(_cached_size_, other->_cached_size_);
-}
-
-::google::protobuf::Metadata Manual_operation_msg::GetMetadata() const {
-  protobuf_manual_5foperation_5fmessage_2eproto::protobuf_AssignDescriptorsOnce();
-  return ::protobuf_manual_5foperation_5fmessage_2eproto::file_level_metadata[kIndexInFileMessages];
-}
-
-
-// @@protoc_insertion_point(namespace_scope)
-}  // namespace message
-
-// @@protoc_insertion_point(global_scope)

message/manual_operation_message.pb.h

@@ -1,467 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: manual_operation_message.proto
-
-#ifndef PROTOBUF_manual_5foperation_5fmessage_2eproto__INCLUDED
-#define PROTOBUF_manual_5foperation_5fmessage_2eproto__INCLUDED
-
-#include <string>
-
-#include <google/protobuf/stubs/common.h>
-
-#if GOOGLE_PROTOBUF_VERSION < 3005000
-#error This file was generated by a newer version of protoc which is
-#error incompatible with your Protocol Buffer headers.  Please update
-#error your headers.
-#endif
-#if 3005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
-#error This file was generated by an older version of protoc which is
-#error incompatible with your Protocol Buffer headers.  Please
-#error regenerate this file with a newer version of protoc.
-#endif
-
-#include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/arena.h>
-#include <google/protobuf/arenastring.h>
-#include <google/protobuf/generated_message_table_driven.h>
-#include <google/protobuf/generated_message_util.h>
-#include <google/protobuf/metadata.h>
-#include <google/protobuf/message.h>
-#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
-#include <google/protobuf/extension_set.h>  // IWYU pragma: export
-#include <google/protobuf/generated_enum_reflection.h>
-#include <google/protobuf/unknown_field_set.h>
-#include "message_base.pb.h"
-// @@protoc_insertion_point(includes)
-
-namespace protobuf_manual_5foperation_5fmessage_2eproto {
-// Internal implementation detail -- do not use these members.
-struct TableStruct {
-  static const ::google::protobuf::internal::ParseTableField entries[];
-  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
-  static const ::google::protobuf::internal::ParseTable schema[1];
-  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
-  static const ::google::protobuf::internal::SerializationTable serialization_table[];
-  static const ::google::protobuf::uint32 offsets[];
-};
-void AddDescriptors();
-void InitDefaultsManual_operation_msgImpl();
-void InitDefaultsManual_operation_msg();
-inline void InitDefaults() {
-  InitDefaultsManual_operation_msg();
-}
-}  // namespace protobuf_manual_5foperation_5fmessage_2eproto
-namespace message {
-class Manual_operation_msg;
-class Manual_operation_msgDefaultTypeInternal;
-extern Manual_operation_msgDefaultTypeInternal _Manual_operation_msg_default_instance_;
-}  // namespace message
-namespace message {
-
-enum Step_type {
-  eAlloc_step = 0,
-  eMeasure_step = 1,
-  eCompare_step = 2,
-  eDispatch_step = 3,
-  eConfirm_step = 4,
-  eSearch_step = 5,
-  eWait_step = 6,
-  eRelease_step = 7,
-  eComplete = 8,
-  eBackConfirm_step = 9,
-  eBack_compare_step = 10,
-  eBackMeasure_step = 11,
-  eBackAlloc_step = 12,
-  eBackWait_step = 13,
-  eBackDispatch_step = 14,
-  eBackSearch_step = 15,
-  eBackComplete = 16
-};
-bool Step_type_IsValid(int value);
-const Step_type Step_type_MIN = eAlloc_step;
-const Step_type Step_type_MAX = eBackComplete;
-const int Step_type_ARRAYSIZE = Step_type_MAX + 1;
-
-const ::google::protobuf::EnumDescriptor* Step_type_descriptor();
-inline const ::std::string& Step_type_Name(Step_type value) {
-  return ::google::protobuf::internal::NameOfEnum(
-    Step_type_descriptor(), value);
-}
-inline bool Step_type_Parse(
-    const ::std::string& name, Step_type* value) {
-  return ::google::protobuf::internal::ParseNamedEnum<Step_type>(
-    Step_type_descriptor(), name, value);
-}
-enum Operation_type {
-  eManual_cancel = 0,
-  eManual_retry = 1
-};
-bool Operation_type_IsValid(int value);
-const Operation_type Operation_type_MIN = eManual_cancel;
-const Operation_type Operation_type_MAX = eManual_retry;
-const int Operation_type_ARRAYSIZE = Operation_type_MAX + 1;
-
-const ::google::protobuf::EnumDescriptor* Operation_type_descriptor();
-inline const ::std::string& Operation_type_Name(Operation_type value) {
-  return ::google::protobuf::internal::NameOfEnum(
-    Operation_type_descriptor(), value);
-}
-inline bool Operation_type_Parse(
-    const ::std::string& name, Operation_type* value) {
-  return ::google::protobuf::internal::ParseNamedEnum<Operation_type>(
-    Operation_type_descriptor(), name, value);
-}
-// ===================================================================
-
-class Manual_operation_msg : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Manual_operation_msg) */ {
- public:
-  Manual_operation_msg();
-  virtual ~Manual_operation_msg();
-
-  Manual_operation_msg(const Manual_operation_msg& from);
-
-  inline Manual_operation_msg& operator=(const Manual_operation_msg& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  #if LANG_CXX11
-  Manual_operation_msg(Manual_operation_msg&& from) noexcept
-    : Manual_operation_msg() {
-    *this = ::std::move(from);
-  }
-
-  inline Manual_operation_msg& operator=(Manual_operation_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 Manual_operation_msg& default_instance();
-
-  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
-  static inline const Manual_operation_msg* internal_default_instance() {
-    return reinterpret_cast<const Manual_operation_msg*>(
-               &_Manual_operation_msg_default_instance_);
-  }
-  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
-    0;
-
-  void Swap(Manual_operation_msg* other);
-  friend void swap(Manual_operation_msg& a, Manual_operation_msg& b) {
-    a.Swap(&b);
-  }
-
-  // implements Message ----------------------------------------------
-
-  inline Manual_operation_msg* New() const PROTOBUF_FINAL { return New(NULL); }
-
-  Manual_operation_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 Manual_operation_msg& from);
-  void MergeFrom(const Manual_operation_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(Manual_operation_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 string license = 2;
-  bool has_license() const;
-  void clear_license();
-  static const int kLicenseFieldNumber = 2;
-  const ::std::string& license() const;
-  void set_license(const ::std::string& value);
-  #if LANG_CXX11
-  void set_license(::std::string&& value);
-  #endif
-  void set_license(const char* value);
-  void set_license(const char* value, size_t size);
-  ::std::string* mutable_license();
-  ::std::string* release_license();
-  void set_allocated_license(::std::string* license);
-
-  // 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.Step_type step_type = 3;
-  bool has_step_type() const;
-  void clear_step_type();
-  static const int kStepTypeFieldNumber = 3;
-  ::message::Step_type step_type() const;
-  void set_step_type(::message::Step_type value);
-
-  // required .message.Operation_type operate_type = 4;
-  bool has_operate_type() const;
-  void clear_operate_type();
-  static const int kOperateTypeFieldNumber = 4;
-  ::message::Operation_type operate_type() const;
-  void set_operate_type(::message::Operation_type value);
-
-  // @@protoc_insertion_point(class_scope:message.Manual_operation_msg)
- private:
-  void set_has_base_info();
-  void clear_has_base_info();
-  void set_has_license();
-  void clear_has_license();
-  void set_has_step_type();
-  void clear_has_step_type();
-  void set_has_operate_type();
-  void clear_has_operate_type();
-
-  // helper for ByteSizeLong()
-  size_t RequiredFieldsByteSizeFallback() const;
-
-  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
-  ::google::protobuf::internal::HasBits<1> _has_bits_;
-  mutable int _cached_size_;
-  ::google::protobuf::internal::ArenaStringPtr license_;
-  ::message::Base_info* base_info_;
-  int step_type_;
-  int operate_type_;
-  friend struct ::protobuf_manual_5foperation_5fmessage_2eproto::TableStruct;
-  friend void ::protobuf_manual_5foperation_5fmessage_2eproto::InitDefaultsManual_operation_msgImpl();
-};
-// ===================================================================
-
-
-// ===================================================================
-
-#ifdef __GNUC__
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
-#endif  // __GNUC__
-// Manual_operation_msg
-
-// required .message.Base_info base_info = 1;
-inline bool Manual_operation_msg::has_base_info() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void Manual_operation_msg::set_has_base_info() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void Manual_operation_msg::clear_has_base_info() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline const ::message::Base_info& Manual_operation_msg::base_info() const {
-  const ::message::Base_info* p = base_info_;
-  // @@protoc_insertion_point(field_get:message.Manual_operation_msg.base_info)
-  return p != NULL ? *p : *reinterpret_cast<const ::message::Base_info*>(
-      &::message::_Base_info_default_instance_);
-}
-inline ::message::Base_info* Manual_operation_msg::release_base_info() {
-  // @@protoc_insertion_point(field_release:message.Manual_operation_msg.base_info)
-  clear_has_base_info();
-  ::message::Base_info* temp = base_info_;
-  base_info_ = NULL;
-  return temp;
-}
-inline ::message::Base_info* Manual_operation_msg::mutable_base_info() {
-  set_has_base_info();
-  if (base_info_ == NULL) {
-    base_info_ = new ::message::Base_info;
-  }
-  // @@protoc_insertion_point(field_mutable:message.Manual_operation_msg.base_info)
-  return base_info_;
-}
-inline void Manual_operation_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.Manual_operation_msg.base_info)
-}
-
-// required string license = 2;
-inline bool Manual_operation_msg::has_license() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void Manual_operation_msg::set_has_license() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void Manual_operation_msg::clear_has_license() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void Manual_operation_msg::clear_license() {
-  license_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  clear_has_license();
-}
-inline const ::std::string& Manual_operation_msg::license() const {
-  // @@protoc_insertion_point(field_get:message.Manual_operation_msg.license)
-  return license_.GetNoArena();
-}
-inline void Manual_operation_msg::set_license(const ::std::string& value) {
-  set_has_license();
-  license_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
-  // @@protoc_insertion_point(field_set:message.Manual_operation_msg.license)
-}
-#if LANG_CXX11
-inline void Manual_operation_msg::set_license(::std::string&& value) {
-  set_has_license();
-  license_.SetNoArena(
-    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
-  // @@protoc_insertion_point(field_set_rvalue:message.Manual_operation_msg.license)
-}
-#endif
-inline void Manual_operation_msg::set_license(const char* value) {
-  GOOGLE_DCHECK(value != NULL);
-  set_has_license();
-  license_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
-  // @@protoc_insertion_point(field_set_char:message.Manual_operation_msg.license)
-}
-inline void Manual_operation_msg::set_license(const char* value, size_t size) {
-  set_has_license();
-  license_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
-      ::std::string(reinterpret_cast<const char*>(value), size));
-  // @@protoc_insertion_point(field_set_pointer:message.Manual_operation_msg.license)
-}
-inline ::std::string* Manual_operation_msg::mutable_license() {
-  set_has_license();
-  // @@protoc_insertion_point(field_mutable:message.Manual_operation_msg.license)
-  return license_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-inline ::std::string* Manual_operation_msg::release_license() {
-  // @@protoc_insertion_point(field_release:message.Manual_operation_msg.license)
-  clear_has_license();
-  return license_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-inline void Manual_operation_msg::set_allocated_license(::std::string* license) {
-  if (license != NULL) {
-    set_has_license();
-  } else {
-    clear_has_license();
-  }
-  license_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), license);
-  // @@protoc_insertion_point(field_set_allocated:message.Manual_operation_msg.license)
-}
-
-// required .message.Step_type step_type = 3;
-inline bool Manual_operation_msg::has_step_type() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void Manual_operation_msg::set_has_step_type() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void Manual_operation_msg::clear_has_step_type() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void Manual_operation_msg::clear_step_type() {
-  step_type_ = 0;
-  clear_has_step_type();
-}
-inline ::message::Step_type Manual_operation_msg::step_type() const {
-  // @@protoc_insertion_point(field_get:message.Manual_operation_msg.step_type)
-  return static_cast< ::message::Step_type >(step_type_);
-}
-inline void Manual_operation_msg::set_step_type(::message::Step_type value) {
-  assert(::message::Step_type_IsValid(value));
-  set_has_step_type();
-  step_type_ = value;
-  // @@protoc_insertion_point(field_set:message.Manual_operation_msg.step_type)
-}
-
-// required .message.Operation_type operate_type = 4;
-inline bool Manual_operation_msg::has_operate_type() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void Manual_operation_msg::set_has_operate_type() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void Manual_operation_msg::clear_has_operate_type() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void Manual_operation_msg::clear_operate_type() {
-  operate_type_ = 0;
-  clear_has_operate_type();
-}
-inline ::message::Operation_type Manual_operation_msg::operate_type() const {
-  // @@protoc_insertion_point(field_get:message.Manual_operation_msg.operate_type)
-  return static_cast< ::message::Operation_type >(operate_type_);
-}
-inline void Manual_operation_msg::set_operate_type(::message::Operation_type value) {
-  assert(::message::Operation_type_IsValid(value));
-  set_has_operate_type();
-  operate_type_ = value;
-  // @@protoc_insertion_point(field_set:message.Manual_operation_msg.operate_type)
-}
-
-#ifdef __GNUC__
-  #pragma GCC diagnostic pop
-#endif  // __GNUC__
-
-// @@protoc_insertion_point(namespace_scope)
-
-}  // namespace message
-
-namespace google {
-namespace protobuf {
-
-template <> struct is_proto_enum< ::message::Step_type> : ::google::protobuf::internal::true_type {};
-template <>
-inline const EnumDescriptor* GetEnumDescriptor< ::message::Step_type>() {
-  return ::message::Step_type_descriptor();
-}
-template <> struct is_proto_enum< ::message::Operation_type> : ::google::protobuf::internal::true_type {};
-template <>
-inline const EnumDescriptor* GetEnumDescriptor< ::message::Operation_type>() {
-  return ::message::Operation_type_descriptor();
-}
-
-}  // namespace protobuf
-}  // namespace google
-
-// @@protoc_insertion_point(global_scope)
-
-#endif  // PROTOBUF_manual_5foperation_5fmessage_2eproto__INCLUDED

message/manual_operation_message.proto

@@ -1,46 +0,0 @@
-syntax = "proto2";
-package message;
-import "message_base.proto";
-
-//所属步骤类型
-enum Step_type
-{
-    eAlloc_step=0;
-    eMeasure_step=1;
-    eCompare_step=2;
-    eDispatch_step=3;
-    eConfirm_step=4;
-
-    eSearch_step=5;        //查询数据库
-    eWait_step=6;             //等待车辆离开
-    eRelease_step=7;          //释放车位
-
-    eComplete=8;              //完成
-
-    eBackConfirm_step=9;
-    eBack_compare_step=10;
-    eBackMeasure_step=11;
-    eBackAlloc_step=12;
-
-    eBackWait_step=13;
-    eBackDispatch_step=14;
-    eBackSearch_step=15;
-
-    eBackComplete=16;
-}
-
-//手动操作类型
-enum Operation_type
-{
-    eManual_cancel=0;                   //取消流程
-    eManual_retry=1;                    //重试
-}
-
-//中控手动操作消息
-message Manual_operation_msg
-{
-    required Base_info                  base_info=1;
-    required string                     license=2;
-    required Step_type                  step_type=3;
-    required Operation_type             operate_type=4;
-}

message/message_base.pb.cc

@@ -342,7 +342,7 @@ void AddDescriptorsImpl() {
       "\016\n\006height\030\007 \001(\002\0223\n\020parkspace_status\030\010 \001("
       "\0162\031.message.Parkspace_status\022#\n\010car_info"
       "\030\t \001(\0132\021.message.Car_info\022\022\n\nentry_time\030"
-      "\n \001(\t\022\022\n\nleave_time\030\013 \001(\t*\376\006\n\014Message_ty"
+      "\n \001(\t\022\022\n\nleave_time\030\013 \001(\t*\253\007\n\014Message_ty"
       "pe\022\r\n\teBase_msg\020\000\022\020\n\014eCommand_msg\020\001\022\026\n\022e"
       "Locate_status_msg\020\021\022\027\n\023eLocate_request_m"
       "sg\020\022\022\030\n\024eLocate_response_msg\020\023\022\030\n\024eDispa"
@@ -364,21 +364,22 @@ void AddDescriptorsImpl() {
       "\n\034ePickup_command_response_msg\020D\022\037\n\032eSto"
       "ring_process_statu_msg\020\220\001\022\037\n\032ePicking_pr"
       "ocess_statu_msg\020\221\001\022\"\n\035eCentral_controlle"
-      "r_statu_msg\020\240\001\022\032\n\025eManual_operation_msg\020"
-      "\260\001*f\n\014Communicator\022\n\n\006eEmpty\020\000\022\t\n\005eMain\020"
-      "\001\022\016\n\teTerminor\020\200\002\022\017\n\neParkspace\020\200\004\022\016\n\teM"
-      "easurer\020\200\006\022\016\n\teDispatch\020\200\010*#\n\005Event\022\014\n\010e"
-      "Storing\020\001\022\014\n\010ePicking\020\002*e\n\013Error_level\022\n"
-      "\n\006NORMAL\020\000\022\024\n\020NEGLIGIBLE_ERROR\020\001\022\017\n\013MINO"
-      "R_ERROR\020\002\022\017\n\013MAJOR_ERROR\020\003\022\022\n\016CRITICAL_E"
-      "RROR\020\004*q\n\020Parkspace_status\022\024\n\020eParkspace"
-      "_empty\020\000\022\027\n\023eParkspace_occupied\020\001\022\030\n\024ePa"
-      "rkspace_reserverd\020\002\022\024\n\020eParkspace_error\020"
-      "\003*(\n\tDirection\022\014\n\010eForward\020\001\022\r\n\teBackwar"
-      "d\020\002"
+      "r_statu_msg\020\240\001\022#\n\036eEntrance_manual_opera"
+      "tion_msg\020\260\001\022\"\n\035eProcess_manual_operation"
+      "_msg\020\261\001*f\n\014Communicator\022\n\n\006eEmpty\020\000\022\t\n\005e"
+      "Main\020\001\022\016\n\teTerminor\020\200\002\022\017\n\neParkspace\020\200\004\022"
+      "\016\n\teMeasurer\020\200\006\022\016\n\teDispatch\020\200\010**\n\014Proce"
+      "ss_type\022\014\n\010eStoring\020\001\022\014\n\010ePicking\020\002*e\n\013E"
+      "rror_level\022\n\n\006NORMAL\020\000\022\024\n\020NEGLIGIBLE_ERR"
+      "OR\020\001\022\017\n\013MINOR_ERROR\020\002\022\017\n\013MAJOR_ERROR\020\003\022\022"
+      "\n\016CRITICAL_ERROR\020\004*q\n\020Parkspace_status\022\024"
+      "\n\020eParkspace_empty\020\000\022\027\n\023eParkspace_occup"
+      "ied\020\001\022\030\n\024eParkspace_reserverd\020\002\022\024\n\020ePark"
+      "space_error\020\003*(\n\tDirection\022\014\n\010eForward\020\001"
+      "\022\r\n\teBackward\020\002"
   };
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
-      descriptor, 2243);
+      descriptor, 2295);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "message_base.proto", &protobuf_RegisterTypes);
 }
@@ -428,6 +429,7 @@ bool Message_type_IsValid(int value) {
     case 145:
     case 160:
     case 176:
+    case 177:
       return true;
     default:
       return false;
@@ -452,11 +454,11 @@ bool Communicator_IsValid(int value) {
   }
 }
 
-const ::google::protobuf::EnumDescriptor* Event_descriptor() {
+const ::google::protobuf::EnumDescriptor* Process_type_descriptor() {
   protobuf_message_5fbase_2eproto::protobuf_AssignDescriptorsOnce();
   return protobuf_message_5fbase_2eproto::file_level_enum_descriptors[2];
 }
-bool Event_IsValid(int value) {
+bool Process_type_IsValid(int value) {
   switch (value) {
     case 1:
     case 2:

message/message_base.pb.h

@@ -113,11 +113,12 @@ enum Message_type {
   eStoring_process_statu_msg = 144,
   ePicking_process_statu_msg = 145,
   eCentral_controller_statu_msg = 160,
-  eManual_operation_msg = 176
+  eEntrance_manual_operation_msg = 176,
+  eProcess_manual_operation_msg = 177
 };
 bool Message_type_IsValid(int value);
 const Message_type Message_type_MIN = eBase_msg;
-const Message_type Message_type_MAX = eManual_operation_msg;
+const Message_type Message_type_MAX = eProcess_manual_operation_msg;
 const int Message_type_ARRAYSIZE = Message_type_MAX + 1;
 
 const ::google::protobuf::EnumDescriptor* Message_type_descriptor();
@@ -153,24 +154,24 @@ inline bool Communicator_Parse(
   return ::google::protobuf::internal::ParseNamedEnum<Communicator>(
     Communicator_descriptor(), name, value);
 }
-enum Event {
+enum Process_type {
   eStoring = 1,
   ePicking = 2
 };
-bool Event_IsValid(int value);
-const Event Event_MIN = eStoring;
-const Event Event_MAX = ePicking;
-const int Event_ARRAYSIZE = Event_MAX + 1;
+bool Process_type_IsValid(int value);
+const Process_type Process_type_MIN = eStoring;
+const Process_type Process_type_MAX = ePicking;
+const int Process_type_ARRAYSIZE = Process_type_MAX + 1;
 
-const ::google::protobuf::EnumDescriptor* Event_descriptor();
-inline const ::std::string& Event_Name(Event value) {
+const ::google::protobuf::EnumDescriptor* Process_type_descriptor();
+inline const ::std::string& Process_type_Name(Process_type value) {
   return ::google::protobuf::internal::NameOfEnum(
-    Event_descriptor(), value);
+    Process_type_descriptor(), value);
 }
-inline bool Event_Parse(
-    const ::std::string& name, Event* value) {
-  return ::google::protobuf::internal::ParseNamedEnum<Event>(
-    Event_descriptor(), name, value);
+inline bool Process_type_Parse(
+    const ::std::string& name, Process_type* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<Process_type>(
+    Process_type_descriptor(), name, value);
 }
 enum Error_level {
   NORMAL = 0,
@@ -2245,10 +2246,10 @@ template <>
 inline const EnumDescriptor* GetEnumDescriptor< ::message::Communicator>() {
   return ::message::Communicator_descriptor();
 }
-template <> struct is_proto_enum< ::message::Event> : ::google::protobuf::internal::true_type {};
+template <> struct is_proto_enum< ::message::Process_type> : ::google::protobuf::internal::true_type {};
 template <>
-inline const EnumDescriptor* GetEnumDescriptor< ::message::Event>() {
-  return ::message::Event_descriptor();
+inline const EnumDescriptor* GetEnumDescriptor< ::message::Process_type>() {
+  return ::message::Process_type_descriptor();
 }
 template <> struct is_proto_enum< ::message::Error_level> : ::google::protobuf::internal::true_type {};
 template <>

message/message_base.proto

@@ -44,7 +44,8 @@ enum Message_type
     eCentral_controller_statu_msg=0xa0;     //中控系统状态消息
 
 
-    eManual_operation_msg=0xb0;             //中控手动操作消息
+    eEntrance_manual_operation_msg=0xb0;            //针对出入口状态操作的手动消息
+    eProcess_manual_operation_msg=0xb1;             //针对流程的手动消息
 
 
 }
@@ -76,7 +77,7 @@ message Base_info
 }
 
 // 事件,停车或者取车
-enum Event
+enum Process_type
 {
     eStoring=1;
     ePicking=2;

proto.sh

@@ -5,7 +5,5 @@ protoc -I=./message terminal_message.proto --cpp_out=./message
 protoc -I=./message process_message.proto --cpp_out=./message
 protoc -I=./message dispatch_message.proto --cpp_out=./message
 protoc -I=./message central_control_message.proto --cpp_out=./message
-protoc -I=./message manual_operation_message.proto --cpp_out=./message
-
 
 protoc -I=./system system_setting.proto --cpp_out=./system

solve_exception/exception_solver.cpp

@@ -53,9 +53,9 @@ Error_manager Exception_solver::execute_msg(Communication_message* p_msg)
 
     switch (p_msg->get_message_type())
     {
-        case Communication_message::eManual_operation_msg:
+        case Communication_message::eProcess_manual_operation_msg:
         {
-            message::Manual_operation_msg msg;
+            message::Process_manual_operation_msg msg;
             if(msg.ParseFromString(p_msg->get_message_buf())==false)
             {
                 LOG(ERROR)<<"  手动消息解析失败  !!!";
@@ -69,6 +69,29 @@ Error_manager Exception_solver::execute_msg(Communication_message* p_msg)
             LOG(INFO)<<"接收到手动消息//////////////////////////  : "<<msg.license();
             m_manual_msg_map[msg.license()]=msg;
         }
+        case Communication_message::eEntrance_manual_operation_msg:
+        {
+            message::Entrance_manual_operation_msg msg;
+            if(msg.ParseFromString(p_msg->get_message_buf())==false)
+            {
+                LOG(ERROR)<<"  手动消息解析失败  !!!";
+                break;
+            }
+            LOG(INFO)<<" communication 接收到手动消息  : "<<msg.GetTypeName();
+            switch (msg.process_type())
+            {
+                case message::eStoring:
+                {
+                    Command_manager::get_instance_pointer()->enable_entrance(msg.terminal_id(),(Command_manager::Entrance_statu)msg.entrance_statu());
+                    break;
+                }
+                case message::ePicking:
+                {
+                    Command_manager::get_instance_pointer()->enable_export(msg.terminal_id(),(Command_manager::Entrance_statu)msg.entrance_statu());
+                    break;
+                }
+            }
+        }
 
         default:break;
     }
@@ -97,7 +120,7 @@ Error_manager Exception_solver::check_executer(Communication_message* p_msg)
 /*
      * 等待手动消息
      */
-Error_manager Exception_solver::waitfor_manual_operate_msg(Process_task* task,message::Manual_operation_msg msg)
+Error_manager Exception_solver::waitfor_manual_operate_msg(Process_task* task,message::Process_manual_operation_msg& msg)
 {
     //清除旧的手动操作消息
     if(m_manual_msg_map.find(task->license()))
@@ -109,13 +132,14 @@ Error_manager Exception_solver::waitfor_manual_operate_msg(Process_task* task,me
         {
             if(msg.has_base_info() && msg.has_license() && msg.has_operate_type() && msg.has_step_type())
             {
-                if(msg.license()==task->license()&&msg.step_type()==task->step_type()) {
-                    LOG(INFO) << "查询到手动消息|||||||||||||||  : " << msg.license();
+                if(msg.license()==task->license()&& msg.step_type()==task->step_type()) {
+                    LOG(INFO) << " 查询到: " << task->license()<<"  操作类型:"<<Process_operation_type_Name(msg.operate_type());
                     return SUCCESS;
                 }
                 else
                 {
                     LOG(WARNING)<<"xxxx .. ..  非当前步骤的手动操作 车牌: "<<msg.license()<<", 操作步骤:"<<Step_type_Name(msg.step_type());
+                    m_manual_msg_map.erase(task->license());
                 }
             }
         }
@@ -136,26 +160,36 @@ Error_manager Exception_solver::solve_exception(Error_manager code,Process_task*
         if(task->GetCategory()==message::eStoring) {
             Command_manager::get_instance_pointer()->enable_entrance(task->terminal_id(),Command_manager::Entrance_statu::Disable);
             LOG(ERROR)<<"关闭入口:"<<task->terminal_id()<<"   四级故障  !!!!!!  等待手动操作 ... ";
-            message::Manual_operation_msg operate_msg;
+            message::Process_manual_operation_msg operate_msg;
             code_operate=waitfor_manual_operate_msg(task,operate_msg);
             if(code_operate!=SUCCESS)
                 return code_operate;
             switch (operate_msg.operate_type())
             {
                 //取消任务
-                case message::eManual_cancel: {
+                case message::eManual_cancel:
+                {
+                    LOG(INFO) << "手动消息 ,车牌号  : " << task->license()<<"  操作类型:"<<Process_operation_type_Name(operate_msg.operate_type());
                     task->Cancel();
-                    Command_manager::get_instance_pointer()->enable_entrance(task->terminal_id(),Command_manager::Entrance_statu::Enable);
-                    return SUCCESS;
+                    Command_manager::get_instance_pointer()->enable_entrance(task->terminal_id(),
+                            Command_manager::Entrance_statu::Enable);
+                    break;
+                }
+                case message::eManual_retry:{
+                    LOG(INFO) << "手动消息 ,车牌号  : " << task->license()<<"  操作类型:"<<Process_operation_type_Name(operate_msg.operate_type());
+                    Command_manager::get_instance_pointer()->enable_entrance(task->terminal_id(),
+                                                                             Command_manager::Entrance_statu::Enable);
+                    break;
                 }
             }
 
 
+
         }
         if(task->GetCategory()==message::ePicking) {
             Command_manager::get_instance_pointer()->enable_export(task->terminal_id(),Command_manager::Entrance_statu::Disable);
             LOG(ERROR)<<"关闭出口:"<<task->terminal_id()<<"   四级故障  !!!!!!  等待手动操作 ...";
-            message::Manual_operation_msg operate_msg;
+            message::Process_manual_operation_msg operate_msg;
             code_operate=waitfor_manual_operate_msg(task,operate_msg);
             if(code_operate!=SUCCESS)
                 return code_operate;

solve_exception/exception_solver.h

@@ -7,7 +7,7 @@
 #include "communication_socket_base.h"
 
 #include "singleton.h"
-#include "manual_operation_message.pb.h"
+#include "central_control_message.pb.h"
 #include "error_code.h"
 #include "thread_safe_map.h"
 #include "StoreProcessTask.h"
@@ -37,7 +37,7 @@ public:
     /*
      * 等待手动消息
      */
-    Error_manager waitfor_manual_operate_msg(Process_task* task,message::Manual_operation_msg msg);
+    Error_manager waitfor_manual_operate_msg(Process_task* task,message::Process_manual_operation_msg& msg);
 
 protected:
     Exception_solver();
@@ -56,8 +56,8 @@ protected:
     virtual Error_manager check_executer(Communication_message* p_msg);
 
 private:
-    thread_safe_map<std::string,tq::BaseTask*>                  m_ptask_map;
-    thread_safe_map<std::string,message::Manual_operation_msg>  m_manual_msg_map;
+    thread_safe_map<std::string,tq::BaseTask*>                              m_ptask_map;
+    thread_safe_map<std::string,message::Process_manual_operation_msg>      m_manual_msg_map;
 
 };
 

system/StoreProcessTask.cpp

@@ -96,7 +96,9 @@ Error_manager StoreProcessTask::back_locate_step()
 {
     m_measure_request_msg=message::Measure_request_msg();
     m_measure_response_msg=message::Measure_response_msg();
-
+    int k=rand()%5;
+    if(k==0)
+        return Error_manager(ERROR,CRITICAL_ERROR,"回退测量对比失败");
     return SUCCESS;
 }
 
@@ -112,7 +114,7 @@ Error_manager StoreProcessTask::compare_step()
  */
 Error_manager StoreProcessTask::back_compare_step()
 {
-    int k=rand()%10;
+    int k=rand()%5;
     if(k==0)
         return Error_manager(ERROR,CRITICAL_ERROR,"回退检验对比失败");
     return SUCCESS;
@@ -309,12 +311,15 @@ Error_manager StoreProcessTask::confirm_space_step()
  */
 Error_manager StoreProcessTask::back_alloc_space_step()
 {
+    int k=rand()%5;
+    if(k==0)
+        return Error_manager(ERROR,CRITICAL_ERROR,"回退车位分配失败");
     /*
     * 检查是否曾经分配过车位
     */
     if(m_parcspace_alloc_response_msg.has_allocated_space_info()==false)
     {
-        return Error_manager(FAILED,MINOR_ERROR," parkspace release request without space info");
+        return Error_manager(FAILED,CRITICAL_ERROR," parkspace release request without space info");
     }
 
     /*
@@ -322,7 +327,7 @@ Error_manager StoreProcessTask::back_alloc_space_step()
      */
     Error_manager code=Parkspace_communicator::get_instance_pointer()->check_statu();
     if(code!=SUCCESS)
-        return code;
+        return Error_manager(code.get_error_code(),CRITICAL_ERROR,code.get_error_description());
 
     message::Parkspace_release_request_msg request;
     message::Base_info base_info;
@@ -339,7 +344,7 @@ Error_manager StoreProcessTask::back_alloc_space_step()
     message::Parkspace_release_response_msg release_response;
     code=Parkspace_communicator::get_instance_pointer()->release_request(request,release_response,m_cancel_condition);
     if(code!=SUCCESS)
-        return code;
+        return Error_manager(code.get_error_code(),CRITICAL_ERROR,code.get_error_description());
 
     if(release_response.error_manager().error_code()==0) {
         /*LOG(WARNING)<<"停车流程异常,释放车位成功,停车终端:"<<m_terminor_id
@@ -356,7 +361,7 @@ Error_manager StoreProcessTask::back_alloc_space_step()
     {
         Error_code t_code=(Error_code)release_response.error_manager().error_code();
         Error_level t_level=(Error_level)release_response.error_manager().error_level();
-        return Error_manager(t_code,t_level,"parkspace release response error_code error");
+        return Error_manager(t_code,CRITICAL_ERROR,"back alloc response error_code error");
     }
 }