注释掉新日志

communication/communication.pb.cc

@@ -5,347 +5,280 @@
 
 #include <algorithm>
 
-#include <google/protobuf/stubs/common.h>
-#include <google/protobuf/stubs/port.h>
 #include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.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 protobuf_communication_2eproto {
-extern PROTOBUF_INTERNAL_EXPORT_protobuf_communication_2eproto ::google::protobuf::internal::SCCInfo<0> scc_info_Communication_parameter;
-}  // namespace protobuf_communication_2eproto
+#include <google/protobuf/port_def.inc>
+extern PROTOBUF_INTERNAL_EXPORT_communication_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Communication_parameter_communication_2eproto;
 namespace Communication_proto {
 class Communication_parameterDefaultTypeInternal {
  public:
-  ::google::protobuf::internal::ExplicitlyConstructed<Communication_parameter>
-      _instance;
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Communication_parameter> _instance;
 } _Communication_parameter_default_instance_;
 class Communication_parameter_allDefaultTypeInternal {
  public:
-  ::google::protobuf::internal::ExplicitlyConstructed<Communication_parameter_all>
-      _instance;
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Communication_parameter_all> _instance;
 } _Communication_parameter_all_default_instance_;
 }  // namespace Communication_proto
-namespace protobuf_communication_2eproto {
-static void InitDefaultsCommunication_parameter() {
+static void InitDefaultsscc_info_Communication_parameter_communication_2eproto() {
   GOOGLE_PROTOBUF_VERIFY_VERSION;
 
   {
     void* ptr = &::Communication_proto::_Communication_parameter_default_instance_;
     new (ptr) ::Communication_proto::Communication_parameter();
-    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
   }
   ::Communication_proto::Communication_parameter::InitAsDefaultInstance();
 }
 
-::google::protobuf::internal::SCCInfo<0> scc_info_Communication_parameter =
-    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsCommunication_parameter}, {}};
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Communication_parameter_communication_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_Communication_parameter_communication_2eproto}, {}};
 
-static void InitDefaultsCommunication_parameter_all() {
+static void InitDefaultsscc_info_Communication_parameter_all_communication_2eproto() {
   GOOGLE_PROTOBUF_VERIFY_VERSION;
 
   {
     void* ptr = &::Communication_proto::_Communication_parameter_all_default_instance_;
     new (ptr) ::Communication_proto::Communication_parameter_all();
-    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
   }
   ::Communication_proto::Communication_parameter_all::InitAsDefaultInstance();
 }
 
-::google::protobuf::internal::SCCInfo<1> scc_info_Communication_parameter_all =
-    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsCommunication_parameter_all}, {
-      &protobuf_communication_2eproto::scc_info_Communication_parameter.base,}};
-
-void InitDefaults() {
-  ::google::protobuf::internal::InitSCC(&scc_info_Communication_parameter.base);
-  ::google::protobuf::internal::InitSCC(&scc_info_Communication_parameter_all.base);
-}
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_Communication_parameter_all_communication_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_Communication_parameter_all_communication_2eproto}, {
+      &scc_info_Communication_parameter_communication_2eproto.base,}};
 
-::google::protobuf::Metadata file_level_metadata[2];
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_communication_2eproto[2];
+static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_communication_2eproto = nullptr;
+static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_communication_2eproto = nullptr;
 
-const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
-  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Communication_proto::Communication_parameter, _has_bits_),
-  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Communication_proto::Communication_parameter, _internal_metadata_),
+const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_communication_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  PROTOBUF_FIELD_OFFSET(::Communication_proto::Communication_parameter, _has_bits_),
+  PROTOBUF_FIELD_OFFSET(::Communication_proto::Communication_parameter, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
-  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Communication_proto::Communication_parameter, bind_string_),
-  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Communication_proto::Communication_parameter, connect_string_vector_),
+  PROTOBUF_FIELD_OFFSET(::Communication_proto::Communication_parameter, bind_string_),
+  PROTOBUF_FIELD_OFFSET(::Communication_proto::Communication_parameter, connect_string_vector_),
   0,
   ~0u,
-  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Communication_proto::Communication_parameter_all, _has_bits_),
-  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Communication_proto::Communication_parameter_all, _internal_metadata_),
+  PROTOBUF_FIELD_OFFSET(::Communication_proto::Communication_parameter_all, _has_bits_),
+  PROTOBUF_FIELD_OFFSET(::Communication_proto::Communication_parameter_all, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
-  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Communication_proto::Communication_parameter_all, communication_parameters_),
+  PROTOBUF_FIELD_OFFSET(::Communication_proto::Communication_parameter_all, communication_parameters_),
   0,
 };
-static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
+static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
   { 0, 7, sizeof(::Communication_proto::Communication_parameter)},
   { 9, 15, sizeof(::Communication_proto::Communication_parameter_all)},
 };
 
-static ::google::protobuf::Message const * const file_default_instances[] = {
-  reinterpret_cast<const ::google::protobuf::Message*>(&::Communication_proto::_Communication_parameter_default_instance_),
-  reinterpret_cast<const ::google::protobuf::Message*>(&::Communication_proto::_Communication_parameter_all_default_instance_),
+static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::Communication_proto::_Communication_parameter_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::Communication_proto::_Communication_parameter_all_default_instance_),
 };
 
-void protobuf_AssignDescriptors() {
-  AddDescriptors();
-  AssignDescriptors(
-      "communication.proto", schemas, file_default_instances, TableStruct::offsets,
-      file_level_metadata, NULL, NULL);
-}
-
-void protobuf_AssignDescriptorsOnce() {
-  static ::google::protobuf::internal::once_flag once;
-  ::google::protobuf::internal::call_once(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, 2);
-}
-
-void AddDescriptorsImpl() {
-  InitDefaults();
-  static const char descriptor[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
-      "\n\023communication.proto\022\023Communication_pro"
-      "to\"M\n\027Communication_parameter\022\023\n\013bind_st"
-      "ring\030\001 \001(\t\022\035\n\025connect_string_vector\030\002 \003("
-      "\t\"m\n\033Communication_parameter_all\022N\n\030comm"
-      "unication_parameters\030\001 \001(\0132,.Communicati"
-      "on_proto.Communication_parameter"
-  };
-  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
-      descriptor, 232);
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
-    "communication.proto", &protobuf_RegisterTypes);
-}
+const char descriptor_table_protodef_communication_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n\023communication.proto\022\023Communication_pro"
+  "to\"M\n\027Communication_parameter\022\023\n\013bind_st"
+  "ring\030\001 \001(\t\022\035\n\025connect_string_vector\030\002 \003("
+  "\t\"m\n\033Communication_parameter_all\022N\n\030comm"
+  "unication_parameters\030\001 \001(\0132,.Communicati"
+  "on_proto.Communication_parameter"
+  ;
+static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_communication_2eproto_deps[1] = {
+};
+static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_communication_2eproto_sccs[2] = {
+  &scc_info_Communication_parameter_communication_2eproto.base,
+  &scc_info_Communication_parameter_all_communication_2eproto.base,
+};
+static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_communication_2eproto_once;
+const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_communication_2eproto = {
+  false, false, descriptor_table_protodef_communication_2eproto, "communication.proto", 232,
+  &descriptor_table_communication_2eproto_once, descriptor_table_communication_2eproto_sccs, descriptor_table_communication_2eproto_deps, 2, 0,
+  schemas, file_default_instances, TableStruct_communication_2eproto::offsets,
+  file_level_metadata_communication_2eproto, 2, file_level_enum_descriptors_communication_2eproto, file_level_service_descriptors_communication_2eproto,
+};
 
-void AddDescriptors() {
-  static ::google::protobuf::internal::once_flag once;
-  ::google::protobuf::internal::call_once(once, AddDescriptorsImpl);
-}
-// Force AddDescriptors() to be called at dynamic initialization time.
-struct StaticDescriptorInitializer {
-  StaticDescriptorInitializer() {
-    AddDescriptors();
-  }
-} static_descriptor_initializer;
-}  // namespace protobuf_communication_2eproto
+// Force running AddDescriptors() at dynamic initialization time.
+static bool dynamic_init_dummy_communication_2eproto = (static_cast<void>(::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_communication_2eproto)), true);
 namespace Communication_proto {
 
 // ===================================================================
 
 void Communication_parameter::InitAsDefaultInstance() {
 }
-#if !defined(_MSC_VER) || _MSC_VER >= 1900
-const int Communication_parameter::kBindStringFieldNumber;
-const int Communication_parameter::kConnectStringVectorFieldNumber;
-#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+class Communication_parameter::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Communication_parameter>()._has_bits_);
+  static void set_has_bind_string(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
 
-Communication_parameter::Communication_parameter()
-  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
-  ::google::protobuf::internal::InitSCC(
-      &protobuf_communication_2eproto::scc_info_Communication_parameter.base);
+Communication_parameter::Communication_parameter(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena),
+  connect_string_vector_(arena) {
   SharedCtor();
-  // @@protoc_insertion_point(constructor:Communication_proto.Communication_parameter)
+  RegisterArenaDtor(arena);
+  // @@protoc_insertion_point(arena_constructor:Communication_proto.Communication_parameter)
 }
 Communication_parameter::Communication_parameter(const Communication_parameter& from)
-  : ::google::protobuf::Message(),
-      _internal_metadata_(NULL),
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
       _has_bits_(from._has_bits_),
       connect_string_vector_(from.connect_string_vector_) {
-  _internal_metadata_.MergeFrom(from._internal_metadata_);
-  bind_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  if (from.has_bind_string()) {
-    bind_string_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.bind_string_);
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  bind_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (from._internal_has_bind_string()) {
+    bind_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_bind_string(),
+      GetArena());
   }
   // @@protoc_insertion_point(copy_constructor:Communication_proto.Communication_parameter)
 }
 
 void Communication_parameter::SharedCtor() {
-  bind_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Communication_parameter_communication_2eproto.base);
+  bind_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 }
 
 Communication_parameter::~Communication_parameter() {
   // @@protoc_insertion_point(destructor:Communication_proto.Communication_parameter)
   SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
 void Communication_parameter::SharedDtor() {
-  bind_string_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  GOOGLE_DCHECK(GetArena() == nullptr);
+  bind_string_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 }
 
+void Communication_parameter::ArenaDtor(void* object) {
+  Communication_parameter* _this = reinterpret_cast< Communication_parameter* >(object);
+  (void)_this;
+}
+void Communication_parameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
 void Communication_parameter::SetCachedSize(int size) const {
   _cached_size_.Set(size);
 }
-const ::google::protobuf::Descriptor* Communication_parameter::descriptor() {
-  ::protobuf_communication_2eproto::protobuf_AssignDescriptorsOnce();
-  return ::protobuf_communication_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
-}
-
 const Communication_parameter& Communication_parameter::default_instance() {
-  ::google::protobuf::internal::InitSCC(&protobuf_communication_2eproto::scc_info_Communication_parameter.base);
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Communication_parameter_communication_2eproto.base);
   return *internal_default_instance();
 }
 
 
 void Communication_parameter::Clear() {
 // @@protoc_insertion_point(message_clear_start:Communication_proto.Communication_parameter)
-  ::google::protobuf::uint32 cached_has_bits = 0;
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
   connect_string_vector_.Clear();
   cached_has_bits = _has_bits_[0];
   if (cached_has_bits & 0x00000001u) {
-    bind_string_.ClearNonDefaultToEmptyNoArena();
+    bind_string_.ClearNonDefaultToEmpty();
   }
   _has_bits_.Clear();
-  _internal_metadata_.Clear();
-}
-
-bool Communication_parameter::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:Communication_proto.Communication_parameter)
-  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)) {
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Communication_parameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
       // optional string bind_string = 1;
-      case 1: {
-        if (static_cast< ::google::protobuf::uint8>(tag) ==
-            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_bind_string()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->bind_string().data(), static_cast<int>(this->bind_string().length()),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "Communication_proto.Communication_parameter.bind_string");
-        } else {
-          goto handle_unusual;
-        }
-        break;
-      }
-
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          auto str = _internal_mutable_bind_string();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          #ifndef NDEBUG
+          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "Communication_proto.Communication_parameter.bind_string");
+          #endif  // !NDEBUG
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
       // repeated string connect_string_vector = 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->add_connect_string_vector()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->connect_string_vector(this->connect_string_vector_size() - 1).data(),
-            static_cast<int>(this->connect_string_vector(this->connect_string_vector_size() - 1).length()),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "Communication_proto.Communication_parameter.connect_string_vector");
-        } else {
-          goto handle_unusual;
-        }
-        break;
-      }
-
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_connect_string_vector();
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+            #ifndef NDEBUG
+            ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "Communication_proto.Communication_parameter.connect_string_vector");
+            #endif  // !NDEBUG
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else goto handle_unusual;
+        continue;
       default: {
       handle_unusual:
-        if (tag == 0) {
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
           goto success;
         }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, _internal_metadata_.mutable_unknown_fields()));
-        break;
+        ptr = UnknownFieldParse(tag,
+            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+            ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
       }
-    }
-  }
+    }  // switch
+  }  // while
 success:
-  // @@protoc_insertion_point(parse_success:Communication_proto.Communication_parameter)
-  return true;
+  _has_bits_.Or(has_bits);
+  return ptr;
 failure:
-  // @@protoc_insertion_point(parse_failure:Communication_proto.Communication_parameter)
-  return false;
-#undef DO_
-}
-
-void Communication_parameter::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:Communication_proto.Communication_parameter)
-  ::google::protobuf::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional string bind_string = 1;
-  if (cached_has_bits & 0x00000001u) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->bind_string().data(), static_cast<int>(this->bind_string().length()),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "Communication_proto.Communication_parameter.bind_string");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      1, this->bind_string(), output);
-  }
-
-  // repeated string connect_string_vector = 2;
-  for (int i = 0, n = this->connect_string_vector_size(); i < n; i++) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->connect_string_vector(i).data(), static_cast<int>(this->connect_string_vector(i).length()),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "Communication_proto.Communication_parameter.connect_string_vector");
-    ::google::protobuf::internal::WireFormatLite::WriteString(
-      2, this->connect_string_vector(i), output);
-  }
-
-  if (_internal_metadata_.have_unknown_fields()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        _internal_metadata_.unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:Communication_proto.Communication_parameter)
+  ptr = nullptr;
+  goto success;
+#undef CHK_
 }
 
-::google::protobuf::uint8* Communication_parameter::InternalSerializeWithCachedSizesToArray(
-    bool deterministic, ::google::protobuf::uint8* target) const {
-  (void)deterministic; // Unused
+::PROTOBUF_NAMESPACE_ID::uint8* Communication_parameter::_InternalSerialize(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
   // @@protoc_insertion_point(serialize_to_array_start:Communication_proto.Communication_parameter)
-  ::google::protobuf::uint32 cached_has_bits = 0;
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   (void) cached_has_bits;
 
   cached_has_bits = _has_bits_[0];
   // optional string bind_string = 1;
   if (cached_has_bits & 0x00000001u) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->bind_string().data(), static_cast<int>(this->bind_string().length()),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_bind_string().data(), static_cast<int>(this->_internal_bind_string().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
       "Communication_proto.Communication_parameter.bind_string");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        1, this->bind_string(), target);
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_bind_string(), target);
   }
 
   // repeated string connect_string_vector = 2;
-  for (int i = 0, n = this->connect_string_vector_size(); i < n; i++) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->connect_string_vector(i).data(), static_cast<int>(this->connect_string_vector(i).length()),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
+  for (int i = 0, n = this->_internal_connect_string_vector_size(); i < n; i++) {
+    const auto& s = this->_internal_connect_string_vector(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
       "Communication_proto.Communication_parameter.connect_string_vector");
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteStringToArray(2, this->connect_string_vector(i), target);
+    target = stream->WriteString(2, s, target);
   }
 
-  if (_internal_metadata_.have_unknown_fields()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        _internal_metadata_.unknown_fields(), target);
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
   // @@protoc_insertion_point(serialize_to_array_end:Communication_proto.Communication_parameter)
   return target;
@@ -355,40 +288,44 @@ size_t Communication_parameter::ByteSizeLong() const {
 // @@protoc_insertion_point(message_byte_size_start:Communication_proto.Communication_parameter)
   size_t total_size = 0;
 
-  if (_internal_metadata_.have_unknown_fields()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        _internal_metadata_.unknown_fields());
-  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
   // repeated string connect_string_vector = 2;
   total_size += 1 *
-      ::google::protobuf::internal::FromIntSize(this->connect_string_vector_size());
-  for (int i = 0, n = this->connect_string_vector_size(); i < n; i++) {
-    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
-      this->connect_string_vector(i));
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(connect_string_vector_.size());
+  for (int i = 0, n = connect_string_vector_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      connect_string_vector_.Get(i));
   }
 
   // optional string bind_string = 1;
-  if (has_bind_string()) {
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
     total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::StringSize(
-        this->bind_string());
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_bind_string());
   }
 
-  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+        _internal_metadata_, total_size, &_cached_size_);
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
   SetCachedSize(cached_size);
   return total_size;
 }
 
-void Communication_parameter::MergeFrom(const ::google::protobuf::Message& from) {
+void Communication_parameter::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
 // @@protoc_insertion_point(generalized_merge_from_start:Communication_proto.Communication_parameter)
   GOOGLE_DCHECK_NE(&from, this);
   const Communication_parameter* source =
-      ::google::protobuf::internal::DynamicCastToGenerated<const Communication_parameter>(
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Communication_parameter>(
           &from);
-  if (source == NULL) {
+  if (source == nullptr) {
   // @@protoc_insertion_point(generalized_merge_from_cast_fail:Communication_proto.Communication_parameter)
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
   } else {
   // @@protoc_insertion_point(generalized_merge_from_cast_success:Communication_proto.Communication_parameter)
     MergeFrom(*source);
@@ -398,18 +335,17 @@ void Communication_parameter::MergeFrom(const ::google::protobuf::Message& from)
 void Communication_parameter::MergeFrom(const Communication_parameter& from) {
 // @@protoc_insertion_point(class_specific_merge_from_start:Communication_proto.Communication_parameter)
   GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom(from._internal_metadata_);
-  ::google::protobuf::uint32 cached_has_bits = 0;
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   (void) cached_has_bits;
 
   connect_string_vector_.MergeFrom(from.connect_string_vector_);
-  if (from.has_bind_string()) {
-    set_has_bind_string();
-    bind_string_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.bind_string_);
+  if (from._internal_has_bind_string()) {
+    _internal_set_bind_string(from._internal_bind_string());
   }
 }
 
-void Communication_parameter::CopyFrom(const ::google::protobuf::Message& from) {
+void Communication_parameter::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
 // @@protoc_insertion_point(generalized_copy_from_start:Communication_proto.Communication_parameter)
   if (&from == this) return;
   Clear();
@@ -427,22 +363,16 @@ bool Communication_parameter::IsInitialized() const {
   return true;
 }
 
-void Communication_parameter::Swap(Communication_parameter* other) {
-  if (other == this) return;
-  InternalSwap(other);
-}
 void Communication_parameter::InternalSwap(Communication_parameter* other) {
   using std::swap;
-  connect_string_vector_.InternalSwap(CastToBase(&other->connect_string_vector_));
-  bind_string_.Swap(&other->bind_string_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
-    GetArenaNoVirtual());
+  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
   swap(_has_bits_[0], other->_has_bits_[0]);
-  _internal_metadata_.Swap(&other->_internal_metadata_);
+  connect_string_vector_.InternalSwap(&other->connect_string_vector_);
+  bind_string_.Swap(&other->bind_string_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 }
 
-::google::protobuf::Metadata Communication_parameter::GetMetadata() const {
-  protobuf_communication_2eproto::protobuf_AssignDescriptorsOnce();
-  return ::protobuf_communication_2eproto::file_level_metadata[kIndexInFileMessages];
+::PROTOBUF_NAMESPACE_ID::Metadata Communication_parameter::GetMetadata() const {
+  return GetMetadataStatic();
 }
 
 
@@ -452,152 +382,140 @@ void Communication_parameter_all::InitAsDefaultInstance() {
   ::Communication_proto::_Communication_parameter_all_default_instance_._instance.get_mutable()->communication_parameters_ = const_cast< ::Communication_proto::Communication_parameter*>(
       ::Communication_proto::Communication_parameter::internal_default_instance());
 }
-#if !defined(_MSC_VER) || _MSC_VER >= 1900
-const int Communication_parameter_all::kCommunicationParametersFieldNumber;
-#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+class Communication_parameter_all::_Internal {
+ public:
+  using HasBits = decltype(std::declval<Communication_parameter_all>()._has_bits_);
+  static const ::Communication_proto::Communication_parameter& communication_parameters(const Communication_parameter_all* msg);
+  static void set_has_communication_parameters(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
 
-Communication_parameter_all::Communication_parameter_all()
-  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
-  ::google::protobuf::internal::InitSCC(
-      &protobuf_communication_2eproto::scc_info_Communication_parameter_all.base);
+const ::Communication_proto::Communication_parameter&
+Communication_parameter_all::_Internal::communication_parameters(const Communication_parameter_all* msg) {
+  return *msg->communication_parameters_;
+}
+Communication_parameter_all::Communication_parameter_all(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
   SharedCtor();
-  // @@protoc_insertion_point(constructor:Communication_proto.Communication_parameter_all)
+  RegisterArenaDtor(arena);
+  // @@protoc_insertion_point(arena_constructor:Communication_proto.Communication_parameter_all)
 }
 Communication_parameter_all::Communication_parameter_all(const Communication_parameter_all& from)
-  : ::google::protobuf::Message(),
-      _internal_metadata_(NULL),
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
       _has_bits_(from._has_bits_) {
-  _internal_metadata_.MergeFrom(from._internal_metadata_);
-  if (from.has_communication_parameters()) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_communication_parameters()) {
     communication_parameters_ = new ::Communication_proto::Communication_parameter(*from.communication_parameters_);
   } else {
-    communication_parameters_ = NULL;
+    communication_parameters_ = nullptr;
   }
   // @@protoc_insertion_point(copy_constructor:Communication_proto.Communication_parameter_all)
 }
 
 void Communication_parameter_all::SharedCtor() {
-  communication_parameters_ = NULL;
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Communication_parameter_all_communication_2eproto.base);
+  communication_parameters_ = nullptr;
 }
 
 Communication_parameter_all::~Communication_parameter_all() {
   // @@protoc_insertion_point(destructor:Communication_proto.Communication_parameter_all)
   SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
 void Communication_parameter_all::SharedDtor() {
+  GOOGLE_DCHECK(GetArena() == nullptr);
   if (this != internal_default_instance()) delete communication_parameters_;
 }
 
+void Communication_parameter_all::ArenaDtor(void* object) {
+  Communication_parameter_all* _this = reinterpret_cast< Communication_parameter_all* >(object);
+  (void)_this;
+}
+void Communication_parameter_all::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
 void Communication_parameter_all::SetCachedSize(int size) const {
   _cached_size_.Set(size);
 }
-const ::google::protobuf::Descriptor* Communication_parameter_all::descriptor() {
-  ::protobuf_communication_2eproto::protobuf_AssignDescriptorsOnce();
-  return ::protobuf_communication_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
-}
-
 const Communication_parameter_all& Communication_parameter_all::default_instance() {
-  ::google::protobuf::internal::InitSCC(&protobuf_communication_2eproto::scc_info_Communication_parameter_all.base);
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Communication_parameter_all_communication_2eproto.base);
   return *internal_default_instance();
 }
 
 
 void Communication_parameter_all::Clear() {
 // @@protoc_insertion_point(message_clear_start:Communication_proto.Communication_parameter_all)
-  ::google::protobuf::uint32 cached_has_bits = 0;
+  ::PROTOBUF_NAMESPACE_ID::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 & 0x00000001u) {
-    GOOGLE_DCHECK(communication_parameters_ != NULL);
+    GOOGLE_DCHECK(communication_parameters_ != nullptr);
     communication_parameters_->Clear();
   }
   _has_bits_.Clear();
-  _internal_metadata_.Clear();
-}
-
-bool Communication_parameter_all::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:Communication_proto.Communication_parameter_all)
-  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)) {
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Communication_parameter_all::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
       // optional .Communication_proto.Communication_parameter communication_parameters = 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_communication_parameters()));
-        } else {
-          goto handle_unusual;
-        }
-        break;
-      }
-
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_communication_parameters(), ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
       default: {
       handle_unusual:
-        if (tag == 0) {
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
           goto success;
         }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, _internal_metadata_.mutable_unknown_fields()));
-        break;
+        ptr = UnknownFieldParse(tag,
+            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+            ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
       }
-    }
-  }
+    }  // switch
+  }  // while
 success:
-  // @@protoc_insertion_point(parse_success:Communication_proto.Communication_parameter_all)
-  return true;
+  _has_bits_.Or(has_bits);
+  return ptr;
 failure:
-  // @@protoc_insertion_point(parse_failure:Communication_proto.Communication_parameter_all)
-  return false;
-#undef DO_
-}
-
-void Communication_parameter_all::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:Communication_proto.Communication_parameter_all)
-  ::google::protobuf::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // optional .Communication_proto.Communication_parameter communication_parameters = 1;
-  if (cached_has_bits & 0x00000001u) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->_internal_communication_parameters(), output);
-  }
-
-  if (_internal_metadata_.have_unknown_fields()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        _internal_metadata_.unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:Communication_proto.Communication_parameter_all)
+  ptr = nullptr;
+  goto success;
+#undef CHK_
 }
 
-::google::protobuf::uint8* Communication_parameter_all::InternalSerializeWithCachedSizesToArray(
-    bool deterministic, ::google::protobuf::uint8* target) const {
-  (void)deterministic; // Unused
+::PROTOBUF_NAMESPACE_ID::uint8* Communication_parameter_all::_InternalSerialize(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
   // @@protoc_insertion_point(serialize_to_array_start:Communication_proto.Communication_parameter_all)
-  ::google::protobuf::uint32 cached_has_bits = 0;
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   (void) cached_has_bits;
 
   cached_has_bits = _has_bits_[0];
   // optional .Communication_proto.Communication_parameter communication_parameters = 1;
   if (cached_has_bits & 0x00000001u) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      InternalWriteMessageToArray(
-        1, this->_internal_communication_parameters(), deterministic, target);
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::communication_parameters(this), target, stream);
   }
 
-  if (_internal_metadata_.have_unknown_fields()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        _internal_metadata_.unknown_fields(), target);
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
   // @@protoc_insertion_point(serialize_to_array_end:Communication_proto.Communication_parameter_all)
   return target;
@@ -607,32 +525,36 @@ size_t Communication_parameter_all::ByteSizeLong() const {
 // @@protoc_insertion_point(message_byte_size_start:Communication_proto.Communication_parameter_all)
   size_t total_size = 0;
 
-  if (_internal_metadata_.have_unknown_fields()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        _internal_metadata_.unknown_fields());
-  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
   // optional .Communication_proto.Communication_parameter communication_parameters = 1;
-  if (has_communication_parameters()) {
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
     total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::MessageSize(
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
         *communication_parameters_);
   }
 
-  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+        _internal_metadata_, total_size, &_cached_size_);
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
   SetCachedSize(cached_size);
   return total_size;
 }
 
-void Communication_parameter_all::MergeFrom(const ::google::protobuf::Message& from) {
+void Communication_parameter_all::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
 // @@protoc_insertion_point(generalized_merge_from_start:Communication_proto.Communication_parameter_all)
   GOOGLE_DCHECK_NE(&from, this);
   const Communication_parameter_all* source =
-      ::google::protobuf::internal::DynamicCastToGenerated<const Communication_parameter_all>(
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Communication_parameter_all>(
           &from);
-  if (source == NULL) {
+  if (source == nullptr) {
   // @@protoc_insertion_point(generalized_merge_from_cast_fail:Communication_proto.Communication_parameter_all)
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
   } else {
   // @@protoc_insertion_point(generalized_merge_from_cast_success:Communication_proto.Communication_parameter_all)
     MergeFrom(*source);
@@ -642,16 +564,16 @@ void Communication_parameter_all::MergeFrom(const ::google::protobuf::Message& f
 void Communication_parameter_all::MergeFrom(const Communication_parameter_all& from) {
 // @@protoc_insertion_point(class_specific_merge_from_start:Communication_proto.Communication_parameter_all)
   GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom(from._internal_metadata_);
-  ::google::protobuf::uint32 cached_has_bits = 0;
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   (void) cached_has_bits;
 
-  if (from.has_communication_parameters()) {
-    mutable_communication_parameters()->::Communication_proto::Communication_parameter::MergeFrom(from.communication_parameters());
+  if (from._internal_has_communication_parameters()) {
+    _internal_mutable_communication_parameters()->::Communication_proto::Communication_parameter::MergeFrom(from._internal_communication_parameters());
   }
 }
 
-void Communication_parameter_all::CopyFrom(const ::google::protobuf::Message& from) {
+void Communication_parameter_all::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
 // @@protoc_insertion_point(generalized_copy_from_start:Communication_proto.Communication_parameter_all)
   if (&from == this) return;
   Clear();
@@ -669,34 +591,28 @@ bool Communication_parameter_all::IsInitialized() const {
   return true;
 }
 
-void Communication_parameter_all::Swap(Communication_parameter_all* other) {
-  if (other == this) return;
-  InternalSwap(other);
-}
 void Communication_parameter_all::InternalSwap(Communication_parameter_all* other) {
   using std::swap;
-  swap(communication_parameters_, other->communication_parameters_);
+  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
   swap(_has_bits_[0], other->_has_bits_[0]);
-  _internal_metadata_.Swap(&other->_internal_metadata_);
+  swap(communication_parameters_, other->communication_parameters_);
 }
 
-::google::protobuf::Metadata Communication_parameter_all::GetMetadata() const {
-  protobuf_communication_2eproto::protobuf_AssignDescriptorsOnce();
-  return ::protobuf_communication_2eproto::file_level_metadata[kIndexInFileMessages];
+::PROTOBUF_NAMESPACE_ID::Metadata Communication_parameter_all::GetMetadata() const {
+  return GetMetadataStatic();
 }
 
 
 // @@protoc_insertion_point(namespace_scope)
 }  // namespace Communication_proto
-namespace google {
-namespace protobuf {
-template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Communication_proto::Communication_parameter* Arena::CreateMaybeMessage< ::Communication_proto::Communication_parameter >(Arena* arena) {
-  return Arena::CreateInternal< ::Communication_proto::Communication_parameter >(arena);
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::Communication_proto::Communication_parameter* Arena::CreateMaybeMessage< ::Communication_proto::Communication_parameter >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::Communication_proto::Communication_parameter >(arena);
 }
-template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::Communication_proto::Communication_parameter_all* Arena::CreateMaybeMessage< ::Communication_proto::Communication_parameter_all >(Arena* arena) {
-  return Arena::CreateInternal< ::Communication_proto::Communication_parameter_all >(arena);
+template<> PROTOBUF_NOINLINE ::Communication_proto::Communication_parameter_all* Arena::CreateMaybeMessage< ::Communication_proto::Communication_parameter_all >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::Communication_proto::Communication_parameter_all >(arena);
 }
-}  // namespace protobuf
-}  // namespace google
+PROTOBUF_NAMESPACE_CLOSE
 
 // @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>

communication/communication.pb.h

@@ -1,50 +1,59 @@
 // Generated by the protocol buffer compiler.  DO NOT EDIT!
 // source: communication.proto
 
-#ifndef PROTOBUF_INCLUDED_communication_2eproto
-#define PROTOBUF_INCLUDED_communication_2eproto
+#ifndef GOOGLE_PROTOBUF_INCLUDED_communication_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_communication_2eproto
 
+#include <limits>
 #include <string>
 
-#include <google/protobuf/stubs/common.h>
-
-#if GOOGLE_PROTOBUF_VERSION < 3006000
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3013000
 #error This file was generated by a newer version of protoc which is
-#error incompatible with your Protocol Buffer headers.  Please update
+#error incompatible with your Protocol Buffer headers. Please update
 #error your headers.
 #endif
-#if 3006000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#if 3013000 < PROTOBUF_MIN_PROTOC_VERSION
 #error This file was generated by an older version of protoc which is
-#error incompatible with your Protocol Buffer headers.  Please
+#error incompatible with your Protocol Buffer headers. Please
 #error regenerate this file with a newer version of protoc.
 #endif
 
+#include <google/protobuf/port_undef.inc>
 #include <google/protobuf/io/coded_stream.h>
 #include <google/protobuf/arena.h>
 #include <google/protobuf/arenastring.h>
 #include <google/protobuf/generated_message_table_driven.h>
 #include <google/protobuf/generated_message_util.h>
 #include <google/protobuf/inlined_string_field.h>
-#include <google/protobuf/metadata.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
 #include <google/protobuf/message.h>
 #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
 #include <google/protobuf/extension_set.h>  // IWYU pragma: export
 #include <google/protobuf/unknown_field_set.h>
 // @@protoc_insertion_point(includes)
-#define PROTOBUF_INTERNAL_EXPORT_protobuf_communication_2eproto 
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_communication_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
 
-namespace protobuf_communication_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[2];
-  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
-  static const ::google::protobuf::internal::SerializationTable serialization_table[];
-  static const ::google::protobuf::uint32 offsets[];
+struct TableStruct_communication_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[2]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
 };
-void AddDescriptors();
-}  // namespace protobuf_communication_2eproto
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_communication_2eproto;
 namespace Communication_proto {
 class Communication_parameter;
 class Communication_parameterDefaultTypeInternal;
@@ -53,50 +62,55 @@ class Communication_parameter_all;
 class Communication_parameter_allDefaultTypeInternal;
 extern Communication_parameter_allDefaultTypeInternal _Communication_parameter_all_default_instance_;
 }  // namespace Communication_proto
-namespace google {
-namespace protobuf {
+PROTOBUF_NAMESPACE_OPEN
 template<> ::Communication_proto::Communication_parameter* Arena::CreateMaybeMessage<::Communication_proto::Communication_parameter>(Arena*);
 template<> ::Communication_proto::Communication_parameter_all* Arena::CreateMaybeMessage<::Communication_proto::Communication_parameter_all>(Arena*);
-}  // namespace protobuf
-}  // namespace google
+PROTOBUF_NAMESPACE_CLOSE
 namespace Communication_proto {
 
 // ===================================================================
 
-class Communication_parameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Communication_proto.Communication_parameter) */ {
+class Communication_parameter PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Communication_proto.Communication_parameter) */ {
  public:
-  Communication_parameter();
+  inline Communication_parameter() : Communication_parameter(nullptr) {}
   virtual ~Communication_parameter();
 
   Communication_parameter(const Communication_parameter& from);
-
-  inline Communication_parameter& operator=(const Communication_parameter& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  #if LANG_CXX11
   Communication_parameter(Communication_parameter&& from) noexcept
     : Communication_parameter() {
     *this = ::std::move(from);
   }
 
+  inline Communication_parameter& operator=(const Communication_parameter& from) {
+    CopyFrom(from);
+    return *this;
+  }
   inline Communication_parameter& operator=(Communication_parameter&& from) noexcept {
-    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+    if (GetArena() == from.GetArena()) {
       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 const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
   }
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields();
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
   }
 
-  static const ::google::protobuf::Descriptor* descriptor();
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
   static const Communication_parameter& default_instance();
 
   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
@@ -107,141 +121,178 @@ class Communication_parameter : public ::google::protobuf::Message /* @@protoc_i
   static constexpr int kIndexInFileMessages =
     0;
 
-  void Swap(Communication_parameter* other);
   friend void swap(Communication_parameter& a, Communication_parameter& b) {
     a.Swap(&b);
   }
+  inline void Swap(Communication_parameter* other) {
+    if (other == this) return;
+    if (GetArena() == other->GetArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Communication_parameter* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    InternalSwap(other);
+  }
 
   // implements Message ----------------------------------------------
 
   inline Communication_parameter* New() const final {
-    return CreateMaybeMessage<Communication_parameter>(NULL);
+    return CreateMaybeMessage<Communication_parameter>(nullptr);
   }
 
-  Communication_parameter* New(::google::protobuf::Arena* arena) const final {
+  Communication_parameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
     return CreateMaybeMessage<Communication_parameter>(arena);
   }
-  void CopyFrom(const ::google::protobuf::Message& from) final;
-  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
   void CopyFrom(const Communication_parameter& from);
   void MergeFrom(const Communication_parameter& from);
-  void Clear() final;
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
   bool IsInitialized() const final;
 
   size_t ByteSizeLong() const final;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input) final;
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const final;
-  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
-      bool deterministic, ::google::protobuf::uint8* target) const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
   int GetCachedSize() const final { return _cached_size_.Get(); }
 
   private:
-  void SharedCtor();
-  void SharedDtor();
+  inline void SharedCtor();
+  inline void SharedDtor();
   void SetCachedSize(int size) const final;
   void InternalSwap(Communication_parameter* other);
-  private:
-  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
-    return NULL;
-  }
-  inline void* MaybeArenaPtr() const {
-    return NULL;
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "Communication_proto.Communication_parameter";
   }
+  protected:
+  explicit Communication_parameter(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   public:
 
-  ::google::protobuf::Metadata GetMetadata() const final;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_communication_2eproto);
+    return ::descriptor_table_communication_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
 
   // nested types ----------------------------------------------------
 
   // accessors -------------------------------------------------------
 
+  enum : int {
+    kConnectStringVectorFieldNumber = 2,
+    kBindStringFieldNumber = 1,
+  };
   // repeated string connect_string_vector = 2;
   int connect_string_vector_size() const;
+  private:
+  int _internal_connect_string_vector_size() const;
+  public:
   void clear_connect_string_vector();
-  static const int kConnectStringVectorFieldNumber = 2;
-  const ::std::string& connect_string_vector(int index) const;
-  ::std::string* mutable_connect_string_vector(int index);
-  void set_connect_string_vector(int index, const ::std::string& value);
-  #if LANG_CXX11
-  void set_connect_string_vector(int index, ::std::string&& value);
-  #endif
+  const std::string& connect_string_vector(int index) const;
+  std::string* mutable_connect_string_vector(int index);
+  void set_connect_string_vector(int index, const std::string& value);
+  void set_connect_string_vector(int index, std::string&& value);
   void set_connect_string_vector(int index, const char* value);
   void set_connect_string_vector(int index, const char* value, size_t size);
-  ::std::string* add_connect_string_vector();
-  void add_connect_string_vector(const ::std::string& value);
-  #if LANG_CXX11
-  void add_connect_string_vector(::std::string&& value);
-  #endif
+  std::string* add_connect_string_vector();
+  void add_connect_string_vector(const std::string& value);
+  void add_connect_string_vector(std::string&& value);
   void add_connect_string_vector(const char* value);
   void add_connect_string_vector(const char* value, size_t size);
-  const ::google::protobuf::RepeatedPtrField< ::std::string>& connect_string_vector() const;
-  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_connect_string_vector();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& connect_string_vector() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_connect_string_vector();
+  private:
+  const std::string& _internal_connect_string_vector(int index) const;
+  std::string* _internal_add_connect_string_vector();
+  public:
 
   // optional string bind_string = 1;
   bool has_bind_string() const;
+  private:
+  bool _internal_has_bind_string() const;
+  public:
   void clear_bind_string();
-  static const int kBindStringFieldNumber = 1;
-  const ::std::string& bind_string() const;
-  void set_bind_string(const ::std::string& value);
-  #if LANG_CXX11
-  void set_bind_string(::std::string&& value);
-  #endif
+  const std::string& bind_string() const;
+  void set_bind_string(const std::string& value);
+  void set_bind_string(std::string&& value);
   void set_bind_string(const char* value);
   void set_bind_string(const char* value, size_t size);
-  ::std::string* mutable_bind_string();
-  ::std::string* release_bind_string();
-  void set_allocated_bind_string(::std::string* bind_string);
+  std::string* mutable_bind_string();
+  std::string* release_bind_string();
+  void set_allocated_bind_string(std::string* bind_string);
+  private:
+  const std::string& _internal_bind_string() const;
+  void _internal_set_bind_string(const std::string& value);
+  std::string* _internal_mutable_bind_string();
+  public:
 
   // @@protoc_insertion_point(class_scope:Communication_proto.Communication_parameter)
  private:
-  void set_has_bind_string();
-  void clear_has_bind_string();
-
-  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
-  ::google::protobuf::internal::HasBits<1> _has_bits_;
-  mutable ::google::protobuf::internal::CachedSize _cached_size_;
-  ::google::protobuf::RepeatedPtrField< ::std::string> connect_string_vector_;
-  ::google::protobuf::internal::ArenaStringPtr bind_string_;
-  friend struct ::protobuf_communication_2eproto::TableStruct;
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> connect_string_vector_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bind_string_;
+  friend struct ::TableStruct_communication_2eproto;
 };
 // -------------------------------------------------------------------
 
-class Communication_parameter_all : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Communication_proto.Communication_parameter_all) */ {
+class Communication_parameter_all PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Communication_proto.Communication_parameter_all) */ {
  public:
-  Communication_parameter_all();
+  inline Communication_parameter_all() : Communication_parameter_all(nullptr) {}
   virtual ~Communication_parameter_all();
 
   Communication_parameter_all(const Communication_parameter_all& from);
-
-  inline Communication_parameter_all& operator=(const Communication_parameter_all& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  #if LANG_CXX11
   Communication_parameter_all(Communication_parameter_all&& from) noexcept
     : Communication_parameter_all() {
     *this = ::std::move(from);
   }
 
+  inline Communication_parameter_all& operator=(const Communication_parameter_all& from) {
+    CopyFrom(from);
+    return *this;
+  }
   inline Communication_parameter_all& operator=(Communication_parameter_all&& from) noexcept {
-    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+    if (GetArena() == from.GetArena()) {
       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 const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
   }
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields();
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
   }
 
-  static const ::google::protobuf::Descriptor* descriptor();
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
   static const Communication_parameter_all& default_instance();
 
   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
@@ -252,78 +303,106 @@ class Communication_parameter_all : public ::google::protobuf::Message /* @@prot
   static constexpr int kIndexInFileMessages =
     1;
 
-  void Swap(Communication_parameter_all* other);
   friend void swap(Communication_parameter_all& a, Communication_parameter_all& b) {
     a.Swap(&b);
   }
+  inline void Swap(Communication_parameter_all* other) {
+    if (other == this) return;
+    if (GetArena() == other->GetArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Communication_parameter_all* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    InternalSwap(other);
+  }
 
   // implements Message ----------------------------------------------
 
   inline Communication_parameter_all* New() const final {
-    return CreateMaybeMessage<Communication_parameter_all>(NULL);
+    return CreateMaybeMessage<Communication_parameter_all>(nullptr);
   }
 
-  Communication_parameter_all* New(::google::protobuf::Arena* arena) const final {
+  Communication_parameter_all* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
     return CreateMaybeMessage<Communication_parameter_all>(arena);
   }
-  void CopyFrom(const ::google::protobuf::Message& from) final;
-  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
   void CopyFrom(const Communication_parameter_all& from);
   void MergeFrom(const Communication_parameter_all& from);
-  void Clear() final;
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
   bool IsInitialized() const final;
 
   size_t ByteSizeLong() const final;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input) final;
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const final;
-  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
-      bool deterministic, ::google::protobuf::uint8* target) const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
   int GetCachedSize() const final { return _cached_size_.Get(); }
 
   private:
-  void SharedCtor();
-  void SharedDtor();
+  inline void SharedCtor();
+  inline void SharedDtor();
   void SetCachedSize(int size) const final;
   void InternalSwap(Communication_parameter_all* other);
-  private:
-  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
-    return NULL;
-  }
-  inline void* MaybeArenaPtr() const {
-    return NULL;
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "Communication_proto.Communication_parameter_all";
   }
+  protected:
+  explicit Communication_parameter_all(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   public:
 
-  ::google::protobuf::Metadata GetMetadata() const final;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_communication_2eproto);
+    return ::descriptor_table_communication_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
 
   // nested types ----------------------------------------------------
 
   // accessors -------------------------------------------------------
 
+  enum : int {
+    kCommunicationParametersFieldNumber = 1,
+  };
   // optional .Communication_proto.Communication_parameter communication_parameters = 1;
   bool has_communication_parameters() const;
-  void clear_communication_parameters();
-  static const int kCommunicationParametersFieldNumber = 1;
   private:
-  const ::Communication_proto::Communication_parameter& _internal_communication_parameters() const;
+  bool _internal_has_communication_parameters() const;
   public:
+  void clear_communication_parameters();
   const ::Communication_proto::Communication_parameter& communication_parameters() const;
   ::Communication_proto::Communication_parameter* release_communication_parameters();
   ::Communication_proto::Communication_parameter* mutable_communication_parameters();
   void set_allocated_communication_parameters(::Communication_proto::Communication_parameter* communication_parameters);
+  private:
+  const ::Communication_proto::Communication_parameter& _internal_communication_parameters() const;
+  ::Communication_proto::Communication_parameter* _internal_mutable_communication_parameters();
+  public:
+  void unsafe_arena_set_allocated_communication_parameters(
+      ::Communication_proto::Communication_parameter* communication_parameters);
+  ::Communication_proto::Communication_parameter* unsafe_arena_release_communication_parameters();
 
   // @@protoc_insertion_point(class_scope:Communication_proto.Communication_parameter_all)
  private:
-  void set_has_communication_parameters();
-  void clear_has_communication_parameters();
+  class _Internal;
 
-  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
-  ::google::protobuf::internal::HasBits<1> _has_bits_;
-  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   ::Communication_proto::Communication_parameter* communication_parameters_;
-  friend struct ::protobuf_communication_2eproto::TableStruct;
+  friend struct ::TableStruct_communication_2eproto;
 };
 // ===================================================================
 
@@ -337,98 +416,114 @@ class Communication_parameter_all : public ::google::protobuf::Message /* @@prot
 // Communication_parameter
 
 // optional string bind_string = 1;
-inline bool Communication_parameter::has_bind_string() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
+inline bool Communication_parameter::_internal_has_bind_string() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
 }
-inline void Communication_parameter::set_has_bind_string() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void Communication_parameter::clear_has_bind_string() {
-  _has_bits_[0] &= ~0x00000001u;
+inline bool Communication_parameter::has_bind_string() const {
+  return _internal_has_bind_string();
 }
 inline void Communication_parameter::clear_bind_string() {
-  bind_string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  clear_has_bind_string();
+  bind_string_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  _has_bits_[0] &= ~0x00000001u;
 }
-inline const ::std::string& Communication_parameter::bind_string() const {
+inline const std::string& Communication_parameter::bind_string() const {
   // @@protoc_insertion_point(field_get:Communication_proto.Communication_parameter.bind_string)
-  return bind_string_.GetNoArena();
+  return _internal_bind_string();
 }
-inline void Communication_parameter::set_bind_string(const ::std::string& value) {
-  set_has_bind_string();
-  bind_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+inline void Communication_parameter::set_bind_string(const std::string& value) {
+  _internal_set_bind_string(value);
   // @@protoc_insertion_point(field_set:Communication_proto.Communication_parameter.bind_string)
 }
-#if LANG_CXX11
-inline void Communication_parameter::set_bind_string(::std::string&& value) {
-  set_has_bind_string();
-  bind_string_.SetNoArena(
-    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+inline std::string* Communication_parameter::mutable_bind_string() {
+  // @@protoc_insertion_point(field_mutable:Communication_proto.Communication_parameter.bind_string)
+  return _internal_mutable_bind_string();
+}
+inline const std::string& Communication_parameter::_internal_bind_string() const {
+  return bind_string_.Get();
+}
+inline void Communication_parameter::_internal_set_bind_string(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  bind_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
+}
+inline void Communication_parameter::set_bind_string(std::string&& value) {
+  _has_bits_[0] |= 0x00000001u;
+  bind_string_.Set(
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
   // @@protoc_insertion_point(field_set_rvalue:Communication_proto.Communication_parameter.bind_string)
 }
-#endif
 inline void Communication_parameter::set_bind_string(const char* value) {
-  GOOGLE_DCHECK(value != NULL);
-  set_has_bind_string();
-  bind_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  GOOGLE_DCHECK(value != nullptr);
+  _has_bits_[0] |= 0x00000001u;
+  bind_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArena());
   // @@protoc_insertion_point(field_set_char:Communication_proto.Communication_parameter.bind_string)
 }
-inline void Communication_parameter::set_bind_string(const char* value, size_t size) {
-  set_has_bind_string();
-  bind_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
-      ::std::string(reinterpret_cast<const char*>(value), size));
+inline void Communication_parameter::set_bind_string(const char* value,
+    size_t size) {
+  _has_bits_[0] |= 0x00000001u;
+  bind_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArena());
   // @@protoc_insertion_point(field_set_pointer:Communication_proto.Communication_parameter.bind_string)
 }
-inline ::std::string* Communication_parameter::mutable_bind_string() {
-  set_has_bind_string();
-  // @@protoc_insertion_point(field_mutable:Communication_proto.Communication_parameter.bind_string)
-  return bind_string_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+inline std::string* Communication_parameter::_internal_mutable_bind_string() {
+  _has_bits_[0] |= 0x00000001u;
+  return bind_string_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 }
-inline ::std::string* Communication_parameter::release_bind_string() {
+inline std::string* Communication_parameter::release_bind_string() {
   // @@protoc_insertion_point(field_release:Communication_proto.Communication_parameter.bind_string)
-  if (!has_bind_string()) {
-    return NULL;
+  if (!_internal_has_bind_string()) {
+    return nullptr;
   }
-  clear_has_bind_string();
-  return bind_string_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  _has_bits_[0] &= ~0x00000001u;
+  return bind_string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 }
-inline void Communication_parameter::set_allocated_bind_string(::std::string* bind_string) {
-  if (bind_string != NULL) {
-    set_has_bind_string();
+inline void Communication_parameter::set_allocated_bind_string(std::string* bind_string) {
+  if (bind_string != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
   } else {
-    clear_has_bind_string();
+    _has_bits_[0] &= ~0x00000001u;
   }
-  bind_string_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), bind_string);
+  bind_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), bind_string,
+      GetArena());
   // @@protoc_insertion_point(field_set_allocated:Communication_proto.Communication_parameter.bind_string)
 }
 
 // repeated string connect_string_vector = 2;
-inline int Communication_parameter::connect_string_vector_size() const {
+inline int Communication_parameter::_internal_connect_string_vector_size() const {
   return connect_string_vector_.size();
 }
+inline int Communication_parameter::connect_string_vector_size() const {
+  return _internal_connect_string_vector_size();
+}
 inline void Communication_parameter::clear_connect_string_vector() {
   connect_string_vector_.Clear();
 }
-inline const ::std::string& Communication_parameter::connect_string_vector(int index) const {
-  // @@protoc_insertion_point(field_get:Communication_proto.Communication_parameter.connect_string_vector)
+inline std::string* Communication_parameter::add_connect_string_vector() {
+  // @@protoc_insertion_point(field_add_mutable:Communication_proto.Communication_parameter.connect_string_vector)
+  return _internal_add_connect_string_vector();
+}
+inline const std::string& Communication_parameter::_internal_connect_string_vector(int index) const {
   return connect_string_vector_.Get(index);
 }
-inline ::std::string* Communication_parameter::mutable_connect_string_vector(int index) {
+inline const std::string& Communication_parameter::connect_string_vector(int index) const {
+  // @@protoc_insertion_point(field_get:Communication_proto.Communication_parameter.connect_string_vector)
+  return _internal_connect_string_vector(index);
+}
+inline std::string* Communication_parameter::mutable_connect_string_vector(int index) {
   // @@protoc_insertion_point(field_mutable:Communication_proto.Communication_parameter.connect_string_vector)
   return connect_string_vector_.Mutable(index);
 }
-inline void Communication_parameter::set_connect_string_vector(int index, const ::std::string& value) {
+inline void Communication_parameter::set_connect_string_vector(int index, const std::string& value) {
   // @@protoc_insertion_point(field_set:Communication_proto.Communication_parameter.connect_string_vector)
   connect_string_vector_.Mutable(index)->assign(value);
 }
-#if LANG_CXX11
-inline void Communication_parameter::set_connect_string_vector(int index, ::std::string&& value) {
+inline void Communication_parameter::set_connect_string_vector(int index, std::string&& value) {
   // @@protoc_insertion_point(field_set:Communication_proto.Communication_parameter.connect_string_vector)
   connect_string_vector_.Mutable(index)->assign(std::move(value));
 }
-#endif
 inline void Communication_parameter::set_connect_string_vector(int index, const char* value) {
-  GOOGLE_DCHECK(value != NULL);
+  GOOGLE_DCHECK(value != nullptr);
   connect_string_vector_.Mutable(index)->assign(value);
   // @@protoc_insertion_point(field_set_char:Communication_proto.Communication_parameter.connect_string_vector)
 }
@@ -437,22 +532,19 @@ inline void Communication_parameter::set_connect_string_vector(int index, const
     reinterpret_cast<const char*>(value), size);
   // @@protoc_insertion_point(field_set_pointer:Communication_proto.Communication_parameter.connect_string_vector)
 }
-inline ::std::string* Communication_parameter::add_connect_string_vector() {
-  // @@protoc_insertion_point(field_add_mutable:Communication_proto.Communication_parameter.connect_string_vector)
+inline std::string* Communication_parameter::_internal_add_connect_string_vector() {
   return connect_string_vector_.Add();
 }
-inline void Communication_parameter::add_connect_string_vector(const ::std::string& value) {
+inline void Communication_parameter::add_connect_string_vector(const std::string& value) {
   connect_string_vector_.Add()->assign(value);
   // @@protoc_insertion_point(field_add:Communication_proto.Communication_parameter.connect_string_vector)
 }
-#if LANG_CXX11
-inline void Communication_parameter::add_connect_string_vector(::std::string&& value) {
+inline void Communication_parameter::add_connect_string_vector(std::string&& value) {
   connect_string_vector_.Add(std::move(value));
   // @@protoc_insertion_point(field_add:Communication_proto.Communication_parameter.connect_string_vector)
 }
-#endif
 inline void Communication_parameter::add_connect_string_vector(const char* value) {
-  GOOGLE_DCHECK(value != NULL);
+  GOOGLE_DCHECK(value != nullptr);
   connect_string_vector_.Add()->assign(value);
   // @@protoc_insertion_point(field_add_char:Communication_proto.Communication_parameter.connect_string_vector)
 }
@@ -460,12 +552,12 @@ inline void Communication_parameter::add_connect_string_vector(const char* value
   connect_string_vector_.Add()->assign(reinterpret_cast<const char*>(value), size);
   // @@protoc_insertion_point(field_add_pointer:Communication_proto.Communication_parameter.connect_string_vector)
 }
-inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
 Communication_parameter::connect_string_vector() const {
   // @@protoc_insertion_point(field_list:Communication_proto.Communication_parameter.connect_string_vector)
   return connect_string_vector_;
 }
-inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
 Communication_parameter::mutable_connect_string_vector() {
   // @@protoc_insertion_point(field_mutable_list:Communication_proto.Communication_parameter.connect_string_vector)
   return &connect_string_vector_;
@@ -476,58 +568,83 @@ Communication_parameter::mutable_connect_string_vector() {
 // Communication_parameter_all
 
 // optional .Communication_proto.Communication_parameter communication_parameters = 1;
-inline bool Communication_parameter_all::has_communication_parameters() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void Communication_parameter_all::set_has_communication_parameters() {
-  _has_bits_[0] |= 0x00000001u;
+inline bool Communication_parameter_all::_internal_has_communication_parameters() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || communication_parameters_ != nullptr);
+  return value;
 }
-inline void Communication_parameter_all::clear_has_communication_parameters() {
-  _has_bits_[0] &= ~0x00000001u;
+inline bool Communication_parameter_all::has_communication_parameters() const {
+  return _internal_has_communication_parameters();
 }
 inline void Communication_parameter_all::clear_communication_parameters() {
-  if (communication_parameters_ != NULL) communication_parameters_->Clear();
-  clear_has_communication_parameters();
+  if (communication_parameters_ != nullptr) communication_parameters_->Clear();
+  _has_bits_[0] &= ~0x00000001u;
 }
 inline const ::Communication_proto::Communication_parameter& Communication_parameter_all::_internal_communication_parameters() const {
-  return *communication_parameters_;
+  const ::Communication_proto::Communication_parameter* p = communication_parameters_;
+  return p != nullptr ? *p : *reinterpret_cast<const ::Communication_proto::Communication_parameter*>(
+      &::Communication_proto::_Communication_parameter_default_instance_);
 }
 inline const ::Communication_proto::Communication_parameter& Communication_parameter_all::communication_parameters() const {
-  const ::Communication_proto::Communication_parameter* p = communication_parameters_;
   // @@protoc_insertion_point(field_get:Communication_proto.Communication_parameter_all.communication_parameters)
-  return p != NULL ? *p : *reinterpret_cast<const ::Communication_proto::Communication_parameter*>(
-      &::Communication_proto::_Communication_parameter_default_instance_);
+  return _internal_communication_parameters();
+}
+inline void Communication_parameter_all::unsafe_arena_set_allocated_communication_parameters(
+    ::Communication_proto::Communication_parameter* communication_parameters) {
+  if (GetArena() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(communication_parameters_);
+  }
+  communication_parameters_ = communication_parameters;
+  if (communication_parameters) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Communication_proto.Communication_parameter_all.communication_parameters)
 }
 inline ::Communication_proto::Communication_parameter* Communication_parameter_all::release_communication_parameters() {
+  _has_bits_[0] &= ~0x00000001u;
+  ::Communication_proto::Communication_parameter* temp = communication_parameters_;
+  communication_parameters_ = nullptr;
+  if (GetArena() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+  return temp;
+}
+inline ::Communication_proto::Communication_parameter* Communication_parameter_all::unsafe_arena_release_communication_parameters() {
   // @@protoc_insertion_point(field_release:Communication_proto.Communication_parameter_all.communication_parameters)
-  clear_has_communication_parameters();
+  _has_bits_[0] &= ~0x00000001u;
   ::Communication_proto::Communication_parameter* temp = communication_parameters_;
-  communication_parameters_ = NULL;
+  communication_parameters_ = nullptr;
   return temp;
 }
-inline ::Communication_proto::Communication_parameter* Communication_parameter_all::mutable_communication_parameters() {
-  set_has_communication_parameters();
-  if (communication_parameters_ == NULL) {
-    auto* p = CreateMaybeMessage<::Communication_proto::Communication_parameter>(GetArenaNoVirtual());
+inline ::Communication_proto::Communication_parameter* Communication_parameter_all::_internal_mutable_communication_parameters() {
+  _has_bits_[0] |= 0x00000001u;
+  if (communication_parameters_ == nullptr) {
+    auto* p = CreateMaybeMessage<::Communication_proto::Communication_parameter>(GetArena());
     communication_parameters_ = p;
   }
-  // @@protoc_insertion_point(field_mutable:Communication_proto.Communication_parameter_all.communication_parameters)
   return communication_parameters_;
 }
+inline ::Communication_proto::Communication_parameter* Communication_parameter_all::mutable_communication_parameters() {
+  // @@protoc_insertion_point(field_mutable:Communication_proto.Communication_parameter_all.communication_parameters)
+  return _internal_mutable_communication_parameters();
+}
 inline void Communication_parameter_all::set_allocated_communication_parameters(::Communication_proto::Communication_parameter* communication_parameters) {
-  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
-  if (message_arena == NULL) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+  if (message_arena == nullptr) {
     delete communication_parameters_;
   }
   if (communication_parameters) {
-    ::google::protobuf::Arena* submessage_arena = NULL;
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(communication_parameters);
     if (message_arena != submessage_arena) {
-      communication_parameters = ::google::protobuf::internal::GetOwnedMessage(
+      communication_parameters = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
           message_arena, communication_parameters, submessage_arena);
     }
-    set_has_communication_parameters();
+    _has_bits_[0] |= 0x00000001u;
   } else {
-    clear_has_communication_parameters();
+    _has_bits_[0] &= ~0x00000001u;
   }
   communication_parameters_ = communication_parameters;
   // @@protoc_insertion_point(field_set_allocated:Communication_proto.Communication_parameter_all.communication_parameters)
@@ -545,4 +662,5 @@ inline void Communication_parameter_all::set_allocated_communication_parameters(
 
 // @@protoc_insertion_point(global_scope)
 
-#endif  // PROTOBUF_INCLUDED_communication_2eproto
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_communication_2eproto

system/PickupProcessTask.cpp

@@ -19,11 +19,11 @@ PickupProcessTask::PickupProcessTask(unsigned int terminal_id,message::Car_info
 PickupProcessTask::~PickupProcessTask()
 {
 }
-Error_manager PickupProcessTask::init_task()
+Error_manager PickupProcessTask::init_task(const ::google::protobuf::Message& parameter)
 {
-    char log[255]={0};
+    /*char log[255]={0};
     sprintf(log,"来自终端 %d 的取车指令:\n %s",m_terminor_id,m_car_info.DebugString().c_str());
-    ALOG(INFO)<<log;
+    ALOG(INFO)<<log;*/
 
     reset_msg();
 
@@ -37,14 +37,8 @@ Error_manager PickupProcessTask::init_task()
     m_process_msg.set_license(m_car_info.license());
 
     m_current_step_type=message::eSearch_step;
-    ///创建状态发布线程
-    if(m_publish_statu_thread== nullptr)
-    {
-        m_publish_exit_condition.reset(false, false, false);
-        m_publish_statu_thread=new std::thread(publish_thread_func,this);
-    }
 
-   return SUCCESS;
+   return Process_task::init_task(parameter);
 
 }
 
@@ -118,10 +112,10 @@ Error_manager PickupProcessTask::search_space_step()
     code = Parkspace_excutor::get_instance_pointer()->search_request(m_search_request_msg,
             m_search_response_msg,m_cancel_condition);
 
-    message::Node_log node_log;
+    /*message::Node_log node_log;
     node_log.mutable_search_request()->CopyFrom(m_search_request_msg);
     node_log.mutable_search_response()->CopyFrom(m_search_response_msg);
-    ALOG(INFO)<<node_log;
+    ALOG(INFO)<<node_log;*/
 
     return code;
 }
@@ -131,7 +125,7 @@ Error_manager PickupProcessTask::search_space_step()
  */
 Error_manager PickupProcessTask::back_search_space_step()
 {
-    ALOG(INFO)<<"回退查询车位";
+    //ALOG(INFO)<<"回退查询车位";
     return SUCCESS;
 }
 
@@ -173,7 +167,7 @@ Error_manager PickupProcessTask::next_step()
             LOG(ERROR)<<"-------  取  ------- 下一步失败,当前步骤未知: "<<message::Step_type_Name(m_current_step_type);
             break;
     }
-    ALOG(INFO)<<"进入下一步:"<<message::Step_type_Name(m_current_step_type);
+    //ALOG(INFO)<<"进入下一步:"<<message::Step_type_Name(m_current_step_type);
     return SUCCESS;
 }
 
@@ -199,8 +193,8 @@ void PickupProcessTask::Main()
 
             LOG_IF(ERROR, code != SUCCESS) << "-------  取  -------查询失败,取车终端:"<<m_terminor_id
                                            <<", 车牌号:"<<m_car_info.license()<<code.get_error_description();
-            ALOG_IF(ERROR, code != SUCCESS) << "-------  取  -------查询失败,取车终端:"<<m_terminor_id
-                                           <<", 车牌号:"<<m_car_info.license()<<code.get_error_description();
+            /*ALOG_IF(ERROR, code != SUCCESS) << "-------  取  -------查询失败,取车终端:"<<m_terminor_id
+                                           <<", 车牌号:"<<m_car_info.license()<<code.get_error_description();*/
         }
 
         if(m_current_step_type== message::eDispatch_step)
@@ -216,13 +210,13 @@ void PickupProcessTask::Main()
                                            <<", 车牌号:"<<m_car_info.license()
                                            <<", 库内车牌号:"<<m_search_response_msg.query_parkspace_info_ex(0).car_info().license()
                                            <<code.get_error_description();
-            ALOG_IF(ERROR, code != SUCCESS) << "-------  取  -------取车调度失败,取车终端:"<<m_terminor_id
+            /*ALOG_IF(ERROR, code != SUCCESS) << "-------  取  -------取车调度失败,取车终端:"<<m_terminor_id
                     <<", 车位id:"<<m_search_response_msg.query_parkspace_info_ex(0).parkingspace_room_id()
                     <<", 车位楼层:"<<m_search_response_msg.query_parkspace_info_ex(0).parkingspace_floor_id()
                     <<", 车位序号:"<<m_search_response_msg.query_parkspace_info_ex(0).parkingspace_index_id()
                     <<", 车牌号:"<<m_car_info.license()
                     <<", 库内车牌号:"<<m_search_response_msg.query_parkspace_info_ex(0).car_info().license()
-                    <<code.get_error_description();
+                    <<code.get_error_description();*/
         }
         if(m_current_step_type== message::eWait_step)
         {
@@ -231,8 +225,8 @@ void PickupProcessTask::Main()
             code!=SUCCESS?updata_step_statu(message::eError):updata_step_statu(message::eFinished);
             LOG_IF(ERROR, code != SUCCESS) << "-------  取  -------等待车辆离开失败,取车终端:"<<m_terminor_id
                                            <<", 车牌号:"<<m_car_info.license();
-            ALOG_IF(ERROR, code != SUCCESS) << "-------  取  -------等待车辆离开失败,取车终端:"<<m_terminor_id
-                                           <<", 车牌号:"<<m_car_info.license();
+            /*ALOG_IF(ERROR, code != SUCCESS) << "-------  取  -------等待车辆离开失败,取车终端:"<<m_terminor_id
+                                           <<", 车牌号:"<<m_car_info.license();*/
         }
         if(m_current_step_type== message::eRelease_step)
         {
@@ -244,7 +238,7 @@ void PickupProcessTask::Main()
             {
                 //提升错误等级为三级
                 LOG(ERROR)<<"-------  取  -------  释放车位失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
-                ALOG(ERROR)<<"-------  取  -------  释放车位失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
+                //ALOG(ERROR)<<"-------  取  -------  释放车位失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
                 code.set_error_level_location(MAJOR_ERROR);
                 Exception_solver::get_instance_pointer()->solve_exception(code, this);
                 continue;
@@ -268,7 +262,7 @@ void PickupProcessTask::Main()
             {
                 //提升错误等级为四级
                 LOG(ERROR)<<"-------  取  -------  回退等待失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
-                ALOG(ERROR)<<"-------  取  -------  回退等待失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
+                //ALOG(ERROR)<<"-------  取  -------  回退等待失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
                 Exception_solver::get_instance_pointer()->solve_exception(code,this);
                 continue;
             }
@@ -282,7 +276,7 @@ void PickupProcessTask::Main()
             {
                 //提升错误等级为四级
                 LOG(ERROR)<<"-------  取  -------  回退调度失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
-                ALOG(ERROR)<<"-------  取  -------  回退调度失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
+                //ALOG(ERROR)<<"-------  取  -------  回退调度失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
                 Exception_solver::get_instance_pointer()->solve_exception(code,this);
                 continue;
             }
@@ -296,7 +290,7 @@ void PickupProcessTask::Main()
             {
                 //提升错误等级为四级
                 LOG(ERROR)<<"-------  取  -------  回退调度失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
-                ALOG(ERROR)<<"-------  取  -------  回退调度失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
+                //ALOG(ERROR)<<"-------  取  -------  回退调度失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
                 Exception_solver::get_instance_pointer()->solve_exception(code,this);
                 continue;
             }
@@ -316,8 +310,8 @@ void PickupProcessTask::Main()
     if(m_cancel_condition.wait_for_millisecond(1)==true) {
         LOG(ERROR) << "-------  取  -------取车任务被强制取消,车牌号:" << m_car_info.license()
                    << ",  终端号:" << m_terminor_id;
-        ALOG(ERROR) << "-------  取  -------取车任务被强制取消,车牌号:" << m_car_info.license()
-                   << ",  终端号:" << m_terminor_id;
+        /*ALOG(ERROR) << "-------  取  -------取车任务被强制取消,车牌号:" << m_car_info.license()
+                   << ",  终端号:" << m_terminor_id;*/
         usleep(1000*500);
         return ;
     }
@@ -328,8 +322,8 @@ void PickupProcessTask::Main()
         usleep(1000*500);
         LOG(ERROR)<<"-------  取  -------异常取车,回退结束"<<"车牌号:"<<m_car_info.license()
                   <<",xxxxxxxxxxxxxx  终端:"<<m_terminor_id<<"  xxxxxxxxxxxxxx";
-        ALOG(ERROR)<<"-------  取  -------异常取车,回退结束"<<"车牌号:"<<m_car_info.license()
-                  <<",xxxxxxxxxxxxxx  终端:"<<m_terminor_id<<"  xxxxxxxxxxxxxx";
+        /*ALOG(ERROR)<<"-------  取  -------异常取车,回退结束"<<"车牌号:"<<m_car_info.license()
+                  <<",xxxxxxxxxxxxxx  终端:"<<m_terminor_id<<"  xxxxxxxxxxxxxx";*/
     }
     if(m_current_step_type== message::eComplete)
     {
@@ -337,10 +331,10 @@ void PickupProcessTask::Main()
         usleep(1000*500);
         LOG(INFO)<<"-------  取  -------取车结束,"<<"车牌号:"<<m_car_info.license()
                  <<",--------------  终端:"<<m_terminor_id<<"  --------------";
-        ALOG(INFO)<<"-------  取  -------取车结束,"<<"车牌号:"<<m_car_info.license()
-                 <<",--------------  终端:"<<m_terminor_id<<"  --------------";
+        /*ALOG(INFO)<<"-------  取  -------取车结束,"<<"车牌号:"<<m_car_info.license()
+                 <<",--------------  终端:"<<m_terminor_id<<"  --------------";*/
     }
-    return Process_task::Main();
+    //return Process_task::Main();
 }
 
 /*
@@ -374,10 +368,11 @@ Error_manager PickupProcessTask::dispatch_step()
     m_dispatch_request_msg.set_terminal_id(m_terminor_id);
 
     code=Dispatch_excutor::get_instance_pointer()->dispatch_request(m_dispatch_request_msg,m_dispatch_response_msg,m_cancel_condition);
-    message::Node_log dispatch_log;
+
+    /*message::Node_log dispatch_log;
     dispatch_log.mutable_dispatch_request()->CopyFrom(m_dispatch_request_msg);
     dispatch_log.mutable_dispatch_response()->CopyFrom(m_dispatch_response_msg);
-    ALOG(INFO)<<dispatch_log;
+    ALOG(INFO)<<dispatch_log;*/
 
     if(code!=SUCCESS)
         return code;
@@ -401,7 +396,7 @@ Error_manager PickupProcessTask::back_dispatch_step()
     int k=rand()%10;
     if(k==0)
         return Error_manager(ERROR,MINOR_ERROR,"手动制造错误");*/
-    ALOG(INFO)<<"回退调度";
+    //ALOG(INFO)<<"回退调度";
     return SUCCESS;
 }
 
@@ -414,7 +409,7 @@ Error_manager PickupProcessTask::wait_for_leave_step()
     /*int k=rand()%10;
     if(k==0)
         return Error_manager(ERROR,MINOR_ERROR,"手动制造错误");*/
-    ALOG(INFO)<<"等待离开";
+    //ALOG(INFO)<<"等待离开";
     return SUCCESS;
 }
 
@@ -458,10 +453,10 @@ Error_manager PickupProcessTask::release_space_step()
     m_release_request_msg.mutable_release_parkspace_info_ex()->CopyFrom(m_search_response_msg.query_parkspace_info_ex());
 
     code=Parkspace_excutor::get_instance_pointer()->release_request(m_release_request_msg,m_release_response_msg,m_cancel_condition);
-    message::Node_log node_log;
+    /*message::Node_log node_log;
     node_log.mutable_release_request()->CopyFrom(m_release_request_msg);
     node_log.mutable_release_response()->CopyFrom(m_release_response_msg);
-    ALOG(INFO)<<node_log;
+    ALOG(INFO)<<node_log;*/
 
     if(code!=SUCCESS)
         return code;

system/PickupProcessTask.h

@@ -17,7 +17,7 @@ public:
     PickupProcessTask(unsigned int terminal_id,message::Car_info car_info);
     virtual  ~PickupProcessTask();
 
-    Error_manager init_task();
+    virtual Error_manager init_task(const ::google::protobuf::Message& parameter);
     // 获取任务类型
     virtual message::Process_type get_process_type()const{return message::ePicking;};
 

system/StoreProcessTask.cpp

@@ -23,12 +23,15 @@ StoreProcessTask::~StoreProcessTask()
 {
 }
 
-Error_manager StoreProcessTask::init_task(message::Locate_information locate_info)
+Error_manager StoreProcessTask::init_task(const ::google::protobuf::Message& parameter)
 {
 
-    char log[255]={0};
+    message::Locate_information locate_info;
+    locate_info.CopyFrom(parameter);
+
+    /*char log[255]={0};
     sprintf(log,"来自终端 %d 的停车指令:\n %s",m_terminor_id,locate_info.DebugString().c_str());
-    ALOG(INFO)<<log;
+    ALOG(INFO)<<log;*/
 
     reset_msg();
     m_locate_info=locate_info;
@@ -43,14 +46,9 @@ Error_manager StoreProcessTask::init_task(message::Locate_information locate_inf
     m_process_msg.set_license(m_car_info.license());
 
     m_current_step_type=message::eAlloc_step;
-    ///创建状态发布线程
-    if(m_publish_statu_thread== nullptr)
-    {
-        m_publish_exit_condition.reset(false, false, false);
-        m_publish_statu_thread=new std::thread(publish_thread_func,this);
-    }
 
-    return SUCCESS;
+
+    return Process_task::init_task(locate_info);
 
 }
 
@@ -67,7 +65,7 @@ Error_manager StoreProcessTask::compare_step()
  */
 Error_manager StoreProcessTask::back_compare_step()
 {
-    ALOG(INFO)<<" 回退compare";
+    //ALOG(INFO)<<" 回退compare";
     return SUCCESS;
 }
 
@@ -111,10 +109,10 @@ Error_manager StoreProcessTask::dispatch_step()
     code=Dispatch_excutor::get_instance_pointer()->dispatch_request(m_dispatch_request_msg,
             m_dispatch_response_msg,m_cancel_condition);
     //记录
-    message::Node_log node_log;
+    /*message::Node_log node_log;
     node_log.mutable_dispatch_request()->CopyFrom(m_dispatch_request_msg);
     node_log.mutable_dispatch_response()->CopyFrom(m_dispatch_response_msg);
-    ALOG(INFO)<<node_log;
+    ALOG(INFO)<<node_log;*/
 
     if(code!=SUCCESS)
         return code;
@@ -139,7 +137,7 @@ Error_manager StoreProcessTask::back_dispatch_step()
     m_dispatch_request_msg=message::Dispatch_request_msg();
     m_dispatch_response_msg=message::Dispatch_response_msg();
 
-    ALOG(INFO)<<" 回退调度 ";
+    //ALOG(INFO)<<" 回退调度 ";
 
     return SUCCESS;
 }
@@ -203,10 +201,10 @@ Error_manager StoreProcessTask::alloc_space_step()
             m_parcspace_alloc_response_msg,m_cancel_condition);
 
     //记录日志
-    message::Node_log node_log;
+    /*message::Node_log node_log;
     node_log.mutable_alloc_request()->CopyFrom(m_alloc_request_msg);
     node_log.mutable_alloc_response()->CopyFrom(m_parcspace_alloc_response_msg);
-    ALOG(INFO)<<node_log;
+    ALOG(INFO)<<node_log;*/
 
     if(code!=SUCCESS)
     {
@@ -258,17 +256,16 @@ Error_manager StoreProcessTask::confirm_space_step()
     base_info.set_timeout_ms(5000); //测量超时1s
     request.mutable_base_info()->CopyFrom(base_info);
 
-
     request.mutable_confirm_parkspace_info_ex()->CopyFrom(m_dispatch_response_msg.parkspace_info_ex());
     request.set_command_key(create_key());
 
     message::Parkspace_confirm_alloc_response_msg confirm_response;
     code=Parkspace_excutor::get_instance_pointer()->confirm_request(request,confirm_response,m_cancel_condition);
     //记录日志
-    message::Node_log node_log;
+    /*message::Node_log node_log;
     node_log.mutable_confirm_request()->CopyFrom(request);
     node_log.mutable_confirm_response()->CopyFrom(confirm_response);
-    ALOG(INFO)<<node_log;
+    ALOG(INFO)<<node_log;*/
 
     if(code!=SUCCESS)
         return code;
@@ -332,11 +329,11 @@ Error_manager StoreProcessTask::back_alloc_space_step()
     code=Parkspace_excutor::get_instance_pointer()->release_request(request,release_response,m_cancel_condition);
 
     //记录
-    message::Node_log node_log;
+    /*message::Node_log node_log;
     node_log.mutable_release_request()->CopyFrom(request);
     node_log.mutable_release_response()->CopyFrom(release_response);
     node_log.set_description("回退分配步骤，释放车位");
-    ALOG(INFO)<<node_log;
+    ALOG(INFO)<<node_log;*/
 
     if(code!=SUCCESS) {
         code.set_error_level_location(MAJOR_ERROR);
@@ -397,7 +394,7 @@ Error_manager StoreProcessTask::next_step()
         case message::eBackComplete:
             break;
     }
-    ALOG(INFO)<<"进入下一步:"<<message::Step_type_Name(m_current_step_type);
+    //ALOG(INFO)<<"进入下一步:"<<message::Step_type_Name(m_current_step_type);
     return SUCCESS;
 }
 
@@ -431,7 +428,7 @@ void StoreProcessTask::Main()
             Communication_message msg;
             msg.reset(m_command_response_msg.base_info(),m_command_response_msg.SerializeAsString());
             Message_communicator::get_instance_pointer()->send_msg(&msg);
-            ALOG_IF(WARNING, code != SUCCESS) << "------  停  ------- 分配失败:" <<m_car_info.license()<< code.get_error_description();
+            //ALOG_IF(WARNING, code != SUCCESS) << "------  停  ------- 分配失败:" <<m_car_info.license()<< code.get_error_description();
             LOG_IF(WARNING, code != SUCCESS) << "------  停  ------- 分配失败:" <<m_car_info.license()<< code.get_error_description();
         }
 
@@ -441,7 +438,7 @@ void StoreProcessTask::Main()
             updata_step_statu(message::eWorking);
             code=compare_step();
             usleep(500*1000);
-            ALOG_IF(WARNING, code != SUCCESS) << "------  停  ------- 检验失败:"<<m_car_info.license() << code.get_error_description();
+            //ALOG_IF(WARNING, code != SUCCESS) << "------  停  ------- 检验失败:"<<m_car_info.license() << code.get_error_description();
             LOG_IF(WARNING, code != SUCCESS) << "------  停  ------- 检验失败:"<<m_car_info.license() << code.get_error_description();
         }
         //调度
@@ -451,7 +448,7 @@ void StoreProcessTask::Main()
             updata_step_statu(message::eWorking);
             code = dispatch_step();
             usleep(1000 * 500 );
-            ALOG_IF(WARNING, code != SUCCESS) << "------  停  ------- 调度失败:"<<m_car_info.license() << code.get_error_description();
+            //ALOG_IF(WARNING, code != SUCCESS) << "------  停  ------- 调度失败:"<<m_car_info.license() << code.get_error_description();
             LOG_IF(WARNING, code != SUCCESS) << "------  停  ------- 调度失败:"<<m_car_info.license() << code.get_error_description();
         }
         //占据车位
@@ -460,10 +457,10 @@ void StoreProcessTask::Main()
             updata_step_statu(message::eWorking);
             code = confirm_space_step();
             usleep(1000 * 200);
-            ALOG_IF(WARNING, code != SUCCESS) << "------  停  ------- 占据车位失败,终端号:" << m_terminor_id
-                                                << "停车流程:"<<code.get_error_description() <<",车牌:" << m_car_info.license()<<code.to_string();
+            /*ALOG_IF(WARNING, code != SUCCESS) << "------  停  ------- 占据车位失败,终端:" << m_terminor_id
+                                                << "停车流程:"<<code.get_error_description() <<",车牌:" << m_car_info.license()<<code.to_string();*/
 
-            LOG_IF(WARNING, code != SUCCESS) << "------  停  ------- 占据车位失败,终端号:" << m_terminor_id
+            LOG_IF(WARNING, code != SUCCESS) << "------  停  ------- 占据车位失败,终端:" << m_terminor_id
                                                 << "停车流程:" << code.get_error_description()
                                               << ",车牌:" << m_car_info.license()<<code.to_string();
         }
@@ -489,8 +486,8 @@ void StoreProcessTask::Main()
             updata_step_statu(message::eWorking);
             code=back_dispatch_step();
             usleep(1000*500);
-            ALOG_IF(WARNING,code!=SUCCESS)<<" ------  停  ------- 回退调度失败 ------进入异常处理,  车牌号:"
-                                            <<m_car_info.license();
+            /*ALOG_IF(WARNING,code!=SUCCESS)<<" ------  停  ------- 回退调度失败 ------进入异常处理,  车牌号:"
+                                            <<m_car_info.license();*/
             LOG_IF(WARNING,code!=SUCCESS)<<" ------  停  ------- 回退调度失败 ------进入异常处理,  车牌号:"
                                           <<m_car_info.license();
         }
@@ -500,7 +497,7 @@ void StoreProcessTask::Main()
             updata_step_statu(message::eWorking);
             code=back_compare_step();
             usleep(1000*200);
-            ALOG_IF(WARNING,code!=SUCCESS)<<" ------  停  ------- 回退对比失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
+            //ALOG_IF(WARNING,code!=SUCCESS)<<" ------  停  ------- 回退对比失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
             LOG_IF(WARNING,code!=SUCCESS)<<" ------  停  ------- 回退对比失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
         }
 
@@ -509,8 +506,8 @@ void StoreProcessTask::Main()
             updata_step_statu(message::eWorking);
             code=back_alloc_space_step();
 
-            ALOG_IF(WARNING,code!=SUCCESS)
-                <<" ------  停  ------- 回退分配车位失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
+            /*ALOG_IF(WARNING,code!=SUCCESS)
+                <<" ------  停  ------- 回退分配车位失败 ------进入异常处理,  车牌号:"<<m_car_info.license();*/
             LOG_IF(WARNING,code!=SUCCESS)
                     <<" ------  停  ------- 回退分配车位失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
 
@@ -545,8 +542,8 @@ void StoreProcessTask::Main()
     publish_step_status();
 
     if(m_cancel_condition.wait_for_millisecond(1)==true) {
-        ALOG(ERROR) << "------  停  ------- 停车任务被强制取消,车牌号:" << m_car_info.license()
-                   << ",  终端号:" << m_terminor_id;
+        /*ALOG(ERROR) << "------  停  ------- 停车任务被强制取消,车牌号:" << m_car_info.license()
+                   << ",  终端号:" << m_terminor_id;*/
         LOG(ERROR) << "------  停  ------- 停车任务被强制取消,车牌号:" << m_car_info.license()
                               << ",  终端号:" << m_terminor_id;
         usleep(1000*200);
@@ -557,8 +554,8 @@ void StoreProcessTask::Main()
     {
         //异常结束
         usleep(1000*200);
-        ALOG(WARNING)<<"------  停  ------- 异常停车,回退结束"<<"车牌号:"<<m_car_info.license()
-            <<",xxxxxxxxxxxxxx  终端:"<<m_terminor_id<<"  xxxxxxxxxxxxxx";
+        /*ALOG(WARNING)<<"------  停  ------- 异常停车,回退结束"<<"车牌号:"<<m_car_info.license()
+            <<",xxxxxxxxxxxxxx  终端:"<<m_terminor_id<<"  xxxxxxxxxxxxxx";*/
         LOG(WARNING)<<"------  停  ------- 异常停车,回退结束"<<"车牌号:"<<m_car_info.license()
                                <<",xxxxxxxxxxxxxx  终端:"<<m_terminor_id<<"  xxxxxxxxxxxxxx";
     }
@@ -566,13 +563,13 @@ void StoreProcessTask::Main()
     {
         //正常结束
         usleep(1000*200);
-        ALOG(INFO)<<"------  停  ------- 停车结束,"<<"车牌号:"<<m_car_info.license()
-            <<",--------------  终端:"<<m_terminor_id<<"  --------------";
+        /*ALOG(INFO)<<"------  停  ------- 停车结束,"<<"车牌号:"<<m_car_info.license()
+            <<",--------------  终端:"<<m_terminor_id<<"  --------------";*/
         LOG(INFO)<<"------  停  ------- 停车结束,"<<"车牌号:"<<m_car_info.license()
             <<",--------------  终端:"<<m_terminor_id<<"  --------------";
     }
 
-    return Process_task::Main();
+    //return Process_task::Main();
 
 }
 

system/StoreProcessTask.h

@@ -16,7 +16,7 @@ class StoreProcessTask :public Process_task{
 public:
     StoreProcessTask(unsigned int command_id,message::Car_info car_info);
     virtual  ~StoreProcessTask();
-    Error_manager init_task(message::Locate_information locate_info);
+    virtual Error_manager init_task(const ::google::protobuf::Message& parameter);
     // 获取任务类型
     virtual message::Process_type get_process_type()const{return message::eStoring;}
 

system/command_manager.cpp

@@ -161,7 +161,7 @@ Error_manager Command_manager::init(setting::System_setting system_setting) {
  * 执行停车请求
  */
 
-Error_manager Command_manager::execute_store_command(message::Store_command_request_msg& request)
+Error_manager Command_manager::execute_store_command(const message::Store_command_request_msg& request)
 {
     message::Error_manager error_msg;
     message::Store_command_response_msg response;
@@ -309,7 +309,7 @@ Error_manager Command_manager::execute_store_command(message::Store_command_requ
 /*
  * 执行取车请求
  */
-Error_manager Command_manager::execute_pickup_command(message::Pickup_command_request_msg& request)
+Error_manager Command_manager::execute_pickup_command(const message::Pickup_command_request_msg& request)
 {
     message::Error_manager error_msg;
     message::Pickup_command_response_msg response;
@@ -409,14 +409,14 @@ Error_manager Command_manager::execute_pickup_command(message::Pickup_command_re
         Process_task *ptask = new PickupProcessTask(request.terminal_id(), request.car_info());
         PickupProcessTask *pPick_task = (PickupProcessTask *) ptask;
         //初始化流程
-        code = pPick_task->init_task();
+        code = pPick_task->init_task(request);
 
         if (code == SUCCESS)
         {
             m_thread_queue_process->AddTask(pPick_task);
             return SUCCESS;
         }
-        usleep(1000 * 1000);
+
         error_msg.set_error_code(code.get_error_code());
         error_msg.set_error_description(code.to_string());
         response.mutable_code()->CopyFrom(error_msg);

system/command_manager.h

@@ -33,12 +33,12 @@ public:
     /*
      * 执行停车请求
      */
-    Error_manager execute_store_command(message::Store_command_request_msg& request);
+    Error_manager execute_store_command(const message::Store_command_request_msg& request);
 
     /*
      * 执行取车请求
      */
-    Error_manager execute_pickup_command(message::Pickup_command_request_msg& request);
+    Error_manager execute_pickup_command(const message::Pickup_command_request_msg& request);
 
     /*
      * 控制入口 开放或者关闭

system/process_task.cpp

@@ -29,6 +29,18 @@ Process_task::~Process_task()
     }
 }
 
+Error_manager Process_task::init_task(const ::google::protobuf::Message& parameter)
+{
+    ///创建状态发布线程
+    if(m_publish_statu_thread== nullptr)
+    {
+        m_publish_exit_condition.reset(false, false, false);
+        m_publish_statu_thread=new std::thread(publish_thread_func,this);
+    }
+    return SUCCESS;
+}
+
+
 /*
  * 取消任务
  */

system/process_task.h

@@ -24,6 +24,7 @@ class Process_task : public tq::BaseTask{
 
 public:
     Process_task(unsigned int command_id,message::Car_info car_info);
+    virtual Error_manager init_task(const ::google::protobuf::Message& parameter);
     virtual ~Process_task();
 
     /*
@@ -84,7 +85,7 @@ protected:
             m_severity=severity;
             m_condition=condition;
         }
-        ~Log_container()
+        virtual ~Log_container()
         {
             if(m_process&& m_str.length()>0)
             {
@@ -127,6 +128,7 @@ protected:
             m_severity=message::Log_data_Severity_INFO;
             m_condition=condition;
         }
+        virtual ~Log_container_INFO(){}
     };
     class Log_container_WARNING :public Log_container
     {
@@ -136,6 +138,7 @@ protected:
             m_severity=message::Log_data_Severity_WARNING;
             m_condition=condition;
         }
+        virtual ~Log_container_WARNING(){}
     };
     class Log_container_ERROR :public Log_container
     {
@@ -145,6 +148,7 @@ protected:
             m_severity=message::Log_data_Severity_ERROR;
             m_condition=condition;
         }
+        virtual ~Log_container_ERROR(){}
     };
 
 

system/system_setting.pb.cc

@@ -5,142 +5,123 @@
 
 #include <algorithm>
 
-#include <google/protobuf/stubs/common.h>
-#include <google/protobuf/stubs/port.h>
 #include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.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)
-
+#include <google/protobuf/port_def.inc>
 namespace setting {
 class System_settingDefaultTypeInternal {
  public:
-  ::google::protobuf::internal::ExplicitlyConstructed<System_setting>
-      _instance;
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<System_setting> _instance;
 } _System_setting_default_instance_;
 }  // namespace setting
-namespace protobuf_system_5fsetting_2eproto {
-static void InitDefaultsSystem_setting() {
+static void InitDefaultsscc_info_System_setting_system_5fsetting_2eproto() {
   GOOGLE_PROTOBUF_VERIFY_VERSION;
 
   {
     void* ptr = &::setting::_System_setting_default_instance_;
     new (ptr) ::setting::System_setting();
-    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
   }
   ::setting::System_setting::InitAsDefaultInstance();
 }
 
-::google::protobuf::internal::SCCInfo<0> scc_info_System_setting =
-    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsSystem_setting}, {}};
-
-void InitDefaults() {
-  ::google::protobuf::internal::InitSCC(&scc_info_System_setting.base);
-}
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_System_setting_system_5fsetting_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_System_setting_system_5fsetting_2eproto}, {}};
 
-::google::protobuf::Metadata file_level_metadata[1];
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_system_5fsetting_2eproto[1];
+static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_system_5fsetting_2eproto = nullptr;
+static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_system_5fsetting_2eproto = nullptr;
 
-const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
-  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::setting::System_setting, _has_bits_),
-  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::setting::System_setting, _internal_metadata_),
+const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_system_5fsetting_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  PROTOBUF_FIELD_OFFSET(::setting::System_setting, _has_bits_),
+  PROTOBUF_FIELD_OFFSET(::setting::System_setting, _internal_metadata_),
   ~0u,  // no _extensions_
   ~0u,  // no _oneof_case_
   ~0u,  // no _weak_field_map_
-  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::setting::System_setting, bind_ip_),
-  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::setting::System_setting, bind_port_),
-  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::setting::System_setting, entrance_num_),
-  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::setting::System_setting, export_num_),
+  PROTOBUF_FIELD_OFFSET(::setting::System_setting, bind_ip_),
+  PROTOBUF_FIELD_OFFSET(::setting::System_setting, bind_port_),
+  PROTOBUF_FIELD_OFFSET(::setting::System_setting, entrance_num_),
+  PROTOBUF_FIELD_OFFSET(::setting::System_setting, export_num_),
   0,
   3,
   1,
   2,
 };
-static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
+static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
   { 0, 9, sizeof(::setting::System_setting)},
 };
 
-static ::google::protobuf::Message const * const file_default_instances[] = {
-  reinterpret_cast<const ::google::protobuf::Message*>(&::setting::_System_setting_default_instance_),
+static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::setting::_System_setting_default_instance_),
 };
 
-void protobuf_AssignDescriptors() {
-  AddDescriptors();
-  AssignDescriptors(
-      "system_setting.proto", schemas, file_default_instances, TableStruct::offsets,
-      file_level_metadata, NULL, NULL);
-}
-
-void protobuf_AssignDescriptorsOnce() {
-  static ::google::protobuf::internal::once_flag once;
-  ::google::protobuf::internal::call_once(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\024system_setting.proto\022\007setting\"e\n\016Syste"
-      "m_setting\022\017\n\007bind_ip\030\001 \002(\t\022\030\n\tbind_port\030"
-      "\002 \001(\005:\00530000\022\024\n\014entrance_num\030\003 \002(\005\022\022\n\nex"
-      "port_num\030\004 \002(\005"
-  };
-  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
-      descriptor, 134);
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
-    "system_setting.proto", &protobuf_RegisterTypes);
-}
+const char descriptor_table_protodef_system_5fsetting_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n\024system_setting.proto\022\007setting\"e\n\016Syste"
+  "m_setting\022\017\n\007bind_ip\030\001 \002(\t\022\030\n\tbind_port\030"
+  "\002 \001(\005:\00530000\022\024\n\014entrance_num\030\003 \002(\005\022\022\n\nex"
+  "port_num\030\004 \002(\005"
+  ;
+static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_system_5fsetting_2eproto_deps[1] = {
+};
+static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_system_5fsetting_2eproto_sccs[1] = {
+  &scc_info_System_setting_system_5fsetting_2eproto.base,
+};
+static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_system_5fsetting_2eproto_once;
+const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_system_5fsetting_2eproto = {
+  false, false, descriptor_table_protodef_system_5fsetting_2eproto, "system_setting.proto", 134,
+  &descriptor_table_system_5fsetting_2eproto_once, descriptor_table_system_5fsetting_2eproto_sccs, descriptor_table_system_5fsetting_2eproto_deps, 1, 0,
+  schemas, file_default_instances, TableStruct_system_5fsetting_2eproto::offsets,
+  file_level_metadata_system_5fsetting_2eproto, 1, file_level_enum_descriptors_system_5fsetting_2eproto, file_level_service_descriptors_system_5fsetting_2eproto,
+};
 
-void AddDescriptors() {
-  static ::google::protobuf::internal::once_flag once;
-  ::google::protobuf::internal::call_once(once, AddDescriptorsImpl);
-}
-// Force AddDescriptors() to be called at dynamic initialization time.
-struct StaticDescriptorInitializer {
-  StaticDescriptorInitializer() {
-    AddDescriptors();
-  }
-} static_descriptor_initializer;
-}  // namespace protobuf_system_5fsetting_2eproto
+// Force running AddDescriptors() at dynamic initialization time.
+static bool dynamic_init_dummy_system_5fsetting_2eproto = (static_cast<void>(::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_system_5fsetting_2eproto)), true);
 namespace setting {
 
 // ===================================================================
 
 void System_setting::InitAsDefaultInstance() {
 }
-#if !defined(_MSC_VER) || _MSC_VER >= 1900
-const int System_setting::kBindIpFieldNumber;
-const int System_setting::kBindPortFieldNumber;
-const int System_setting::kEntranceNumFieldNumber;
-const int System_setting::kExportNumFieldNumber;
-#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
-
-System_setting::System_setting()
-  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
-  ::google::protobuf::internal::InitSCC(
-      &protobuf_system_5fsetting_2eproto::scc_info_System_setting.base);
+class System_setting::_Internal {
+ public:
+  using HasBits = decltype(std::declval<System_setting>()._has_bits_);
+  static void set_has_bind_ip(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_bind_port(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_entrance_num(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_export_num(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000007) ^ 0x00000007) != 0;
+  }
+};
+
+System_setting::System_setting(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
   SharedCtor();
-  // @@protoc_insertion_point(constructor:setting.System_setting)
+  RegisterArenaDtor(arena);
+  // @@protoc_insertion_point(arena_constructor:setting.System_setting)
 }
 System_setting::System_setting(const System_setting& from)
-  : ::google::protobuf::Message(),
-      _internal_metadata_(NULL),
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
       _has_bits_(from._has_bits_) {
-  _internal_metadata_.MergeFrom(from._internal_metadata_);
-  bind_ip_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  if (from.has_bind_ip()) {
-    bind_ip_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.bind_ip_);
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  bind_ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (from._internal_has_bind_ip()) {
+    bind_ip_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_bind_ip(),
+      GetArena());
   }
   ::memcpy(&entrance_num_, &from.entrance_num_,
     static_cast<size_t>(reinterpret_cast<char*>(&bind_port_) -
@@ -149,7 +130,8 @@ System_setting::System_setting(const System_setting& from)
 }
 
 void System_setting::SharedCtor() {
-  bind_ip_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_System_setting_system_5fsetting_2eproto.base);
+  bind_ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
   ::memset(&entrance_num_, 0, static_cast<size_t>(
       reinterpret_cast<char*>(&export_num_) -
       reinterpret_cast<char*>(&entrance_num_)) + sizeof(export_num_));
@@ -159,210 +141,154 @@ void System_setting::SharedCtor() {
 System_setting::~System_setting() {
   // @@protoc_insertion_point(destructor:setting.System_setting)
   SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
 void System_setting::SharedDtor() {
-  bind_ip_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  GOOGLE_DCHECK(GetArena() == nullptr);
+  bind_ip_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 }
 
+void System_setting::ArenaDtor(void* object) {
+  System_setting* _this = reinterpret_cast< System_setting* >(object);
+  (void)_this;
+}
+void System_setting::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
 void System_setting::SetCachedSize(int size) const {
   _cached_size_.Set(size);
 }
-const ::google::protobuf::Descriptor* System_setting::descriptor() {
-  ::protobuf_system_5fsetting_2eproto::protobuf_AssignDescriptorsOnce();
-  return ::protobuf_system_5fsetting_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
-}
-
 const System_setting& System_setting::default_instance() {
-  ::google::protobuf::internal::InitSCC(&protobuf_system_5fsetting_2eproto::scc_info_System_setting.base);
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_System_setting_system_5fsetting_2eproto.base);
   return *internal_default_instance();
 }
 
 
 void System_setting::Clear() {
 // @@protoc_insertion_point(message_clear_start:setting.System_setting)
-  ::google::protobuf::uint32 cached_has_bits = 0;
+  ::PROTOBUF_NAMESPACE_ID::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 & 0x00000001u) {
-    bind_ip_.ClearNonDefaultToEmptyNoArena();
+    bind_ip_.ClearNonDefaultToEmpty();
   }
-  if (cached_has_bits & 14u) {
+  if (cached_has_bits & 0x0000000eu) {
     ::memset(&entrance_num_, 0, static_cast<size_t>(
         reinterpret_cast<char*>(&export_num_) -
         reinterpret_cast<char*>(&entrance_num_)) + sizeof(export_num_));
     bind_port_ = 30000;
   }
   _has_bits_.Clear();
-  _internal_metadata_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-bool System_setting::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:setting.System_setting)
-  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)) {
+const char* System_setting::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
       // required string bind_ip = 1;
-      case 1: {
-        if (static_cast< ::google::protobuf::uint8>(tag) ==
-            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_bind_ip()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->bind_ip().data(), static_cast<int>(this->bind_ip().length()),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "setting.System_setting.bind_ip");
-        } else {
-          goto handle_unusual;
-        }
-        break;
-      }
-
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          auto str = _internal_mutable_bind_ip();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          #ifndef NDEBUG
+          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "setting.System_setting.bind_ip");
+          #endif  // !NDEBUG
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
       // optional int32 bind_port = 2 [default = 30000];
-      case 2: {
-        if (static_cast< ::google::protobuf::uint8>(tag) ==
-            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
-          set_has_bind_port();
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
-                 input, &bind_port_)));
-        } else {
-          goto handle_unusual;
-        }
-        break;
-      }
-
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
+          _Internal::set_has_bind_port(&has_bits);
+          bind_port_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
       // required int32 entrance_num = 3;
-      case 3: {
-        if (static_cast< ::google::protobuf::uint8>(tag) ==
-            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
-          set_has_entrance_num();
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
-                 input, &entrance_num_)));
-        } else {
-          goto handle_unusual;
-        }
-        break;
-      }
-
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
+          _Internal::set_has_entrance_num(&has_bits);
+          entrance_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
       // required int32 export_num = 4;
-      case 4: {
-        if (static_cast< ::google::protobuf::uint8>(tag) ==
-            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
-          set_has_export_num();
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
-                 input, &export_num_)));
-        } else {
-          goto handle_unusual;
-        }
-        break;
-      }
-
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
+          _Internal::set_has_export_num(&has_bits);
+          export_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
       default: {
       handle_unusual:
-        if (tag == 0) {
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
           goto success;
         }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, _internal_metadata_.mutable_unknown_fields()));
-        break;
+        ptr = UnknownFieldParse(tag,
+            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+            ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
       }
-    }
-  }
+    }  // switch
+  }  // while
 success:
-  // @@protoc_insertion_point(parse_success:setting.System_setting)
-  return true;
+  _has_bits_.Or(has_bits);
+  return ptr;
 failure:
-  // @@protoc_insertion_point(parse_failure:setting.System_setting)
-  return false;
-#undef DO_
+  ptr = nullptr;
+  goto success;
+#undef CHK_
 }
 
-void System_setting::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:setting.System_setting)
-  ::google::protobuf::uint32 cached_has_bits = 0;
-  (void) cached_has_bits;
-
-  cached_has_bits = _has_bits_[0];
-  // required string bind_ip = 1;
-  if (cached_has_bits & 0x00000001u) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->bind_ip().data(), static_cast<int>(this->bind_ip().length()),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "setting.System_setting.bind_ip");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      1, this->bind_ip(), output);
-  }
-
-  // optional int32 bind_port = 2 [default = 30000];
-  if (cached_has_bits & 0x00000008u) {
-    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->bind_port(), output);
-  }
-
-  // required int32 entrance_num = 3;
-  if (cached_has_bits & 0x00000002u) {
-    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->entrance_num(), output);
-  }
-
-  // required int32 export_num = 4;
-  if (cached_has_bits & 0x00000004u) {
-    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->export_num(), output);
-  }
-
-  if (_internal_metadata_.have_unknown_fields()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        _internal_metadata_.unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:setting.System_setting)
-}
-
-::google::protobuf::uint8* System_setting::InternalSerializeWithCachedSizesToArray(
-    bool deterministic, ::google::protobuf::uint8* target) const {
-  (void)deterministic; // Unused
+::PROTOBUF_NAMESPACE_ID::uint8* System_setting::_InternalSerialize(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
   // @@protoc_insertion_point(serialize_to_array_start:setting.System_setting)
-  ::google::protobuf::uint32 cached_has_bits = 0;
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   (void) cached_has_bits;
 
   cached_has_bits = _has_bits_[0];
   // required string bind_ip = 1;
   if (cached_has_bits & 0x00000001u) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->bind_ip().data(), static_cast<int>(this->bind_ip().length()),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->_internal_bind_ip().data(), static_cast<int>(this->_internal_bind_ip().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
       "setting.System_setting.bind_ip");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        1, this->bind_ip(), target);
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_bind_ip(), target);
   }
 
   // optional int32 bind_port = 2 [default = 30000];
   if (cached_has_bits & 0x00000008u) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->bind_port(), target);
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_bind_port(), target);
   }
 
   // required int32 entrance_num = 3;
   if (cached_has_bits & 0x00000002u) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->entrance_num(), target);
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_entrance_num(), target);
   }
 
   // required int32 export_num = 4;
   if (cached_has_bits & 0x00000004u) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->export_num(), target);
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_export_num(), target);
   }
 
-  if (_internal_metadata_.have_unknown_fields()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        _internal_metadata_.unknown_fields(), target);
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
   }
   // @@protoc_insertion_point(serialize_to_array_end:setting.System_setting)
   return target;
@@ -372,25 +298,25 @@ size_t System_setting::RequiredFieldsByteSizeFallback() const {
 // @@protoc_insertion_point(required_fields_byte_size_fallback_start:setting.System_setting)
   size_t total_size = 0;
 
-  if (has_bind_ip()) {
+  if (_internal_has_bind_ip()) {
     // required string bind_ip = 1;
     total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::StringSize(
-        this->bind_ip());
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_bind_ip());
   }
 
-  if (has_entrance_num()) {
+  if (_internal_has_entrance_num()) {
     // required int32 entrance_num = 3;
     total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::Int32Size(
-        this->entrance_num());
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+        this->_internal_entrance_num());
   }
 
-  if (has_export_num()) {
+  if (_internal_has_export_num()) {
     // required int32 export_num = 4;
     total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::Int32Size(
-        this->export_num());
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+        this->_internal_export_num());
   }
 
   return total_size;
@@ -399,51 +325,55 @@ size_t System_setting::ByteSizeLong() const {
 // @@protoc_insertion_point(message_byte_size_start:setting.System_setting)
   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] & 0x00000007) ^ 0x00000007) == 0) {  // All required fields are present.
     // required string bind_ip = 1;
     total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::StringSize(
-        this->bind_ip());
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_bind_ip());
 
     // required int32 entrance_num = 3;
     total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::Int32Size(
-        this->entrance_num());
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+        this->_internal_entrance_num());
 
     // required int32 export_num = 4;
     total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::Int32Size(
-        this->export_num());
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+        this->_internal_export_num());
 
   } else {
     total_size += RequiredFieldsByteSizeFallback();
   }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
   // optional int32 bind_port = 2 [default = 30000];
-  if (has_bind_port()) {
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000008u) {
     total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::Int32Size(
-        this->bind_port());
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+        this->_internal_bind_port());
   }
 
-  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+        _internal_metadata_, total_size, &_cached_size_);
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
   SetCachedSize(cached_size);
   return total_size;
 }
 
-void System_setting::MergeFrom(const ::google::protobuf::Message& from) {
+void System_setting::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
 // @@protoc_insertion_point(generalized_merge_from_start:setting.System_setting)
   GOOGLE_DCHECK_NE(&from, this);
   const System_setting* source =
-      ::google::protobuf::internal::DynamicCastToGenerated<const System_setting>(
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<System_setting>(
           &from);
-  if (source == NULL) {
+  if (source == nullptr) {
   // @@protoc_insertion_point(generalized_merge_from_cast_fail:setting.System_setting)
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
   } else {
   // @@protoc_insertion_point(generalized_merge_from_cast_success:setting.System_setting)
     MergeFrom(*source);
@@ -453,15 +383,14 @@ void System_setting::MergeFrom(const ::google::protobuf::Message& from) {
 void System_setting::MergeFrom(const System_setting& from) {
 // @@protoc_insertion_point(class_specific_merge_from_start:setting.System_setting)
   GOOGLE_DCHECK_NE(&from, this);
-  _internal_metadata_.MergeFrom(from._internal_metadata_);
-  ::google::protobuf::uint32 cached_has_bits = 0;
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::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 & 0x0000000fu) {
     if (cached_has_bits & 0x00000001u) {
-      set_has_bind_ip();
-      bind_ip_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.bind_ip_);
+      _internal_set_bind_ip(from._internal_bind_ip());
     }
     if (cached_has_bits & 0x00000002u) {
       entrance_num_ = from.entrance_num_;
@@ -476,7 +405,7 @@ void System_setting::MergeFrom(const System_setting& from) {
   }
 }
 
-void System_setting::CopyFrom(const ::google::protobuf::Message& from) {
+void System_setting::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
 // @@protoc_insertion_point(generalized_copy_from_start:setting.System_setting)
   if (&from == this) return;
   Clear();
@@ -491,39 +420,36 @@ void System_setting::CopyFrom(const System_setting& from) {
 }
 
 bool System_setting::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
+  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
   return true;
 }
 
-void System_setting::Swap(System_setting* other) {
-  if (other == this) return;
-  InternalSwap(other);
-}
 void System_setting::InternalSwap(System_setting* other) {
   using std::swap;
-  bind_ip_.Swap(&other->bind_ip_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
-    GetArenaNoVirtual());
-  swap(entrance_num_, other->entrance_num_);
-  swap(export_num_, other->export_num_);
-  swap(bind_port_, other->bind_port_);
+  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
   swap(_has_bits_[0], other->_has_bits_[0]);
-  _internal_metadata_.Swap(&other->_internal_metadata_);
+  bind_ip_.Swap(&other->bind_ip_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(System_setting, export_num_)
+      + sizeof(System_setting::export_num_)
+      - PROTOBUF_FIELD_OFFSET(System_setting, entrance_num_)>(
+          reinterpret_cast<char*>(&entrance_num_),
+          reinterpret_cast<char*>(&other->entrance_num_));
+  swap(bind_port_, other->bind_port_);
 }
 
-::google::protobuf::Metadata System_setting::GetMetadata() const {
-  protobuf_system_5fsetting_2eproto::protobuf_AssignDescriptorsOnce();
-  return ::protobuf_system_5fsetting_2eproto::file_level_metadata[kIndexInFileMessages];
+::PROTOBUF_NAMESPACE_ID::Metadata System_setting::GetMetadata() const {
+  return GetMetadataStatic();
 }
 
 
 // @@protoc_insertion_point(namespace_scope)
 }  // namespace setting
-namespace google {
-namespace protobuf {
-template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::setting::System_setting* Arena::CreateMaybeMessage< ::setting::System_setting >(Arena* arena) {
-  return Arena::CreateInternal< ::setting::System_setting >(arena);
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::setting::System_setting* Arena::CreateMaybeMessage< ::setting::System_setting >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::setting::System_setting >(arena);
 }
-}  // namespace protobuf
-}  // namespace google
+PROTOBUF_NAMESPACE_CLOSE
 
 // @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>

system/system_setting.pb.h

@@ -1,98 +1,112 @@
 // Generated by the protocol buffer compiler.  DO NOT EDIT!
 // source: system_setting.proto
 
-#ifndef PROTOBUF_INCLUDED_system_5fsetting_2eproto
-#define PROTOBUF_INCLUDED_system_5fsetting_2eproto
+#ifndef GOOGLE_PROTOBUF_INCLUDED_system_5fsetting_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_system_5fsetting_2eproto
 
+#include <limits>
 #include <string>
 
-#include <google/protobuf/stubs/common.h>
-
-#if GOOGLE_PROTOBUF_VERSION < 3006000
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3013000
 #error This file was generated by a newer version of protoc which is
-#error incompatible with your Protocol Buffer headers.  Please update
+#error incompatible with your Protocol Buffer headers. Please update
 #error your headers.
 #endif
-#if 3006000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#if 3013000 < PROTOBUF_MIN_PROTOC_VERSION
 #error This file was generated by an older version of protoc which is
-#error incompatible with your Protocol Buffer headers.  Please
+#error incompatible with your Protocol Buffer headers. Please
 #error regenerate this file with a newer version of protoc.
 #endif
 
+#include <google/protobuf/port_undef.inc>
 #include <google/protobuf/io/coded_stream.h>
 #include <google/protobuf/arena.h>
 #include <google/protobuf/arenastring.h>
 #include <google/protobuf/generated_message_table_driven.h>
 #include <google/protobuf/generated_message_util.h>
 #include <google/protobuf/inlined_string_field.h>
-#include <google/protobuf/metadata.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
 #include <google/protobuf/message.h>
 #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
 #include <google/protobuf/extension_set.h>  // IWYU pragma: export
 #include <google/protobuf/unknown_field_set.h>
 // @@protoc_insertion_point(includes)
-#define PROTOBUF_INTERNAL_EXPORT_protobuf_system_5fsetting_2eproto 
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_system_5fsetting_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
 
-namespace protobuf_system_5fsetting_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[];
+struct TableStruct_system_5fsetting_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
 };
-void AddDescriptors();
-}  // namespace protobuf_system_5fsetting_2eproto
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_system_5fsetting_2eproto;
 namespace setting {
 class System_setting;
 class System_settingDefaultTypeInternal;
 extern System_settingDefaultTypeInternal _System_setting_default_instance_;
 }  // namespace setting
-namespace google {
-namespace protobuf {
+PROTOBUF_NAMESPACE_OPEN
 template<> ::setting::System_setting* Arena::CreateMaybeMessage<::setting::System_setting>(Arena*);
-}  // namespace protobuf
-}  // namespace google
+PROTOBUF_NAMESPACE_CLOSE
 namespace setting {
 
 // ===================================================================
 
-class System_setting : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:setting.System_setting) */ {
+class System_setting PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:setting.System_setting) */ {
  public:
-  System_setting();
+  inline System_setting() : System_setting(nullptr) {}
   virtual ~System_setting();
 
   System_setting(const System_setting& from);
-
-  inline System_setting& operator=(const System_setting& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  #if LANG_CXX11
   System_setting(System_setting&& from) noexcept
     : System_setting() {
     *this = ::std::move(from);
   }
 
+  inline System_setting& operator=(const System_setting& from) {
+    CopyFrom(from);
+    return *this;
+  }
   inline System_setting& operator=(System_setting&& from) noexcept {
-    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+    if (GetArena() == from.GetArena()) {
       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 const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
   }
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields();
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
   }
 
-  static const ::google::protobuf::Descriptor* descriptor();
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
   static const System_setting& default_instance();
 
   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
@@ -103,114 +117,156 @@ class System_setting : public ::google::protobuf::Message /* @@protoc_insertion_
   static constexpr int kIndexInFileMessages =
     0;
 
-  void Swap(System_setting* other);
   friend void swap(System_setting& a, System_setting& b) {
     a.Swap(&b);
   }
+  inline void Swap(System_setting* other) {
+    if (other == this) return;
+    if (GetArena() == other->GetArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(System_setting* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    InternalSwap(other);
+  }
 
   // implements Message ----------------------------------------------
 
   inline System_setting* New() const final {
-    return CreateMaybeMessage<System_setting>(NULL);
+    return CreateMaybeMessage<System_setting>(nullptr);
   }
 
-  System_setting* New(::google::protobuf::Arena* arena) const final {
+  System_setting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
     return CreateMaybeMessage<System_setting>(arena);
   }
-  void CopyFrom(const ::google::protobuf::Message& from) final;
-  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
   void CopyFrom(const System_setting& from);
   void MergeFrom(const System_setting& from);
-  void Clear() final;
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
   bool IsInitialized() const final;
 
   size_t ByteSizeLong() const final;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input) final;
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const final;
-  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
-      bool deterministic, ::google::protobuf::uint8* target) const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
   int GetCachedSize() const final { return _cached_size_.Get(); }
 
   private:
-  void SharedCtor();
-  void SharedDtor();
+  inline void SharedCtor();
+  inline void SharedDtor();
   void SetCachedSize(int size) const final;
   void InternalSwap(System_setting* other);
-  private:
-  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
-    return NULL;
-  }
-  inline void* MaybeArenaPtr() const {
-    return NULL;
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "setting.System_setting";
   }
+  protected:
+  explicit System_setting(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   public:
 
-  ::google::protobuf::Metadata GetMetadata() const final;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_system_5fsetting_2eproto);
+    return ::descriptor_table_system_5fsetting_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
 
   // nested types ----------------------------------------------------
 
   // accessors -------------------------------------------------------
 
+  enum : int {
+    kBindIpFieldNumber = 1,
+    kEntranceNumFieldNumber = 3,
+    kExportNumFieldNumber = 4,
+    kBindPortFieldNumber = 2,
+  };
   // required string bind_ip = 1;
   bool has_bind_ip() const;
+  private:
+  bool _internal_has_bind_ip() const;
+  public:
   void clear_bind_ip();
-  static const int kBindIpFieldNumber = 1;
-  const ::std::string& bind_ip() const;
-  void set_bind_ip(const ::std::string& value);
-  #if LANG_CXX11
-  void set_bind_ip(::std::string&& value);
-  #endif
+  const std::string& bind_ip() const;
+  void set_bind_ip(const std::string& value);
+  void set_bind_ip(std::string&& value);
   void set_bind_ip(const char* value);
   void set_bind_ip(const char* value, size_t size);
-  ::std::string* mutable_bind_ip();
-  ::std::string* release_bind_ip();
-  void set_allocated_bind_ip(::std::string* bind_ip);
+  std::string* mutable_bind_ip();
+  std::string* release_bind_ip();
+  void set_allocated_bind_ip(std::string* bind_ip);
+  private:
+  const std::string& _internal_bind_ip() const;
+  void _internal_set_bind_ip(const std::string& value);
+  std::string* _internal_mutable_bind_ip();
+  public:
 
   // required int32 entrance_num = 3;
   bool has_entrance_num() const;
+  private:
+  bool _internal_has_entrance_num() const;
+  public:
   void clear_entrance_num();
-  static const int kEntranceNumFieldNumber = 3;
-  ::google::protobuf::int32 entrance_num() const;
-  void set_entrance_num(::google::protobuf::int32 value);
+  ::PROTOBUF_NAMESPACE_ID::int32 entrance_num() const;
+  void set_entrance_num(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_entrance_num() const;
+  void _internal_set_entrance_num(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
 
   // required int32 export_num = 4;
   bool has_export_num() const;
+  private:
+  bool _internal_has_export_num() const;
+  public:
   void clear_export_num();
-  static const int kExportNumFieldNumber = 4;
-  ::google::protobuf::int32 export_num() const;
-  void set_export_num(::google::protobuf::int32 value);
+  ::PROTOBUF_NAMESPACE_ID::int32 export_num() const;
+  void set_export_num(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_export_num() const;
+  void _internal_set_export_num(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
 
   // optional int32 bind_port = 2 [default = 30000];
   bool has_bind_port() const;
+  private:
+  bool _internal_has_bind_port() const;
+  public:
   void clear_bind_port();
-  static const int kBindPortFieldNumber = 2;
-  ::google::protobuf::int32 bind_port() const;
-  void set_bind_port(::google::protobuf::int32 value);
+  ::PROTOBUF_NAMESPACE_ID::int32 bind_port() const;
+  void set_bind_port(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_bind_port() const;
+  void _internal_set_bind_port(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
 
   // @@protoc_insertion_point(class_scope:setting.System_setting)
  private:
-  void set_has_bind_ip();
-  void clear_has_bind_ip();
-  void set_has_bind_port();
-  void clear_has_bind_port();
-  void set_has_entrance_num();
-  void clear_has_entrance_num();
-  void set_has_export_num();
-  void clear_has_export_num();
+  class _Internal;
 
   // helper for ByteSizeLong()
   size_t RequiredFieldsByteSizeFallback() const;
 
-  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
-  ::google::protobuf::internal::HasBits<1> _has_bits_;
-  mutable ::google::protobuf::internal::CachedSize _cached_size_;
-  ::google::protobuf::internal::ArenaStringPtr bind_ip_;
-  ::google::protobuf::int32 entrance_num_;
-  ::google::protobuf::int32 export_num_;
-  ::google::protobuf::int32 bind_port_;
-  friend struct ::protobuf_system_5fsetting_2eproto::TableStruct;
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bind_ip_;
+  ::PROTOBUF_NAMESPACE_ID::int32 entrance_num_;
+  ::PROTOBUF_NAMESPACE_ID::int32 export_num_;
+  ::PROTOBUF_NAMESPACE_ID::int32 bind_port_;
+  friend struct ::TableStruct_system_5fsetting_2eproto;
 };
 // ===================================================================
 
@@ -224,140 +280,160 @@ class System_setting : public ::google::protobuf::Message /* @@protoc_insertion_
 // System_setting
 
 // required string bind_ip = 1;
-inline bool System_setting::has_bind_ip() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void System_setting::set_has_bind_ip() {
-  _has_bits_[0] |= 0x00000001u;
+inline bool System_setting::_internal_has_bind_ip() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
 }
-inline void System_setting::clear_has_bind_ip() {
-  _has_bits_[0] &= ~0x00000001u;
+inline bool System_setting::has_bind_ip() const {
+  return _internal_has_bind_ip();
 }
 inline void System_setting::clear_bind_ip() {
-  bind_ip_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  clear_has_bind_ip();
+  bind_ip_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+  _has_bits_[0] &= ~0x00000001u;
 }
-inline const ::std::string& System_setting::bind_ip() const {
+inline const std::string& System_setting::bind_ip() const {
   // @@protoc_insertion_point(field_get:setting.System_setting.bind_ip)
-  return bind_ip_.GetNoArena();
+  return _internal_bind_ip();
 }
-inline void System_setting::set_bind_ip(const ::std::string& value) {
-  set_has_bind_ip();
-  bind_ip_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+inline void System_setting::set_bind_ip(const std::string& value) {
+  _internal_set_bind_ip(value);
   // @@protoc_insertion_point(field_set:setting.System_setting.bind_ip)
 }
-#if LANG_CXX11
-inline void System_setting::set_bind_ip(::std::string&& value) {
-  set_has_bind_ip();
-  bind_ip_.SetNoArena(
-    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+inline std::string* System_setting::mutable_bind_ip() {
+  // @@protoc_insertion_point(field_mutable:setting.System_setting.bind_ip)
+  return _internal_mutable_bind_ip();
+}
+inline const std::string& System_setting::_internal_bind_ip() const {
+  return bind_ip_.Get();
+}
+inline void System_setting::_internal_set_bind_ip(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  bind_ip_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
+}
+inline void System_setting::set_bind_ip(std::string&& value) {
+  _has_bits_[0] |= 0x00000001u;
+  bind_ip_.Set(
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
   // @@protoc_insertion_point(field_set_rvalue:setting.System_setting.bind_ip)
 }
-#endif
 inline void System_setting::set_bind_ip(const char* value) {
-  GOOGLE_DCHECK(value != NULL);
-  set_has_bind_ip();
-  bind_ip_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  GOOGLE_DCHECK(value != nullptr);
+  _has_bits_[0] |= 0x00000001u;
+  bind_ip_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArena());
   // @@protoc_insertion_point(field_set_char:setting.System_setting.bind_ip)
 }
-inline void System_setting::set_bind_ip(const char* value, size_t size) {
-  set_has_bind_ip();
-  bind_ip_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
-      ::std::string(reinterpret_cast<const char*>(value), size));
+inline void System_setting::set_bind_ip(const char* value,
+    size_t size) {
+  _has_bits_[0] |= 0x00000001u;
+  bind_ip_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArena());
   // @@protoc_insertion_point(field_set_pointer:setting.System_setting.bind_ip)
 }
-inline ::std::string* System_setting::mutable_bind_ip() {
-  set_has_bind_ip();
-  // @@protoc_insertion_point(field_mutable:setting.System_setting.bind_ip)
-  return bind_ip_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+inline std::string* System_setting::_internal_mutable_bind_ip() {
+  _has_bits_[0] |= 0x00000001u;
+  return bind_ip_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 }
-inline ::std::string* System_setting::release_bind_ip() {
+inline std::string* System_setting::release_bind_ip() {
   // @@protoc_insertion_point(field_release:setting.System_setting.bind_ip)
-  if (!has_bind_ip()) {
-    return NULL;
+  if (!_internal_has_bind_ip()) {
+    return nullptr;
   }
-  clear_has_bind_ip();
-  return bind_ip_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  _has_bits_[0] &= ~0x00000001u;
+  return bind_ip_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 }
-inline void System_setting::set_allocated_bind_ip(::std::string* bind_ip) {
-  if (bind_ip != NULL) {
-    set_has_bind_ip();
+inline void System_setting::set_allocated_bind_ip(std::string* bind_ip) {
+  if (bind_ip != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
   } else {
-    clear_has_bind_ip();
+    _has_bits_[0] &= ~0x00000001u;
   }
-  bind_ip_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), bind_ip);
+  bind_ip_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), bind_ip,
+      GetArena());
   // @@protoc_insertion_point(field_set_allocated:setting.System_setting.bind_ip)
 }
 
 // optional int32 bind_port = 2 [default = 30000];
-inline bool System_setting::has_bind_port() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void System_setting::set_has_bind_port() {
-  _has_bits_[0] |= 0x00000008u;
+inline bool System_setting::_internal_has_bind_port() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
 }
-inline void System_setting::clear_has_bind_port() {
-  _has_bits_[0] &= ~0x00000008u;
+inline bool System_setting::has_bind_port() const {
+  return _internal_has_bind_port();
 }
 inline void System_setting::clear_bind_port() {
   bind_port_ = 30000;
-  clear_has_bind_port();
+  _has_bits_[0] &= ~0x00000008u;
 }
-inline ::google::protobuf::int32 System_setting::bind_port() const {
-  // @@protoc_insertion_point(field_get:setting.System_setting.bind_port)
+inline ::PROTOBUF_NAMESPACE_ID::int32 System_setting::_internal_bind_port() const {
   return bind_port_;
 }
-inline void System_setting::set_bind_port(::google::protobuf::int32 value) {
-  set_has_bind_port();
+inline ::PROTOBUF_NAMESPACE_ID::int32 System_setting::bind_port() const {
+  // @@protoc_insertion_point(field_get:setting.System_setting.bind_port)
+  return _internal_bind_port();
+}
+inline void System_setting::_internal_set_bind_port(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000008u;
   bind_port_ = value;
+}
+inline void System_setting::set_bind_port(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_bind_port(value);
   // @@protoc_insertion_point(field_set:setting.System_setting.bind_port)
 }
 
 // required int32 entrance_num = 3;
-inline bool System_setting::has_entrance_num() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void System_setting::set_has_entrance_num() {
-  _has_bits_[0] |= 0x00000002u;
+inline bool System_setting::_internal_has_entrance_num() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
 }
-inline void System_setting::clear_has_entrance_num() {
-  _has_bits_[0] &= ~0x00000002u;
+inline bool System_setting::has_entrance_num() const {
+  return _internal_has_entrance_num();
 }
 inline void System_setting::clear_entrance_num() {
   entrance_num_ = 0;
-  clear_has_entrance_num();
+  _has_bits_[0] &= ~0x00000002u;
 }
-inline ::google::protobuf::int32 System_setting::entrance_num() const {
-  // @@protoc_insertion_point(field_get:setting.System_setting.entrance_num)
+inline ::PROTOBUF_NAMESPACE_ID::int32 System_setting::_internal_entrance_num() const {
   return entrance_num_;
 }
-inline void System_setting::set_entrance_num(::google::protobuf::int32 value) {
-  set_has_entrance_num();
+inline ::PROTOBUF_NAMESPACE_ID::int32 System_setting::entrance_num() const {
+  // @@protoc_insertion_point(field_get:setting.System_setting.entrance_num)
+  return _internal_entrance_num();
+}
+inline void System_setting::_internal_set_entrance_num(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000002u;
   entrance_num_ = value;
+}
+inline void System_setting::set_entrance_num(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_entrance_num(value);
   // @@protoc_insertion_point(field_set:setting.System_setting.entrance_num)
 }
 
 // required int32 export_num = 4;
-inline bool System_setting::has_export_num() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void System_setting::set_has_export_num() {
-  _has_bits_[0] |= 0x00000004u;
+inline bool System_setting::_internal_has_export_num() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
 }
-inline void System_setting::clear_has_export_num() {
-  _has_bits_[0] &= ~0x00000004u;
+inline bool System_setting::has_export_num() const {
+  return _internal_has_export_num();
 }
 inline void System_setting::clear_export_num() {
   export_num_ = 0;
-  clear_has_export_num();
+  _has_bits_[0] &= ~0x00000004u;
 }
-inline ::google::protobuf::int32 System_setting::export_num() const {
-  // @@protoc_insertion_point(field_get:setting.System_setting.export_num)
+inline ::PROTOBUF_NAMESPACE_ID::int32 System_setting::_internal_export_num() const {
   return export_num_;
 }
-inline void System_setting::set_export_num(::google::protobuf::int32 value) {
-  set_has_export_num();
+inline ::PROTOBUF_NAMESPACE_ID::int32 System_setting::export_num() const {
+  // @@protoc_insertion_point(field_get:setting.System_setting.export_num)
+  return _internal_export_num();
+}
+inline void System_setting::_internal_set_export_num(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000004u;
   export_num_ = value;
+}
+inline void System_setting::set_export_num(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_export_num(value);
   // @@protoc_insertion_point(field_set:setting.System_setting.export_num)
 }
 
@@ -371,4 +447,5 @@ inline void System_setting::set_export_num(::google::protobuf::int32 value) {
 
 // @@protoc_insertion_point(global_scope)
 
-#endif  // PROTOBUF_INCLUDED_system_5fsetting_2eproto
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_system_5fsetting_2eproto

tool/TaskQueue/ThreadTaskQueue.cpp

@@ -50,6 +50,8 @@ namespace tq{
             queue->LockQueue();
             currentTask = NULL;
             queue->FinishTask(task);
+            //析构任务
+            delete task;
             queue->NotifyQueue();
             queue->UnlockQueue();
         }
@@ -256,8 +258,6 @@ namespace tq{
             }
             _recyclerMutex.unlock();
         }
-        //析构任务
-        delete task;
 
     }