针对楚天项目调整流程

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

dispatch/dispatch_excutor.cpp

@@ -15,7 +15,7 @@ Error_manager Dispatch_excutor::dispatch_request(message::Dispatch_request_msg&
       * 检查request合法性,以及模块状态
       */
 
-    if(request.base_info().sender()!=message::eMain||request.base_info().receiver()!=message::eDispatch)
+    if(request.base_info().sender()!=message::eMain||request.base_info().receiver()!=message::eDispatch_manager)
         return Error_manager(ERROR,MINOR_ERROR,"dispatch request invalid");
 
     request.set_command_key(create_key());
@@ -31,7 +31,7 @@ Error_manager Dispatch_excutor::dispatch_request(message::Dispatch_request_msg&
     message::Base_info base_msg;
     base_msg.set_msg_type(message::eDispatch_request_msg);
     base_msg.set_sender(message::eMain);
-    base_msg.set_receiver(message::eDispatch);
+    base_msg.set_receiver(message::eDispatch_manager);
     base_msg.set_timeout_ms(timeout);
     message.reset(base_msg,request.SerializeAsString());
 
@@ -63,7 +63,7 @@ Error_manager Dispatch_excutor::dispatch_request(message::Dispatch_request_msg&
                                          "dispatch response basemsg type error");
                 }
                 //检查基本信息是否匹配
-                if (response_base.sender() != message::eDispatch ||
+                if (response_base.sender() != message::eDispatch_manager ||
                     response_base.receiver() != message::eMain ||
                     response.command_key() != request.command_key()) {
                     return Error_manager(ERROR, MAJOR_ERROR,

lidar_locate/measure_excutor.cpp

@@ -1,175 +0,0 @@
-//
-// Created by zx on 2020/6/18.
-//
-
-#include "measure_excutor.h"
-#include "uniq_key.h"
-Measure_excutor::Measure_excutor()
-{
-}
-Measure_excutor::~Measure_excutor()
-{
-}
-
-Error_manager Measure_excutor::locate_request(message::Measure_request_msg& request,
-        message::Measure_response_msg& result,Thread_condition& cancel_condition)
-{
-    /*
-     * 检查request合法性,以及模块状态
-     */
-
-    if(request.base_info().sender()!=message::eMain||request.base_info().receiver()!=message::eMeasurer)
-        return Error_manager(LOCATER_MSG_REQUEST_INVALID,MINOR_ERROR,"measure request invalid");
-
-    request.set_command_key(create_key());
-    if(m_response_table.find(request.command_key())==true)
-        return Error_manager(LOCATER_MSG_REQUEST_REPEATED,MAJOR_ERROR," measure reques repeated");
-    //设置超时,若没有设置,默认3000
-    int timeout=request.base_info().has_timeout_ms()?request.base_info().timeout_ms():3000;
-
-    //向测量节点发送测量请求,并记录请求
-    Error_manager code;
-    Communication_message message;
-
-    message::Base_info base_msg;
-    base_msg.set_msg_type(message::eLocate_request_msg);
-    base_msg.set_sender(message::eMain);
-    base_msg.set_receiver(message::eMeasurer);
-    base_msg.set_timeout_ms(timeout);
-    message.reset(base_msg,request.SerializeAsString());
-
-    m_response_table[request.command_key()]=message::Measure_response_msg();
-    //发送请求
-    code= Message_communicator::get_instance_pointer()->send_msg(&message);
-    if(code!=SUCCESS)
-    {
-        m_response_table.erase(request.command_key());
-        return code;
-    }
-    //循环查询请求是否被处理
-    auto start_time=std::chrono::system_clock::now();
-    double time=0;
-    do{
-        //查询到记录
-        message::Measure_response_msg response;
-        ///查询是否存在,并且删除该记录,
-        if(m_response_table.find(request.command_key(),response))
-        {
-            //判断是否接收到回应,若回应信息被赋值则证明有回应
-            if (response.has_base_info() && response.has_command_key())
-            {
-                message::Base_info response_base = response.base_info();
-                //检查类型是否匹配
-                if (response_base.msg_type() != message::eLocate_response_msg) {
-                    return Error_manager(LOCATER_MSG_RESPONSE_TYPE_ERROR, MAJOR_ERROR,
-                                         "measure response msg type error");
-                }
-                //检查基本信息是否匹配
-                if (response_base.sender() != message::eMeasurer ||
-                    response_base.receiver() != message::eMain ||
-                    !(response.command_key() == request.command_key())) {
-                    return Error_manager(LOCATER_MSG_RESPONSE_INFO_ERROR, MAJOR_ERROR,
-                                         "measure response msg info error");
-                }
-                result = response;
-                m_response_table.erase(request.command_key());
-                return SUCCESS;
-            }
-        }
-        else
-        {
-             //未查询到记录,任务已经被提前取消,记录被删除
-             return Error_manager(TASK_CANCEL,MINOR_ERROR,"measure request canceled");
-        }
-
-        auto end_time=std::chrono::system_clock::now();
-        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);
-        time=1000.0*double(duration.count()) * std::chrono::microseconds::period::num / std::chrono::microseconds::period::den;
-        std::this_thread::yield();
-        if(time>double(timeout))
-        {
-            m_response_table.erase(request.command_key());
-            return Error_manager(RESPONSE_TIMEOUT,MINOR_ERROR,"measure request timeout");
-        }
-    }while(cancel_condition.wait_for_ex(std::chrono::milliseconds(1))==false);
-    m_response_table.erase(request.command_key());
-    return Error_manager(TASK_CANCEL,MINOR_ERROR,"measure request timeout");
-}
-
-Error_manager Measure_excutor::check_statu(int terminal_id)
-{
-    if(m_measure_statu_msg_map.find(terminal_id)==false || m_statu_recv_time_map.find(terminal_id)==false)
-        return Error_manager(FAILED,MINOR_ERROR,"测量节点状态不存在");
-
-    std::chrono::system_clock::time_point time_now=std::chrono::system_clock::now();
-    auto durantion=time_now-m_statu_recv_time_map[terminal_id];
-    if(m_measure_statu_msg_map[terminal_id].has_base_info()== false
-        || durantion>std::chrono::seconds(5))
-    {
-        return Error_manager(DISCONNECT,MINOR_ERROR,"测量节点通讯断开");
-    }
-    if(m_measure_statu_msg_map[terminal_id].laser_manager_status()==message::LASER_MANAGER_FAULT)
-    {
-        return Error_manager(ERROR,MINOR_ERROR,"测量模块扫描控制故障");
-    }
-    for(int i=0;i<m_measure_statu_msg_map[terminal_id].laser_statu_vector_size();++i)
-    {
-        message::Laser_statu laser_statu=m_measure_statu_msg_map[terminal_id].laser_statu_vector(i);
-        if(laser_statu==message::LASER_FAULT )
-        {
-            return Error_manager(ERROR,MINOR_ERROR,"测量模块雷达故障");
-        }
-        if(laser_statu==message::LASER_DISCONNECT)
-        {
-            return Error_manager(DISCONNECT,MINOR_ERROR,"测量模块雷达断线");
-        }
-    }
-    return SUCCESS;
-}
-
-
-Error_manager Measure_excutor::consume_msg(Communication_message* p_msg)
-{
-    if(p_msg== nullptr)
-        return Error_manager(POINTER_IS_NULL,CRITICAL_ERROR,"measure response msg pointer is null");
-
-
-    //测量response消息
-    switch (p_msg->get_message_type())
-    {
-        ///测量结果反馈消息
-        case Communication_message::eLocate_response_msg:
-        {
-            message::Measure_response_msg response;
-            response.ParseFromString(p_msg->get_message_buf());
-            ///查询请求表是否存在,并且更新
-            if(m_response_table.find_update(response.command_key(),response)==false)
-            {
-                return Error_manager(LOCATER_MSG_RESPONSE_HAS_NO_REQUEST,NEGLIGIBLE_ERROR,"measure response without request");
-            }
-
-            break;
-        }
-        ///测量系统状态
-        case Communication_message::eLocate_status_msg:
-        {
-            message::Measure_status_msg statu_msg;
-            if(statu_msg.ParseFromString(p_msg->get_message_buf())==false)
-                return Error_manager(ERROR,CRITICAL_ERROR,"measure statu msg parse failed, CRITICAL_ERROR");
-            m_measure_statu_msg_map[statu_msg.terminal_id()]=statu_msg;
-            m_statu_recv_time_map[statu_msg.terminal_id()]=std::chrono::system_clock::now();
-            break;
-        }
-    }
-    return SUCCESS;
-
-}
-
-Error_manager Measure_excutor::cancel_request(message::Measure_request_msg& request)
-{
-    if(m_response_table.find(request.command_key())==true)
-        m_response_table.erase(request.command_key());
-    return SUCCESS;
-}
-
-

lidar_locate/measure_excutor.h

@@ -1,45 +0,0 @@
-//
-// Created by zx on 2020/6/18.
-//
-
-#ifndef NNXX_TESTS_LOCATE_COMMUNICATOR_H
-#define NNXX_TESTS_LOCATE_COMMUNICATOR_H
-
-
-#include <mutex>
-#include "message_communicator.h"
-#include "measure_message.pb.h"
-#include "thread_safe_map.h"
-
-/*
- * 注册消息的比较函数,用于重载==与<符号,使其可以用作map中的key
- */
-
-
-class Measure_excutor: public Singleton<Measure_excutor>
-{
-    friend Singleton<Measure_excutor>;
-public:
-    virtual ~Measure_excutor();
-    Error_manager locate_request(message::Measure_request_msg& request,
-            message::Measure_response_msg& result,Thread_condition& cancel_condition);
-    Error_manager consume_msg(Communication_message* p_msg);
-    /*
-     * 提前取消请求
-     */
-    Error_manager cancel_request(message::Measure_request_msg& request);
-    Error_manager check_statu(int terminal_id);
-
-protected:
-    Measure_excutor();
-
-protected:
-
-    thread_safe_map<std::string,message::Measure_response_msg>                                  m_response_table;
-
-    thread_safe_map<int ,message::Measure_status_msg >                                          m_measure_statu_msg_map;
-    thread_safe_map<int ,std::chrono::system_clock::time_point>		                            m_statu_recv_time_map;
-};
-
-
-#endif //NNXX_TESTS_LOCATE_COMMUNICATOR_H

main.cpp

@@ -6,7 +6,6 @@
 #include <glog/logging.h>
 
 #include "command_accepter.h"
-#include "measure_excutor.h"
 #include "command_manager.h"
 #include "exception_solver.h"
 #include "proto_tool.h"
@@ -72,8 +71,6 @@ Error_manager init_communicators()
     /*
      * 初始化各个模块,
      */
-    if(Measure_excutor::get_instance_pointer()== nullptr)
-        return FAILED;
 
     if(Dispatch_excutor::get_instance_pointer()== nullptr)
         return FAILED;

message/message_base.pb.cc

@@ -348,23 +348,22 @@ const char descriptor_table_protodef_message_5fbase_2eproto[] PROTOBUF_SECTION_V
   "KINGSPACE\020\001\022\024\n\020MID_PARKINGSPACE\020\002\022\024\n\020BIG"
   "_PARKINGSPACE\020\003*F\n\010Car_type\022\023\n\017UNKNOW_CA"
   "R_TYPE\020\000\022\013\n\007MIN_CAR\020\001\022\013\n\007MID_CAR\020\002\022\013\n\007BI"
-  "G_CAR\020\003*\335\002\n\tStep_type\022\017\n\013eAlloc_step\020\000\022\021"
-  "\n\reMeasure_step\020\001\022\021\n\reCompare_step\020\002\022\022\n\016"
-  "eDispatch_step\020\003\022\021\n\reConfirm_step\020\004\022\020\n\014e"
-  "Search_step\020\005\022\016\n\neWait_step\020\006\022\021\n\reReleas"
-  "e_step\020\007\022\r\n\teComplete\020\010\022\025\n\021eBackConfirm_"
-  "step\020\t\022\026\n\022eBack_compare_step\020\n\022\025\n\021eBackM"
-  "easure_step\020\013\022\023\n\017eBackAlloc_step\020\014\022\022\n\016eB"
-  "ackWait_step\020\r\022\026\n\022eBackDispatch_step\020\016\022\024"
-  "\n\020eBackSearch_step\020\017\022\021\n\reBackComplete\020\020*"
-  "C\n\nStep_statu\022\014\n\010eWaiting\020\000\022\014\n\010eWorking\020"
-  "\001\022\n\n\006eError\020\002\022\r\n\teFinished\020\003*\370\001\n\024Dispatc"
-  "h_device_type\022\013\n\007ROBOT_1\020e\022\013\n\007ROBOT_2\020f\022"
-  "\016\n\tCARRIER_1\020\310\001\022\016\n\tCARRIER_2\020\317\001\022\016\n\tCARRI"
-  "ER_3\020\313\001\022\021\n\014PASSAGEWAY_0\020\254\002\022\021\n\014PASSAGEWAY"
-  "_1\020\255\002\022\021\n\014PASSAGEWAY_2\020\256\002\022\021\n\014PASSAGEWAY_3"
-  "\020\257\002\022\021\n\014PASSAGEWAY_4\020\260\002\022\021\n\014PASSAGEWAY_5\020\261"
-  "\002\022\021\n\014PASSAGEWAY_6\020\262\002\022\021\n\014PASSAGEWAY_7\020\263\002"
+  "G_CAR\020\003*\263\002\n\tStep_type\022\017\n\013eAlloc_step\020\000\022\021"
+  "\n\reCompare_step\020\002\022\022\n\016eDispatch_step\020\003\022\021\n"
+  "\reConfirm_step\020\004\022\020\n\014eSearch_step\020\005\022\016\n\neW"
+  "ait_step\020\006\022\021\n\reRelease_step\020\007\022\r\n\teComple"
+  "te\020\010\022\025\n\021eBackConfirm_step\020\t\022\026\n\022eBack_com"
+  "pare_step\020\n\022\023\n\017eBackAlloc_step\020\014\022\022\n\016eBac"
+  "kWait_step\020\r\022\026\n\022eBackDispatch_step\020\016\022\024\n\020"
+  "eBackSearch_step\020\017\022\021\n\reBackComplete\020\020*C\n"
+  "\nStep_statu\022\014\n\010eWaiting\020\000\022\014\n\010eWorking\020\001\022"
+  "\n\n\006eError\020\002\022\r\n\teFinished\020\003*\370\001\n\024Dispatch_"
+  "device_type\022\013\n\007ROBOT_1\020e\022\013\n\007ROBOT_2\020f\022\016\n"
+  "\tCARRIER_1\020\310\001\022\016\n\tCARRIER_2\020\317\001\022\016\n\tCARRIER"
+  "_3\020\313\001\022\021\n\014PASSAGEWAY_0\020\254\002\022\021\n\014PASSAGEWAY_1"
+  "\020\255\002\022\021\n\014PASSAGEWAY_2\020\256\002\022\021\n\014PASSAGEWAY_3\020\257"
+  "\002\022\021\n\014PASSAGEWAY_4\020\260\002\022\021\n\014PASSAGEWAY_5\020\261\002\022"
+  "\021\n\014PASSAGEWAY_6\020\262\002\022\021\n\014PASSAGEWAY_7\020\263\002"
   ;
 static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_message_5fbase_2eproto_deps[1] = {
 };
@@ -378,7 +377,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mes
 };
 static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_message_5fbase_2eproto_once;
 const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_message_5fbase_2eproto = {
-  false, false, descriptor_table_protodef_message_5fbase_2eproto, "message_base.proto", 4159,
+  false, false, descriptor_table_protodef_message_5fbase_2eproto, "message_base.proto", 4117,
   &descriptor_table_message_5fbase_2eproto_once, descriptor_table_message_5fbase_2eproto_sccs, descriptor_table_message_5fbase_2eproto_deps, 6, 0,
   schemas, file_default_instances, TableStruct_message_5fbase_2eproto::offsets,
   file_level_metadata_message_5fbase_2eproto, 6, file_level_enum_descriptors_message_5fbase_2eproto, file_level_service_descriptors_message_5fbase_2eproto,
@@ -576,7 +575,6 @@ const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Step_type_descriptor() {
 bool Step_type_IsValid(int value) {
   switch (value) {
     case 0:
-    case 1:
     case 2:
     case 3:
     case 4:
@@ -586,7 +584,6 @@ bool Step_type_IsValid(int value) {
     case 8:
     case 9:
     case 10:
-    case 11:
     case 12:
     case 13:
     case 14:

message/message_base.pb.h

@@ -350,7 +350,6 @@ inline bool Car_type_Parse(
 }
 enum Step_type : int {
   eAlloc_step = 0,
-  eMeasure_step = 1,
   eCompare_step = 2,
   eDispatch_step = 3,
   eConfirm_step = 4,
@@ -360,7 +359,6 @@ enum Step_type : int {
   eComplete = 8,
   eBackConfirm_step = 9,
   eBack_compare_step = 10,
-  eBackMeasure_step = 11,
   eBackAlloc_step = 12,
   eBackWait_step = 13,
   eBackDispatch_step = 14,

message/message_base.proto

@@ -227,7 +227,6 @@ message Parkspace_info
 enum Step_type
 {
     eAlloc_step=0;
-    eMeasure_step=1;
     eCompare_step=2;
     eDispatch_step=3;
     eConfirm_step=4;
@@ -240,7 +239,6 @@ enum Step_type
 
     eBackConfirm_step=9;
     eBack_compare_step=10;
-    eBackMeasure_step=11;
     eBackAlloc_step=12;
 
     eBackWait_step=13;

message/process_message.proto

@@ -58,18 +58,6 @@ message Back_release_space_step_statu
     optional string                     description=3;      //状态说明/错误说明
 }
 
-//测量步骤状态
-message Measure_step_statu
-{
-    optional Step_statu                 step_statu=1 [default=eWaiting];       //状态
-    optional Locate_information         locate_info=2;      //定位结果
-    optional string                     description=3;      //状态说明/错误说明
-}
-message Back_measure_step_statu
-{
-    optional Step_statu                 step_statu=1 [default=eWaiting];       //状态
-    optional string                     description=3;      //状态说明/错误说明
-}
 //对比节点
 message Compare_step_statu
 {
@@ -139,7 +127,6 @@ message Storing_process_statu_msg
     required string                             license=3;
 
     optional Alloc_space_step_statu             alloc_space_step=4;
-    optional Measure_step_statu                 measure_step=5;
     optional Compare_step_statu                 compare_step=6;
     optional Dispatch_store_step_statu          dispatch_step=7;
     optional Confirm_space_step_statu           confirm_space_step=8;
@@ -147,7 +134,6 @@ message Storing_process_statu_msg
     optional Back_confirm_space_step_statu      back_confirm_step=10;
     optional Back_dispatch_store_step_statu     back_dispatch_step=11;
     optional Back_compare_step_statu            back_compare_step=12;
-    optional Back_measure_step_statu            back_measure_step=13;
     optional Back_alloc_space_step_statu        back_alloc_space_step=14;
     optional bool                               back_completed=15 [default=false];
 }

system/PickupProcessTask.cpp

@@ -75,15 +75,12 @@ Error_manager PickupProcessTask::search_space_step()
         return Error_manager(PAUSE, MINOR_ERROR, "系统已急停");
     }
 
-    message::Entrance_statu statu=Command_manager::get_instance_pointer()->export_statu(m_terminor_id);
-    if(statu.has_paused()==false) {
-        return Error_manager(ERROR, MINOR_ERROR, "出口已禁止使用 Disable");
-    }
-    if(statu.paused()==true)
-    {
+    bool paused=Command_manager::get_instance_pointer()->export_paused(m_terminor_id);
+    if(paused) {
         return Error_manager(ERROR, MINOR_ERROR, "出口已禁止使用 Disable");
     }
 
+
     /*
      * 检验汽车信息是否正常
      */

system/StoreProcessTask.cpp

@@ -54,53 +54,6 @@ Error_manager StoreProcessTask::init_task(message::Locate_information locate_inf
 
 }
 
-Error_manager StoreProcessTask::locate_step() {
-    Error_manager code;
-    //检查测量模块状态
-    code=Measure_excutor::get_instance_pointer()->check_statu(m_terminor_id);
-    if(code!=SUCCESS)
-        return code;
-
-    message::Base_info base_info;
-    base_info.set_msg_type(message::eLocate_request_msg);
-    base_info.set_sender(message::eMain);
-    base_info.set_receiver(message::eMeasurer);
-    base_info.set_timeout_ms(20000); //测量超时5s
-    m_measure_request_msg.mutable_base_info()->CopyFrom(base_info);
-
-    m_measure_request_msg.set_terminal_id(m_terminor_id);
-
-    code=Measure_excutor::get_instance_pointer()->locate_request(m_measure_request_msg,
-            m_measure_response_msg,m_cancel_condition);
-    message::Node_log node_log;
-    node_log.mutable_measure_request()->CopyFrom(m_measure_request_msg);
-    node_log.mutable_measure_response()->CopyFrom(m_measure_response_msg);
-    ALOG(INFO)<<node_log;
-
-    if(code!=SUCCESS)
-        return code;
-
-    if(m_measure_response_msg.error_manager().error_code()==0) {
-        return SUCCESS;
-    }
-    else {
-        Error_code t_code=(Error_code)m_measure_response_msg.error_manager().error_code();
-        Error_level t_level=(Error_level)m_measure_response_msg.error_manager().error_level();
-        return Error_manager(t_code, t_level, m_measure_response_msg.error_manager().error_description().c_str());
-    }
-
-}
-
-/*
-     * 回退定位
-     */
-Error_manager StoreProcessTask::back_locate_step()
-{
-    m_measure_request_msg=message::Measure_request_msg();
-    m_measure_response_msg=message::Measure_response_msg();
-    ALOG(INFO)<<"回退测量";
-    return SUCCESS;
-}
 
 /*
      * 检验结果
@@ -205,12 +158,8 @@ Error_manager StoreProcessTask::alloc_space_step()
         return Error_manager(PAUSE, MINOR_ERROR, "系统已急停");
     }
     //
-    message::Entrance_statu statu=Command_manager::get_instance_pointer()->entrance_statu(m_terminor_id);
-    if(statu.has_paused()==false) {
-        return Error_manager(ERROR, MINOR_ERROR, "入口已禁止使用 Disable");
-    }
-    if(statu.paused()==true)
-    {
+    bool paused=Command_manager::get_instance_pointer()->entrance_paused(m_terminor_id);
+    if(paused) {
         return Error_manager(ERROR, MINOR_ERROR, "入口已禁止使用 Disable");
     }
 
@@ -413,13 +362,10 @@ Error_manager StoreProcessTask::next_step()
     switch (m_current_step_type)
     {
         case message::eAlloc_step:
-            m_current_step_type=(m_current_step_statu==message::eFinished)?message::eMeasure_step:message::eBackComplete;
-            break;
-        case message::eMeasure_step:
-            m_current_step_type=(m_current_step_statu==message::eFinished)?message::eCompare_step:message::eBackAlloc_step;
+            m_current_step_type=(m_current_step_statu==message::eFinished)?message::eCompare_step:message::eBackComplete;
             break;
         case message::eCompare_step:
-            m_current_step_type=(m_current_step_statu==message::eFinished)?message::eDispatch_step:message::eBackMeasure_step;
+            m_current_step_type=(m_current_step_statu==message::eFinished)?message::eDispatch_step:message::eBackAlloc_step;
             break;
         case message::eDispatch_step:
             m_current_step_type=(m_current_step_statu==message::eFinished)?message::eConfirm_step:message::eBack_compare_step;
@@ -433,9 +379,6 @@ Error_manager StoreProcessTask::next_step()
             m_current_step_type=message::eBack_compare_step;
             break;
         case message::eBack_compare_step:
-            m_current_step_type=message::eBackMeasure_step;
-            break;
-        case message::eBackMeasure_step:
             m_current_step_type=message::eBackAlloc_step;
             break;
         case message::eBackAlloc_step:
@@ -482,16 +425,7 @@ void StoreProcessTask::Main()
             LOG_IF(WARNING, code != SUCCESS) << "------  停  ------- 分配失败:" <<m_car_info.license()<< code.get_error_description();
         }
 
-        //测量
-        if (m_current_step_type ==  message::eMeasure_step)
-        {
-            //开始定位
-            updata_step_statu(message::eWorking);
-            code = locate_step();
-            usleep(1000 * 500 );
-            ALOG_IF(WARNING, code != SUCCESS) << "------  停  ------- 测量失败:" <<m_car_info.license()<< code.get_error_description();
-            LOG_IF(WARNING, code != SUCCESS) << "------  停  ------- 测量失败:" <<m_car_info.license()<< code.get_error_description();
-        }
+
         if(m_current_step_type== message::eCompare_step)
         {
             updata_step_statu(message::eWorking);
@@ -560,18 +494,6 @@ void StoreProcessTask::Main()
             LOG_IF(WARNING,code!=SUCCESS)<<" ------  停  ------- 回退对比失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
         }
 
-        if(m_current_step_type== message::eBackMeasure_step)
-        {
-            updata_step_statu(message::eWorking);
-            code=back_locate_step();
-            usleep(1000*200);
-
-            ALOG_IF(WARNING,code!=SUCCESS)
-                <<" ------  停  ------- 回退测量失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
-            LOG_IF(WARNING,code!=SUCCESS)
-                    <<" ------  停  ------- 回退测量失败 ------进入异常处理,  车牌号:"<<m_car_info.license();
-
-        }
         if(m_current_step_type== message::eBackAlloc_step)
         {
             updata_step_statu(message::eWorking);
@@ -669,13 +591,6 @@ void StoreProcessTask::updata_step_statu(message::Step_statu statu)
                 m_process_msg.mutable_alloc_space_step()->CopyFrom(alloc_step_statu);
             break;
         }
-        case  message::eMeasure_step: {
-                message::Measure_step_statu measure_step_statu;
-                measure_step_statu.set_step_statu(statu);
-                measure_step_statu.mutable_locate_info()->CopyFrom(m_locate_info);
-                m_process_msg.mutable_measure_step()->CopyFrom(measure_step_statu);
-           break;
-        }
         case  message::eCompare_step:{
             message::Compare_step_statu     compare_step;
             compare_step.mutable_locate_info_wj()->CopyFrom(m_locate_info);
@@ -727,12 +642,7 @@ void StoreProcessTask::updata_step_statu(message::Step_statu statu)
             m_process_msg.mutable_back_compare_step()->CopyFrom(back_compare_step_statu);
             break;
         }
-        case  message::eBackMeasure_step: {
-            message::Back_measure_step_statu        back_measure_step_statu;
-            back_measure_step_statu.set_step_statu(statu);
-            m_process_msg.mutable_back_measure_step()->CopyFrom(back_measure_step_statu);
-            break;
-        }
+
         case  message::eBackAlloc_step: {
             message::Back_alloc_space_step_statu    back_alloc_step_statu;
             back_alloc_step_statu.set_step_statu(statu);

system/StoreProcessTask.h

@@ -9,7 +9,6 @@
 #include <terminal_message.pb.h>
 #include "dispatch_excutor.h"
 #include "process_task.h"
-#include "measure_excutor.h"
 #include "process_message.pb.h"
 
 class StoreProcessTask :public Process_task{
@@ -43,15 +42,6 @@ protected:
      */
     Error_manager back_alloc_space_step();
 
-    /*
-     * 定位
-     */
-    Error_manager locate_step();
-
-    /*
-     * 回退定位
-     */
-    Error_manager back_locate_step();
 
     /*
      * 检验结果

system/command_manager.cpp

@@ -13,7 +13,6 @@
 Command_manager::Command_manager()
     :m_thread_queue_process(nullptr)
     ,m_system_paused(false)
-    ,m_publish_statu_thread(nullptr)
 {
 
 }
@@ -25,17 +24,6 @@ Command_manager::~Command_manager()
         m_thread_queue_process->WaitForFinish();
         m_thread_queue_process->Stop();
     }
-    //退出发布线程
-    m_publish_exit_condition.set_pass_ever(true);
-    if(m_publish_statu_thread!= nullptr)
-    {
-        if(m_publish_statu_thread->joinable())
-        {
-            m_publish_statu_thread->join();
-        }
-        delete m_publish_statu_thread;
-        m_publish_statu_thread=nullptr;
-    }
 
 }
 
@@ -146,14 +134,7 @@ Error_manager Command_manager::init(setting::System_setting system_setting) {
      */
     m_system_setting=system_setting;
 
-    /*
-     * 创建发布线程
-     */
-    if(m_publish_statu_thread== nullptr)
-    {
-        m_publish_exit_condition.reset(false, false, false);
-        m_publish_statu_thread=new std::thread(publish_statu_function,this);
-    }
+
 
     return SUCCESS;
 }
@@ -226,7 +207,6 @@ Error_manager Command_manager::execute_store_command(message::Store_command_requ
                                   ",终端:" << request.terminal_id() << "............................";
                         //check hardwared
                         Error_manager parkspace_code = Parkspace_excutor::get_instance_pointer()->check_statu();
-                        Error_manager locate_code = Measure_excutor::get_instance_pointer()->check_statu(request.terminal_id());
                         Error_manager dispatch_code = Dispatch_excutor::get_instance_pointer()->check_entrance_statu(request.terminal_id());
                         if(parkspace_code!=SUCCESS)
                         {
@@ -240,18 +220,6 @@ Error_manager Command_manager::execute_store_command(message::Store_command_requ
                             Message_communicator::get_instance_pointer()->send_msg(&msg);
                             return parkspace_code;
                         }
-                        if(locate_code!=SUCCESS)
-                        {
-                            error_msg.set_error_code(locate_code.get_error_code());
-                            error_msg.set_error_description(locate_code.to_string());
-                            response.mutable_code()->CopyFrom(error_msg);
-                            LOG(ERROR) << "xxxx 创建停车流程失败:" << request.terminal_id() <<
-                                       "车牌:" << request.car_info().license() << "  " << locate_code.to_string();
-                            Communication_message msg;
-                            msg.reset(response.base_info(), response.SerializeAsString());
-                            Message_communicator::get_instance_pointer()->send_msg(&msg);
-                            return locate_code;
-                        }
                         if(dispatch_code!=SUCCESS)
                         {
                             error_msg.set_error_code(dispatch_code.get_error_code());
@@ -463,53 +431,6 @@ Error_manager Command_manager::pause_entrance(int terminal_id,bool paused)
     return SUCCESS;
 }
 
-message::Entrance_statu Command_manager::entrance_statu(int terminal_id)
-{
-    message::Entrance_statu entrance_statu;
-
-    if(terminal_id<0 || terminal_id>=m_system_setting.entrance_num())
-        return entrance_statu;
-
-    message::Module_statu  statu=message::eConnected;
-    Error_manager code=Parkspace_excutor::get_instance_pointer()->check_statu();
-    statu=(code==SUCCESS)?message::eConnected:message::eFault;
-    entrance_statu.set_parkspace_statu(statu);
-
-    code=Measure_excutor::get_instance_pointer()->check_statu(terminal_id);
-    if (code==ERROR) statu=message::eFault;
-    if(code==DISCONNECT) statu=message::eDisconnected;
-    entrance_statu.set_measure_statu(statu);
-
-    code=Dispatch_excutor::get_instance_pointer()->check_entrance_statu(terminal_id);
-    if (code==ERROR) statu=message::eFault;
-    if(code==DISCONNECT) statu=message::eDisconnected;
-    entrance_statu.set_dispatch_statu(statu);
-
-    entrance_statu.set_paused(m_input_entrance_paused[terminal_id]);
-
-
-    return entrance_statu;
-}
-message::Entrance_statu Command_manager::export_statu(int terminal_id)
-{
-    message::Entrance_statu entrance_statu;
-    if(terminal_id<0 || terminal_id>=m_system_setting.export_num())
-        return entrance_statu;
-
-    message::Module_statu  statu=message::eConnected;
-    Error_manager code=Parkspace_excutor::get_instance_pointer()->check_statu();
-    statu=(code==SUCCESS)?message::eConnected:message::eFault;
-    entrance_statu.set_parkspace_statu(statu);
-
-    code=Dispatch_excutor::get_instance_pointer()->check_entrance_statu(terminal_id);
-    if (code==ERROR) statu=message::eFault;
-    if(code==DISCONNECT) statu=message::eDisconnected;
-    entrance_statu.set_dispatch_statu(statu);
-
-    entrance_statu.set_paused(m_output_entrance_paused[terminal_id]);
-
-    return entrance_statu;
-}
 /*
  * 控制出口 开放或者关闭
  */
@@ -529,64 +450,17 @@ void Command_manager::pause_system()
     m_system_paused=true;
 }
 
-void Command_manager::publish_statu_function(Command_manager* commander)
+
+bool Command_manager::entrance_paused(int terminal_id)
 {
-    if(commander== nullptr)
-        return ;
-    commander->publish_statu();
+    if(terminal_id>=m_system_setting.export_num())
+        return false;
+    return m_output_entrance_paused[terminal_id];
 }
-void Command_manager::publish_statu()
-{
-    while(m_publish_exit_condition.wait_for_millisecond(100)==false)
-    {
-        message::Central_controller_statu_msg msg;
-        message::Base_info baseInfo;
-        baseInfo.set_msg_type(message::eCentral_controller_statu_msg);
-        baseInfo.set_sender(message::eMain);
-        baseInfo.set_receiver(message::eEmpty);
-        msg.mutable_base_info()->CopyFrom(baseInfo);
-        for(int i=0;i<m_system_setting.entrance_num();++i)
-        {
-            message::Entrance_statu entrance_statu;
-            message::Module_statu  statu=message::eConnected;
-            Error_manager code=Parkspace_excutor::get_instance_pointer()->check_statu();
-            statu=(code==SUCCESS)?message::eConnected:message::eFault;
-            entrance_statu.set_parkspace_statu(statu);
-
-            code=Measure_excutor::get_instance_pointer()->check_statu(i);
-            statu=(code==SUCCESS)?message::eConnected:message::eFault;
-            if(code==DISCONNECT) statu=message::eDisconnected;
-            entrance_statu.set_measure_statu(statu);
-
-            code=Dispatch_excutor::get_instance_pointer()->check_entrance_statu(i);
-            statu=(code==SUCCESS)?message::eConnected:message::eFault;
-            if(code==DISCONNECT) statu=message::eDisconnected;
-            entrance_statu.set_dispatch_statu(statu);
-
-            entrance_statu.set_paused(m_input_entrance_paused[i]);
-
-            msg.mutable_entrance_statu_vector()->Add();
-            msg.mutable_entrance_statu_vector(msg.entrance_statu_vector_size()-1)->CopyFrom(entrance_statu);
-        }
-
-        for(int i=0;i<m_system_setting.export_num();++i)
-        {
-            message::Entrance_statu entrance_statu;
-            message::Module_statu  statu=message::eConnected;
-            Error_manager code=Parkspace_excutor::get_instance_pointer()->check_statu();
-            statu=(code==SUCCESS)?message::eConnected:message::eFault;
-            entrance_statu.set_parkspace_statu(statu);
 
-            code=Dispatch_excutor::get_instance_pointer()->check_export_statu(i);
-            statu=(code==SUCCESS)?message::eConnected:message::eFault;
-            if(code==DISCONNECT) statu=message::eDisconnected;
-            entrance_statu.set_dispatch_statu(statu);
-
-            entrance_statu.set_paused(m_output_entrance_paused[i]);
-
-            msg.mutable_export_statu_vector()->Add();
-            msg.mutable_export_statu_vector(msg.export_statu_vector_size()-1)->CopyFrom(entrance_statu);
-        }
-        Command_accepter::get_instance_pointer()->post_central_statu(msg);
-    }
+bool Command_manager::export_paused(int terminal_id)
+{
+    if(terminal_id>=m_system_setting.entrance_num())
+        return false;
+    return m_input_entrance_paused[terminal_id];
 }

system/command_manager.h

@@ -44,18 +44,15 @@ public:
      * 控制入口 开放或者关闭
      */
     Error_manager pause_entrance(int terminal_id,bool paused);
-
-    /*
-     * 获取出入口状态
-     */
-    message::Entrance_statu entrance_statu(int terminal_id);
-    message::Entrance_statu export_statu(int terminal_id);
+    bool entrance_paused(int terminal_id);
 
     /*
      * 控制出口 开放或者关闭
      */
     Error_manager pause_export(int terminal_id, bool paused);
 
+    bool export_paused(int terminal_id);
+
     /*
      * pause,系统急停,急停状态下不允许自动流程的指令执行,允许管理员手动指令执行
      */
@@ -69,9 +66,6 @@ public:
 private:
     Command_manager();
 
-    static void publish_statu_function(Command_manager* commander);
-    void publish_statu();
-
 protected:
     tq::IQueue*                         m_thread_queue_process;         //指令流程线程池
 
@@ -81,8 +75,6 @@ protected:
 
     setting::System_setting             m_system_setting;
 
-    std::thread*                        m_publish_statu_thread;             //广播状态线程
-    Thread_condition				    m_publish_exit_condition;			//发送的条件变量
 
 };
 

system/message_communicator.cpp

@@ -3,7 +3,6 @@
 //
 
 #include "message_communicator.h"
-#include "measure_excutor.h"
 #include "exception_solver.h"
 #include "dispatch_excutor.h"
 #include "parkspace_excutor.h"
@@ -121,18 +120,6 @@ Error_manager Message_communicator::execute_msg(Communication_message* p_msg)
         {
             Parkspace_excutor::get_instance_pointer()->consume_msg(p_msg);
             break;
-        }
-            ///测量结果反馈消息
-        case Communication_message::eLocate_response_msg:
-        {
-            Measure_excutor::get_instance_pointer()->consume_msg(p_msg);
-            break;
-        }
-            //测量系统状态
-        case Communication_message::eLocate_status_msg:
-        {
-            Measure_excutor::get_instance_pointer()->consume_msg(p_msg);
-            break;
         }
             //异常处理,手动操作
         case Communication_message::eProcess_manual_operation_msg:

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