From 458d0f0511acdf181671f13c2b6967d9d95b9316 Mon Sep 17 00:00:00 2001
From: shenxin <shenxin@basic.com>
Date: 星期六, 21 八月 2021 21:54:57 +0800
Subject: [PATCH] add lichao's interface
---
src/proto/error_msg.pb.cc | 332 +
src/proto/bhome_msg.pb.h | 2823 +++++++++++
src/bh_api.cc | 495 +
src/proto/bhome_msg.proto | 102
src/proto/bhome_msg_api.pb.cc | 3799 +++++++++++++++
src/proto/bhome_msg_api.pb.h | 4283 +++++++++++++++++
src/bh_api.h | 88
src/proto/error_msg.pb.h | 325 +
src/proto/error_msg.proto | 22
src/proto/bhome_msg_api.proto | 90
src/proto/bhome_msg.pb.cc | 2616 ++++++++++
11 files changed, 14,975 insertions(+), 0 deletions(-)
diff --git a/src/bh_api.cc b/src/bh_api.cc
new file mode 100644
index 0000000..f96e7cb
--- /dev/null
+++ b/src/bh_api.cc
@@ -0,0 +1,495 @@
+#include "bh_api.h"
+#include <stdlib.h>
+#include <string.h>
+#include "proto/bhome_msg.pb.h"
+#include "proto/bhome_msg_api.pb.h"
+
+int BHRegister(const void *proc_info, const int proc_info_len, void **reply, int *reply_len, const int timeout_ms)
+{
+ //鍙嶅簭鍒楀寲鍏ュ弬
+ ProcInfo input;
+ if(!input.ParseFromArray(proc_info,proc_info_len))
+ return false;
+ struct _ProcInfo
+ {
+ const char *proc_id;
+ const char *name;
+ const char *public_info;
+ const char *private_info;
+ }_input;
+ _input.proc_id=input.proc_id().c_str();
+ _input.name=input.name().c_str();
+ _input.public_info=input.public_info().c_str();
+ _input.private_info=input.private_info().c_str();
+
+ //璋冪敤鍑芥暟瀹炵幇
+ int errCode=0;//0 is success
+ //errCode=call_Register(&_input,timeout_ms);//杩欏彞鏄姛鑳界殑鍏蜂綋瀹炵幇
+ char errString[32]={0};
+ if(errCode!=0)
+ strcpy(errString,"閿欒鍘熷洜鎻忚堪...");
+
+ //搴忓垪鍖栬繑鍥炴暟鎹�
+ MsgCommonReply mcr;
+ mcr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
+ mcr.mutable_errmsg()->set_errstring(errString);
+ *reply_len=mcr.ByteSizeLong();
+ *reply=malloc(*reply_len);
+ mcr.SerializePartialToArray(*reply,*reply_len);
+
+ return errCode==0?true:false;
+}
+int BHUnregister(const void *proc_info, const int proc_info_len, void **reply, int *reply_len, const int timeout_ms)
+{
+ //鍙嶅簭鍒楀寲鍏ュ弬
+ ProcInfo input;
+ if(!input.ParseFromArray(proc_info,proc_info_len))
+ return false;
+ struct _ProcInfo
+ {
+ const char *proc_id;
+ const char *name;
+ const char *public_info;
+ const char *private_info;
+ }_input;
+ _input.proc_id=input.proc_id().c_str();
+ _input.name=input.name().c_str();
+ _input.public_info=input.public_info().c_str();
+ _input.private_info=input.private_info().c_str();
+
+ //璋冪敤鍑芥暟瀹炵幇
+ int errCode=0;//0 is success
+ //errCode=call_UnRegister(&_input,timeout_ms);//杩欏彞鏄姛鑳界殑鍏蜂綋瀹炵幇
+ char errString[32]={0};
+ if(errCode!=0)
+ strcpy(errString,"閿欒鍘熷洜鎻忚堪...");
+
+ //搴忓垪鍖栬繑鍥炴暟鎹�
+ MsgCommonReply mcr;
+ mcr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
+ mcr.mutable_errmsg()->set_errstring(errString);
+ *reply_len=mcr.ByteSizeLong();
+ *reply=malloc(*reply_len);
+ mcr.SerializePartialToArray(*reply,*reply_len);
+
+ return errCode==0?true:false;
+}
+
+int BHHeartbeatEasy(const int timeout_ms)
+{
+ bool Rel=true;
+ //Rel=call_HeartbeatEasy(timeout_ms);//杩欏彞鏄姛鑳界殑鍏蜂綋瀹炵幇
+ return Rel;
+}
+
+int BHHeartbeat(const void *proc_info, const int proc_info_len, void **reply, int *reply_len, const int timeout_ms)
+{
+ //鍙嶅簭鍒楀寲鍏ュ弬
+ ProcInfo input;
+ if(!input.ParseFromArray(proc_info,proc_info_len))
+ return false;
+ struct _ProcInfo
+ {
+ const char *proc_id;
+ const char *name;
+ const char *public_info;
+ const char *private_info;
+ }_input;
+ _input.proc_id=input.proc_id().c_str();
+ _input.name=input.name().c_str();
+ _input.public_info=input.public_info().c_str();
+ _input.private_info=input.private_info().c_str();
+
+ //璋冪敤鍑芥暟瀹炵幇
+ int errCode=0;//0 is success
+ //errCode=call_Heartbeat(&_input,timeout_ms);//杩欏彞鏄姛鑳界殑鍏蜂綋瀹炵幇
+ char errString[32]={0};
+ if(errCode!=0)
+ strcpy(errString,"閿欒鍘熷洜鎻忚堪...");
+
+ //搴忓垪鍖栬繑鍥炴暟鎹�
+ MsgCommonReply mcr;
+ mcr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
+ mcr.mutable_errmsg()->set_errstring(errString);
+ *reply_len=mcr.ByteSizeLong();
+ *reply=malloc(*reply_len);
+ mcr.SerializePartialToArray(*reply,*reply_len);
+
+ return errCode==0?true:false;
+}
+
+int BHRegisterTopics(const void *topics, const int topics_len, void **reply, int *reply_len, const int timeout_ms)
+{
+ //鍙嶅簭鍒楀寲鍏ュ弬
+ MsgTopicList input;
+ if(!input.ParseFromArray(topics,topics_len))
+ return false;
+ struct _MsgTopicList
+ {
+ int amount;
+ const char *topics[128];
+ }_input;
+ _input.amount=input.topic_list_size();
+ for(int i=0;i<_input.amount;i++)
+ _input.topics[i]=input.topic_list(i).c_str();
+
+ //璋冪敤鍑芥暟瀹炵幇
+ int errCode=0;//0 is success
+ //errCode=call_RegisterTopics(&_input,timeout_ms);//杩欏彞鏄姛鑳界殑鍏蜂綋瀹炵幇
+ char errString[32]={0};
+ if(errCode!=0)
+ strcpy(errString,"閿欒鍘熷洜鎻忚堪...");
+
+ //搴忓垪鍖栬繑鍥炴暟鎹�
+ MsgCommonReply mcr;
+ mcr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
+ mcr.mutable_errmsg()->set_errstring(errString);
+ *reply_len=mcr.ByteSizeLong();
+ *reply=malloc(*reply_len);
+ mcr.SerializePartialToArray(*reply,*reply_len);
+
+ return errCode==0?true:false;
+}
+
+int BHQueryProcs(const void *remote,
+ const int remote_len,
+ const void *query,
+ const int query_len,
+ void **reply,
+ int *reply_len,
+ const int timeout_ms)
+{
+ //鍙嶅簭鍒楀寲鍏ュ弬
+ BHAddress input0;
+ MsgQueryProc input1;
+ if (!input0.ParseFromArray(remote,remote_len)||!input1.ParseFromArray(query,query_len))
+ return false;
+ struct _BHAddress
+ {
+ unsigned long long mq_id;
+ long long abs_addr;
+ const char *ip;
+ int port;
+ }_input0;
+ const char *_input1;
+ _input0.mq_id=input0.mq_id();
+ _input0.abs_addr=input0.abs_addr();
+ _input0.ip=input0.ip().c_str();
+ _input0.port=input0.port();
+ _input1=input1.proc_id().c_str();
+
+ //璋冪敤鍑芥暟瀹炵幇
+ int errCode=0;//0 is success
+ //姝ょ浠ュ浐瀹氱粨鏋勮繑鍥炴暟鎹殑鏂瑰紡,鍙兘鏆傛椂鍥哄畾鏁伴噺涓婇檺銆傝繖閲岄檺鍒舵渶澶�128涓猚lient,姣忎釜client鏈�澶�128涓猼opic
+ //鑻ヤ笉闄愭暟閲�,闇�閲嶆柊璁捐鏁版嵁杩斿洖鐨勬柟寮�
+ struct _MsgQueryProcReply
+ {
+ std::string proc_id;
+ std::string name;
+ std::string public_info;
+ std::string private_info;
+
+ bool online;
+
+ std::string topic_list[128];
+ int topic_list_num;//瀹為檯鍦╰opic_list涓～鍐欎簡澶氬皯涓」鐩�
+ }mpr_list[128];
+ int mpr_list_num=0;//瀹為檯鍦╩pr_list涓～鍐欎簡澶氬皯涓」鐩�
+ //errCode=call_QueryProcs(&_input0,_input1,mpr_list,&mpr_list_num,timeout_ms);//杩欏彞鏄姛鑳界殑鍏蜂綋瀹炵幇
+ char errString[32]={0};
+ if(errCode!=0)
+ strcpy(errString,"閿欒鍘熷洜鎻忚堪...");
+
+ //搴忓垪鍖栬繑鍥炴暟鎹�
+ MsgQueryProcReply mpr;
+ mpr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
+ mpr.mutable_errmsg()->set_errstring(errString);
+ for(int i=0;i<mpr_list_num;i++)
+ {
+ MsgQueryProcReply_Info *mpri=mpr.add_proc_list();
+ mpri->mutable_proc()->set_proc_id(mpr_list[i].proc_id);
+ mpri->mutable_proc()->set_name(mpr_list[i].name);
+ mpri->mutable_proc()->set_public_info(mpr_list[i].public_info);
+ mpri->mutable_proc()->set_private_info(mpr_list[i].private_info);
+ mpri->set_online(mpr_list[i].online);
+ for(int j=0;j<mpr_list[i].topic_list_num;j++)
+ {
+ mpri->mutable_topics()->add_topic_list(mpr_list[i].topic_list[j]);
+ }
+ }
+ *reply_len=mpr.ByteSizeLong();
+ *reply=malloc(*reply_len);
+ mpr.SerializePartialToArray(*reply,*reply_len);
+
+ return errCode==0?true:false;
+}
+
+int BHSubscribeTopics(const void *topics, const int topics_len, void **reply, int *reply_len, const int timeout_ms)
+{
+ //鍙嶅簭鍒楀寲鍏ュ弬
+ MsgTopicList input;
+ if(!input.ParseFromArray(topics,topics_len))
+ return false;
+ struct _MsgTopicList
+ {
+ int amount;
+ const char *topics[128];
+ }_input;
+ _input.amount=input.topic_list_size();
+ for(int i=0;i<_input.amount;i++)
+ _input.topics[i]=input.topic_list(i).c_str();
+
+ //璋冪敤鍑芥暟瀹炵幇
+ int errCode=0;//0 is success
+ //errCode=call_SubscribeTopics(&_input,timeout_ms);//杩欏彞鏄姛鑳界殑鍏蜂綋瀹炵幇
+ char errString[32]={0};
+ if(errCode!=0)
+ strcpy(errString,"閿欒鍘熷洜鎻忚堪...");
+
+ //搴忓垪鍖栬繑鍥炴暟鎹�
+ MsgCommonReply mcr;
+ mcr.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
+ mcr.mutable_errmsg()->set_errstring(errString);
+ *reply_len=mcr.ByteSizeLong();
+ *reply=malloc(*reply_len);
+ mcr.SerializePartialToArray(*reply,*reply_len);
+
+ return errCode==0?true:false;
+}
+
+int BHPublish(const void *msgpub,
+ const int msgpub_len,
+ const int timeout_ms)
+{
+ //鍙嶅簭鍒楀寲鍏ュ弬
+ MsgPublish input;
+ if(!input.ParseFromArray(msgpub,msgpub_len))
+ return false;
+ struct _MsgPublish
+ {
+ const char *topic;
+ const char *data;
+ }_input;
+ _input.topic=input.topic().c_str();
+ _input.data=input.data().c_str();
+
+ //璋冪敤鍑芥暟瀹炵幇
+ int errCode=0;//0 is success
+ //errCode=call_Publish(&_input,timeout_ms);//杩欏彞鏄姛鑳界殑鍏蜂綋瀹炵幇
+
+ return errCode==0?true:false;
+}
+
+int BHReadSub(void **proc_id,
+ int *proc_id_len,
+ void **msgpub,
+ int *msgpub_len,
+ const int timeout_ms)
+{
+ //鏃犲叆鍙�,鐨嗕负杩斿洖
+
+ //璋冪敤鍑芥暟瀹炵幇
+ int errCode=0;//0 is success
+ struct _ReadSubReply
+ {
+ std::string proc_id;
+ std::string topic;
+ std::string data;
+ }rsr;
+ //errCode=call_ReadSub(&rsr,&timeout_ms);//杩欏彞鏄姛鑳界殑鍏蜂綋瀹炵幇
+ if(errCode!=0)
+ return false;
+
+ //搴忓垪鍖栬繑鍥炴暟鎹�
+ *proc_id_len=rsr.proc_id.size();
+ *proc_id=malloc(*proc_id_len);
+ memcpy(*proc_id,rsr.proc_id.data(),*proc_id_len);
+
+ MsgPublish Mp;
+ Mp.set_topic(rsr.topic);
+ Mp.set_data(rsr.data.data());
+ *msgpub_len=Mp.ByteSizeLong();
+ *msgpub=malloc(*msgpub_len);
+ Mp.SerializePartialToArray(*msgpub,*msgpub_len);
+
+ return true;
+}
+
+int BHAsyncRequest(const void *remote,
+ const int remote_len,
+ const void *request,
+ const int request_len,
+ void **msg_id,
+ int *msg_id_len)
+{
+ //鍙嶅簭鍒楀寲鍏ュ弬
+ BHAddress input0;
+ MsgRequestTopic input1;
+ if (!input0.ParseFromArray(remote,remote_len)||!input1.ParseFromArray(request,request_len))
+ return false;
+ struct _BHAddress
+ {
+ unsigned long long mq_id;
+ long long abs_addr;
+ const char *ip;
+ int port;
+ }_input0;
+ struct _MsgRequestTopic
+ {
+ const char *topic;
+ const char *data;
+ }_input1;
+ _input0.mq_id=input0.mq_id();
+ _input0.abs_addr=input0.abs_addr();
+ _input0.ip=input0.ip().c_str();
+ _input0.port=input0.port();
+ _input1.topic=input1.topic().c_str();
+ _input1.data=input1.data().c_str();
+
+ //璋冪敤鍑芥暟瀹炵幇
+ int errCode=0;//0 is success
+ std::string msg_id;
+ //errCode=call_AsyncRequest(&_input0,&_input1,&msg_id,&timeout_ms);//杩欏彞鏄姛鑳界殑鍏蜂綋瀹炵幇
+ if(errCode!=0)
+ return false;
+
+ //搴忓垪鍖栬繑鍥炴暟鎹�
+ if(msg_id==nullptr||msg_id_len==nullptr)//杩欓噷鏈夊彲鑳借皟鐢ㄨ�呬笉闇�瑕佽繑鍥�
+ return true;
+ *msg_id_len=msg_id.size();
+ *msg_id=malloc(*msg_id_len);
+ memcpy(*msg_id,msg_id.data(),*msg_id_len);
+
+ return true;
+}
+
+int BHRequest(const void *remote,
+ const int remote_len,
+ const void *request,
+ const int request_len,
+ void **proc_id,
+ int *proc_id_len,
+ void **reply,
+ int *reply_len,
+ const int timeout_ms)
+{
+ //鍙嶅簭鍒楀寲鍏ュ弬
+ BHAddress input0;
+ MsgRequestTopic input1;
+ if (!input0.ParseFromArray(remote,remote_len)||!input1.ParseFromArray(request,request_len))
+ return false;
+ struct _BHAddress
+ {
+ unsigned long long mq_id;
+ long long abs_addr;
+ const char *ip;
+ int port;
+ }_input0;
+ struct _MsgRequestTopic
+ {
+ const char *topic;
+ const char *data;
+ }_input1;
+ _input0.mq_id=input0.mq_id();
+ _input0.abs_addr=input0.abs_addr();
+ _input0.ip=input0.ip().c_str();
+ _input0.port=input0.port();
+ _input1.topic=input1.topic().c_str();
+ _input1.data=input1.data().c_str();
+
+ //璋冪敤鍑芥暟瀹炵幇
+ int errCode=0;//0 is success
+ struct _RequestReply
+ {
+ std::string proc_id;
+ std::string data;
+ }rr;
+ //errCode=call_Request(&_input0,&_input1,&rr,&timeout_ms);//杩欏彞鏄姛鑳界殑鍏蜂綋瀹炵幇
+ char errString[32]={0};
+ if(errCode!=0)
+ strcpy(errString,"閿欒鍘熷洜鎻忚堪...");
+
+ //搴忓垪鍖栬繑鍥炴暟鎹�
+ *proc_id_len=rr.proc_id.size();
+ *proc_id=malloc(*proc_id_len);
+ memcpy(*proc_id,rr.proc_id.data(),*proc_id_len);
+
+ MsgRequestTopicReply mrt;
+ mrt.mutable_errmsg()->set_errcode(::bhome_msg::ErrorCode(errCode));
+ mrt.mutable_errmsg()->set_errstring(errString);
+ mrt.set_data(rr.data.data());
+ *reply_len=mrt.ByteSizeLong();
+ *reply=malloc(*reply_len);
+ mrt.SerializePartialToArray(*reply,*reply_len);
+
+ return errCode==0?true:false;
+}
+
+int BHReadRequest(void **proc_id,
+ int *proc_id_len,
+ void **request,
+ int *request_len,
+ void **src,
+ const int timeout_ms)
+{
+ //鏃犲叆鍙�,鐨嗕负杩斿洖
+
+ //璋冪敤鍑芥暟瀹炵幇
+ int errCode=0;//0 is success
+ struct _ReadRequestReply
+ {
+ std::string proc_id;
+ std::string topic;
+ std::string data;
+ void *src;
+ }rrr;
+ //errCode=call_ReadRequest(&rrr,&timeout_ms);//杩欏彞鏄姛鑳界殑鍏蜂綋瀹炵幇
+ if(errCode!=0)
+ return false;
+
+ //搴忓垪鍖栬繑鍥炴暟鎹�
+ *proc_id_len=rrr.proc_id.size();
+ *proc_id=malloc(*proc_id_len);
+ memcpy(*proc_id,rrr.proc_id.data(),*proc_id_len);
+
+ MsgRequestTopic mrt;
+ mrt.set_topic(rrr.topic);
+ mrt.set_data(rrr.data.data());
+ *request_len=mrt.ByteSizeLong();
+ *request=malloc(*request_len);
+ mrt.SerializePartialToArray(*request,*request_len);
+
+ *src=rrr.src;
+
+ return true;
+}
+
+int BHSendReply(void *src,
+ const void *reply,
+ const int reply_len)
+{
+ //鍙嶅簭鍒楀寲鍏ュ弬
+ MsgRequestTopicReply input;
+ if(!input.ParseFromArray(reply,reply_len))
+ return false;
+ const char *_input;
+ _input=input.data().data();
+
+ //璋冪敤鍑芥暟瀹炵幇
+ int errCode=0;//0 is success
+ //errCode=call_SendReply(src,_input,timeout_ms);//杩欏彞鏄姛鑳界殑鍏蜂綋瀹炵幇
+
+ return errCode==0?true:false;
+}
+
+void BHFree(void *data, int size)
+{
+ free(data);
+}
+
+int BHCleanup()
+{
+ int errCode=0;//0 is success
+ //errCode=call_Cleanup();//杩欏彞鏄姛鑳界殑鍏蜂綋瀹炵幇
+ return errCode==0?true:false;
+}
\ No newline at end of file
diff --git a/src/bh_api.h b/src/bh_api.h
new file mode 100644
index 0000000..3ef07cc
--- /dev/null
+++ b/src/bh_api.h
@@ -0,0 +1,88 @@
+#ifndef BH_API
+#define BH_API
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int BHRegister(const void *proc_info,
+ const int proc_info_len,
+ void **reply,
+ int *reply_len,
+ const int timeout_ms);
+
+int BHUnregister(const void *proc_info,
+ const int proc_info_len,
+ void **reply,
+ int *reply_len,
+ const int timeout_ms);
+
+int BHRegisterTopics(const void *topics,
+ const int topics_len,
+ void **reply,
+ int *reply_len,
+ const int timeout_ms);
+
+int BHQueryProcs(const void *remote,
+ const int remote_len,
+ const void *query,
+ const int query_len,
+ void **reply,
+ int *reply_len,
+ const int timeout_ms);
+
+int BHHeartbeatEasy(const int timeout_ms);
+int BHHeartbeat(const void *proc_info,
+ const int proc_info_len,
+ void **reply,
+ int *reply_len,
+ const int timeout_ms);
+
+int BHPublish(const void *msgpub,
+ const int msgpub_len,
+ const int timeout_ms);
+
+int BHReadSub(void **proc_id,
+ int *proc_id_len,
+ void **msgpub,
+ int *msgpub_len,
+ const int timeout_ms);
+
+int BHAsyncRequest(const void *remote,
+ const int remote_len,
+ const void *request,
+ const int request_len,
+ void **msg_id,
+ int *msg_id_len);
+
+int BHRequest(const void *remote,
+ const int remote_len,
+ const void *request,
+ const int request_len,
+ void **proc_id,
+ int *proc_id_len,
+ void **reply,
+ int *reply_len,
+ const int timeout_ms);
+
+int BHReadRequest(void **proc_id,
+ int *proc_id_len,
+ void **request,
+ int *request_len,
+ void **src,
+ const int timeout_ms);
+
+int BHSendReply(void *src,
+ const void *reply,
+ const int reply_len);
+
+int BHCleanup();
+
+void BHFree(void *buf, int size);
+
+int BHGetLastError(void **msg, int *msg_len);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/proto/bhome_msg.pb.cc b/src/proto/bhome_msg.pb.cc
new file mode 100644
index 0000000..406af9a
--- /dev/null
+++ b/src/proto/bhome_msg.pb.cc
@@ -0,0 +1,2616 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: bhome_msg.proto
+
+#include "bhome_msg.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+namespace bhome_msg {
+constexpr BHMsgHead::BHMsgHead(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : route_()
+ , msg_id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+ , proc_id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+ , topic_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+ , dest_(nullptr)
+ , timestamp_(int64_t{0})
+ , ssn_id_(uint64_t{0u})
+ , type_(0){}
+struct BHMsgHeadDefaultTypeInternal {
+ constexpr BHMsgHeadDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~BHMsgHeadDefaultTypeInternal() {}
+ union {
+ BHMsgHead _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BHMsgHeadDefaultTypeInternal _BHMsgHead_default_instance_;
+constexpr MsgSubscribe::MsgSubscribe(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : topics_(nullptr){}
+struct MsgSubscribeDefaultTypeInternal {
+ constexpr MsgSubscribeDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~MsgSubscribeDefaultTypeInternal() {}
+ union {
+ MsgSubscribe _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgSubscribeDefaultTypeInternal _MsgSubscribe_default_instance_;
+constexpr MsgUnsubscribe::MsgUnsubscribe(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : topics_(nullptr){}
+struct MsgUnsubscribeDefaultTypeInternal {
+ constexpr MsgUnsubscribeDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~MsgUnsubscribeDefaultTypeInternal() {}
+ union {
+ MsgUnsubscribe _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgUnsubscribeDefaultTypeInternal _MsgUnsubscribe_default_instance_;
+constexpr MsgRegisterRPC::MsgRegisterRPC(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : topics_(nullptr){}
+struct MsgRegisterRPCDefaultTypeInternal {
+ constexpr MsgRegisterRPCDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~MsgRegisterRPCDefaultTypeInternal() {}
+ union {
+ MsgRegisterRPC _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgRegisterRPCDefaultTypeInternal _MsgRegisterRPC_default_instance_;
+constexpr MsgProcInit::MsgProcInit(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : extra_mq_num_(0){}
+struct MsgProcInitDefaultTypeInternal {
+ constexpr MsgProcInitDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~MsgProcInitDefaultTypeInternal() {}
+ union {
+ MsgProcInit _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgProcInitDefaultTypeInternal _MsgProcInit_default_instance_;
+constexpr MsgProcInitReply::MsgProcInitReply(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : extra_mqs_()
+ , errmsg_(nullptr)
+ , proc_index_(0){}
+struct MsgProcInitReplyDefaultTypeInternal {
+ constexpr MsgProcInitReplyDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~MsgProcInitReplyDefaultTypeInternal() {}
+ union {
+ MsgProcInitReply _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgProcInitReplyDefaultTypeInternal _MsgProcInitReply_default_instance_;
+constexpr MsgRequest::MsgRequest(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : _oneof_case_{}{}
+struct MsgRequestDefaultTypeInternal {
+ constexpr MsgRequestDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~MsgRequestDefaultTypeInternal() {}
+ union {
+ MsgRequest _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgRequestDefaultTypeInternal _MsgRequest_default_instance_;
+constexpr MsgReply::MsgReply(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : err_msg_(nullptr){}
+struct MsgReplyDefaultTypeInternal {
+ constexpr MsgReplyDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~MsgReplyDefaultTypeInternal() {}
+ union {
+ MsgReply _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgReplyDefaultTypeInternal _MsgReply_default_instance_;
+constexpr BHMsgBody::BHMsgBody(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : _oneof_case_{}{}
+struct BHMsgBodyDefaultTypeInternal {
+ constexpr BHMsgBodyDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~BHMsgBodyDefaultTypeInternal() {}
+ union {
+ BHMsgBody _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BHMsgBodyDefaultTypeInternal _BHMsgBody_default_instance_;
+} // namespace bhome_msg
+namespace bhome_msg {
+bool MsgType_IsValid(int value) {
+ switch (value) {
+ case 0:
+ case 1:
+ case 2:
+ case 8:
+ case 9:
+ case 10:
+ case 12:
+ case 14:
+ case 15:
+ case 16:
+ case 17:
+ case 18:
+ case 20:
+ case 22:
+ case 24:
+ case 26:
+ case 28:
+ case 29:
+ return true;
+ default:
+ return false;
+ }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> MsgType_strings[18] = {};
+
+static const char MsgType_names[] =
+ "kMsgTypeCommonReply"
+ "kMsgTypeHeartbeat"
+ "kMsgTypeInvalid"
+ "kMsgTypeProcInit"
+ "kMsgTypeProcInitReply"
+ "kMsgTypePublish"
+ "kMsgTypeQueryProc"
+ "kMsgTypeQueryProcReply"
+ "kMsgTypeQueryTopic"
+ "kMsgTypeQueryTopicReply"
+ "kMsgTypeRawData"
+ "kMsgTypeRegister"
+ "kMsgTypeRegisterRPC"
+ "kMsgTypeRequestTopic"
+ "kMsgTypeRequestTopicReply"
+ "kMsgTypeSubscribe"
+ "kMsgTypeUnregister"
+ "kMsgTypeUnsubscribe";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry MsgType_entries[] = {
+ { {MsgType_names + 0, 19}, 2 },
+ { {MsgType_names + 19, 17}, 12 },
+ { {MsgType_names + 36, 15}, 0 },
+ { {MsgType_names + 51, 16}, 8 },
+ { {MsgType_names + 67, 21}, 9 },
+ { {MsgType_names + 88, 15}, 20 },
+ { {MsgType_names + 103, 17}, 28 },
+ { {MsgType_names + 120, 22}, 29 },
+ { {MsgType_names + 142, 18}, 14 },
+ { {MsgType_names + 160, 23}, 15 },
+ { {MsgType_names + 183, 15}, 1 },
+ { {MsgType_names + 198, 16}, 10 },
+ { {MsgType_names + 214, 19}, 18 },
+ { {MsgType_names + 233, 20}, 16 },
+ { {MsgType_names + 253, 25}, 17 },
+ { {MsgType_names + 278, 17}, 22 },
+ { {MsgType_names + 295, 18}, 26 },
+ { {MsgType_names + 313, 19}, 24 },
+};
+
+static const int MsgType_entries_by_number[] = {
+ 2, // 0 -> kMsgTypeInvalid
+ 10, // 1 -> kMsgTypeRawData
+ 0, // 2 -> kMsgTypeCommonReply
+ 3, // 8 -> kMsgTypeProcInit
+ 4, // 9 -> kMsgTypeProcInitReply
+ 11, // 10 -> kMsgTypeRegister
+ 1, // 12 -> kMsgTypeHeartbeat
+ 8, // 14 -> kMsgTypeQueryTopic
+ 9, // 15 -> kMsgTypeQueryTopicReply
+ 13, // 16 -> kMsgTypeRequestTopic
+ 14, // 17 -> kMsgTypeRequestTopicReply
+ 12, // 18 -> kMsgTypeRegisterRPC
+ 5, // 20 -> kMsgTypePublish
+ 15, // 22 -> kMsgTypeSubscribe
+ 17, // 24 -> kMsgTypeUnsubscribe
+ 16, // 26 -> kMsgTypeUnregister
+ 6, // 28 -> kMsgTypeQueryProc
+ 7, // 29 -> kMsgTypeQueryProcReply
+};
+
+const std::string& MsgType_Name(
+ MsgType value) {
+ static const bool dummy =
+ ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+ MsgType_entries,
+ MsgType_entries_by_number,
+ 18, MsgType_strings);
+ (void) dummy;
+ int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+ MsgType_entries,
+ MsgType_entries_by_number,
+ 18, value);
+ return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+ MsgType_strings[idx].get();
+}
+bool MsgType_Parse(
+ ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MsgType* value) {
+ int int_value;
+ bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+ MsgType_entries, 18, name, &int_value);
+ if (success) {
+ *value = static_cast<MsgType>(int_value);
+ }
+ return success;
+}
+
+// ===================================================================
+
+class BHMsgHead::_Internal {
+ public:
+ static const ::bhome_msg::BHAddress& dest(const BHMsgHead* msg);
+};
+
+const ::bhome_msg::BHAddress&
+BHMsgHead::_Internal::dest(const BHMsgHead* msg) {
+ return *msg->dest_;
+}
+void BHMsgHead::clear_route() {
+ route_.Clear();
+}
+void BHMsgHead::clear_dest() {
+ if (GetArenaForAllocation() == nullptr && dest_ != nullptr) {
+ delete dest_;
+ }
+ dest_ = nullptr;
+}
+BHMsgHead::BHMsgHead(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned),
+ route_(arena) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.BHMsgHead)
+}
+BHMsgHead::BHMsgHead(const BHMsgHead& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
+ route_(from.route_) {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ msg_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_msg_id().empty()) {
+ msg_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_msg_id(),
+ GetArenaForAllocation());
+ }
+ proc_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_proc_id().empty()) {
+ proc_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_proc_id(),
+ GetArenaForAllocation());
+ }
+ topic_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_topic().empty()) {
+ topic_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_topic(),
+ GetArenaForAllocation());
+ }
+ if (from._internal_has_dest()) {
+ dest_ = new ::bhome_msg::BHAddress(*from.dest_);
+ } else {
+ dest_ = nullptr;
+ }
+ ::memcpy(×tamp_, &from.timestamp_,
+ static_cast<size_t>(reinterpret_cast<char*>(&type_) -
+ reinterpret_cast<char*>(×tamp_)) + sizeof(type_));
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.BHMsgHead)
+}
+
+inline void BHMsgHead::SharedCtor() {
+msg_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+proc_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+topic_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&dest_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&type_) -
+ reinterpret_cast<char*>(&dest_)) + sizeof(type_));
+}
+
+BHMsgHead::~BHMsgHead() {
+ // @@protoc_insertion_point(destructor:bhome_msg.BHMsgHead)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void BHMsgHead::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ msg_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ proc_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ topic_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (this != internal_default_instance()) delete dest_;
+}
+
+void BHMsgHead::ArenaDtor(void* object) {
+ BHMsgHead* _this = reinterpret_cast< BHMsgHead* >(object);
+ (void)_this;
+}
+void BHMsgHead::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void BHMsgHead::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void BHMsgHead::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.BHMsgHead)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ route_.Clear();
+ msg_id_.ClearToEmpty();
+ proc_id_.ClearToEmpty();
+ topic_.ClearToEmpty();
+ if (GetArenaForAllocation() == nullptr && dest_ != nullptr) {
+ delete dest_;
+ }
+ dest_ = nullptr;
+ ::memset(×tamp_, 0, static_cast<size_t>(
+ reinterpret_cast<char*>(&type_) -
+ reinterpret_cast<char*>(×tamp_)) + sizeof(type_));
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* BHMsgHead::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // bytes msg_id = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ auto str = _internal_mutable_msg_id();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // repeated .bhome_msg.BHAddress route = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ ptr = ctx->ParseMessage(_internal_add_route(), ptr);
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+ } else goto handle_unusual;
+ continue;
+ // int64 timestamp = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
+ timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // int32 type = 4;
+ case 4:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
+ type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // uint64 ssn_id = 5;
+ case 5:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
+ ssn_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // bytes proc_id = 6;
+ case 6:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
+ auto str = _internal_mutable_proc_id();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // bytes topic = 7;
+ case 7:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
+ auto str = _internal_mutable_topic();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // .bhome_msg.BHAddress dest = 8;
+ case 8:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
+ ptr = ctx->ParseMessage(_internal_mutable_dest(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* BHMsgHead::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.BHMsgHead)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // bytes msg_id = 1;
+ if (!this->_internal_msg_id().empty()) {
+ target = stream->WriteBytesMaybeAliased(
+ 1, this->_internal_msg_id(), target);
+ }
+
+ // repeated .bhome_msg.BHAddress route = 2;
+ for (unsigned int i = 0,
+ n = static_cast<unsigned int>(this->_internal_route_size()); i < n; i++) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(2, this->_internal_route(i), target, stream);
+ }
+
+ // int64 timestamp = 3;
+ if (this->_internal_timestamp() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_timestamp(), target);
+ }
+
+ // int32 type = 4;
+ if (this->_internal_type() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_type(), target);
+ }
+
+ // uint64 ssn_id = 5;
+ if (this->_internal_ssn_id() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(5, this->_internal_ssn_id(), target);
+ }
+
+ // bytes proc_id = 6;
+ if (!this->_internal_proc_id().empty()) {
+ target = stream->WriteBytesMaybeAliased(
+ 6, this->_internal_proc_id(), target);
+ }
+
+ // bytes topic = 7;
+ if (!this->_internal_topic().empty()) {
+ target = stream->WriteBytesMaybeAliased(
+ 7, this->_internal_topic(), target);
+ }
+
+ // .bhome_msg.BHAddress dest = 8;
+ if (this->_internal_has_dest()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 8, _Internal::dest(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.BHMsgHead)
+ return target;
+}
+
+size_t BHMsgHead::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.BHMsgHead)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // repeated .bhome_msg.BHAddress route = 2;
+ total_size += 1UL * this->_internal_route_size();
+ for (const auto& msg : this->route_) {
+ total_size +=
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+ }
+
+ // bytes msg_id = 1;
+ if (!this->_internal_msg_id().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_msg_id());
+ }
+
+ // bytes proc_id = 6;
+ if (!this->_internal_proc_id().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_proc_id());
+ }
+
+ // bytes topic = 7;
+ if (!this->_internal_topic().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_topic());
+ }
+
+ // .bhome_msg.BHAddress dest = 8;
+ if (this->_internal_has_dest()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *dest_);
+ }
+
+ // int64 timestamp = 3;
+ if (this->_internal_timestamp() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
+ this->_internal_timestamp());
+ }
+
+ // uint64 ssn_id = 5;
+ if (this->_internal_ssn_id() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
+ this->_internal_ssn_id());
+ }
+
+ // int32 type = 4;
+ if (this->_internal_type() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ this->_internal_type());
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void BHMsgHead::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const BHMsgHead*>(
+ &from));
+}
+
+void BHMsgHead::MergeFrom(const BHMsgHead& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.BHMsgHead)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ route_.MergeFrom(from.route_);
+ if (!from._internal_msg_id().empty()) {
+ _internal_set_msg_id(from._internal_msg_id());
+ }
+ if (!from._internal_proc_id().empty()) {
+ _internal_set_proc_id(from._internal_proc_id());
+ }
+ if (!from._internal_topic().empty()) {
+ _internal_set_topic(from._internal_topic());
+ }
+ if (from._internal_has_dest()) {
+ _internal_mutable_dest()->::bhome_msg::BHAddress::MergeFrom(from._internal_dest());
+ }
+ if (from._internal_timestamp() != 0) {
+ _internal_set_timestamp(from._internal_timestamp());
+ }
+ if (from._internal_ssn_id() != 0) {
+ _internal_set_ssn_id(from._internal_ssn_id());
+ }
+ if (from._internal_type() != 0) {
+ _internal_set_type(from._internal_type());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void BHMsgHead::CopyFrom(const BHMsgHead& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.BHMsgHead)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool BHMsgHead::IsInitialized() const {
+ return true;
+}
+
+void BHMsgHead::InternalSwap(BHMsgHead* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ route_.InternalSwap(&other->route_);
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &msg_id_, GetArenaForAllocation(),
+ &other->msg_id_, other->GetArenaForAllocation()
+ );
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &proc_id_, GetArenaForAllocation(),
+ &other->proc_id_, other->GetArenaForAllocation()
+ );
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &topic_, GetArenaForAllocation(),
+ &other->topic_, other->GetArenaForAllocation()
+ );
+ ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+ PROTOBUF_FIELD_OFFSET(BHMsgHead, type_)
+ + sizeof(BHMsgHead::type_)
+ - PROTOBUF_FIELD_OFFSET(BHMsgHead, dest_)>(
+ reinterpret_cast<char*>(&dest_),
+ reinterpret_cast<char*>(&other->dest_));
+}
+
+std::string BHMsgHead::GetTypeName() const {
+ return "bhome_msg.BHMsgHead";
+}
+
+
+// ===================================================================
+
+class MsgSubscribe::_Internal {
+ public:
+ static const ::bhome_msg::MsgTopicList& topics(const MsgSubscribe* msg);
+};
+
+const ::bhome_msg::MsgTopicList&
+MsgSubscribe::_Internal::topics(const MsgSubscribe* msg) {
+ return *msg->topics_;
+}
+void MsgSubscribe::clear_topics() {
+ if (GetArenaForAllocation() == nullptr && topics_ != nullptr) {
+ delete topics_;
+ }
+ topics_ = nullptr;
+}
+MsgSubscribe::MsgSubscribe(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgSubscribe)
+}
+MsgSubscribe::MsgSubscribe(const MsgSubscribe& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ if (from._internal_has_topics()) {
+ topics_ = new ::bhome_msg::MsgTopicList(*from.topics_);
+ } else {
+ topics_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgSubscribe)
+}
+
+inline void MsgSubscribe::SharedCtor() {
+topics_ = nullptr;
+}
+
+MsgSubscribe::~MsgSubscribe() {
+ // @@protoc_insertion_point(destructor:bhome_msg.MsgSubscribe)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void MsgSubscribe::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (this != internal_default_instance()) delete topics_;
+}
+
+void MsgSubscribe::ArenaDtor(void* object) {
+ MsgSubscribe* _this = reinterpret_cast< MsgSubscribe* >(object);
+ (void)_this;
+}
+void MsgSubscribe::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MsgSubscribe::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void MsgSubscribe::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgSubscribe)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ if (GetArenaForAllocation() == nullptr && topics_ != nullptr) {
+ delete topics_;
+ }
+ topics_ = nullptr;
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* MsgSubscribe::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .bhome_msg.MsgTopicList topics = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_topics(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MsgSubscribe::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgSubscribe)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .bhome_msg.MsgTopicList topics = 1;
+ if (this->_internal_has_topics()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::topics(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgSubscribe)
+ return target;
+}
+
+size_t MsgSubscribe::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgSubscribe)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // .bhome_msg.MsgTopicList topics = 1;
+ if (this->_internal_has_topics()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *topics_);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MsgSubscribe::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgSubscribe*>(
+ &from));
+}
+
+void MsgSubscribe::MergeFrom(const MsgSubscribe& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgSubscribe)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from._internal_has_topics()) {
+ _internal_mutable_topics()->::bhome_msg::MsgTopicList::MergeFrom(from._internal_topics());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MsgSubscribe::CopyFrom(const MsgSubscribe& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgSubscribe)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MsgSubscribe::IsInitialized() const {
+ return true;
+}
+
+void MsgSubscribe::InternalSwap(MsgSubscribe* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ swap(topics_, other->topics_);
+}
+
+std::string MsgSubscribe::GetTypeName() const {
+ return "bhome_msg.MsgSubscribe";
+}
+
+
+// ===================================================================
+
+class MsgUnsubscribe::_Internal {
+ public:
+ static const ::bhome_msg::MsgTopicList& topics(const MsgUnsubscribe* msg);
+};
+
+const ::bhome_msg::MsgTopicList&
+MsgUnsubscribe::_Internal::topics(const MsgUnsubscribe* msg) {
+ return *msg->topics_;
+}
+void MsgUnsubscribe::clear_topics() {
+ if (GetArenaForAllocation() == nullptr && topics_ != nullptr) {
+ delete topics_;
+ }
+ topics_ = nullptr;
+}
+MsgUnsubscribe::MsgUnsubscribe(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgUnsubscribe)
+}
+MsgUnsubscribe::MsgUnsubscribe(const MsgUnsubscribe& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ if (from._internal_has_topics()) {
+ topics_ = new ::bhome_msg::MsgTopicList(*from.topics_);
+ } else {
+ topics_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgUnsubscribe)
+}
+
+inline void MsgUnsubscribe::SharedCtor() {
+topics_ = nullptr;
+}
+
+MsgUnsubscribe::~MsgUnsubscribe() {
+ // @@protoc_insertion_point(destructor:bhome_msg.MsgUnsubscribe)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void MsgUnsubscribe::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (this != internal_default_instance()) delete topics_;
+}
+
+void MsgUnsubscribe::ArenaDtor(void* object) {
+ MsgUnsubscribe* _this = reinterpret_cast< MsgUnsubscribe* >(object);
+ (void)_this;
+}
+void MsgUnsubscribe::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MsgUnsubscribe::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void MsgUnsubscribe::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgUnsubscribe)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ if (GetArenaForAllocation() == nullptr && topics_ != nullptr) {
+ delete topics_;
+ }
+ topics_ = nullptr;
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* MsgUnsubscribe::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .bhome_msg.MsgTopicList topics = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_topics(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MsgUnsubscribe::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgUnsubscribe)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .bhome_msg.MsgTopicList topics = 1;
+ if (this->_internal_has_topics()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::topics(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgUnsubscribe)
+ return target;
+}
+
+size_t MsgUnsubscribe::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgUnsubscribe)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // .bhome_msg.MsgTopicList topics = 1;
+ if (this->_internal_has_topics()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *topics_);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MsgUnsubscribe::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgUnsubscribe*>(
+ &from));
+}
+
+void MsgUnsubscribe::MergeFrom(const MsgUnsubscribe& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgUnsubscribe)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from._internal_has_topics()) {
+ _internal_mutable_topics()->::bhome_msg::MsgTopicList::MergeFrom(from._internal_topics());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MsgUnsubscribe::CopyFrom(const MsgUnsubscribe& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgUnsubscribe)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MsgUnsubscribe::IsInitialized() const {
+ return true;
+}
+
+void MsgUnsubscribe::InternalSwap(MsgUnsubscribe* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ swap(topics_, other->topics_);
+}
+
+std::string MsgUnsubscribe::GetTypeName() const {
+ return "bhome_msg.MsgUnsubscribe";
+}
+
+
+// ===================================================================
+
+class MsgRegisterRPC::_Internal {
+ public:
+ static const ::bhome_msg::MsgTopicList& topics(const MsgRegisterRPC* msg);
+};
+
+const ::bhome_msg::MsgTopicList&
+MsgRegisterRPC::_Internal::topics(const MsgRegisterRPC* msg) {
+ return *msg->topics_;
+}
+void MsgRegisterRPC::clear_topics() {
+ if (GetArenaForAllocation() == nullptr && topics_ != nullptr) {
+ delete topics_;
+ }
+ topics_ = nullptr;
+}
+MsgRegisterRPC::MsgRegisterRPC(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgRegisterRPC)
+}
+MsgRegisterRPC::MsgRegisterRPC(const MsgRegisterRPC& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ if (from._internal_has_topics()) {
+ topics_ = new ::bhome_msg::MsgTopicList(*from.topics_);
+ } else {
+ topics_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgRegisterRPC)
+}
+
+inline void MsgRegisterRPC::SharedCtor() {
+topics_ = nullptr;
+}
+
+MsgRegisterRPC::~MsgRegisterRPC() {
+ // @@protoc_insertion_point(destructor:bhome_msg.MsgRegisterRPC)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void MsgRegisterRPC::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (this != internal_default_instance()) delete topics_;
+}
+
+void MsgRegisterRPC::ArenaDtor(void* object) {
+ MsgRegisterRPC* _this = reinterpret_cast< MsgRegisterRPC* >(object);
+ (void)_this;
+}
+void MsgRegisterRPC::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MsgRegisterRPC::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void MsgRegisterRPC::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgRegisterRPC)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ if (GetArenaForAllocation() == nullptr && topics_ != nullptr) {
+ delete topics_;
+ }
+ topics_ = nullptr;
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* MsgRegisterRPC::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .bhome_msg.MsgTopicList topics = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_topics(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MsgRegisterRPC::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgRegisterRPC)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .bhome_msg.MsgTopicList topics = 1;
+ if (this->_internal_has_topics()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::topics(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgRegisterRPC)
+ return target;
+}
+
+size_t MsgRegisterRPC::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgRegisterRPC)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // .bhome_msg.MsgTopicList topics = 1;
+ if (this->_internal_has_topics()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *topics_);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MsgRegisterRPC::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgRegisterRPC*>(
+ &from));
+}
+
+void MsgRegisterRPC::MergeFrom(const MsgRegisterRPC& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgRegisterRPC)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from._internal_has_topics()) {
+ _internal_mutable_topics()->::bhome_msg::MsgTopicList::MergeFrom(from._internal_topics());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MsgRegisterRPC::CopyFrom(const MsgRegisterRPC& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgRegisterRPC)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MsgRegisterRPC::IsInitialized() const {
+ return true;
+}
+
+void MsgRegisterRPC::InternalSwap(MsgRegisterRPC* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ swap(topics_, other->topics_);
+}
+
+std::string MsgRegisterRPC::GetTypeName() const {
+ return "bhome_msg.MsgRegisterRPC";
+}
+
+
+// ===================================================================
+
+class MsgProcInit::_Internal {
+ public:
+};
+
+MsgProcInit::MsgProcInit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgProcInit)
+}
+MsgProcInit::MsgProcInit(const MsgProcInit& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ extra_mq_num_ = from.extra_mq_num_;
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgProcInit)
+}
+
+inline void MsgProcInit::SharedCtor() {
+extra_mq_num_ = 0;
+}
+
+MsgProcInit::~MsgProcInit() {
+ // @@protoc_insertion_point(destructor:bhome_msg.MsgProcInit)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void MsgProcInit::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void MsgProcInit::ArenaDtor(void* object) {
+ MsgProcInit* _this = reinterpret_cast< MsgProcInit* >(object);
+ (void)_this;
+}
+void MsgProcInit::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MsgProcInit::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void MsgProcInit::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgProcInit)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ extra_mq_num_ = 0;
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* MsgProcInit::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // int32 extra_mq_num = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
+ extra_mq_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MsgProcInit::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgProcInit)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // int32 extra_mq_num = 1;
+ if (this->_internal_extra_mq_num() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_extra_mq_num(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgProcInit)
+ return target;
+}
+
+size_t MsgProcInit::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgProcInit)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // int32 extra_mq_num = 1;
+ if (this->_internal_extra_mq_num() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ this->_internal_extra_mq_num());
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MsgProcInit::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgProcInit*>(
+ &from));
+}
+
+void MsgProcInit::MergeFrom(const MsgProcInit& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgProcInit)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from._internal_extra_mq_num() != 0) {
+ _internal_set_extra_mq_num(from._internal_extra_mq_num());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MsgProcInit::CopyFrom(const MsgProcInit& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgProcInit)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MsgProcInit::IsInitialized() const {
+ return true;
+}
+
+void MsgProcInit::InternalSwap(MsgProcInit* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ swap(extra_mq_num_, other->extra_mq_num_);
+}
+
+std::string MsgProcInit::GetTypeName() const {
+ return "bhome_msg.MsgProcInit";
+}
+
+
+// ===================================================================
+
+class MsgProcInitReply::_Internal {
+ public:
+ static const ::bhome_msg::ErrorMsg& errmsg(const MsgProcInitReply* msg);
+};
+
+const ::bhome_msg::ErrorMsg&
+MsgProcInitReply::_Internal::errmsg(const MsgProcInitReply* msg) {
+ return *msg->errmsg_;
+}
+void MsgProcInitReply::clear_errmsg() {
+ if (GetArenaForAllocation() == nullptr && errmsg_ != nullptr) {
+ delete errmsg_;
+ }
+ errmsg_ = nullptr;
+}
+void MsgProcInitReply::clear_extra_mqs() {
+ extra_mqs_.Clear();
+}
+MsgProcInitReply::MsgProcInitReply(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned),
+ extra_mqs_(arena) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgProcInitReply)
+}
+MsgProcInitReply::MsgProcInitReply(const MsgProcInitReply& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
+ extra_mqs_(from.extra_mqs_) {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ if (from._internal_has_errmsg()) {
+ errmsg_ = new ::bhome_msg::ErrorMsg(*from.errmsg_);
+ } else {
+ errmsg_ = nullptr;
+ }
+ proc_index_ = from.proc_index_;
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgProcInitReply)
+}
+
+inline void MsgProcInitReply::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&errmsg_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&proc_index_) -
+ reinterpret_cast<char*>(&errmsg_)) + sizeof(proc_index_));
+}
+
+MsgProcInitReply::~MsgProcInitReply() {
+ // @@protoc_insertion_point(destructor:bhome_msg.MsgProcInitReply)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void MsgProcInitReply::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (this != internal_default_instance()) delete errmsg_;
+}
+
+void MsgProcInitReply::ArenaDtor(void* object) {
+ MsgProcInitReply* _this = reinterpret_cast< MsgProcInitReply* >(object);
+ (void)_this;
+}
+void MsgProcInitReply::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MsgProcInitReply::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void MsgProcInitReply::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgProcInitReply)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ extra_mqs_.Clear();
+ if (GetArenaForAllocation() == nullptr && errmsg_ != nullptr) {
+ delete errmsg_;
+ }
+ errmsg_ = nullptr;
+ proc_index_ = 0;
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* MsgProcInitReply::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .bhome_msg.ErrorMsg errmsg = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_errmsg(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // int32 proc_index = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
+ proc_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // repeated .bhome_msg.BHAddress extra_mqs = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ ptr = ctx->ParseMessage(_internal_add_extra_mqs(), ptr);
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MsgProcInitReply::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgProcInitReply)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .bhome_msg.ErrorMsg errmsg = 1;
+ if (this->_internal_has_errmsg()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::errmsg(this), target, stream);
+ }
+
+ // int32 proc_index = 2;
+ if (this->_internal_proc_index() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_proc_index(), target);
+ }
+
+ // repeated .bhome_msg.BHAddress extra_mqs = 3;
+ for (unsigned int i = 0,
+ n = static_cast<unsigned int>(this->_internal_extra_mqs_size()); i < n; i++) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(3, this->_internal_extra_mqs(i), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgProcInitReply)
+ return target;
+}
+
+size_t MsgProcInitReply::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgProcInitReply)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // repeated .bhome_msg.BHAddress extra_mqs = 3;
+ total_size += 1UL * this->_internal_extra_mqs_size();
+ for (const auto& msg : this->extra_mqs_) {
+ total_size +=
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+ }
+
+ // .bhome_msg.ErrorMsg errmsg = 1;
+ if (this->_internal_has_errmsg()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *errmsg_);
+ }
+
+ // int32 proc_index = 2;
+ if (this->_internal_proc_index() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ this->_internal_proc_index());
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MsgProcInitReply::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgProcInitReply*>(
+ &from));
+}
+
+void MsgProcInitReply::MergeFrom(const MsgProcInitReply& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgProcInitReply)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ extra_mqs_.MergeFrom(from.extra_mqs_);
+ if (from._internal_has_errmsg()) {
+ _internal_mutable_errmsg()->::bhome_msg::ErrorMsg::MergeFrom(from._internal_errmsg());
+ }
+ if (from._internal_proc_index() != 0) {
+ _internal_set_proc_index(from._internal_proc_index());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MsgProcInitReply::CopyFrom(const MsgProcInitReply& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgProcInitReply)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MsgProcInitReply::IsInitialized() const {
+ return true;
+}
+
+void MsgProcInitReply::InternalSwap(MsgProcInitReply* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ extra_mqs_.InternalSwap(&other->extra_mqs_);
+ ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+ PROTOBUF_FIELD_OFFSET(MsgProcInitReply, proc_index_)
+ + sizeof(MsgProcInitReply::proc_index_)
+ - PROTOBUF_FIELD_OFFSET(MsgProcInitReply, errmsg_)>(
+ reinterpret_cast<char*>(&errmsg_),
+ reinterpret_cast<char*>(&other->errmsg_));
+}
+
+std::string MsgProcInitReply::GetTypeName() const {
+ return "bhome_msg.MsgProcInitReply";
+}
+
+
+// ===================================================================
+
+class MsgRequest::_Internal {
+ public:
+ static const ::bhome_msg::MsgRegister& register_(const MsgRequest* msg);
+ static const ::bhome_msg::MsgRequestTopic& topic_request(const MsgRequest* msg);
+ static const ::bhome_msg::MsgQueryTopic& topic_query(const MsgRequest* msg);
+};
+
+const ::bhome_msg::MsgRegister&
+MsgRequest::_Internal::register_(const MsgRequest* msg) {
+ return *msg->request_.register__;
+}
+const ::bhome_msg::MsgRequestTopic&
+MsgRequest::_Internal::topic_request(const MsgRequest* msg) {
+ return *msg->request_.topic_request_;
+}
+const ::bhome_msg::MsgQueryTopic&
+MsgRequest::_Internal::topic_query(const MsgRequest* msg) {
+ return *msg->request_.topic_query_;
+}
+void MsgRequest::set_allocated_register_(::bhome_msg::MsgRegister* register_) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ clear_request();
+ if (register_) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+ ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+ reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(register_));
+ if (message_arena != submessage_arena) {
+ register_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, register_, submessage_arena);
+ }
+ set_has_register_();
+ request_.register__ = register_;
+ }
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgRequest.register)
+}
+void MsgRequest::clear_register_() {
+ if (_internal_has_register_()) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete request_.register__;
+ }
+ clear_has_request();
+ }
+}
+void MsgRequest::set_allocated_topic_request(::bhome_msg::MsgRequestTopic* topic_request) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ clear_request();
+ if (topic_request) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+ ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+ reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(topic_request));
+ if (message_arena != submessage_arena) {
+ topic_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, topic_request, submessage_arena);
+ }
+ set_has_topic_request();
+ request_.topic_request_ = topic_request;
+ }
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgRequest.topic_request)
+}
+void MsgRequest::clear_topic_request() {
+ if (_internal_has_topic_request()) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete request_.topic_request_;
+ }
+ clear_has_request();
+ }
+}
+void MsgRequest::set_allocated_topic_query(::bhome_msg::MsgQueryTopic* topic_query) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ clear_request();
+ if (topic_query) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+ ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+ reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(topic_query));
+ if (message_arena != submessage_arena) {
+ topic_query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, topic_query, submessage_arena);
+ }
+ set_has_topic_query();
+ request_.topic_query_ = topic_query;
+ }
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgRequest.topic_query)
+}
+void MsgRequest::clear_topic_query() {
+ if (_internal_has_topic_query()) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete request_.topic_query_;
+ }
+ clear_has_request();
+ }
+}
+MsgRequest::MsgRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgRequest)
+}
+MsgRequest::MsgRequest(const MsgRequest& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ clear_has_request();
+ switch (from.request_case()) {
+ case kRegister: {
+ _internal_mutable_register_()->::bhome_msg::MsgRegister::MergeFrom(from._internal_register_());
+ break;
+ }
+ case kTopicRequest: {
+ _internal_mutable_topic_request()->::bhome_msg::MsgRequestTopic::MergeFrom(from._internal_topic_request());
+ break;
+ }
+ case kTopicQuery: {
+ _internal_mutable_topic_query()->::bhome_msg::MsgQueryTopic::MergeFrom(from._internal_topic_query());
+ break;
+ }
+ case REQUEST_NOT_SET: {
+ break;
+ }
+ }
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgRequest)
+}
+
+inline void MsgRequest::SharedCtor() {
+clear_has_request();
+}
+
+MsgRequest::~MsgRequest() {
+ // @@protoc_insertion_point(destructor:bhome_msg.MsgRequest)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void MsgRequest::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (has_request()) {
+ clear_request();
+ }
+}
+
+void MsgRequest::ArenaDtor(void* object) {
+ MsgRequest* _this = reinterpret_cast< MsgRequest* >(object);
+ (void)_this;
+}
+void MsgRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MsgRequest::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void MsgRequest::clear_request() {
+// @@protoc_insertion_point(one_of_clear_start:bhome_msg.MsgRequest)
+ switch (request_case()) {
+ case kRegister: {
+ if (GetArenaForAllocation() == nullptr) {
+ delete request_.register__;
+ }
+ break;
+ }
+ case kTopicRequest: {
+ if (GetArenaForAllocation() == nullptr) {
+ delete request_.topic_request_;
+ }
+ break;
+ }
+ case kTopicQuery: {
+ if (GetArenaForAllocation() == nullptr) {
+ delete request_.topic_query_;
+ }
+ break;
+ }
+ case REQUEST_NOT_SET: {
+ break;
+ }
+ }
+ _oneof_case_[0] = REQUEST_NOT_SET;
+}
+
+
+void MsgRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgRequest)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ clear_request();
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* MsgRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .bhome_msg.MsgRegister register = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_register_(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // .bhome_msg.MsgRequestTopic topic_request = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ ptr = ctx->ParseMessage(_internal_mutable_topic_request(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // .bhome_msg.MsgQueryTopic topic_query = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+ ptr = ctx->ParseMessage(_internal_mutable_topic_query(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MsgRequest::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgRequest)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .bhome_msg.MsgRegister register = 1;
+ if (_internal_has_register_()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::register_(this), target, stream);
+ }
+
+ // .bhome_msg.MsgRequestTopic topic_request = 2;
+ if (_internal_has_topic_request()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 2, _Internal::topic_request(this), target, stream);
+ }
+
+ // .bhome_msg.MsgQueryTopic topic_query = 3;
+ if (_internal_has_topic_query()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 3, _Internal::topic_query(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgRequest)
+ return target;
+}
+
+size_t MsgRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgRequest)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ switch (request_case()) {
+ // .bhome_msg.MsgRegister register = 1;
+ case kRegister: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *request_.register__);
+ break;
+ }
+ // .bhome_msg.MsgRequestTopic topic_request = 2;
+ case kTopicRequest: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *request_.topic_request_);
+ break;
+ }
+ // .bhome_msg.MsgQueryTopic topic_query = 3;
+ case kTopicQuery: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *request_.topic_query_);
+ break;
+ }
+ case REQUEST_NOT_SET: {
+ break;
+ }
+ }
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MsgRequest::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgRequest*>(
+ &from));
+}
+
+void MsgRequest::MergeFrom(const MsgRequest& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgRequest)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ switch (from.request_case()) {
+ case kRegister: {
+ _internal_mutable_register_()->::bhome_msg::MsgRegister::MergeFrom(from._internal_register_());
+ break;
+ }
+ case kTopicRequest: {
+ _internal_mutable_topic_request()->::bhome_msg::MsgRequestTopic::MergeFrom(from._internal_topic_request());
+ break;
+ }
+ case kTopicQuery: {
+ _internal_mutable_topic_query()->::bhome_msg::MsgQueryTopic::MergeFrom(from._internal_topic_query());
+ break;
+ }
+ case REQUEST_NOT_SET: {
+ break;
+ }
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MsgRequest::CopyFrom(const MsgRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgRequest)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MsgRequest::IsInitialized() const {
+ return true;
+}
+
+void MsgRequest::InternalSwap(MsgRequest* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ swap(request_, other->request_);
+ swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+std::string MsgRequest::GetTypeName() const {
+ return "bhome_msg.MsgRequest";
+}
+
+
+// ===================================================================
+
+class MsgReply::_Internal {
+ public:
+ static const ::bhome_msg::ErrorMsg& err_msg(const MsgReply* msg);
+};
+
+const ::bhome_msg::ErrorMsg&
+MsgReply::_Internal::err_msg(const MsgReply* msg) {
+ return *msg->err_msg_;
+}
+void MsgReply::clear_err_msg() {
+ if (GetArenaForAllocation() == nullptr && err_msg_ != nullptr) {
+ delete err_msg_;
+ }
+ err_msg_ = nullptr;
+}
+MsgReply::MsgReply(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgReply)
+}
+MsgReply::MsgReply(const MsgReply& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ if (from._internal_has_err_msg()) {
+ err_msg_ = new ::bhome_msg::ErrorMsg(*from.err_msg_);
+ } else {
+ err_msg_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgReply)
+}
+
+inline void MsgReply::SharedCtor() {
+err_msg_ = nullptr;
+}
+
+MsgReply::~MsgReply() {
+ // @@protoc_insertion_point(destructor:bhome_msg.MsgReply)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void MsgReply::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (this != internal_default_instance()) delete err_msg_;
+}
+
+void MsgReply::ArenaDtor(void* object) {
+ MsgReply* _this = reinterpret_cast< MsgReply* >(object);
+ (void)_this;
+}
+void MsgReply::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MsgReply::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void MsgReply::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgReply)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ if (GetArenaForAllocation() == nullptr && err_msg_ != nullptr) {
+ delete err_msg_;
+ }
+ err_msg_ = nullptr;
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* MsgReply::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .bhome_msg.ErrorMsg err_msg = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_err_msg(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MsgReply::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgReply)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .bhome_msg.ErrorMsg err_msg = 1;
+ if (this->_internal_has_err_msg()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::err_msg(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgReply)
+ return target;
+}
+
+size_t MsgReply::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgReply)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // .bhome_msg.ErrorMsg err_msg = 1;
+ if (this->_internal_has_err_msg()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *err_msg_);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MsgReply::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgReply*>(
+ &from));
+}
+
+void MsgReply::MergeFrom(const MsgReply& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgReply)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from._internal_has_err_msg()) {
+ _internal_mutable_err_msg()->::bhome_msg::ErrorMsg::MergeFrom(from._internal_err_msg());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MsgReply::CopyFrom(const MsgReply& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgReply)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MsgReply::IsInitialized() const {
+ return true;
+}
+
+void MsgReply::InternalSwap(MsgReply* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ swap(err_msg_, other->err_msg_);
+}
+
+std::string MsgReply::GetTypeName() const {
+ return "bhome_msg.MsgReply";
+}
+
+
+// ===================================================================
+
+class BHMsgBody::_Internal {
+ public:
+ static const ::bhome_msg::MsgRequest& request(const BHMsgBody* msg);
+ static const ::bhome_msg::MsgReply& reply(const BHMsgBody* msg);
+};
+
+const ::bhome_msg::MsgRequest&
+BHMsgBody::_Internal::request(const BHMsgBody* msg) {
+ return *msg->reqrep_.request_;
+}
+const ::bhome_msg::MsgReply&
+BHMsgBody::_Internal::reply(const BHMsgBody* msg) {
+ return *msg->reqrep_.reply_;
+}
+void BHMsgBody::set_allocated_request(::bhome_msg::MsgRequest* request) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ clear_reqrep();
+ if (request) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::bhome_msg::MsgRequest>::GetOwningArena(request);
+ if (message_arena != submessage_arena) {
+ request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, request, submessage_arena);
+ }
+ set_has_request();
+ reqrep_.request_ = request;
+ }
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.BHMsgBody.request)
+}
+void BHMsgBody::set_allocated_reply(::bhome_msg::MsgReply* reply) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ clear_reqrep();
+ if (reply) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::bhome_msg::MsgReply>::GetOwningArena(reply);
+ if (message_arena != submessage_arena) {
+ reply = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, reply, submessage_arena);
+ }
+ set_has_reply();
+ reqrep_.reply_ = reply;
+ }
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.BHMsgBody.reply)
+}
+BHMsgBody::BHMsgBody(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.BHMsgBody)
+}
+BHMsgBody::BHMsgBody(const BHMsgBody& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ clear_has_reqrep();
+ switch (from.reqrep_case()) {
+ case kRequest: {
+ _internal_mutable_request()->::bhome_msg::MsgRequest::MergeFrom(from._internal_request());
+ break;
+ }
+ case kReply: {
+ _internal_mutable_reply()->::bhome_msg::MsgReply::MergeFrom(from._internal_reply());
+ break;
+ }
+ case REQREP_NOT_SET: {
+ break;
+ }
+ }
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.BHMsgBody)
+}
+
+inline void BHMsgBody::SharedCtor() {
+clear_has_reqrep();
+}
+
+BHMsgBody::~BHMsgBody() {
+ // @@protoc_insertion_point(destructor:bhome_msg.BHMsgBody)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void BHMsgBody::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (has_reqrep()) {
+ clear_reqrep();
+ }
+}
+
+void BHMsgBody::ArenaDtor(void* object) {
+ BHMsgBody* _this = reinterpret_cast< BHMsgBody* >(object);
+ (void)_this;
+}
+void BHMsgBody::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void BHMsgBody::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void BHMsgBody::clear_reqrep() {
+// @@protoc_insertion_point(one_of_clear_start:bhome_msg.BHMsgBody)
+ switch (reqrep_case()) {
+ case kRequest: {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reqrep_.request_;
+ }
+ break;
+ }
+ case kReply: {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reqrep_.reply_;
+ }
+ break;
+ }
+ case REQREP_NOT_SET: {
+ break;
+ }
+ }
+ _oneof_case_[0] = REQREP_NOT_SET;
+}
+
+
+void BHMsgBody::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.BHMsgBody)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ clear_reqrep();
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* BHMsgBody::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .bhome_msg.MsgRequest request = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_request(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // .bhome_msg.MsgReply reply = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ ptr = ctx->ParseMessage(_internal_mutable_reply(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* BHMsgBody::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.BHMsgBody)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .bhome_msg.MsgRequest request = 1;
+ if (_internal_has_request()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::request(this), target, stream);
+ }
+
+ // .bhome_msg.MsgReply reply = 2;
+ if (_internal_has_reply()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 2, _Internal::reply(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.BHMsgBody)
+ return target;
+}
+
+size_t BHMsgBody::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.BHMsgBody)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ switch (reqrep_case()) {
+ // .bhome_msg.MsgRequest request = 1;
+ case kRequest: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *reqrep_.request_);
+ break;
+ }
+ // .bhome_msg.MsgReply reply = 2;
+ case kReply: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *reqrep_.reply_);
+ break;
+ }
+ case REQREP_NOT_SET: {
+ break;
+ }
+ }
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void BHMsgBody::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const BHMsgBody*>(
+ &from));
+}
+
+void BHMsgBody::MergeFrom(const BHMsgBody& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.BHMsgBody)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ switch (from.reqrep_case()) {
+ case kRequest: {
+ _internal_mutable_request()->::bhome_msg::MsgRequest::MergeFrom(from._internal_request());
+ break;
+ }
+ case kReply: {
+ _internal_mutable_reply()->::bhome_msg::MsgReply::MergeFrom(from._internal_reply());
+ break;
+ }
+ case REQREP_NOT_SET: {
+ break;
+ }
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void BHMsgBody::CopyFrom(const BHMsgBody& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.BHMsgBody)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool BHMsgBody::IsInitialized() const {
+ return true;
+}
+
+void BHMsgBody::InternalSwap(BHMsgBody* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ swap(reqrep_, other->reqrep_);
+ swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+std::string BHMsgBody::GetTypeName() const {
+ return "bhome_msg.BHMsgBody";
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+} // namespace bhome_msg
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::bhome_msg::BHMsgHead* Arena::CreateMaybeMessage< ::bhome_msg::BHMsgHead >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::BHMsgHead >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::MsgSubscribe* Arena::CreateMaybeMessage< ::bhome_msg::MsgSubscribe >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::MsgSubscribe >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::MsgUnsubscribe* Arena::CreateMaybeMessage< ::bhome_msg::MsgUnsubscribe >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::MsgUnsubscribe >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::MsgRegisterRPC* Arena::CreateMaybeMessage< ::bhome_msg::MsgRegisterRPC >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::MsgRegisterRPC >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::MsgProcInit* Arena::CreateMaybeMessage< ::bhome_msg::MsgProcInit >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::MsgProcInit >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::MsgProcInitReply* Arena::CreateMaybeMessage< ::bhome_msg::MsgProcInitReply >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::MsgProcInitReply >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::MsgRequest* Arena::CreateMaybeMessage< ::bhome_msg::MsgRequest >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::MsgRequest >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::MsgReply* Arena::CreateMaybeMessage< ::bhome_msg::MsgReply >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::MsgReply >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::BHMsgBody* Arena::CreateMaybeMessage< ::bhome_msg::BHMsgBody >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::BHMsgBody >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>
diff --git a/src/proto/bhome_msg.pb.h b/src/proto/bhome_msg.pb.h
new file mode 100644
index 0000000..0057ff0
--- /dev/null
+++ b/src/proto/bhome_msg.pb.h
@@ -0,0 +1,2823 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: bhome_msg.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_bhome_5fmsg_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_bhome_5fmsg_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/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/metadata_lite.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/repeated_field.h> // IWYU pragma: export
+#include <google/protobuf/extension_set.h> // IWYU pragma: export
+#include <google/protobuf/generated_enum_util.h>
+#include "bhome_msg_api.pb.h"
+#include "error_msg.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_bhome_5fmsg_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+} // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_bhome_5fmsg_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[9]
+ 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[];
+};
+namespace bhome_msg {
+class BHMsgBody;
+struct BHMsgBodyDefaultTypeInternal;
+extern BHMsgBodyDefaultTypeInternal _BHMsgBody_default_instance_;
+class BHMsgHead;
+struct BHMsgHeadDefaultTypeInternal;
+extern BHMsgHeadDefaultTypeInternal _BHMsgHead_default_instance_;
+class MsgProcInit;
+struct MsgProcInitDefaultTypeInternal;
+extern MsgProcInitDefaultTypeInternal _MsgProcInit_default_instance_;
+class MsgProcInitReply;
+struct MsgProcInitReplyDefaultTypeInternal;
+extern MsgProcInitReplyDefaultTypeInternal _MsgProcInitReply_default_instance_;
+class MsgRegisterRPC;
+struct MsgRegisterRPCDefaultTypeInternal;
+extern MsgRegisterRPCDefaultTypeInternal _MsgRegisterRPC_default_instance_;
+class MsgReply;
+struct MsgReplyDefaultTypeInternal;
+extern MsgReplyDefaultTypeInternal _MsgReply_default_instance_;
+class MsgRequest;
+struct MsgRequestDefaultTypeInternal;
+extern MsgRequestDefaultTypeInternal _MsgRequest_default_instance_;
+class MsgSubscribe;
+struct MsgSubscribeDefaultTypeInternal;
+extern MsgSubscribeDefaultTypeInternal _MsgSubscribe_default_instance_;
+class MsgUnsubscribe;
+struct MsgUnsubscribeDefaultTypeInternal;
+extern MsgUnsubscribeDefaultTypeInternal _MsgUnsubscribe_default_instance_;
+} // namespace bhome_msg
+PROTOBUF_NAMESPACE_OPEN
+template<> ::bhome_msg::BHMsgBody* Arena::CreateMaybeMessage<::bhome_msg::BHMsgBody>(Arena*);
+template<> ::bhome_msg::BHMsgHead* Arena::CreateMaybeMessage<::bhome_msg::BHMsgHead>(Arena*);
+template<> ::bhome_msg::MsgProcInit* Arena::CreateMaybeMessage<::bhome_msg::MsgProcInit>(Arena*);
+template<> ::bhome_msg::MsgProcInitReply* Arena::CreateMaybeMessage<::bhome_msg::MsgProcInitReply>(Arena*);
+template<> ::bhome_msg::MsgRegisterRPC* Arena::CreateMaybeMessage<::bhome_msg::MsgRegisterRPC>(Arena*);
+template<> ::bhome_msg::MsgReply* Arena::CreateMaybeMessage<::bhome_msg::MsgReply>(Arena*);
+template<> ::bhome_msg::MsgRequest* Arena::CreateMaybeMessage<::bhome_msg::MsgRequest>(Arena*);
+template<> ::bhome_msg::MsgSubscribe* Arena::CreateMaybeMessage<::bhome_msg::MsgSubscribe>(Arena*);
+template<> ::bhome_msg::MsgUnsubscribe* Arena::CreateMaybeMessage<::bhome_msg::MsgUnsubscribe>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace bhome_msg {
+
+enum MsgType : int {
+ kMsgTypeInvalid = 0,
+ kMsgTypeRawData = 1,
+ kMsgTypeCommonReply = 2,
+ kMsgTypeProcInit = 8,
+ kMsgTypeProcInitReply = 9,
+ kMsgTypeRegister = 10,
+ kMsgTypeHeartbeat = 12,
+ kMsgTypeQueryTopic = 14,
+ kMsgTypeQueryTopicReply = 15,
+ kMsgTypeRequestTopic = 16,
+ kMsgTypeRequestTopicReply = 17,
+ kMsgTypeRegisterRPC = 18,
+ kMsgTypePublish = 20,
+ kMsgTypeSubscribe = 22,
+ kMsgTypeUnsubscribe = 24,
+ kMsgTypeUnregister = 26,
+ kMsgTypeQueryProc = 28,
+ kMsgTypeQueryProcReply = 29,
+ MsgType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+ MsgType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool MsgType_IsValid(int value);
+constexpr MsgType MsgType_MIN = kMsgTypeInvalid;
+constexpr MsgType MsgType_MAX = kMsgTypeQueryProcReply;
+constexpr int MsgType_ARRAYSIZE = MsgType_MAX + 1;
+
+const std::string& MsgType_Name(MsgType value);
+template<typename T>
+inline const std::string& MsgType_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, MsgType>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function MsgType_Name.");
+ return MsgType_Name(static_cast<MsgType>(enum_t_value));
+}
+bool MsgType_Parse(
+ ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MsgType* value);
+// ===================================================================
+
+class BHMsgHead final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.BHMsgHead) */ {
+ public:
+ inline BHMsgHead() : BHMsgHead(nullptr) {}
+ ~BHMsgHead() override;
+ explicit constexpr BHMsgHead(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ BHMsgHead(const BHMsgHead& from);
+ BHMsgHead(BHMsgHead&& from) noexcept
+ : BHMsgHead() {
+ *this = ::std::move(from);
+ }
+
+ inline BHMsgHead& operator=(const BHMsgHead& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline BHMsgHead& operator=(BHMsgHead&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const BHMsgHead& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const BHMsgHead* internal_default_instance() {
+ return reinterpret_cast<const BHMsgHead*>(
+ &_BHMsgHead_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 0;
+
+ friend void swap(BHMsgHead& a, BHMsgHead& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(BHMsgHead* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(BHMsgHead* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline BHMsgHead* New() const final {
+ return new BHMsgHead();
+ }
+
+ BHMsgHead* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<BHMsgHead>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const BHMsgHead& from);
+ void MergeFrom(const BHMsgHead& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(BHMsgHead* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.BHMsgHead";
+ }
+ protected:
+ explicit BHMsgHead(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kRouteFieldNumber = 2,
+ kMsgIdFieldNumber = 1,
+ kProcIdFieldNumber = 6,
+ kTopicFieldNumber = 7,
+ kDestFieldNumber = 8,
+ kTimestampFieldNumber = 3,
+ kSsnIdFieldNumber = 5,
+ kTypeFieldNumber = 4,
+ };
+ // repeated .bhome_msg.BHAddress route = 2;
+ int route_size() const;
+ private:
+ int _internal_route_size() const;
+ public:
+ void clear_route();
+ ::bhome_msg::BHAddress* mutable_route(int index);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::BHAddress >*
+ mutable_route();
+ private:
+ const ::bhome_msg::BHAddress& _internal_route(int index) const;
+ ::bhome_msg::BHAddress* _internal_add_route();
+ public:
+ const ::bhome_msg::BHAddress& route(int index) const;
+ ::bhome_msg::BHAddress* add_route();
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::BHAddress >&
+ route() const;
+
+ // bytes msg_id = 1;
+ void clear_msg_id();
+ const std::string& msg_id() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_msg_id(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_msg_id();
+ PROTOBUF_MUST_USE_RESULT std::string* release_msg_id();
+ void set_allocated_msg_id(std::string* msg_id);
+ private:
+ const std::string& _internal_msg_id() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_msg_id(const std::string& value);
+ std::string* _internal_mutable_msg_id();
+ public:
+
+ // bytes proc_id = 6;
+ void clear_proc_id();
+ const std::string& proc_id() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_proc_id(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_proc_id();
+ PROTOBUF_MUST_USE_RESULT std::string* release_proc_id();
+ void set_allocated_proc_id(std::string* proc_id);
+ private:
+ const std::string& _internal_proc_id() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_proc_id(const std::string& value);
+ std::string* _internal_mutable_proc_id();
+ public:
+
+ // bytes topic = 7;
+ void clear_topic();
+ const std::string& topic() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_topic(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_topic();
+ PROTOBUF_MUST_USE_RESULT std::string* release_topic();
+ void set_allocated_topic(std::string* topic);
+ private:
+ const std::string& _internal_topic() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_topic(const std::string& value);
+ std::string* _internal_mutable_topic();
+ public:
+
+ // .bhome_msg.BHAddress dest = 8;
+ bool has_dest() const;
+ private:
+ bool _internal_has_dest() const;
+ public:
+ void clear_dest();
+ const ::bhome_msg::BHAddress& dest() const;
+ PROTOBUF_MUST_USE_RESULT ::bhome_msg::BHAddress* release_dest();
+ ::bhome_msg::BHAddress* mutable_dest();
+ void set_allocated_dest(::bhome_msg::BHAddress* dest);
+ private:
+ const ::bhome_msg::BHAddress& _internal_dest() const;
+ ::bhome_msg::BHAddress* _internal_mutable_dest();
+ public:
+ void unsafe_arena_set_allocated_dest(
+ ::bhome_msg::BHAddress* dest);
+ ::bhome_msg::BHAddress* unsafe_arena_release_dest();
+
+ // int64 timestamp = 3;
+ void clear_timestamp();
+ ::PROTOBUF_NAMESPACE_ID::int64 timestamp() const;
+ void set_timestamp(::PROTOBUF_NAMESPACE_ID::int64 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int64 _internal_timestamp() const;
+ void _internal_set_timestamp(::PROTOBUF_NAMESPACE_ID::int64 value);
+ public:
+
+ // uint64 ssn_id = 5;
+ void clear_ssn_id();
+ ::PROTOBUF_NAMESPACE_ID::uint64 ssn_id() const;
+ void set_ssn_id(::PROTOBUF_NAMESPACE_ID::uint64 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::uint64 _internal_ssn_id() const;
+ void _internal_set_ssn_id(::PROTOBUF_NAMESPACE_ID::uint64 value);
+ public:
+
+ // int32 type = 4;
+ void clear_type();
+ ::PROTOBUF_NAMESPACE_ID::int32 type() const;
+ void set_type(::PROTOBUF_NAMESPACE_ID::int32 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int32 _internal_type() const;
+ void _internal_set_type(::PROTOBUF_NAMESPACE_ID::int32 value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.BHMsgHead)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::BHAddress > route_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr msg_id_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr proc_id_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr topic_;
+ ::bhome_msg::BHAddress* dest_;
+ ::PROTOBUF_NAMESPACE_ID::int64 timestamp_;
+ ::PROTOBUF_NAMESPACE_ID::uint64 ssn_id_;
+ ::PROTOBUF_NAMESPACE_ID::int32 type_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgSubscribe final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgSubscribe) */ {
+ public:
+ inline MsgSubscribe() : MsgSubscribe(nullptr) {}
+ ~MsgSubscribe() override;
+ explicit constexpr MsgSubscribe(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ MsgSubscribe(const MsgSubscribe& from);
+ MsgSubscribe(MsgSubscribe&& from) noexcept
+ : MsgSubscribe() {
+ *this = ::std::move(from);
+ }
+
+ inline MsgSubscribe& operator=(const MsgSubscribe& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MsgSubscribe& operator=(MsgSubscribe&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const MsgSubscribe& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const MsgSubscribe* internal_default_instance() {
+ return reinterpret_cast<const MsgSubscribe*>(
+ &_MsgSubscribe_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 1;
+
+ friend void swap(MsgSubscribe& a, MsgSubscribe& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MsgSubscribe* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(MsgSubscribe* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MsgSubscribe* New() const final {
+ return new MsgSubscribe();
+ }
+
+ MsgSubscribe* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MsgSubscribe>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const MsgSubscribe& from);
+ void MergeFrom(const MsgSubscribe& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(MsgSubscribe* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.MsgSubscribe";
+ }
+ protected:
+ explicit MsgSubscribe(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kTopicsFieldNumber = 1,
+ };
+ // .bhome_msg.MsgTopicList topics = 1;
+ bool has_topics() const;
+ private:
+ bool _internal_has_topics() const;
+ public:
+ void clear_topics();
+ const ::bhome_msg::MsgTopicList& topics() const;
+ PROTOBUF_MUST_USE_RESULT ::bhome_msg::MsgTopicList* release_topics();
+ ::bhome_msg::MsgTopicList* mutable_topics();
+ void set_allocated_topics(::bhome_msg::MsgTopicList* topics);
+ private:
+ const ::bhome_msg::MsgTopicList& _internal_topics() const;
+ ::bhome_msg::MsgTopicList* _internal_mutable_topics();
+ public:
+ void unsafe_arena_set_allocated_topics(
+ ::bhome_msg::MsgTopicList* topics);
+ ::bhome_msg::MsgTopicList* unsafe_arena_release_topics();
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.MsgSubscribe)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::bhome_msg::MsgTopicList* topics_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgUnsubscribe final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgUnsubscribe) */ {
+ public:
+ inline MsgUnsubscribe() : MsgUnsubscribe(nullptr) {}
+ ~MsgUnsubscribe() override;
+ explicit constexpr MsgUnsubscribe(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ MsgUnsubscribe(const MsgUnsubscribe& from);
+ MsgUnsubscribe(MsgUnsubscribe&& from) noexcept
+ : MsgUnsubscribe() {
+ *this = ::std::move(from);
+ }
+
+ inline MsgUnsubscribe& operator=(const MsgUnsubscribe& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MsgUnsubscribe& operator=(MsgUnsubscribe&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const MsgUnsubscribe& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const MsgUnsubscribe* internal_default_instance() {
+ return reinterpret_cast<const MsgUnsubscribe*>(
+ &_MsgUnsubscribe_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 2;
+
+ friend void swap(MsgUnsubscribe& a, MsgUnsubscribe& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MsgUnsubscribe* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(MsgUnsubscribe* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MsgUnsubscribe* New() const final {
+ return new MsgUnsubscribe();
+ }
+
+ MsgUnsubscribe* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MsgUnsubscribe>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const MsgUnsubscribe& from);
+ void MergeFrom(const MsgUnsubscribe& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(MsgUnsubscribe* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.MsgUnsubscribe";
+ }
+ protected:
+ explicit MsgUnsubscribe(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kTopicsFieldNumber = 1,
+ };
+ // .bhome_msg.MsgTopicList topics = 1;
+ bool has_topics() const;
+ private:
+ bool _internal_has_topics() const;
+ public:
+ void clear_topics();
+ const ::bhome_msg::MsgTopicList& topics() const;
+ PROTOBUF_MUST_USE_RESULT ::bhome_msg::MsgTopicList* release_topics();
+ ::bhome_msg::MsgTopicList* mutable_topics();
+ void set_allocated_topics(::bhome_msg::MsgTopicList* topics);
+ private:
+ const ::bhome_msg::MsgTopicList& _internal_topics() const;
+ ::bhome_msg::MsgTopicList* _internal_mutable_topics();
+ public:
+ void unsafe_arena_set_allocated_topics(
+ ::bhome_msg::MsgTopicList* topics);
+ ::bhome_msg::MsgTopicList* unsafe_arena_release_topics();
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.MsgUnsubscribe)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::bhome_msg::MsgTopicList* topics_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgRegisterRPC final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgRegisterRPC) */ {
+ public:
+ inline MsgRegisterRPC() : MsgRegisterRPC(nullptr) {}
+ ~MsgRegisterRPC() override;
+ explicit constexpr MsgRegisterRPC(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ MsgRegisterRPC(const MsgRegisterRPC& from);
+ MsgRegisterRPC(MsgRegisterRPC&& from) noexcept
+ : MsgRegisterRPC() {
+ *this = ::std::move(from);
+ }
+
+ inline MsgRegisterRPC& operator=(const MsgRegisterRPC& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MsgRegisterRPC& operator=(MsgRegisterRPC&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const MsgRegisterRPC& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const MsgRegisterRPC* internal_default_instance() {
+ return reinterpret_cast<const MsgRegisterRPC*>(
+ &_MsgRegisterRPC_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 3;
+
+ friend void swap(MsgRegisterRPC& a, MsgRegisterRPC& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MsgRegisterRPC* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(MsgRegisterRPC* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MsgRegisterRPC* New() const final {
+ return new MsgRegisterRPC();
+ }
+
+ MsgRegisterRPC* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MsgRegisterRPC>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const MsgRegisterRPC& from);
+ void MergeFrom(const MsgRegisterRPC& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(MsgRegisterRPC* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.MsgRegisterRPC";
+ }
+ protected:
+ explicit MsgRegisterRPC(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kTopicsFieldNumber = 1,
+ };
+ // .bhome_msg.MsgTopicList topics = 1;
+ bool has_topics() const;
+ private:
+ bool _internal_has_topics() const;
+ public:
+ void clear_topics();
+ const ::bhome_msg::MsgTopicList& topics() const;
+ PROTOBUF_MUST_USE_RESULT ::bhome_msg::MsgTopicList* release_topics();
+ ::bhome_msg::MsgTopicList* mutable_topics();
+ void set_allocated_topics(::bhome_msg::MsgTopicList* topics);
+ private:
+ const ::bhome_msg::MsgTopicList& _internal_topics() const;
+ ::bhome_msg::MsgTopicList* _internal_mutable_topics();
+ public:
+ void unsafe_arena_set_allocated_topics(
+ ::bhome_msg::MsgTopicList* topics);
+ ::bhome_msg::MsgTopicList* unsafe_arena_release_topics();
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.MsgRegisterRPC)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::bhome_msg::MsgTopicList* topics_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgProcInit final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgProcInit) */ {
+ public:
+ inline MsgProcInit() : MsgProcInit(nullptr) {}
+ ~MsgProcInit() override;
+ explicit constexpr MsgProcInit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ MsgProcInit(const MsgProcInit& from);
+ MsgProcInit(MsgProcInit&& from) noexcept
+ : MsgProcInit() {
+ *this = ::std::move(from);
+ }
+
+ inline MsgProcInit& operator=(const MsgProcInit& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MsgProcInit& operator=(MsgProcInit&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const MsgProcInit& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const MsgProcInit* internal_default_instance() {
+ return reinterpret_cast<const MsgProcInit*>(
+ &_MsgProcInit_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 4;
+
+ friend void swap(MsgProcInit& a, MsgProcInit& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MsgProcInit* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(MsgProcInit* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MsgProcInit* New() const final {
+ return new MsgProcInit();
+ }
+
+ MsgProcInit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MsgProcInit>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const MsgProcInit& from);
+ void MergeFrom(const MsgProcInit& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(MsgProcInit* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.MsgProcInit";
+ }
+ protected:
+ explicit MsgProcInit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kExtraMqNumFieldNumber = 1,
+ };
+ // int32 extra_mq_num = 1;
+ void clear_extra_mq_num();
+ ::PROTOBUF_NAMESPACE_ID::int32 extra_mq_num() const;
+ void set_extra_mq_num(::PROTOBUF_NAMESPACE_ID::int32 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int32 _internal_extra_mq_num() const;
+ void _internal_set_extra_mq_num(::PROTOBUF_NAMESPACE_ID::int32 value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.MsgProcInit)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::int32 extra_mq_num_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgProcInitReply final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgProcInitReply) */ {
+ public:
+ inline MsgProcInitReply() : MsgProcInitReply(nullptr) {}
+ ~MsgProcInitReply() override;
+ explicit constexpr MsgProcInitReply(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ MsgProcInitReply(const MsgProcInitReply& from);
+ MsgProcInitReply(MsgProcInitReply&& from) noexcept
+ : MsgProcInitReply() {
+ *this = ::std::move(from);
+ }
+
+ inline MsgProcInitReply& operator=(const MsgProcInitReply& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MsgProcInitReply& operator=(MsgProcInitReply&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const MsgProcInitReply& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const MsgProcInitReply* internal_default_instance() {
+ return reinterpret_cast<const MsgProcInitReply*>(
+ &_MsgProcInitReply_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 5;
+
+ friend void swap(MsgProcInitReply& a, MsgProcInitReply& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MsgProcInitReply* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(MsgProcInitReply* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MsgProcInitReply* New() const final {
+ return new MsgProcInitReply();
+ }
+
+ MsgProcInitReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MsgProcInitReply>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const MsgProcInitReply& from);
+ void MergeFrom(const MsgProcInitReply& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(MsgProcInitReply* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.MsgProcInitReply";
+ }
+ protected:
+ explicit MsgProcInitReply(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kExtraMqsFieldNumber = 3,
+ kErrmsgFieldNumber = 1,
+ kProcIndexFieldNumber = 2,
+ };
+ // repeated .bhome_msg.BHAddress extra_mqs = 3;
+ int extra_mqs_size() const;
+ private:
+ int _internal_extra_mqs_size() const;
+ public:
+ void clear_extra_mqs();
+ ::bhome_msg::BHAddress* mutable_extra_mqs(int index);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::BHAddress >*
+ mutable_extra_mqs();
+ private:
+ const ::bhome_msg::BHAddress& _internal_extra_mqs(int index) const;
+ ::bhome_msg::BHAddress* _internal_add_extra_mqs();
+ public:
+ const ::bhome_msg::BHAddress& extra_mqs(int index) const;
+ ::bhome_msg::BHAddress* add_extra_mqs();
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::BHAddress >&
+ extra_mqs() const;
+
+ // .bhome_msg.ErrorMsg errmsg = 1;
+ bool has_errmsg() const;
+ private:
+ bool _internal_has_errmsg() const;
+ public:
+ void clear_errmsg();
+ const ::bhome_msg::ErrorMsg& errmsg() const;
+ PROTOBUF_MUST_USE_RESULT ::bhome_msg::ErrorMsg* release_errmsg();
+ ::bhome_msg::ErrorMsg* mutable_errmsg();
+ void set_allocated_errmsg(::bhome_msg::ErrorMsg* errmsg);
+ private:
+ const ::bhome_msg::ErrorMsg& _internal_errmsg() const;
+ ::bhome_msg::ErrorMsg* _internal_mutable_errmsg();
+ public:
+ void unsafe_arena_set_allocated_errmsg(
+ ::bhome_msg::ErrorMsg* errmsg);
+ ::bhome_msg::ErrorMsg* unsafe_arena_release_errmsg();
+
+ // int32 proc_index = 2;
+ void clear_proc_index();
+ ::PROTOBUF_NAMESPACE_ID::int32 proc_index() const;
+ void set_proc_index(::PROTOBUF_NAMESPACE_ID::int32 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int32 _internal_proc_index() const;
+ void _internal_set_proc_index(::PROTOBUF_NAMESPACE_ID::int32 value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.MsgProcInitReply)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::BHAddress > extra_mqs_;
+ ::bhome_msg::ErrorMsg* errmsg_;
+ ::PROTOBUF_NAMESPACE_ID::int32 proc_index_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgRequest final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgRequest) */ {
+ public:
+ inline MsgRequest() : MsgRequest(nullptr) {}
+ ~MsgRequest() override;
+ explicit constexpr MsgRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ MsgRequest(const MsgRequest& from);
+ MsgRequest(MsgRequest&& from) noexcept
+ : MsgRequest() {
+ *this = ::std::move(from);
+ }
+
+ inline MsgRequest& operator=(const MsgRequest& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MsgRequest& operator=(MsgRequest&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const MsgRequest& default_instance() {
+ return *internal_default_instance();
+ }
+ enum RequestCase {
+ kRegister = 1,
+ kTopicRequest = 2,
+ kTopicQuery = 3,
+ REQUEST_NOT_SET = 0,
+ };
+
+ static inline const MsgRequest* internal_default_instance() {
+ return reinterpret_cast<const MsgRequest*>(
+ &_MsgRequest_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 6;
+
+ friend void swap(MsgRequest& a, MsgRequest& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MsgRequest* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(MsgRequest* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MsgRequest* New() const final {
+ return new MsgRequest();
+ }
+
+ MsgRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MsgRequest>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const MsgRequest& from);
+ void MergeFrom(const MsgRequest& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(MsgRequest* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.MsgRequest";
+ }
+ protected:
+ explicit MsgRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kRegisterFieldNumber = 1,
+ kTopicRequestFieldNumber = 2,
+ kTopicQueryFieldNumber = 3,
+ };
+ // .bhome_msg.MsgRegister register = 1;
+ bool has_register_() const;
+ private:
+ bool _internal_has_register_() const;
+ public:
+ void clear_register_();
+ const ::bhome_msg::MsgRegister& register_() const;
+ PROTOBUF_MUST_USE_RESULT ::bhome_msg::MsgRegister* release_register_();
+ ::bhome_msg::MsgRegister* mutable_register_();
+ void set_allocated_register_(::bhome_msg::MsgRegister* register_);
+ private:
+ const ::bhome_msg::MsgRegister& _internal_register_() const;
+ ::bhome_msg::MsgRegister* _internal_mutable_register_();
+ public:
+ void unsafe_arena_set_allocated_register_(
+ ::bhome_msg::MsgRegister* register_);
+ ::bhome_msg::MsgRegister* unsafe_arena_release_register_();
+
+ // .bhome_msg.MsgRequestTopic topic_request = 2;
+ bool has_topic_request() const;
+ private:
+ bool _internal_has_topic_request() const;
+ public:
+ void clear_topic_request();
+ const ::bhome_msg::MsgRequestTopic& topic_request() const;
+ PROTOBUF_MUST_USE_RESULT ::bhome_msg::MsgRequestTopic* release_topic_request();
+ ::bhome_msg::MsgRequestTopic* mutable_topic_request();
+ void set_allocated_topic_request(::bhome_msg::MsgRequestTopic* topic_request);
+ private:
+ const ::bhome_msg::MsgRequestTopic& _internal_topic_request() const;
+ ::bhome_msg::MsgRequestTopic* _internal_mutable_topic_request();
+ public:
+ void unsafe_arena_set_allocated_topic_request(
+ ::bhome_msg::MsgRequestTopic* topic_request);
+ ::bhome_msg::MsgRequestTopic* unsafe_arena_release_topic_request();
+
+ // .bhome_msg.MsgQueryTopic topic_query = 3;
+ bool has_topic_query() const;
+ private:
+ bool _internal_has_topic_query() const;
+ public:
+ void clear_topic_query();
+ const ::bhome_msg::MsgQueryTopic& topic_query() const;
+ PROTOBUF_MUST_USE_RESULT ::bhome_msg::MsgQueryTopic* release_topic_query();
+ ::bhome_msg::MsgQueryTopic* mutable_topic_query();
+ void set_allocated_topic_query(::bhome_msg::MsgQueryTopic* topic_query);
+ private:
+ const ::bhome_msg::MsgQueryTopic& _internal_topic_query() const;
+ ::bhome_msg::MsgQueryTopic* _internal_mutable_topic_query();
+ public:
+ void unsafe_arena_set_allocated_topic_query(
+ ::bhome_msg::MsgQueryTopic* topic_query);
+ ::bhome_msg::MsgQueryTopic* unsafe_arena_release_topic_query();
+
+ void clear_request();
+ RequestCase request_case() const;
+ // @@protoc_insertion_point(class_scope:bhome_msg.MsgRequest)
+ private:
+ class _Internal;
+ void set_has_register_();
+ void set_has_topic_request();
+ void set_has_topic_query();
+
+ inline bool has_request() const;
+ inline void clear_has_request();
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ union RequestUnion {
+ constexpr RequestUnion() : _constinit_{} {}
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+ ::bhome_msg::MsgRegister* register__;
+ ::bhome_msg::MsgRequestTopic* topic_request_;
+ ::bhome_msg::MsgQueryTopic* topic_query_;
+ } request_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
+ friend struct ::TableStruct_bhome_5fmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgReply final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgReply) */ {
+ public:
+ inline MsgReply() : MsgReply(nullptr) {}
+ ~MsgReply() override;
+ explicit constexpr MsgReply(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ MsgReply(const MsgReply& from);
+ MsgReply(MsgReply&& from) noexcept
+ : MsgReply() {
+ *this = ::std::move(from);
+ }
+
+ inline MsgReply& operator=(const MsgReply& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MsgReply& operator=(MsgReply&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const MsgReply& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const MsgReply* internal_default_instance() {
+ return reinterpret_cast<const MsgReply*>(
+ &_MsgReply_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 7;
+
+ friend void swap(MsgReply& a, MsgReply& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MsgReply* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(MsgReply* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MsgReply* New() const final {
+ return new MsgReply();
+ }
+
+ MsgReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MsgReply>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const MsgReply& from);
+ void MergeFrom(const MsgReply& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(MsgReply* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.MsgReply";
+ }
+ protected:
+ explicit MsgReply(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kErrMsgFieldNumber = 1,
+ };
+ // .bhome_msg.ErrorMsg err_msg = 1;
+ bool has_err_msg() const;
+ private:
+ bool _internal_has_err_msg() const;
+ public:
+ void clear_err_msg();
+ const ::bhome_msg::ErrorMsg& err_msg() const;
+ PROTOBUF_MUST_USE_RESULT ::bhome_msg::ErrorMsg* release_err_msg();
+ ::bhome_msg::ErrorMsg* mutable_err_msg();
+ void set_allocated_err_msg(::bhome_msg::ErrorMsg* err_msg);
+ private:
+ const ::bhome_msg::ErrorMsg& _internal_err_msg() const;
+ ::bhome_msg::ErrorMsg* _internal_mutable_err_msg();
+ public:
+ void unsafe_arena_set_allocated_err_msg(
+ ::bhome_msg::ErrorMsg* err_msg);
+ ::bhome_msg::ErrorMsg* unsafe_arena_release_err_msg();
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.MsgReply)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::bhome_msg::ErrorMsg* err_msg_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_2eproto;
+};
+// -------------------------------------------------------------------
+
+class BHMsgBody final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.BHMsgBody) */ {
+ public:
+ inline BHMsgBody() : BHMsgBody(nullptr) {}
+ ~BHMsgBody() override;
+ explicit constexpr BHMsgBody(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ BHMsgBody(const BHMsgBody& from);
+ BHMsgBody(BHMsgBody&& from) noexcept
+ : BHMsgBody() {
+ *this = ::std::move(from);
+ }
+
+ inline BHMsgBody& operator=(const BHMsgBody& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline BHMsgBody& operator=(BHMsgBody&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const BHMsgBody& default_instance() {
+ return *internal_default_instance();
+ }
+ enum ReqrepCase {
+ kRequest = 1,
+ kReply = 2,
+ REQREP_NOT_SET = 0,
+ };
+
+ static inline const BHMsgBody* internal_default_instance() {
+ return reinterpret_cast<const BHMsgBody*>(
+ &_BHMsgBody_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 8;
+
+ friend void swap(BHMsgBody& a, BHMsgBody& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(BHMsgBody* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(BHMsgBody* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline BHMsgBody* New() const final {
+ return new BHMsgBody();
+ }
+
+ BHMsgBody* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<BHMsgBody>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const BHMsgBody& from);
+ void MergeFrom(const BHMsgBody& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(BHMsgBody* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.BHMsgBody";
+ }
+ protected:
+ explicit BHMsgBody(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kRequestFieldNumber = 1,
+ kReplyFieldNumber = 2,
+ };
+ // .bhome_msg.MsgRequest request = 1;
+ bool has_request() const;
+ private:
+ bool _internal_has_request() const;
+ public:
+ void clear_request();
+ const ::bhome_msg::MsgRequest& request() const;
+ PROTOBUF_MUST_USE_RESULT ::bhome_msg::MsgRequest* release_request();
+ ::bhome_msg::MsgRequest* mutable_request();
+ void set_allocated_request(::bhome_msg::MsgRequest* request);
+ private:
+ const ::bhome_msg::MsgRequest& _internal_request() const;
+ ::bhome_msg::MsgRequest* _internal_mutable_request();
+ public:
+ void unsafe_arena_set_allocated_request(
+ ::bhome_msg::MsgRequest* request);
+ ::bhome_msg::MsgRequest* unsafe_arena_release_request();
+
+ // .bhome_msg.MsgReply reply = 2;
+ bool has_reply() const;
+ private:
+ bool _internal_has_reply() const;
+ public:
+ void clear_reply();
+ const ::bhome_msg::MsgReply& reply() const;
+ PROTOBUF_MUST_USE_RESULT ::bhome_msg::MsgReply* release_reply();
+ ::bhome_msg::MsgReply* mutable_reply();
+ void set_allocated_reply(::bhome_msg::MsgReply* reply);
+ private:
+ const ::bhome_msg::MsgReply& _internal_reply() const;
+ ::bhome_msg::MsgReply* _internal_mutable_reply();
+ public:
+ void unsafe_arena_set_allocated_reply(
+ ::bhome_msg::MsgReply* reply);
+ ::bhome_msg::MsgReply* unsafe_arena_release_reply();
+
+ void clear_reqrep();
+ ReqrepCase reqrep_case() const;
+ // @@protoc_insertion_point(class_scope:bhome_msg.BHMsgBody)
+ private:
+ class _Internal;
+ void set_has_request();
+ void set_has_reply();
+
+ inline bool has_reqrep() const;
+ inline void clear_has_reqrep();
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ union ReqrepUnion {
+ constexpr ReqrepUnion() : _constinit_{} {}
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+ ::bhome_msg::MsgRequest* request_;
+ ::bhome_msg::MsgReply* reply_;
+ } reqrep_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
+ friend struct ::TableStruct_bhome_5fmsg_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+ #pragma GCC diagnostic push
+ #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif // __GNUC__
+// BHMsgHead
+
+// bytes msg_id = 1;
+inline void BHMsgHead::clear_msg_id() {
+ msg_id_.ClearToEmpty();
+}
+inline const std::string& BHMsgHead::msg_id() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.BHMsgHead.msg_id)
+ return _internal_msg_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void BHMsgHead::set_msg_id(ArgT0&& arg0, ArgT... args) {
+
+ msg_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:bhome_msg.BHMsgHead.msg_id)
+}
+inline std::string* BHMsgHead::mutable_msg_id() {
+ std::string* _s = _internal_mutable_msg_id();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.BHMsgHead.msg_id)
+ return _s;
+}
+inline const std::string& BHMsgHead::_internal_msg_id() const {
+ return msg_id_.Get();
+}
+inline void BHMsgHead::_internal_set_msg_id(const std::string& value) {
+
+ msg_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* BHMsgHead::_internal_mutable_msg_id() {
+
+ return msg_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* BHMsgHead::release_msg_id() {
+ // @@protoc_insertion_point(field_release:bhome_msg.BHMsgHead.msg_id)
+ return msg_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void BHMsgHead::set_allocated_msg_id(std::string* msg_id) {
+ if (msg_id != nullptr) {
+
+ } else {
+
+ }
+ msg_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), msg_id,
+ GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.BHMsgHead.msg_id)
+}
+
+// repeated .bhome_msg.BHAddress route = 2;
+inline int BHMsgHead::_internal_route_size() const {
+ return route_.size();
+}
+inline int BHMsgHead::route_size() const {
+ return _internal_route_size();
+}
+inline ::bhome_msg::BHAddress* BHMsgHead::mutable_route(int index) {
+ // @@protoc_insertion_point(field_mutable:bhome_msg.BHMsgHead.route)
+ return route_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::BHAddress >*
+BHMsgHead::mutable_route() {
+ // @@protoc_insertion_point(field_mutable_list:bhome_msg.BHMsgHead.route)
+ return &route_;
+}
+inline const ::bhome_msg::BHAddress& BHMsgHead::_internal_route(int index) const {
+ return route_.Get(index);
+}
+inline const ::bhome_msg::BHAddress& BHMsgHead::route(int index) const {
+ // @@protoc_insertion_point(field_get:bhome_msg.BHMsgHead.route)
+ return _internal_route(index);
+}
+inline ::bhome_msg::BHAddress* BHMsgHead::_internal_add_route() {
+ return route_.Add();
+}
+inline ::bhome_msg::BHAddress* BHMsgHead::add_route() {
+ ::bhome_msg::BHAddress* _add = _internal_add_route();
+ // @@protoc_insertion_point(field_add:bhome_msg.BHMsgHead.route)
+ return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::BHAddress >&
+BHMsgHead::route() const {
+ // @@protoc_insertion_point(field_list:bhome_msg.BHMsgHead.route)
+ return route_;
+}
+
+// int64 timestamp = 3;
+inline void BHMsgHead::clear_timestamp() {
+ timestamp_ = int64_t{0};
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 BHMsgHead::_internal_timestamp() const {
+ return timestamp_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 BHMsgHead::timestamp() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.BHMsgHead.timestamp)
+ return _internal_timestamp();
+}
+inline void BHMsgHead::_internal_set_timestamp(::PROTOBUF_NAMESPACE_ID::int64 value) {
+
+ timestamp_ = value;
+}
+inline void BHMsgHead::set_timestamp(::PROTOBUF_NAMESPACE_ID::int64 value) {
+ _internal_set_timestamp(value);
+ // @@protoc_insertion_point(field_set:bhome_msg.BHMsgHead.timestamp)
+}
+
+// int32 type = 4;
+inline void BHMsgHead::clear_type() {
+ type_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 BHMsgHead::_internal_type() const {
+ return type_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 BHMsgHead::type() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.BHMsgHead.type)
+ return _internal_type();
+}
+inline void BHMsgHead::_internal_set_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
+
+ type_ = value;
+}
+inline void BHMsgHead::set_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
+ _internal_set_type(value);
+ // @@protoc_insertion_point(field_set:bhome_msg.BHMsgHead.type)
+}
+
+// uint64 ssn_id = 5;
+inline void BHMsgHead::clear_ssn_id() {
+ ssn_id_ = uint64_t{0u};
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 BHMsgHead::_internal_ssn_id() const {
+ return ssn_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 BHMsgHead::ssn_id() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.BHMsgHead.ssn_id)
+ return _internal_ssn_id();
+}
+inline void BHMsgHead::_internal_set_ssn_id(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+
+ ssn_id_ = value;
+}
+inline void BHMsgHead::set_ssn_id(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+ _internal_set_ssn_id(value);
+ // @@protoc_insertion_point(field_set:bhome_msg.BHMsgHead.ssn_id)
+}
+
+// bytes proc_id = 6;
+inline void BHMsgHead::clear_proc_id() {
+ proc_id_.ClearToEmpty();
+}
+inline const std::string& BHMsgHead::proc_id() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.BHMsgHead.proc_id)
+ return _internal_proc_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void BHMsgHead::set_proc_id(ArgT0&& arg0, ArgT... args) {
+
+ proc_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:bhome_msg.BHMsgHead.proc_id)
+}
+inline std::string* BHMsgHead::mutable_proc_id() {
+ std::string* _s = _internal_mutable_proc_id();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.BHMsgHead.proc_id)
+ return _s;
+}
+inline const std::string& BHMsgHead::_internal_proc_id() const {
+ return proc_id_.Get();
+}
+inline void BHMsgHead::_internal_set_proc_id(const std::string& value) {
+
+ proc_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* BHMsgHead::_internal_mutable_proc_id() {
+
+ return proc_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* BHMsgHead::release_proc_id() {
+ // @@protoc_insertion_point(field_release:bhome_msg.BHMsgHead.proc_id)
+ return proc_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void BHMsgHead::set_allocated_proc_id(std::string* proc_id) {
+ if (proc_id != nullptr) {
+
+ } else {
+
+ }
+ proc_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), proc_id,
+ GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.BHMsgHead.proc_id)
+}
+
+// bytes topic = 7;
+inline void BHMsgHead::clear_topic() {
+ topic_.ClearToEmpty();
+}
+inline const std::string& BHMsgHead::topic() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.BHMsgHead.topic)
+ return _internal_topic();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void BHMsgHead::set_topic(ArgT0&& arg0, ArgT... args) {
+
+ topic_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:bhome_msg.BHMsgHead.topic)
+}
+inline std::string* BHMsgHead::mutable_topic() {
+ std::string* _s = _internal_mutable_topic();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.BHMsgHead.topic)
+ return _s;
+}
+inline const std::string& BHMsgHead::_internal_topic() const {
+ return topic_.Get();
+}
+inline void BHMsgHead::_internal_set_topic(const std::string& value) {
+
+ topic_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* BHMsgHead::_internal_mutable_topic() {
+
+ return topic_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* BHMsgHead::release_topic() {
+ // @@protoc_insertion_point(field_release:bhome_msg.BHMsgHead.topic)
+ return topic_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void BHMsgHead::set_allocated_topic(std::string* topic) {
+ if (topic != nullptr) {
+
+ } else {
+
+ }
+ topic_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), topic,
+ GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.BHMsgHead.topic)
+}
+
+// .bhome_msg.BHAddress dest = 8;
+inline bool BHMsgHead::_internal_has_dest() const {
+ return this != internal_default_instance() && dest_ != nullptr;
+}
+inline bool BHMsgHead::has_dest() const {
+ return _internal_has_dest();
+}
+inline const ::bhome_msg::BHAddress& BHMsgHead::_internal_dest() const {
+ const ::bhome_msg::BHAddress* p = dest_;
+ return p != nullptr ? *p : reinterpret_cast<const ::bhome_msg::BHAddress&>(
+ ::bhome_msg::_BHAddress_default_instance_);
+}
+inline const ::bhome_msg::BHAddress& BHMsgHead::dest() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.BHMsgHead.dest)
+ return _internal_dest();
+}
+inline void BHMsgHead::unsafe_arena_set_allocated_dest(
+ ::bhome_msg::BHAddress* dest) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dest_);
+ }
+ dest_ = dest;
+ if (dest) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:bhome_msg.BHMsgHead.dest)
+}
+inline ::bhome_msg::BHAddress* BHMsgHead::release_dest() {
+
+ ::bhome_msg::BHAddress* temp = dest_;
+ dest_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::bhome_msg::BHAddress* BHMsgHead::unsafe_arena_release_dest() {
+ // @@protoc_insertion_point(field_release:bhome_msg.BHMsgHead.dest)
+
+ ::bhome_msg::BHAddress* temp = dest_;
+ dest_ = nullptr;
+ return temp;
+}
+inline ::bhome_msg::BHAddress* BHMsgHead::_internal_mutable_dest() {
+
+ if (dest_ == nullptr) {
+ auto* p = CreateMaybeMessage<::bhome_msg::BHAddress>(GetArenaForAllocation());
+ dest_ = p;
+ }
+ return dest_;
+}
+inline ::bhome_msg::BHAddress* BHMsgHead::mutable_dest() {
+ ::bhome_msg::BHAddress* _msg = _internal_mutable_dest();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.BHMsgHead.dest)
+ return _msg;
+}
+inline void BHMsgHead::set_allocated_dest(::bhome_msg::BHAddress* dest) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(dest_);
+ }
+ if (dest) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+ ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+ reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dest));
+ if (message_arena != submessage_arena) {
+ dest = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, dest, submessage_arena);
+ }
+
+ } else {
+
+ }
+ dest_ = dest;
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.BHMsgHead.dest)
+}
+
+// -------------------------------------------------------------------
+
+// MsgSubscribe
+
+// .bhome_msg.MsgTopicList topics = 1;
+inline bool MsgSubscribe::_internal_has_topics() const {
+ return this != internal_default_instance() && topics_ != nullptr;
+}
+inline bool MsgSubscribe::has_topics() const {
+ return _internal_has_topics();
+}
+inline const ::bhome_msg::MsgTopicList& MsgSubscribe::_internal_topics() const {
+ const ::bhome_msg::MsgTopicList* p = topics_;
+ return p != nullptr ? *p : reinterpret_cast<const ::bhome_msg::MsgTopicList&>(
+ ::bhome_msg::_MsgTopicList_default_instance_);
+}
+inline const ::bhome_msg::MsgTopicList& MsgSubscribe::topics() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgSubscribe.topics)
+ return _internal_topics();
+}
+inline void MsgSubscribe::unsafe_arena_set_allocated_topics(
+ ::bhome_msg::MsgTopicList* topics) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(topics_);
+ }
+ topics_ = topics;
+ if (topics) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:bhome_msg.MsgSubscribe.topics)
+}
+inline ::bhome_msg::MsgTopicList* MsgSubscribe::release_topics() {
+
+ ::bhome_msg::MsgTopicList* temp = topics_;
+ topics_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::bhome_msg::MsgTopicList* MsgSubscribe::unsafe_arena_release_topics() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgSubscribe.topics)
+
+ ::bhome_msg::MsgTopicList* temp = topics_;
+ topics_ = nullptr;
+ return temp;
+}
+inline ::bhome_msg::MsgTopicList* MsgSubscribe::_internal_mutable_topics() {
+
+ if (topics_ == nullptr) {
+ auto* p = CreateMaybeMessage<::bhome_msg::MsgTopicList>(GetArenaForAllocation());
+ topics_ = p;
+ }
+ return topics_;
+}
+inline ::bhome_msg::MsgTopicList* MsgSubscribe::mutable_topics() {
+ ::bhome_msg::MsgTopicList* _msg = _internal_mutable_topics();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgSubscribe.topics)
+ return _msg;
+}
+inline void MsgSubscribe::set_allocated_topics(::bhome_msg::MsgTopicList* topics) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(topics_);
+ }
+ if (topics) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+ ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+ reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(topics));
+ if (message_arena != submessage_arena) {
+ topics = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, topics, submessage_arena);
+ }
+
+ } else {
+
+ }
+ topics_ = topics;
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgSubscribe.topics)
+}
+
+// -------------------------------------------------------------------
+
+// MsgUnsubscribe
+
+// .bhome_msg.MsgTopicList topics = 1;
+inline bool MsgUnsubscribe::_internal_has_topics() const {
+ return this != internal_default_instance() && topics_ != nullptr;
+}
+inline bool MsgUnsubscribe::has_topics() const {
+ return _internal_has_topics();
+}
+inline const ::bhome_msg::MsgTopicList& MsgUnsubscribe::_internal_topics() const {
+ const ::bhome_msg::MsgTopicList* p = topics_;
+ return p != nullptr ? *p : reinterpret_cast<const ::bhome_msg::MsgTopicList&>(
+ ::bhome_msg::_MsgTopicList_default_instance_);
+}
+inline const ::bhome_msg::MsgTopicList& MsgUnsubscribe::topics() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgUnsubscribe.topics)
+ return _internal_topics();
+}
+inline void MsgUnsubscribe::unsafe_arena_set_allocated_topics(
+ ::bhome_msg::MsgTopicList* topics) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(topics_);
+ }
+ topics_ = topics;
+ if (topics) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:bhome_msg.MsgUnsubscribe.topics)
+}
+inline ::bhome_msg::MsgTopicList* MsgUnsubscribe::release_topics() {
+
+ ::bhome_msg::MsgTopicList* temp = topics_;
+ topics_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::bhome_msg::MsgTopicList* MsgUnsubscribe::unsafe_arena_release_topics() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgUnsubscribe.topics)
+
+ ::bhome_msg::MsgTopicList* temp = topics_;
+ topics_ = nullptr;
+ return temp;
+}
+inline ::bhome_msg::MsgTopicList* MsgUnsubscribe::_internal_mutable_topics() {
+
+ if (topics_ == nullptr) {
+ auto* p = CreateMaybeMessage<::bhome_msg::MsgTopicList>(GetArenaForAllocation());
+ topics_ = p;
+ }
+ return topics_;
+}
+inline ::bhome_msg::MsgTopicList* MsgUnsubscribe::mutable_topics() {
+ ::bhome_msg::MsgTopicList* _msg = _internal_mutable_topics();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgUnsubscribe.topics)
+ return _msg;
+}
+inline void MsgUnsubscribe::set_allocated_topics(::bhome_msg::MsgTopicList* topics) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(topics_);
+ }
+ if (topics) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+ ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+ reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(topics));
+ if (message_arena != submessage_arena) {
+ topics = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, topics, submessage_arena);
+ }
+
+ } else {
+
+ }
+ topics_ = topics;
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgUnsubscribe.topics)
+}
+
+// -------------------------------------------------------------------
+
+// MsgRegisterRPC
+
+// .bhome_msg.MsgTopicList topics = 1;
+inline bool MsgRegisterRPC::_internal_has_topics() const {
+ return this != internal_default_instance() && topics_ != nullptr;
+}
+inline bool MsgRegisterRPC::has_topics() const {
+ return _internal_has_topics();
+}
+inline const ::bhome_msg::MsgTopicList& MsgRegisterRPC::_internal_topics() const {
+ const ::bhome_msg::MsgTopicList* p = topics_;
+ return p != nullptr ? *p : reinterpret_cast<const ::bhome_msg::MsgTopicList&>(
+ ::bhome_msg::_MsgTopicList_default_instance_);
+}
+inline const ::bhome_msg::MsgTopicList& MsgRegisterRPC::topics() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgRegisterRPC.topics)
+ return _internal_topics();
+}
+inline void MsgRegisterRPC::unsafe_arena_set_allocated_topics(
+ ::bhome_msg::MsgTopicList* topics) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(topics_);
+ }
+ topics_ = topics;
+ if (topics) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:bhome_msg.MsgRegisterRPC.topics)
+}
+inline ::bhome_msg::MsgTopicList* MsgRegisterRPC::release_topics() {
+
+ ::bhome_msg::MsgTopicList* temp = topics_;
+ topics_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::bhome_msg::MsgTopicList* MsgRegisterRPC::unsafe_arena_release_topics() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgRegisterRPC.topics)
+
+ ::bhome_msg::MsgTopicList* temp = topics_;
+ topics_ = nullptr;
+ return temp;
+}
+inline ::bhome_msg::MsgTopicList* MsgRegisterRPC::_internal_mutable_topics() {
+
+ if (topics_ == nullptr) {
+ auto* p = CreateMaybeMessage<::bhome_msg::MsgTopicList>(GetArenaForAllocation());
+ topics_ = p;
+ }
+ return topics_;
+}
+inline ::bhome_msg::MsgTopicList* MsgRegisterRPC::mutable_topics() {
+ ::bhome_msg::MsgTopicList* _msg = _internal_mutable_topics();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgRegisterRPC.topics)
+ return _msg;
+}
+inline void MsgRegisterRPC::set_allocated_topics(::bhome_msg::MsgTopicList* topics) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(topics_);
+ }
+ if (topics) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+ ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+ reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(topics));
+ if (message_arena != submessage_arena) {
+ topics = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, topics, submessage_arena);
+ }
+
+ } else {
+
+ }
+ topics_ = topics;
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgRegisterRPC.topics)
+}
+
+// -------------------------------------------------------------------
+
+// MsgProcInit
+
+// int32 extra_mq_num = 1;
+inline void MsgProcInit::clear_extra_mq_num() {
+ extra_mq_num_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 MsgProcInit::_internal_extra_mq_num() const {
+ return extra_mq_num_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 MsgProcInit::extra_mq_num() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgProcInit.extra_mq_num)
+ return _internal_extra_mq_num();
+}
+inline void MsgProcInit::_internal_set_extra_mq_num(::PROTOBUF_NAMESPACE_ID::int32 value) {
+
+ extra_mq_num_ = value;
+}
+inline void MsgProcInit::set_extra_mq_num(::PROTOBUF_NAMESPACE_ID::int32 value) {
+ _internal_set_extra_mq_num(value);
+ // @@protoc_insertion_point(field_set:bhome_msg.MsgProcInit.extra_mq_num)
+}
+
+// -------------------------------------------------------------------
+
+// MsgProcInitReply
+
+// .bhome_msg.ErrorMsg errmsg = 1;
+inline bool MsgProcInitReply::_internal_has_errmsg() const {
+ return this != internal_default_instance() && errmsg_ != nullptr;
+}
+inline bool MsgProcInitReply::has_errmsg() const {
+ return _internal_has_errmsg();
+}
+inline const ::bhome_msg::ErrorMsg& MsgProcInitReply::_internal_errmsg() const {
+ const ::bhome_msg::ErrorMsg* p = errmsg_;
+ return p != nullptr ? *p : reinterpret_cast<const ::bhome_msg::ErrorMsg&>(
+ ::bhome_msg::_ErrorMsg_default_instance_);
+}
+inline const ::bhome_msg::ErrorMsg& MsgProcInitReply::errmsg() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgProcInitReply.errmsg)
+ return _internal_errmsg();
+}
+inline void MsgProcInitReply::unsafe_arena_set_allocated_errmsg(
+ ::bhome_msg::ErrorMsg* errmsg) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(errmsg_);
+ }
+ errmsg_ = errmsg;
+ if (errmsg) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:bhome_msg.MsgProcInitReply.errmsg)
+}
+inline ::bhome_msg::ErrorMsg* MsgProcInitReply::release_errmsg() {
+
+ ::bhome_msg::ErrorMsg* temp = errmsg_;
+ errmsg_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::bhome_msg::ErrorMsg* MsgProcInitReply::unsafe_arena_release_errmsg() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgProcInitReply.errmsg)
+
+ ::bhome_msg::ErrorMsg* temp = errmsg_;
+ errmsg_ = nullptr;
+ return temp;
+}
+inline ::bhome_msg::ErrorMsg* MsgProcInitReply::_internal_mutable_errmsg() {
+
+ if (errmsg_ == nullptr) {
+ auto* p = CreateMaybeMessage<::bhome_msg::ErrorMsg>(GetArenaForAllocation());
+ errmsg_ = p;
+ }
+ return errmsg_;
+}
+inline ::bhome_msg::ErrorMsg* MsgProcInitReply::mutable_errmsg() {
+ ::bhome_msg::ErrorMsg* _msg = _internal_mutable_errmsg();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgProcInitReply.errmsg)
+ return _msg;
+}
+inline void MsgProcInitReply::set_allocated_errmsg(::bhome_msg::ErrorMsg* errmsg) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(errmsg_);
+ }
+ if (errmsg) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+ ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+ reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(errmsg));
+ if (message_arena != submessage_arena) {
+ errmsg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, errmsg, submessage_arena);
+ }
+
+ } else {
+
+ }
+ errmsg_ = errmsg;
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgProcInitReply.errmsg)
+}
+
+// int32 proc_index = 2;
+inline void MsgProcInitReply::clear_proc_index() {
+ proc_index_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 MsgProcInitReply::_internal_proc_index() const {
+ return proc_index_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 MsgProcInitReply::proc_index() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgProcInitReply.proc_index)
+ return _internal_proc_index();
+}
+inline void MsgProcInitReply::_internal_set_proc_index(::PROTOBUF_NAMESPACE_ID::int32 value) {
+
+ proc_index_ = value;
+}
+inline void MsgProcInitReply::set_proc_index(::PROTOBUF_NAMESPACE_ID::int32 value) {
+ _internal_set_proc_index(value);
+ // @@protoc_insertion_point(field_set:bhome_msg.MsgProcInitReply.proc_index)
+}
+
+// repeated .bhome_msg.BHAddress extra_mqs = 3;
+inline int MsgProcInitReply::_internal_extra_mqs_size() const {
+ return extra_mqs_.size();
+}
+inline int MsgProcInitReply::extra_mqs_size() const {
+ return _internal_extra_mqs_size();
+}
+inline ::bhome_msg::BHAddress* MsgProcInitReply::mutable_extra_mqs(int index) {
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgProcInitReply.extra_mqs)
+ return extra_mqs_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::BHAddress >*
+MsgProcInitReply::mutable_extra_mqs() {
+ // @@protoc_insertion_point(field_mutable_list:bhome_msg.MsgProcInitReply.extra_mqs)
+ return &extra_mqs_;
+}
+inline const ::bhome_msg::BHAddress& MsgProcInitReply::_internal_extra_mqs(int index) const {
+ return extra_mqs_.Get(index);
+}
+inline const ::bhome_msg::BHAddress& MsgProcInitReply::extra_mqs(int index) const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgProcInitReply.extra_mqs)
+ return _internal_extra_mqs(index);
+}
+inline ::bhome_msg::BHAddress* MsgProcInitReply::_internal_add_extra_mqs() {
+ return extra_mqs_.Add();
+}
+inline ::bhome_msg::BHAddress* MsgProcInitReply::add_extra_mqs() {
+ ::bhome_msg::BHAddress* _add = _internal_add_extra_mqs();
+ // @@protoc_insertion_point(field_add:bhome_msg.MsgProcInitReply.extra_mqs)
+ return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::BHAddress >&
+MsgProcInitReply::extra_mqs() const {
+ // @@protoc_insertion_point(field_list:bhome_msg.MsgProcInitReply.extra_mqs)
+ return extra_mqs_;
+}
+
+// -------------------------------------------------------------------
+
+// MsgRequest
+
+// .bhome_msg.MsgRegister register = 1;
+inline bool MsgRequest::_internal_has_register_() const {
+ return request_case() == kRegister;
+}
+inline bool MsgRequest::has_register_() const {
+ return _internal_has_register_();
+}
+inline void MsgRequest::set_has_register_() {
+ _oneof_case_[0] = kRegister;
+}
+inline ::bhome_msg::MsgRegister* MsgRequest::release_register_() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgRequest.register)
+ if (_internal_has_register_()) {
+ clear_has_request();
+ ::bhome_msg::MsgRegister* temp = request_.register__;
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ request_.register__ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::bhome_msg::MsgRegister& MsgRequest::_internal_register_() const {
+ return _internal_has_register_()
+ ? *request_.register__
+ : reinterpret_cast< ::bhome_msg::MsgRegister&>(::bhome_msg::_MsgRegister_default_instance_);
+}
+inline const ::bhome_msg::MsgRegister& MsgRequest::register_() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgRequest.register)
+ return _internal_register_();
+}
+inline ::bhome_msg::MsgRegister* MsgRequest::unsafe_arena_release_register_() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:bhome_msg.MsgRequest.register)
+ if (_internal_has_register_()) {
+ clear_has_request();
+ ::bhome_msg::MsgRegister* temp = request_.register__;
+ request_.register__ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void MsgRequest::unsafe_arena_set_allocated_register_(::bhome_msg::MsgRegister* register_) {
+ clear_request();
+ if (register_) {
+ set_has_register_();
+ request_.register__ = register_;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:bhome_msg.MsgRequest.register)
+}
+inline ::bhome_msg::MsgRegister* MsgRequest::_internal_mutable_register_() {
+ if (!_internal_has_register_()) {
+ clear_request();
+ set_has_register_();
+ request_.register__ = CreateMaybeMessage< ::bhome_msg::MsgRegister >(GetArenaForAllocation());
+ }
+ return request_.register__;
+}
+inline ::bhome_msg::MsgRegister* MsgRequest::mutable_register_() {
+ ::bhome_msg::MsgRegister* _msg = _internal_mutable_register_();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgRequest.register)
+ return _msg;
+}
+
+// .bhome_msg.MsgRequestTopic topic_request = 2;
+inline bool MsgRequest::_internal_has_topic_request() const {
+ return request_case() == kTopicRequest;
+}
+inline bool MsgRequest::has_topic_request() const {
+ return _internal_has_topic_request();
+}
+inline void MsgRequest::set_has_topic_request() {
+ _oneof_case_[0] = kTopicRequest;
+}
+inline ::bhome_msg::MsgRequestTopic* MsgRequest::release_topic_request() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgRequest.topic_request)
+ if (_internal_has_topic_request()) {
+ clear_has_request();
+ ::bhome_msg::MsgRequestTopic* temp = request_.topic_request_;
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ request_.topic_request_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::bhome_msg::MsgRequestTopic& MsgRequest::_internal_topic_request() const {
+ return _internal_has_topic_request()
+ ? *request_.topic_request_
+ : reinterpret_cast< ::bhome_msg::MsgRequestTopic&>(::bhome_msg::_MsgRequestTopic_default_instance_);
+}
+inline const ::bhome_msg::MsgRequestTopic& MsgRequest::topic_request() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgRequest.topic_request)
+ return _internal_topic_request();
+}
+inline ::bhome_msg::MsgRequestTopic* MsgRequest::unsafe_arena_release_topic_request() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:bhome_msg.MsgRequest.topic_request)
+ if (_internal_has_topic_request()) {
+ clear_has_request();
+ ::bhome_msg::MsgRequestTopic* temp = request_.topic_request_;
+ request_.topic_request_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void MsgRequest::unsafe_arena_set_allocated_topic_request(::bhome_msg::MsgRequestTopic* topic_request) {
+ clear_request();
+ if (topic_request) {
+ set_has_topic_request();
+ request_.topic_request_ = topic_request;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:bhome_msg.MsgRequest.topic_request)
+}
+inline ::bhome_msg::MsgRequestTopic* MsgRequest::_internal_mutable_topic_request() {
+ if (!_internal_has_topic_request()) {
+ clear_request();
+ set_has_topic_request();
+ request_.topic_request_ = CreateMaybeMessage< ::bhome_msg::MsgRequestTopic >(GetArenaForAllocation());
+ }
+ return request_.topic_request_;
+}
+inline ::bhome_msg::MsgRequestTopic* MsgRequest::mutable_topic_request() {
+ ::bhome_msg::MsgRequestTopic* _msg = _internal_mutable_topic_request();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgRequest.topic_request)
+ return _msg;
+}
+
+// .bhome_msg.MsgQueryTopic topic_query = 3;
+inline bool MsgRequest::_internal_has_topic_query() const {
+ return request_case() == kTopicQuery;
+}
+inline bool MsgRequest::has_topic_query() const {
+ return _internal_has_topic_query();
+}
+inline void MsgRequest::set_has_topic_query() {
+ _oneof_case_[0] = kTopicQuery;
+}
+inline ::bhome_msg::MsgQueryTopic* MsgRequest::release_topic_query() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgRequest.topic_query)
+ if (_internal_has_topic_query()) {
+ clear_has_request();
+ ::bhome_msg::MsgQueryTopic* temp = request_.topic_query_;
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ request_.topic_query_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::bhome_msg::MsgQueryTopic& MsgRequest::_internal_topic_query() const {
+ return _internal_has_topic_query()
+ ? *request_.topic_query_
+ : reinterpret_cast< ::bhome_msg::MsgQueryTopic&>(::bhome_msg::_MsgQueryTopic_default_instance_);
+}
+inline const ::bhome_msg::MsgQueryTopic& MsgRequest::topic_query() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgRequest.topic_query)
+ return _internal_topic_query();
+}
+inline ::bhome_msg::MsgQueryTopic* MsgRequest::unsafe_arena_release_topic_query() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:bhome_msg.MsgRequest.topic_query)
+ if (_internal_has_topic_query()) {
+ clear_has_request();
+ ::bhome_msg::MsgQueryTopic* temp = request_.topic_query_;
+ request_.topic_query_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void MsgRequest::unsafe_arena_set_allocated_topic_query(::bhome_msg::MsgQueryTopic* topic_query) {
+ clear_request();
+ if (topic_query) {
+ set_has_topic_query();
+ request_.topic_query_ = topic_query;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:bhome_msg.MsgRequest.topic_query)
+}
+inline ::bhome_msg::MsgQueryTopic* MsgRequest::_internal_mutable_topic_query() {
+ if (!_internal_has_topic_query()) {
+ clear_request();
+ set_has_topic_query();
+ request_.topic_query_ = CreateMaybeMessage< ::bhome_msg::MsgQueryTopic >(GetArenaForAllocation());
+ }
+ return request_.topic_query_;
+}
+inline ::bhome_msg::MsgQueryTopic* MsgRequest::mutable_topic_query() {
+ ::bhome_msg::MsgQueryTopic* _msg = _internal_mutable_topic_query();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgRequest.topic_query)
+ return _msg;
+}
+
+inline bool MsgRequest::has_request() const {
+ return request_case() != REQUEST_NOT_SET;
+}
+inline void MsgRequest::clear_has_request() {
+ _oneof_case_[0] = REQUEST_NOT_SET;
+}
+inline MsgRequest::RequestCase MsgRequest::request_case() const {
+ return MsgRequest::RequestCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// MsgReply
+
+// .bhome_msg.ErrorMsg err_msg = 1;
+inline bool MsgReply::_internal_has_err_msg() const {
+ return this != internal_default_instance() && err_msg_ != nullptr;
+}
+inline bool MsgReply::has_err_msg() const {
+ return _internal_has_err_msg();
+}
+inline const ::bhome_msg::ErrorMsg& MsgReply::_internal_err_msg() const {
+ const ::bhome_msg::ErrorMsg* p = err_msg_;
+ return p != nullptr ? *p : reinterpret_cast<const ::bhome_msg::ErrorMsg&>(
+ ::bhome_msg::_ErrorMsg_default_instance_);
+}
+inline const ::bhome_msg::ErrorMsg& MsgReply::err_msg() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgReply.err_msg)
+ return _internal_err_msg();
+}
+inline void MsgReply::unsafe_arena_set_allocated_err_msg(
+ ::bhome_msg::ErrorMsg* err_msg) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(err_msg_);
+ }
+ err_msg_ = err_msg;
+ if (err_msg) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:bhome_msg.MsgReply.err_msg)
+}
+inline ::bhome_msg::ErrorMsg* MsgReply::release_err_msg() {
+
+ ::bhome_msg::ErrorMsg* temp = err_msg_;
+ err_msg_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::bhome_msg::ErrorMsg* MsgReply::unsafe_arena_release_err_msg() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgReply.err_msg)
+
+ ::bhome_msg::ErrorMsg* temp = err_msg_;
+ err_msg_ = nullptr;
+ return temp;
+}
+inline ::bhome_msg::ErrorMsg* MsgReply::_internal_mutable_err_msg() {
+
+ if (err_msg_ == nullptr) {
+ auto* p = CreateMaybeMessage<::bhome_msg::ErrorMsg>(GetArenaForAllocation());
+ err_msg_ = p;
+ }
+ return err_msg_;
+}
+inline ::bhome_msg::ErrorMsg* MsgReply::mutable_err_msg() {
+ ::bhome_msg::ErrorMsg* _msg = _internal_mutable_err_msg();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgReply.err_msg)
+ return _msg;
+}
+inline void MsgReply::set_allocated_err_msg(::bhome_msg::ErrorMsg* err_msg) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(err_msg_);
+ }
+ if (err_msg) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+ ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+ reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(err_msg));
+ if (message_arena != submessage_arena) {
+ err_msg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, err_msg, submessage_arena);
+ }
+
+ } else {
+
+ }
+ err_msg_ = err_msg;
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgReply.err_msg)
+}
+
+// -------------------------------------------------------------------
+
+// BHMsgBody
+
+// .bhome_msg.MsgRequest request = 1;
+inline bool BHMsgBody::_internal_has_request() const {
+ return reqrep_case() == kRequest;
+}
+inline bool BHMsgBody::has_request() const {
+ return _internal_has_request();
+}
+inline void BHMsgBody::set_has_request() {
+ _oneof_case_[0] = kRequest;
+}
+inline void BHMsgBody::clear_request() {
+ if (_internal_has_request()) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reqrep_.request_;
+ }
+ clear_has_reqrep();
+ }
+}
+inline ::bhome_msg::MsgRequest* BHMsgBody::release_request() {
+ // @@protoc_insertion_point(field_release:bhome_msg.BHMsgBody.request)
+ if (_internal_has_request()) {
+ clear_has_reqrep();
+ ::bhome_msg::MsgRequest* temp = reqrep_.request_;
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ reqrep_.request_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::bhome_msg::MsgRequest& BHMsgBody::_internal_request() const {
+ return _internal_has_request()
+ ? *reqrep_.request_
+ : reinterpret_cast< ::bhome_msg::MsgRequest&>(::bhome_msg::_MsgRequest_default_instance_);
+}
+inline const ::bhome_msg::MsgRequest& BHMsgBody::request() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.BHMsgBody.request)
+ return _internal_request();
+}
+inline ::bhome_msg::MsgRequest* BHMsgBody::unsafe_arena_release_request() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:bhome_msg.BHMsgBody.request)
+ if (_internal_has_request()) {
+ clear_has_reqrep();
+ ::bhome_msg::MsgRequest* temp = reqrep_.request_;
+ reqrep_.request_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void BHMsgBody::unsafe_arena_set_allocated_request(::bhome_msg::MsgRequest* request) {
+ clear_reqrep();
+ if (request) {
+ set_has_request();
+ reqrep_.request_ = request;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:bhome_msg.BHMsgBody.request)
+}
+inline ::bhome_msg::MsgRequest* BHMsgBody::_internal_mutable_request() {
+ if (!_internal_has_request()) {
+ clear_reqrep();
+ set_has_request();
+ reqrep_.request_ = CreateMaybeMessage< ::bhome_msg::MsgRequest >(GetArenaForAllocation());
+ }
+ return reqrep_.request_;
+}
+inline ::bhome_msg::MsgRequest* BHMsgBody::mutable_request() {
+ ::bhome_msg::MsgRequest* _msg = _internal_mutable_request();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.BHMsgBody.request)
+ return _msg;
+}
+
+// .bhome_msg.MsgReply reply = 2;
+inline bool BHMsgBody::_internal_has_reply() const {
+ return reqrep_case() == kReply;
+}
+inline bool BHMsgBody::has_reply() const {
+ return _internal_has_reply();
+}
+inline void BHMsgBody::set_has_reply() {
+ _oneof_case_[0] = kReply;
+}
+inline void BHMsgBody::clear_reply() {
+ if (_internal_has_reply()) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reqrep_.reply_;
+ }
+ clear_has_reqrep();
+ }
+}
+inline ::bhome_msg::MsgReply* BHMsgBody::release_reply() {
+ // @@protoc_insertion_point(field_release:bhome_msg.BHMsgBody.reply)
+ if (_internal_has_reply()) {
+ clear_has_reqrep();
+ ::bhome_msg::MsgReply* temp = reqrep_.reply_;
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ reqrep_.reply_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::bhome_msg::MsgReply& BHMsgBody::_internal_reply() const {
+ return _internal_has_reply()
+ ? *reqrep_.reply_
+ : reinterpret_cast< ::bhome_msg::MsgReply&>(::bhome_msg::_MsgReply_default_instance_);
+}
+inline const ::bhome_msg::MsgReply& BHMsgBody::reply() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.BHMsgBody.reply)
+ return _internal_reply();
+}
+inline ::bhome_msg::MsgReply* BHMsgBody::unsafe_arena_release_reply() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:bhome_msg.BHMsgBody.reply)
+ if (_internal_has_reply()) {
+ clear_has_reqrep();
+ ::bhome_msg::MsgReply* temp = reqrep_.reply_;
+ reqrep_.reply_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void BHMsgBody::unsafe_arena_set_allocated_reply(::bhome_msg::MsgReply* reply) {
+ clear_reqrep();
+ if (reply) {
+ set_has_reply();
+ reqrep_.reply_ = reply;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:bhome_msg.BHMsgBody.reply)
+}
+inline ::bhome_msg::MsgReply* BHMsgBody::_internal_mutable_reply() {
+ if (!_internal_has_reply()) {
+ clear_reqrep();
+ set_has_reply();
+ reqrep_.reply_ = CreateMaybeMessage< ::bhome_msg::MsgReply >(GetArenaForAllocation());
+ }
+ return reqrep_.reply_;
+}
+inline ::bhome_msg::MsgReply* BHMsgBody::mutable_reply() {
+ ::bhome_msg::MsgReply* _msg = _internal_mutable_reply();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.BHMsgBody.reply)
+ return _msg;
+}
+
+inline bool BHMsgBody::has_reqrep() const {
+ return reqrep_case() != REQREP_NOT_SET;
+}
+inline void BHMsgBody::clear_has_reqrep() {
+ _oneof_case_[0] = REQREP_NOT_SET;
+}
+inline BHMsgBody::ReqrepCase BHMsgBody::reqrep_case() const {
+ return BHMsgBody::ReqrepCase(_oneof_case_[0]);
+}
+#ifdef __GNUC__
+ #pragma GCC diagnostic pop
+#endif // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+} // namespace bhome_msg
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::bhome_msg::MsgType> : ::std::true_type {};
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_bhome_5fmsg_2eproto
diff --git a/src/proto/bhome_msg.proto b/src/proto/bhome_msg.proto
new file mode 100644
index 0000000..f34aebb
--- /dev/null
+++ b/src/proto/bhome_msg.proto
@@ -0,0 +1,102 @@
+syntax = "proto3";
+option optimize_for = LITE_RUNTIME;
+option go_package="./bhome_msg";
+
+// import "google/protobuf/descriptor.proto";
+import "bhome_msg_api.proto";
+import "error_msg.proto";
+
+package bhome_msg;
+
+
+// message format : head_len(4) + head(BHMsgHead) + body_len(4) + body(variable types)
+
+message BHMsgHead {
+ bytes msg_id = 1;
+ repeated BHAddress route = 2; // for reply and proxy.
+ int64 timestamp = 3;
+ int32 type = 4;
+ uint64 ssn_id = 5; // node mq id
+ bytes proc_id = 6;
+ bytes topic = 7; // for request route
+ BHAddress dest = 8; // other host
+}
+
+
+enum MsgType {
+ kMsgTypeInvalid = 0;
+ kMsgTypeRawData = 1;
+
+ kMsgTypeCommonReply = 2;
+
+ kMsgTypeProcInit = 8;
+ kMsgTypeProcInitReply = 9;
+ kMsgTypeRegister= 10;
+ // kMsgTypeRegisterReply= 11;
+ kMsgTypeHeartbeat = 12;
+ // kMsgTypeHeartbeatReply = 13;
+ kMsgTypeQueryTopic = 14;
+ kMsgTypeQueryTopicReply = 15;
+ kMsgTypeRequestTopic = 16;
+ kMsgTypeRequestTopicReply = 17;
+ kMsgTypeRegisterRPC = 18;
+ // reply
+
+ kMsgTypePublish = 20;
+ // kMsgTypePublishReply = 21;
+ kMsgTypeSubscribe = 22;
+ // kMsgTypeSubscribeReply = 23;
+ kMsgTypeUnsubscribe = 24;
+ // kMsgTypeUnsubscribeReply = 25;
+ kMsgTypeUnregister = 26;
+ // kMsgTypeUnregisterReply = 27;
+ kMsgTypeQueryProc = 28;
+ kMsgTypeQueryProcReply = 29;
+
+}
+
+message MsgSubscribe {
+ MsgTopicList topics = 1;
+}
+message MsgUnsubscribe {
+ MsgTopicList topics = 1;
+}
+message MsgRegisterRPC {
+ MsgTopicList topics = 1;
+}
+
+message MsgProcInit{
+ int32 extra_mq_num = 1;
+} // proc_id is in header.
+
+message MsgProcInitReply {
+ ErrorMsg errmsg = 1;
+ int32 proc_index = 2;
+ repeated BHAddress extra_mqs = 3;
+}
+
+service TopicRPC {
+ rpc Query (MsgQueryTopic) returns (MsgQueryTopicReply);
+ rpc Request (MsgRequestTopic) returns (MsgQueryTopicReply);
+}
+
+message MsgRequest {
+ // oneof body;
+ oneof request {
+ MsgRegister register = 1;
+ MsgRequestTopic topic_request = 2;
+ MsgQueryTopic topic_query = 3;
+ }
+}
+
+message MsgReply {
+ ErrorMsg err_msg = 1;
+ // oneof reply
+}
+
+message BHMsgBody {
+ oneof reqrep {
+ MsgRequest request = 1;
+ MsgReply reply = 2;
+ }
+}
diff --git a/src/proto/bhome_msg_api.pb.cc b/src/proto/bhome_msg_api.pb.cc
new file mode 100644
index 0000000..390383d
--- /dev/null
+++ b/src/proto/bhome_msg_api.pb.cc
@@ -0,0 +1,3799 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: bhome_msg_api.proto
+
+#include "bhome_msg_api.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+namespace bhome_msg {
+constexpr BHAddress::BHAddress(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : ip_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+ , mq_id_(uint64_t{0u})
+ , abs_addr_(int64_t{0})
+ , port_(0){}
+struct BHAddressDefaultTypeInternal {
+ constexpr BHAddressDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~BHAddressDefaultTypeInternal() {}
+ union {
+ BHAddress _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BHAddressDefaultTypeInternal _BHAddress_default_instance_;
+constexpr ProcInfo::ProcInfo(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : proc_id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+ , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+ , public_info_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+ , private_info_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct ProcInfoDefaultTypeInternal {
+ constexpr ProcInfoDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~ProcInfoDefaultTypeInternal() {}
+ union {
+ ProcInfo _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ProcInfoDefaultTypeInternal _ProcInfo_default_instance_;
+constexpr MsgTopicList::MsgTopicList(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : topic_list_(){}
+struct MsgTopicListDefaultTypeInternal {
+ constexpr MsgTopicListDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~MsgTopicListDefaultTypeInternal() {}
+ union {
+ MsgTopicList _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgTopicListDefaultTypeInternal _MsgTopicList_default_instance_;
+constexpr MsgPublish::MsgPublish(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : topic_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+ , data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct MsgPublishDefaultTypeInternal {
+ constexpr MsgPublishDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~MsgPublishDefaultTypeInternal() {}
+ union {
+ MsgPublish _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgPublishDefaultTypeInternal _MsgPublish_default_instance_;
+constexpr MsgCommonReply::MsgCommonReply(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : errmsg_(nullptr){}
+struct MsgCommonReplyDefaultTypeInternal {
+ constexpr MsgCommonReplyDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~MsgCommonReplyDefaultTypeInternal() {}
+ union {
+ MsgCommonReply _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgCommonReplyDefaultTypeInternal _MsgCommonReply_default_instance_;
+constexpr MsgRequestTopic::MsgRequestTopic(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : topic_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+ , data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct MsgRequestTopicDefaultTypeInternal {
+ constexpr MsgRequestTopicDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~MsgRequestTopicDefaultTypeInternal() {}
+ union {
+ MsgRequestTopic _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgRequestTopicDefaultTypeInternal _MsgRequestTopic_default_instance_;
+constexpr MsgRequestTopicReply::MsgRequestTopicReply(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+ , errmsg_(nullptr){}
+struct MsgRequestTopicReplyDefaultTypeInternal {
+ constexpr MsgRequestTopicReplyDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~MsgRequestTopicReplyDefaultTypeInternal() {}
+ union {
+ MsgRequestTopicReply _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgRequestTopicReplyDefaultTypeInternal _MsgRequestTopicReply_default_instance_;
+constexpr MsgRegister::MsgRegister(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : proc_(nullptr){}
+struct MsgRegisterDefaultTypeInternal {
+ constexpr MsgRegisterDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~MsgRegisterDefaultTypeInternal() {}
+ union {
+ MsgRegister _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgRegisterDefaultTypeInternal _MsgRegister_default_instance_;
+constexpr MsgUnregister::MsgUnregister(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : proc_(nullptr){}
+struct MsgUnregisterDefaultTypeInternal {
+ constexpr MsgUnregisterDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~MsgUnregisterDefaultTypeInternal() {}
+ union {
+ MsgUnregister _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgUnregisterDefaultTypeInternal _MsgUnregister_default_instance_;
+constexpr MsgHeartbeat::MsgHeartbeat(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : proc_(nullptr){}
+struct MsgHeartbeatDefaultTypeInternal {
+ constexpr MsgHeartbeatDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~MsgHeartbeatDefaultTypeInternal() {}
+ union {
+ MsgHeartbeat _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgHeartbeatDefaultTypeInternal _MsgHeartbeat_default_instance_;
+constexpr MsgQueryTopic::MsgQueryTopic(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : topic_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct MsgQueryTopicDefaultTypeInternal {
+ constexpr MsgQueryTopicDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~MsgQueryTopicDefaultTypeInternal() {}
+ union {
+ MsgQueryTopic _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgQueryTopicDefaultTypeInternal _MsgQueryTopic_default_instance_;
+constexpr MsgQueryTopicReply_BHNodeAddress::MsgQueryTopicReply_BHNodeAddress(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : proc_id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+ , addr_(nullptr){}
+struct MsgQueryTopicReply_BHNodeAddressDefaultTypeInternal {
+ constexpr MsgQueryTopicReply_BHNodeAddressDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~MsgQueryTopicReply_BHNodeAddressDefaultTypeInternal() {}
+ union {
+ MsgQueryTopicReply_BHNodeAddress _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgQueryTopicReply_BHNodeAddressDefaultTypeInternal _MsgQueryTopicReply_BHNodeAddress_default_instance_;
+constexpr MsgQueryTopicReply::MsgQueryTopicReply(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : node_address_()
+ , errmsg_(nullptr){}
+struct MsgQueryTopicReplyDefaultTypeInternal {
+ constexpr MsgQueryTopicReplyDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~MsgQueryTopicReplyDefaultTypeInternal() {}
+ union {
+ MsgQueryTopicReply _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgQueryTopicReplyDefaultTypeInternal _MsgQueryTopicReply_default_instance_;
+constexpr MsgQueryProc::MsgQueryProc(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : proc_id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct MsgQueryProcDefaultTypeInternal {
+ constexpr MsgQueryProcDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~MsgQueryProcDefaultTypeInternal() {}
+ union {
+ MsgQueryProc _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgQueryProcDefaultTypeInternal _MsgQueryProc_default_instance_;
+constexpr MsgQueryProcReply_Info::MsgQueryProcReply_Info(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : proc_(nullptr)
+ , topics_(nullptr)
+ , online_(false){}
+struct MsgQueryProcReply_InfoDefaultTypeInternal {
+ constexpr MsgQueryProcReply_InfoDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~MsgQueryProcReply_InfoDefaultTypeInternal() {}
+ union {
+ MsgQueryProcReply_Info _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgQueryProcReply_InfoDefaultTypeInternal _MsgQueryProcReply_Info_default_instance_;
+constexpr MsgQueryProcReply::MsgQueryProcReply(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : proc_list_()
+ , errmsg_(nullptr){}
+struct MsgQueryProcReplyDefaultTypeInternal {
+ constexpr MsgQueryProcReplyDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~MsgQueryProcReplyDefaultTypeInternal() {}
+ union {
+ MsgQueryProcReply _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgQueryProcReplyDefaultTypeInternal _MsgQueryProcReply_default_instance_;
+} // namespace bhome_msg
+namespace bhome_msg {
+
+// ===================================================================
+
+class BHAddress::_Internal {
+ public:
+};
+
+BHAddress::BHAddress(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.BHAddress)
+}
+BHAddress::BHAddress(const BHAddress& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_ip().empty()) {
+ ip_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_ip(),
+ GetArenaForAllocation());
+ }
+ ::memcpy(&mq_id_, &from.mq_id_,
+ static_cast<size_t>(reinterpret_cast<char*>(&port_) -
+ reinterpret_cast<char*>(&mq_id_)) + sizeof(port_));
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.BHAddress)
+}
+
+inline void BHAddress::SharedCtor() {
+ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&mq_id_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&port_) -
+ reinterpret_cast<char*>(&mq_id_)) + sizeof(port_));
+}
+
+BHAddress::~BHAddress() {
+ // @@protoc_insertion_point(destructor:bhome_msg.BHAddress)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void BHAddress::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ ip_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void BHAddress::ArenaDtor(void* object) {
+ BHAddress* _this = reinterpret_cast< BHAddress* >(object);
+ (void)_this;
+}
+void BHAddress::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void BHAddress::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void BHAddress::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.BHAddress)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ ip_.ClearToEmpty();
+ ::memset(&mq_id_, 0, static_cast<size_t>(
+ reinterpret_cast<char*>(&port_) -
+ reinterpret_cast<char*>(&mq_id_)) + sizeof(port_));
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* BHAddress::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // uint64 mq_id = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
+ mq_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // int64 abs_addr = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
+ abs_addr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // bytes ip = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+ auto str = _internal_mutable_ip();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // int32 port = 4;
+ case 4:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
+ port_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* BHAddress::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.BHAddress)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // uint64 mq_id = 1;
+ if (this->_internal_mq_id() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->_internal_mq_id(), target);
+ }
+
+ // int64 abs_addr = 2;
+ if (this->_internal_abs_addr() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_abs_addr(), target);
+ }
+
+ // bytes ip = 3;
+ if (!this->_internal_ip().empty()) {
+ target = stream->WriteBytesMaybeAliased(
+ 3, this->_internal_ip(), target);
+ }
+
+ // int32 port = 4;
+ if (this->_internal_port() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_port(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.BHAddress)
+ return target;
+}
+
+size_t BHAddress::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.BHAddress)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // bytes ip = 3;
+ if (!this->_internal_ip().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_ip());
+ }
+
+ // uint64 mq_id = 1;
+ if (this->_internal_mq_id() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
+ this->_internal_mq_id());
+ }
+
+ // int64 abs_addr = 2;
+ if (this->_internal_abs_addr() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
+ this->_internal_abs_addr());
+ }
+
+ // int32 port = 4;
+ if (this->_internal_port() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ this->_internal_port());
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void BHAddress::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const BHAddress*>(
+ &from));
+}
+
+void BHAddress::MergeFrom(const BHAddress& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.BHAddress)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (!from._internal_ip().empty()) {
+ _internal_set_ip(from._internal_ip());
+ }
+ if (from._internal_mq_id() != 0) {
+ _internal_set_mq_id(from._internal_mq_id());
+ }
+ if (from._internal_abs_addr() != 0) {
+ _internal_set_abs_addr(from._internal_abs_addr());
+ }
+ if (from._internal_port() != 0) {
+ _internal_set_port(from._internal_port());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void BHAddress::CopyFrom(const BHAddress& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.BHAddress)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool BHAddress::IsInitialized() const {
+ return true;
+}
+
+void BHAddress::InternalSwap(BHAddress* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &ip_, GetArenaForAllocation(),
+ &other->ip_, other->GetArenaForAllocation()
+ );
+ ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+ PROTOBUF_FIELD_OFFSET(BHAddress, port_)
+ + sizeof(BHAddress::port_)
+ - PROTOBUF_FIELD_OFFSET(BHAddress, mq_id_)>(
+ reinterpret_cast<char*>(&mq_id_),
+ reinterpret_cast<char*>(&other->mq_id_));
+}
+
+std::string BHAddress::GetTypeName() const {
+ return "bhome_msg.BHAddress";
+}
+
+
+// ===================================================================
+
+class ProcInfo::_Internal {
+ public:
+};
+
+ProcInfo::ProcInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.ProcInfo)
+}
+ProcInfo::ProcInfo(const ProcInfo& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ proc_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_proc_id().empty()) {
+ proc_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_proc_id(),
+ GetArenaForAllocation());
+ }
+ name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_name().empty()) {
+ name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(),
+ GetArenaForAllocation());
+ }
+ public_info_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_public_info().empty()) {
+ public_info_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_public_info(),
+ GetArenaForAllocation());
+ }
+ private_info_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_private_info().empty()) {
+ private_info_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_private_info(),
+ GetArenaForAllocation());
+ }
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.ProcInfo)
+}
+
+inline void ProcInfo::SharedCtor() {
+proc_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+public_info_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+private_info_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+ProcInfo::~ProcInfo() {
+ // @@protoc_insertion_point(destructor:bhome_msg.ProcInfo)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void ProcInfo::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ proc_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ public_info_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ private_info_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void ProcInfo::ArenaDtor(void* object) {
+ ProcInfo* _this = reinterpret_cast< ProcInfo* >(object);
+ (void)_this;
+}
+void ProcInfo::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ProcInfo::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void ProcInfo::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.ProcInfo)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ proc_id_.ClearToEmpty();
+ name_.ClearToEmpty();
+ public_info_.ClearToEmpty();
+ private_info_.ClearToEmpty();
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* ProcInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // bytes proc_id = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ auto str = _internal_mutable_proc_id();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // bytes name = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ auto str = _internal_mutable_name();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // bytes public_info = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+ auto str = _internal_mutable_public_info();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // bytes private_info = 4;
+ case 4:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
+ auto str = _internal_mutable_private_info();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* ProcInfo::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.ProcInfo)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // bytes proc_id = 1;
+ if (!this->_internal_proc_id().empty()) {
+ target = stream->WriteBytesMaybeAliased(
+ 1, this->_internal_proc_id(), target);
+ }
+
+ // bytes name = 2;
+ if (!this->_internal_name().empty()) {
+ target = stream->WriteBytesMaybeAliased(
+ 2, this->_internal_name(), target);
+ }
+
+ // bytes public_info = 3;
+ if (!this->_internal_public_info().empty()) {
+ target = stream->WriteBytesMaybeAliased(
+ 3, this->_internal_public_info(), target);
+ }
+
+ // bytes private_info = 4;
+ if (!this->_internal_private_info().empty()) {
+ target = stream->WriteBytesMaybeAliased(
+ 4, this->_internal_private_info(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.ProcInfo)
+ return target;
+}
+
+size_t ProcInfo::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.ProcInfo)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // bytes proc_id = 1;
+ if (!this->_internal_proc_id().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_proc_id());
+ }
+
+ // bytes name = 2;
+ if (!this->_internal_name().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_name());
+ }
+
+ // bytes public_info = 3;
+ if (!this->_internal_public_info().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_public_info());
+ }
+
+ // bytes private_info = 4;
+ if (!this->_internal_private_info().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_private_info());
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void ProcInfo::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ProcInfo*>(
+ &from));
+}
+
+void ProcInfo::MergeFrom(const ProcInfo& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.ProcInfo)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (!from._internal_proc_id().empty()) {
+ _internal_set_proc_id(from._internal_proc_id());
+ }
+ if (!from._internal_name().empty()) {
+ _internal_set_name(from._internal_name());
+ }
+ if (!from._internal_public_info().empty()) {
+ _internal_set_public_info(from._internal_public_info());
+ }
+ if (!from._internal_private_info().empty()) {
+ _internal_set_private_info(from._internal_private_info());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ProcInfo::CopyFrom(const ProcInfo& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.ProcInfo)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool ProcInfo::IsInitialized() const {
+ return true;
+}
+
+void ProcInfo::InternalSwap(ProcInfo* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &proc_id_, GetArenaForAllocation(),
+ &other->proc_id_, other->GetArenaForAllocation()
+ );
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &name_, GetArenaForAllocation(),
+ &other->name_, other->GetArenaForAllocation()
+ );
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &public_info_, GetArenaForAllocation(),
+ &other->public_info_, other->GetArenaForAllocation()
+ );
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &private_info_, GetArenaForAllocation(),
+ &other->private_info_, other->GetArenaForAllocation()
+ );
+}
+
+std::string ProcInfo::GetTypeName() const {
+ return "bhome_msg.ProcInfo";
+}
+
+
+// ===================================================================
+
+class MsgTopicList::_Internal {
+ public:
+};
+
+MsgTopicList::MsgTopicList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned),
+ topic_list_(arena) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgTopicList)
+}
+MsgTopicList::MsgTopicList(const MsgTopicList& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
+ topic_list_(from.topic_list_) {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgTopicList)
+}
+
+inline void MsgTopicList::SharedCtor() {
+}
+
+MsgTopicList::~MsgTopicList() {
+ // @@protoc_insertion_point(destructor:bhome_msg.MsgTopicList)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void MsgTopicList::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void MsgTopicList::ArenaDtor(void* object) {
+ MsgTopicList* _this = reinterpret_cast< MsgTopicList* >(object);
+ (void)_this;
+}
+void MsgTopicList::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MsgTopicList::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void MsgTopicList::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgTopicList)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ topic_list_.Clear();
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* MsgTopicList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // repeated bytes topic_list = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ auto str = _internal_add_topic_list();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MsgTopicList::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgTopicList)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // repeated bytes topic_list = 1;
+ for (int i = 0, n = this->_internal_topic_list_size(); i < n; i++) {
+ const auto& s = this->_internal_topic_list(i);
+ target = stream->WriteBytes(1, s, target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgTopicList)
+ return target;
+}
+
+size_t MsgTopicList::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgTopicList)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // repeated bytes topic_list = 1;
+ total_size += 1 *
+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(topic_list_.size());
+ for (int i = 0, n = topic_list_.size(); i < n; i++) {
+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ topic_list_.Get(i));
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MsgTopicList::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgTopicList*>(
+ &from));
+}
+
+void MsgTopicList::MergeFrom(const MsgTopicList& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgTopicList)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ topic_list_.MergeFrom(from.topic_list_);
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MsgTopicList::CopyFrom(const MsgTopicList& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgTopicList)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MsgTopicList::IsInitialized() const {
+ return true;
+}
+
+void MsgTopicList::InternalSwap(MsgTopicList* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ topic_list_.InternalSwap(&other->topic_list_);
+}
+
+std::string MsgTopicList::GetTypeName() const {
+ return "bhome_msg.MsgTopicList";
+}
+
+
+// ===================================================================
+
+class MsgPublish::_Internal {
+ public:
+};
+
+MsgPublish::MsgPublish(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgPublish)
+}
+MsgPublish::MsgPublish(const MsgPublish& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ topic_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_topic().empty()) {
+ topic_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_topic(),
+ GetArenaForAllocation());
+ }
+ data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_data().empty()) {
+ data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_data(),
+ GetArenaForAllocation());
+ }
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgPublish)
+}
+
+inline void MsgPublish::SharedCtor() {
+topic_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+MsgPublish::~MsgPublish() {
+ // @@protoc_insertion_point(destructor:bhome_msg.MsgPublish)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void MsgPublish::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ topic_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void MsgPublish::ArenaDtor(void* object) {
+ MsgPublish* _this = reinterpret_cast< MsgPublish* >(object);
+ (void)_this;
+}
+void MsgPublish::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MsgPublish::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void MsgPublish::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgPublish)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ topic_.ClearToEmpty();
+ data_.ClearToEmpty();
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* MsgPublish::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // bytes topic = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ auto str = _internal_mutable_topic();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // bytes data = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ auto str = _internal_mutable_data();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MsgPublish::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgPublish)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // bytes topic = 1;
+ if (!this->_internal_topic().empty()) {
+ target = stream->WriteBytesMaybeAliased(
+ 1, this->_internal_topic(), target);
+ }
+
+ // bytes data = 2;
+ if (!this->_internal_data().empty()) {
+ target = stream->WriteBytesMaybeAliased(
+ 2, this->_internal_data(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgPublish)
+ return target;
+}
+
+size_t MsgPublish::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgPublish)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // bytes topic = 1;
+ if (!this->_internal_topic().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_topic());
+ }
+
+ // bytes data = 2;
+ if (!this->_internal_data().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_data());
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MsgPublish::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgPublish*>(
+ &from));
+}
+
+void MsgPublish::MergeFrom(const MsgPublish& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgPublish)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (!from._internal_topic().empty()) {
+ _internal_set_topic(from._internal_topic());
+ }
+ if (!from._internal_data().empty()) {
+ _internal_set_data(from._internal_data());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MsgPublish::CopyFrom(const MsgPublish& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgPublish)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MsgPublish::IsInitialized() const {
+ return true;
+}
+
+void MsgPublish::InternalSwap(MsgPublish* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &topic_, GetArenaForAllocation(),
+ &other->topic_, other->GetArenaForAllocation()
+ );
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &data_, GetArenaForAllocation(),
+ &other->data_, other->GetArenaForAllocation()
+ );
+}
+
+std::string MsgPublish::GetTypeName() const {
+ return "bhome_msg.MsgPublish";
+}
+
+
+// ===================================================================
+
+class MsgCommonReply::_Internal {
+ public:
+ static const ::bhome_msg::ErrorMsg& errmsg(const MsgCommonReply* msg);
+};
+
+const ::bhome_msg::ErrorMsg&
+MsgCommonReply::_Internal::errmsg(const MsgCommonReply* msg) {
+ return *msg->errmsg_;
+}
+void MsgCommonReply::clear_errmsg() {
+ if (GetArenaForAllocation() == nullptr && errmsg_ != nullptr) {
+ delete errmsg_;
+ }
+ errmsg_ = nullptr;
+}
+MsgCommonReply::MsgCommonReply(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgCommonReply)
+}
+MsgCommonReply::MsgCommonReply(const MsgCommonReply& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ if (from._internal_has_errmsg()) {
+ errmsg_ = new ::bhome_msg::ErrorMsg(*from.errmsg_);
+ } else {
+ errmsg_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgCommonReply)
+}
+
+inline void MsgCommonReply::SharedCtor() {
+errmsg_ = nullptr;
+}
+
+MsgCommonReply::~MsgCommonReply() {
+ // @@protoc_insertion_point(destructor:bhome_msg.MsgCommonReply)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void MsgCommonReply::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (this != internal_default_instance()) delete errmsg_;
+}
+
+void MsgCommonReply::ArenaDtor(void* object) {
+ MsgCommonReply* _this = reinterpret_cast< MsgCommonReply* >(object);
+ (void)_this;
+}
+void MsgCommonReply::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MsgCommonReply::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void MsgCommonReply::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgCommonReply)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ if (GetArenaForAllocation() == nullptr && errmsg_ != nullptr) {
+ delete errmsg_;
+ }
+ errmsg_ = nullptr;
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* MsgCommonReply::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .bhome_msg.ErrorMsg errmsg = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_errmsg(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MsgCommonReply::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgCommonReply)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .bhome_msg.ErrorMsg errmsg = 1;
+ if (this->_internal_has_errmsg()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::errmsg(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgCommonReply)
+ return target;
+}
+
+size_t MsgCommonReply::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgCommonReply)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // .bhome_msg.ErrorMsg errmsg = 1;
+ if (this->_internal_has_errmsg()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *errmsg_);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MsgCommonReply::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgCommonReply*>(
+ &from));
+}
+
+void MsgCommonReply::MergeFrom(const MsgCommonReply& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgCommonReply)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from._internal_has_errmsg()) {
+ _internal_mutable_errmsg()->::bhome_msg::ErrorMsg::MergeFrom(from._internal_errmsg());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MsgCommonReply::CopyFrom(const MsgCommonReply& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgCommonReply)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MsgCommonReply::IsInitialized() const {
+ return true;
+}
+
+void MsgCommonReply::InternalSwap(MsgCommonReply* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ swap(errmsg_, other->errmsg_);
+}
+
+std::string MsgCommonReply::GetTypeName() const {
+ return "bhome_msg.MsgCommonReply";
+}
+
+
+// ===================================================================
+
+class MsgRequestTopic::_Internal {
+ public:
+};
+
+MsgRequestTopic::MsgRequestTopic(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgRequestTopic)
+}
+MsgRequestTopic::MsgRequestTopic(const MsgRequestTopic& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ topic_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_topic().empty()) {
+ topic_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_topic(),
+ GetArenaForAllocation());
+ }
+ data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_data().empty()) {
+ data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_data(),
+ GetArenaForAllocation());
+ }
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgRequestTopic)
+}
+
+inline void MsgRequestTopic::SharedCtor() {
+topic_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+MsgRequestTopic::~MsgRequestTopic() {
+ // @@protoc_insertion_point(destructor:bhome_msg.MsgRequestTopic)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void MsgRequestTopic::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ topic_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void MsgRequestTopic::ArenaDtor(void* object) {
+ MsgRequestTopic* _this = reinterpret_cast< MsgRequestTopic* >(object);
+ (void)_this;
+}
+void MsgRequestTopic::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MsgRequestTopic::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void MsgRequestTopic::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgRequestTopic)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ topic_.ClearToEmpty();
+ data_.ClearToEmpty();
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* MsgRequestTopic::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // bytes topic = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ auto str = _internal_mutable_topic();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // bytes data = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ auto str = _internal_mutable_data();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MsgRequestTopic::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgRequestTopic)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // bytes topic = 1;
+ if (!this->_internal_topic().empty()) {
+ target = stream->WriteBytesMaybeAliased(
+ 1, this->_internal_topic(), target);
+ }
+
+ // bytes data = 2;
+ if (!this->_internal_data().empty()) {
+ target = stream->WriteBytesMaybeAliased(
+ 2, this->_internal_data(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgRequestTopic)
+ return target;
+}
+
+size_t MsgRequestTopic::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgRequestTopic)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // bytes topic = 1;
+ if (!this->_internal_topic().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_topic());
+ }
+
+ // bytes data = 2;
+ if (!this->_internal_data().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_data());
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MsgRequestTopic::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgRequestTopic*>(
+ &from));
+}
+
+void MsgRequestTopic::MergeFrom(const MsgRequestTopic& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgRequestTopic)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (!from._internal_topic().empty()) {
+ _internal_set_topic(from._internal_topic());
+ }
+ if (!from._internal_data().empty()) {
+ _internal_set_data(from._internal_data());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MsgRequestTopic::CopyFrom(const MsgRequestTopic& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgRequestTopic)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MsgRequestTopic::IsInitialized() const {
+ return true;
+}
+
+void MsgRequestTopic::InternalSwap(MsgRequestTopic* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &topic_, GetArenaForAllocation(),
+ &other->topic_, other->GetArenaForAllocation()
+ );
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &data_, GetArenaForAllocation(),
+ &other->data_, other->GetArenaForAllocation()
+ );
+}
+
+std::string MsgRequestTopic::GetTypeName() const {
+ return "bhome_msg.MsgRequestTopic";
+}
+
+
+// ===================================================================
+
+class MsgRequestTopicReply::_Internal {
+ public:
+ static const ::bhome_msg::ErrorMsg& errmsg(const MsgRequestTopicReply* msg);
+};
+
+const ::bhome_msg::ErrorMsg&
+MsgRequestTopicReply::_Internal::errmsg(const MsgRequestTopicReply* msg) {
+ return *msg->errmsg_;
+}
+void MsgRequestTopicReply::clear_errmsg() {
+ if (GetArenaForAllocation() == nullptr && errmsg_ != nullptr) {
+ delete errmsg_;
+ }
+ errmsg_ = nullptr;
+}
+MsgRequestTopicReply::MsgRequestTopicReply(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgRequestTopicReply)
+}
+MsgRequestTopicReply::MsgRequestTopicReply(const MsgRequestTopicReply& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_data().empty()) {
+ data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_data(),
+ GetArenaForAllocation());
+ }
+ if (from._internal_has_errmsg()) {
+ errmsg_ = new ::bhome_msg::ErrorMsg(*from.errmsg_);
+ } else {
+ errmsg_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgRequestTopicReply)
+}
+
+inline void MsgRequestTopicReply::SharedCtor() {
+data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+errmsg_ = nullptr;
+}
+
+MsgRequestTopicReply::~MsgRequestTopicReply() {
+ // @@protoc_insertion_point(destructor:bhome_msg.MsgRequestTopicReply)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void MsgRequestTopicReply::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (this != internal_default_instance()) delete errmsg_;
+}
+
+void MsgRequestTopicReply::ArenaDtor(void* object) {
+ MsgRequestTopicReply* _this = reinterpret_cast< MsgRequestTopicReply* >(object);
+ (void)_this;
+}
+void MsgRequestTopicReply::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MsgRequestTopicReply::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void MsgRequestTopicReply::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgRequestTopicReply)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ data_.ClearToEmpty();
+ if (GetArenaForAllocation() == nullptr && errmsg_ != nullptr) {
+ delete errmsg_;
+ }
+ errmsg_ = nullptr;
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* MsgRequestTopicReply::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .bhome_msg.ErrorMsg errmsg = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_errmsg(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // bytes data = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ auto str = _internal_mutable_data();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MsgRequestTopicReply::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgRequestTopicReply)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .bhome_msg.ErrorMsg errmsg = 1;
+ if (this->_internal_has_errmsg()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::errmsg(this), target, stream);
+ }
+
+ // bytes data = 2;
+ if (!this->_internal_data().empty()) {
+ target = stream->WriteBytesMaybeAliased(
+ 2, this->_internal_data(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgRequestTopicReply)
+ return target;
+}
+
+size_t MsgRequestTopicReply::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgRequestTopicReply)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // bytes data = 2;
+ if (!this->_internal_data().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_data());
+ }
+
+ // .bhome_msg.ErrorMsg errmsg = 1;
+ if (this->_internal_has_errmsg()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *errmsg_);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MsgRequestTopicReply::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgRequestTopicReply*>(
+ &from));
+}
+
+void MsgRequestTopicReply::MergeFrom(const MsgRequestTopicReply& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgRequestTopicReply)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (!from._internal_data().empty()) {
+ _internal_set_data(from._internal_data());
+ }
+ if (from._internal_has_errmsg()) {
+ _internal_mutable_errmsg()->::bhome_msg::ErrorMsg::MergeFrom(from._internal_errmsg());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MsgRequestTopicReply::CopyFrom(const MsgRequestTopicReply& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgRequestTopicReply)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MsgRequestTopicReply::IsInitialized() const {
+ return true;
+}
+
+void MsgRequestTopicReply::InternalSwap(MsgRequestTopicReply* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &data_, GetArenaForAllocation(),
+ &other->data_, other->GetArenaForAllocation()
+ );
+ swap(errmsg_, other->errmsg_);
+}
+
+std::string MsgRequestTopicReply::GetTypeName() const {
+ return "bhome_msg.MsgRequestTopicReply";
+}
+
+
+// ===================================================================
+
+class MsgRegister::_Internal {
+ public:
+ static const ::bhome_msg::ProcInfo& proc(const MsgRegister* msg);
+};
+
+const ::bhome_msg::ProcInfo&
+MsgRegister::_Internal::proc(const MsgRegister* msg) {
+ return *msg->proc_;
+}
+MsgRegister::MsgRegister(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgRegister)
+}
+MsgRegister::MsgRegister(const MsgRegister& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ if (from._internal_has_proc()) {
+ proc_ = new ::bhome_msg::ProcInfo(*from.proc_);
+ } else {
+ proc_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgRegister)
+}
+
+inline void MsgRegister::SharedCtor() {
+proc_ = nullptr;
+}
+
+MsgRegister::~MsgRegister() {
+ // @@protoc_insertion_point(destructor:bhome_msg.MsgRegister)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void MsgRegister::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (this != internal_default_instance()) delete proc_;
+}
+
+void MsgRegister::ArenaDtor(void* object) {
+ MsgRegister* _this = reinterpret_cast< MsgRegister* >(object);
+ (void)_this;
+}
+void MsgRegister::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MsgRegister::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void MsgRegister::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgRegister)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ if (GetArenaForAllocation() == nullptr && proc_ != nullptr) {
+ delete proc_;
+ }
+ proc_ = nullptr;
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* MsgRegister::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .bhome_msg.ProcInfo proc = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_proc(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MsgRegister::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgRegister)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .bhome_msg.ProcInfo proc = 1;
+ if (this->_internal_has_proc()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::proc(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgRegister)
+ return target;
+}
+
+size_t MsgRegister::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgRegister)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // .bhome_msg.ProcInfo proc = 1;
+ if (this->_internal_has_proc()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *proc_);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MsgRegister::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgRegister*>(
+ &from));
+}
+
+void MsgRegister::MergeFrom(const MsgRegister& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgRegister)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from._internal_has_proc()) {
+ _internal_mutable_proc()->::bhome_msg::ProcInfo::MergeFrom(from._internal_proc());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MsgRegister::CopyFrom(const MsgRegister& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgRegister)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MsgRegister::IsInitialized() const {
+ return true;
+}
+
+void MsgRegister::InternalSwap(MsgRegister* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ swap(proc_, other->proc_);
+}
+
+std::string MsgRegister::GetTypeName() const {
+ return "bhome_msg.MsgRegister";
+}
+
+
+// ===================================================================
+
+class MsgUnregister::_Internal {
+ public:
+ static const ::bhome_msg::ProcInfo& proc(const MsgUnregister* msg);
+};
+
+const ::bhome_msg::ProcInfo&
+MsgUnregister::_Internal::proc(const MsgUnregister* msg) {
+ return *msg->proc_;
+}
+MsgUnregister::MsgUnregister(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgUnregister)
+}
+MsgUnregister::MsgUnregister(const MsgUnregister& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ if (from._internal_has_proc()) {
+ proc_ = new ::bhome_msg::ProcInfo(*from.proc_);
+ } else {
+ proc_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgUnregister)
+}
+
+inline void MsgUnregister::SharedCtor() {
+proc_ = nullptr;
+}
+
+MsgUnregister::~MsgUnregister() {
+ // @@protoc_insertion_point(destructor:bhome_msg.MsgUnregister)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void MsgUnregister::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (this != internal_default_instance()) delete proc_;
+}
+
+void MsgUnregister::ArenaDtor(void* object) {
+ MsgUnregister* _this = reinterpret_cast< MsgUnregister* >(object);
+ (void)_this;
+}
+void MsgUnregister::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MsgUnregister::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void MsgUnregister::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgUnregister)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ if (GetArenaForAllocation() == nullptr && proc_ != nullptr) {
+ delete proc_;
+ }
+ proc_ = nullptr;
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* MsgUnregister::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .bhome_msg.ProcInfo proc = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_proc(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MsgUnregister::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgUnregister)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .bhome_msg.ProcInfo proc = 1;
+ if (this->_internal_has_proc()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::proc(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgUnregister)
+ return target;
+}
+
+size_t MsgUnregister::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgUnregister)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // .bhome_msg.ProcInfo proc = 1;
+ if (this->_internal_has_proc()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *proc_);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MsgUnregister::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgUnregister*>(
+ &from));
+}
+
+void MsgUnregister::MergeFrom(const MsgUnregister& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgUnregister)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from._internal_has_proc()) {
+ _internal_mutable_proc()->::bhome_msg::ProcInfo::MergeFrom(from._internal_proc());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MsgUnregister::CopyFrom(const MsgUnregister& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgUnregister)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MsgUnregister::IsInitialized() const {
+ return true;
+}
+
+void MsgUnregister::InternalSwap(MsgUnregister* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ swap(proc_, other->proc_);
+}
+
+std::string MsgUnregister::GetTypeName() const {
+ return "bhome_msg.MsgUnregister";
+}
+
+
+// ===================================================================
+
+class MsgHeartbeat::_Internal {
+ public:
+ static const ::bhome_msg::ProcInfo& proc(const MsgHeartbeat* msg);
+};
+
+const ::bhome_msg::ProcInfo&
+MsgHeartbeat::_Internal::proc(const MsgHeartbeat* msg) {
+ return *msg->proc_;
+}
+MsgHeartbeat::MsgHeartbeat(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgHeartbeat)
+}
+MsgHeartbeat::MsgHeartbeat(const MsgHeartbeat& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ if (from._internal_has_proc()) {
+ proc_ = new ::bhome_msg::ProcInfo(*from.proc_);
+ } else {
+ proc_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgHeartbeat)
+}
+
+inline void MsgHeartbeat::SharedCtor() {
+proc_ = nullptr;
+}
+
+MsgHeartbeat::~MsgHeartbeat() {
+ // @@protoc_insertion_point(destructor:bhome_msg.MsgHeartbeat)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void MsgHeartbeat::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (this != internal_default_instance()) delete proc_;
+}
+
+void MsgHeartbeat::ArenaDtor(void* object) {
+ MsgHeartbeat* _this = reinterpret_cast< MsgHeartbeat* >(object);
+ (void)_this;
+}
+void MsgHeartbeat::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MsgHeartbeat::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void MsgHeartbeat::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgHeartbeat)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ if (GetArenaForAllocation() == nullptr && proc_ != nullptr) {
+ delete proc_;
+ }
+ proc_ = nullptr;
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* MsgHeartbeat::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .bhome_msg.ProcInfo proc = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_proc(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MsgHeartbeat::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgHeartbeat)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .bhome_msg.ProcInfo proc = 1;
+ if (this->_internal_has_proc()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::proc(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgHeartbeat)
+ return target;
+}
+
+size_t MsgHeartbeat::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgHeartbeat)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // .bhome_msg.ProcInfo proc = 1;
+ if (this->_internal_has_proc()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *proc_);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MsgHeartbeat::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgHeartbeat*>(
+ &from));
+}
+
+void MsgHeartbeat::MergeFrom(const MsgHeartbeat& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgHeartbeat)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from._internal_has_proc()) {
+ _internal_mutable_proc()->::bhome_msg::ProcInfo::MergeFrom(from._internal_proc());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MsgHeartbeat::CopyFrom(const MsgHeartbeat& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgHeartbeat)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MsgHeartbeat::IsInitialized() const {
+ return true;
+}
+
+void MsgHeartbeat::InternalSwap(MsgHeartbeat* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ swap(proc_, other->proc_);
+}
+
+std::string MsgHeartbeat::GetTypeName() const {
+ return "bhome_msg.MsgHeartbeat";
+}
+
+
+// ===================================================================
+
+class MsgQueryTopic::_Internal {
+ public:
+};
+
+MsgQueryTopic::MsgQueryTopic(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgQueryTopic)
+}
+MsgQueryTopic::MsgQueryTopic(const MsgQueryTopic& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ topic_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_topic().empty()) {
+ topic_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_topic(),
+ GetArenaForAllocation());
+ }
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgQueryTopic)
+}
+
+inline void MsgQueryTopic::SharedCtor() {
+topic_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+MsgQueryTopic::~MsgQueryTopic() {
+ // @@protoc_insertion_point(destructor:bhome_msg.MsgQueryTopic)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void MsgQueryTopic::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ topic_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void MsgQueryTopic::ArenaDtor(void* object) {
+ MsgQueryTopic* _this = reinterpret_cast< MsgQueryTopic* >(object);
+ (void)_this;
+}
+void MsgQueryTopic::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MsgQueryTopic::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void MsgQueryTopic::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgQueryTopic)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ topic_.ClearToEmpty();
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* MsgQueryTopic::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // bytes topic = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ auto str = _internal_mutable_topic();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MsgQueryTopic::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgQueryTopic)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // bytes topic = 1;
+ if (!this->_internal_topic().empty()) {
+ target = stream->WriteBytesMaybeAliased(
+ 1, this->_internal_topic(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgQueryTopic)
+ return target;
+}
+
+size_t MsgQueryTopic::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgQueryTopic)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // bytes topic = 1;
+ if (!this->_internal_topic().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_topic());
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MsgQueryTopic::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgQueryTopic*>(
+ &from));
+}
+
+void MsgQueryTopic::MergeFrom(const MsgQueryTopic& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgQueryTopic)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (!from._internal_topic().empty()) {
+ _internal_set_topic(from._internal_topic());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MsgQueryTopic::CopyFrom(const MsgQueryTopic& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgQueryTopic)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MsgQueryTopic::IsInitialized() const {
+ return true;
+}
+
+void MsgQueryTopic::InternalSwap(MsgQueryTopic* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &topic_, GetArenaForAllocation(),
+ &other->topic_, other->GetArenaForAllocation()
+ );
+}
+
+std::string MsgQueryTopic::GetTypeName() const {
+ return "bhome_msg.MsgQueryTopic";
+}
+
+
+// ===================================================================
+
+class MsgQueryTopicReply_BHNodeAddress::_Internal {
+ public:
+ static const ::bhome_msg::BHAddress& addr(const MsgQueryTopicReply_BHNodeAddress* msg);
+};
+
+const ::bhome_msg::BHAddress&
+MsgQueryTopicReply_BHNodeAddress::_Internal::addr(const MsgQueryTopicReply_BHNodeAddress* msg) {
+ return *msg->addr_;
+}
+MsgQueryTopicReply_BHNodeAddress::MsgQueryTopicReply_BHNodeAddress(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgQueryTopicReply.BHNodeAddress)
+}
+MsgQueryTopicReply_BHNodeAddress::MsgQueryTopicReply_BHNodeAddress(const MsgQueryTopicReply_BHNodeAddress& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ proc_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_proc_id().empty()) {
+ proc_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_proc_id(),
+ GetArenaForAllocation());
+ }
+ if (from._internal_has_addr()) {
+ addr_ = new ::bhome_msg::BHAddress(*from.addr_);
+ } else {
+ addr_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgQueryTopicReply.BHNodeAddress)
+}
+
+inline void MsgQueryTopicReply_BHNodeAddress::SharedCtor() {
+proc_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+addr_ = nullptr;
+}
+
+MsgQueryTopicReply_BHNodeAddress::~MsgQueryTopicReply_BHNodeAddress() {
+ // @@protoc_insertion_point(destructor:bhome_msg.MsgQueryTopicReply.BHNodeAddress)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void MsgQueryTopicReply_BHNodeAddress::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ proc_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (this != internal_default_instance()) delete addr_;
+}
+
+void MsgQueryTopicReply_BHNodeAddress::ArenaDtor(void* object) {
+ MsgQueryTopicReply_BHNodeAddress* _this = reinterpret_cast< MsgQueryTopicReply_BHNodeAddress* >(object);
+ (void)_this;
+}
+void MsgQueryTopicReply_BHNodeAddress::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MsgQueryTopicReply_BHNodeAddress::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void MsgQueryTopicReply_BHNodeAddress::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgQueryTopicReply.BHNodeAddress)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ proc_id_.ClearToEmpty();
+ if (GetArenaForAllocation() == nullptr && addr_ != nullptr) {
+ delete addr_;
+ }
+ addr_ = nullptr;
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* MsgQueryTopicReply_BHNodeAddress::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // bytes proc_id = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ auto str = _internal_mutable_proc_id();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // .bhome_msg.BHAddress addr = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ ptr = ctx->ParseMessage(_internal_mutable_addr(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MsgQueryTopicReply_BHNodeAddress::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgQueryTopicReply.BHNodeAddress)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // bytes proc_id = 1;
+ if (!this->_internal_proc_id().empty()) {
+ target = stream->WriteBytesMaybeAliased(
+ 1, this->_internal_proc_id(), target);
+ }
+
+ // .bhome_msg.BHAddress addr = 2;
+ if (this->_internal_has_addr()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 2, _Internal::addr(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgQueryTopicReply.BHNodeAddress)
+ return target;
+}
+
+size_t MsgQueryTopicReply_BHNodeAddress::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgQueryTopicReply.BHNodeAddress)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // bytes proc_id = 1;
+ if (!this->_internal_proc_id().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_proc_id());
+ }
+
+ // .bhome_msg.BHAddress addr = 2;
+ if (this->_internal_has_addr()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *addr_);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MsgQueryTopicReply_BHNodeAddress::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgQueryTopicReply_BHNodeAddress*>(
+ &from));
+}
+
+void MsgQueryTopicReply_BHNodeAddress::MergeFrom(const MsgQueryTopicReply_BHNodeAddress& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgQueryTopicReply.BHNodeAddress)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (!from._internal_proc_id().empty()) {
+ _internal_set_proc_id(from._internal_proc_id());
+ }
+ if (from._internal_has_addr()) {
+ _internal_mutable_addr()->::bhome_msg::BHAddress::MergeFrom(from._internal_addr());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MsgQueryTopicReply_BHNodeAddress::CopyFrom(const MsgQueryTopicReply_BHNodeAddress& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgQueryTopicReply.BHNodeAddress)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MsgQueryTopicReply_BHNodeAddress::IsInitialized() const {
+ return true;
+}
+
+void MsgQueryTopicReply_BHNodeAddress::InternalSwap(MsgQueryTopicReply_BHNodeAddress* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &proc_id_, GetArenaForAllocation(),
+ &other->proc_id_, other->GetArenaForAllocation()
+ );
+ swap(addr_, other->addr_);
+}
+
+std::string MsgQueryTopicReply_BHNodeAddress::GetTypeName() const {
+ return "bhome_msg.MsgQueryTopicReply.BHNodeAddress";
+}
+
+
+// ===================================================================
+
+class MsgQueryTopicReply::_Internal {
+ public:
+ static const ::bhome_msg::ErrorMsg& errmsg(const MsgQueryTopicReply* msg);
+};
+
+const ::bhome_msg::ErrorMsg&
+MsgQueryTopicReply::_Internal::errmsg(const MsgQueryTopicReply* msg) {
+ return *msg->errmsg_;
+}
+void MsgQueryTopicReply::clear_errmsg() {
+ if (GetArenaForAllocation() == nullptr && errmsg_ != nullptr) {
+ delete errmsg_;
+ }
+ errmsg_ = nullptr;
+}
+MsgQueryTopicReply::MsgQueryTopicReply(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned),
+ node_address_(arena) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgQueryTopicReply)
+}
+MsgQueryTopicReply::MsgQueryTopicReply(const MsgQueryTopicReply& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
+ node_address_(from.node_address_) {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ if (from._internal_has_errmsg()) {
+ errmsg_ = new ::bhome_msg::ErrorMsg(*from.errmsg_);
+ } else {
+ errmsg_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgQueryTopicReply)
+}
+
+inline void MsgQueryTopicReply::SharedCtor() {
+errmsg_ = nullptr;
+}
+
+MsgQueryTopicReply::~MsgQueryTopicReply() {
+ // @@protoc_insertion_point(destructor:bhome_msg.MsgQueryTopicReply)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void MsgQueryTopicReply::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (this != internal_default_instance()) delete errmsg_;
+}
+
+void MsgQueryTopicReply::ArenaDtor(void* object) {
+ MsgQueryTopicReply* _this = reinterpret_cast< MsgQueryTopicReply* >(object);
+ (void)_this;
+}
+void MsgQueryTopicReply::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MsgQueryTopicReply::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void MsgQueryTopicReply::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgQueryTopicReply)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ node_address_.Clear();
+ if (GetArenaForAllocation() == nullptr && errmsg_ != nullptr) {
+ delete errmsg_;
+ }
+ errmsg_ = nullptr;
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* MsgQueryTopicReply::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .bhome_msg.ErrorMsg errmsg = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_errmsg(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // repeated .bhome_msg.MsgQueryTopicReply.BHNodeAddress node_address = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ ptr = ctx->ParseMessage(_internal_add_node_address(), ptr);
+ 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) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MsgQueryTopicReply::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgQueryTopicReply)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .bhome_msg.ErrorMsg errmsg = 1;
+ if (this->_internal_has_errmsg()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::errmsg(this), target, stream);
+ }
+
+ // repeated .bhome_msg.MsgQueryTopicReply.BHNodeAddress node_address = 2;
+ for (unsigned int i = 0,
+ n = static_cast<unsigned int>(this->_internal_node_address_size()); i < n; i++) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(2, this->_internal_node_address(i), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgQueryTopicReply)
+ return target;
+}
+
+size_t MsgQueryTopicReply::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgQueryTopicReply)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // repeated .bhome_msg.MsgQueryTopicReply.BHNodeAddress node_address = 2;
+ total_size += 1UL * this->_internal_node_address_size();
+ for (const auto& msg : this->node_address_) {
+ total_size +=
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+ }
+
+ // .bhome_msg.ErrorMsg errmsg = 1;
+ if (this->_internal_has_errmsg()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *errmsg_);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MsgQueryTopicReply::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgQueryTopicReply*>(
+ &from));
+}
+
+void MsgQueryTopicReply::MergeFrom(const MsgQueryTopicReply& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgQueryTopicReply)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ node_address_.MergeFrom(from.node_address_);
+ if (from._internal_has_errmsg()) {
+ _internal_mutable_errmsg()->::bhome_msg::ErrorMsg::MergeFrom(from._internal_errmsg());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MsgQueryTopicReply::CopyFrom(const MsgQueryTopicReply& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgQueryTopicReply)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MsgQueryTopicReply::IsInitialized() const {
+ return true;
+}
+
+void MsgQueryTopicReply::InternalSwap(MsgQueryTopicReply* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ node_address_.InternalSwap(&other->node_address_);
+ swap(errmsg_, other->errmsg_);
+}
+
+std::string MsgQueryTopicReply::GetTypeName() const {
+ return "bhome_msg.MsgQueryTopicReply";
+}
+
+
+// ===================================================================
+
+class MsgQueryProc::_Internal {
+ public:
+};
+
+MsgQueryProc::MsgQueryProc(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgQueryProc)
+}
+MsgQueryProc::MsgQueryProc(const MsgQueryProc& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ proc_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_proc_id().empty()) {
+ proc_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_proc_id(),
+ GetArenaForAllocation());
+ }
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgQueryProc)
+}
+
+inline void MsgQueryProc::SharedCtor() {
+proc_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+MsgQueryProc::~MsgQueryProc() {
+ // @@protoc_insertion_point(destructor:bhome_msg.MsgQueryProc)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void MsgQueryProc::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ proc_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void MsgQueryProc::ArenaDtor(void* object) {
+ MsgQueryProc* _this = reinterpret_cast< MsgQueryProc* >(object);
+ (void)_this;
+}
+void MsgQueryProc::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MsgQueryProc::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void MsgQueryProc::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgQueryProc)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ proc_id_.ClearToEmpty();
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* MsgQueryProc::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // bytes proc_id = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ auto str = _internal_mutable_proc_id();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MsgQueryProc::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgQueryProc)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // bytes proc_id = 1;
+ if (!this->_internal_proc_id().empty()) {
+ target = stream->WriteBytesMaybeAliased(
+ 1, this->_internal_proc_id(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgQueryProc)
+ return target;
+}
+
+size_t MsgQueryProc::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgQueryProc)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // bytes proc_id = 1;
+ if (!this->_internal_proc_id().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_proc_id());
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MsgQueryProc::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgQueryProc*>(
+ &from));
+}
+
+void MsgQueryProc::MergeFrom(const MsgQueryProc& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgQueryProc)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (!from._internal_proc_id().empty()) {
+ _internal_set_proc_id(from._internal_proc_id());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MsgQueryProc::CopyFrom(const MsgQueryProc& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgQueryProc)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MsgQueryProc::IsInitialized() const {
+ return true;
+}
+
+void MsgQueryProc::InternalSwap(MsgQueryProc* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &proc_id_, GetArenaForAllocation(),
+ &other->proc_id_, other->GetArenaForAllocation()
+ );
+}
+
+std::string MsgQueryProc::GetTypeName() const {
+ return "bhome_msg.MsgQueryProc";
+}
+
+
+// ===================================================================
+
+class MsgQueryProcReply_Info::_Internal {
+ public:
+ static const ::bhome_msg::ProcInfo& proc(const MsgQueryProcReply_Info* msg);
+ static const ::bhome_msg::MsgTopicList& topics(const MsgQueryProcReply_Info* msg);
+};
+
+const ::bhome_msg::ProcInfo&
+MsgQueryProcReply_Info::_Internal::proc(const MsgQueryProcReply_Info* msg) {
+ return *msg->proc_;
+}
+const ::bhome_msg::MsgTopicList&
+MsgQueryProcReply_Info::_Internal::topics(const MsgQueryProcReply_Info* msg) {
+ return *msg->topics_;
+}
+MsgQueryProcReply_Info::MsgQueryProcReply_Info(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgQueryProcReply.Info)
+}
+MsgQueryProcReply_Info::MsgQueryProcReply_Info(const MsgQueryProcReply_Info& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ if (from._internal_has_proc()) {
+ proc_ = new ::bhome_msg::ProcInfo(*from.proc_);
+ } else {
+ proc_ = nullptr;
+ }
+ if (from._internal_has_topics()) {
+ topics_ = new ::bhome_msg::MsgTopicList(*from.topics_);
+ } else {
+ topics_ = nullptr;
+ }
+ online_ = from.online_;
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgQueryProcReply.Info)
+}
+
+inline void MsgQueryProcReply_Info::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&proc_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&online_) -
+ reinterpret_cast<char*>(&proc_)) + sizeof(online_));
+}
+
+MsgQueryProcReply_Info::~MsgQueryProcReply_Info() {
+ // @@protoc_insertion_point(destructor:bhome_msg.MsgQueryProcReply.Info)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void MsgQueryProcReply_Info::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (this != internal_default_instance()) delete proc_;
+ if (this != internal_default_instance()) delete topics_;
+}
+
+void MsgQueryProcReply_Info::ArenaDtor(void* object) {
+ MsgQueryProcReply_Info* _this = reinterpret_cast< MsgQueryProcReply_Info* >(object);
+ (void)_this;
+}
+void MsgQueryProcReply_Info::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MsgQueryProcReply_Info::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void MsgQueryProcReply_Info::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgQueryProcReply.Info)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ if (GetArenaForAllocation() == nullptr && proc_ != nullptr) {
+ delete proc_;
+ }
+ proc_ = nullptr;
+ if (GetArenaForAllocation() == nullptr && topics_ != nullptr) {
+ delete topics_;
+ }
+ topics_ = nullptr;
+ online_ = false;
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* MsgQueryProcReply_Info::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .bhome_msg.ProcInfo proc = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_proc(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // bool online = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
+ online_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // .bhome_msg.MsgTopicList topics = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+ ptr = ctx->ParseMessage(_internal_mutable_topics(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MsgQueryProcReply_Info::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgQueryProcReply.Info)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .bhome_msg.ProcInfo proc = 1;
+ if (this->_internal_has_proc()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::proc(this), target, stream);
+ }
+
+ // bool online = 2;
+ if (this->_internal_online() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_online(), target);
+ }
+
+ // .bhome_msg.MsgTopicList topics = 3;
+ if (this->_internal_has_topics()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 3, _Internal::topics(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgQueryProcReply.Info)
+ return target;
+}
+
+size_t MsgQueryProcReply_Info::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgQueryProcReply.Info)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // .bhome_msg.ProcInfo proc = 1;
+ if (this->_internal_has_proc()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *proc_);
+ }
+
+ // .bhome_msg.MsgTopicList topics = 3;
+ if (this->_internal_has_topics()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *topics_);
+ }
+
+ // bool online = 2;
+ if (this->_internal_online() != 0) {
+ total_size += 1 + 1;
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MsgQueryProcReply_Info::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgQueryProcReply_Info*>(
+ &from));
+}
+
+void MsgQueryProcReply_Info::MergeFrom(const MsgQueryProcReply_Info& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgQueryProcReply.Info)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from._internal_has_proc()) {
+ _internal_mutable_proc()->::bhome_msg::ProcInfo::MergeFrom(from._internal_proc());
+ }
+ if (from._internal_has_topics()) {
+ _internal_mutable_topics()->::bhome_msg::MsgTopicList::MergeFrom(from._internal_topics());
+ }
+ if (from._internal_online() != 0) {
+ _internal_set_online(from._internal_online());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MsgQueryProcReply_Info::CopyFrom(const MsgQueryProcReply_Info& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgQueryProcReply.Info)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MsgQueryProcReply_Info::IsInitialized() const {
+ return true;
+}
+
+void MsgQueryProcReply_Info::InternalSwap(MsgQueryProcReply_Info* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+ PROTOBUF_FIELD_OFFSET(MsgQueryProcReply_Info, online_)
+ + sizeof(MsgQueryProcReply_Info::online_)
+ - PROTOBUF_FIELD_OFFSET(MsgQueryProcReply_Info, proc_)>(
+ reinterpret_cast<char*>(&proc_),
+ reinterpret_cast<char*>(&other->proc_));
+}
+
+std::string MsgQueryProcReply_Info::GetTypeName() const {
+ return "bhome_msg.MsgQueryProcReply.Info";
+}
+
+
+// ===================================================================
+
+class MsgQueryProcReply::_Internal {
+ public:
+ static const ::bhome_msg::ErrorMsg& errmsg(const MsgQueryProcReply* msg);
+};
+
+const ::bhome_msg::ErrorMsg&
+MsgQueryProcReply::_Internal::errmsg(const MsgQueryProcReply* msg) {
+ return *msg->errmsg_;
+}
+void MsgQueryProcReply::clear_errmsg() {
+ if (GetArenaForAllocation() == nullptr && errmsg_ != nullptr) {
+ delete errmsg_;
+ }
+ errmsg_ = nullptr;
+}
+MsgQueryProcReply::MsgQueryProcReply(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned),
+ proc_list_(arena) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgQueryProcReply)
+}
+MsgQueryProcReply::MsgQueryProcReply(const MsgQueryProcReply& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
+ proc_list_(from.proc_list_) {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ if (from._internal_has_errmsg()) {
+ errmsg_ = new ::bhome_msg::ErrorMsg(*from.errmsg_);
+ } else {
+ errmsg_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgQueryProcReply)
+}
+
+inline void MsgQueryProcReply::SharedCtor() {
+errmsg_ = nullptr;
+}
+
+MsgQueryProcReply::~MsgQueryProcReply() {
+ // @@protoc_insertion_point(destructor:bhome_msg.MsgQueryProcReply)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void MsgQueryProcReply::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (this != internal_default_instance()) delete errmsg_;
+}
+
+void MsgQueryProcReply::ArenaDtor(void* object) {
+ MsgQueryProcReply* _this = reinterpret_cast< MsgQueryProcReply* >(object);
+ (void)_this;
+}
+void MsgQueryProcReply::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void MsgQueryProcReply::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void MsgQueryProcReply::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgQueryProcReply)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ proc_list_.Clear();
+ if (GetArenaForAllocation() == nullptr && errmsg_ != nullptr) {
+ delete errmsg_;
+ }
+ errmsg_ = nullptr;
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* MsgQueryProcReply::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .bhome_msg.ErrorMsg errmsg = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_errmsg(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // repeated .bhome_msg.MsgQueryProcReply.Info proc_list = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ ptr = ctx->ParseMessage(_internal_add_proc_list(), ptr);
+ 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) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* MsgQueryProcReply::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgQueryProcReply)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .bhome_msg.ErrorMsg errmsg = 1;
+ if (this->_internal_has_errmsg()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::errmsg(this), target, stream);
+ }
+
+ // repeated .bhome_msg.MsgQueryProcReply.Info proc_list = 2;
+ for (unsigned int i = 0,
+ n = static_cast<unsigned int>(this->_internal_proc_list_size()); i < n; i++) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(2, this->_internal_proc_list(i), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgQueryProcReply)
+ return target;
+}
+
+size_t MsgQueryProcReply::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgQueryProcReply)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // repeated .bhome_msg.MsgQueryProcReply.Info proc_list = 2;
+ total_size += 1UL * this->_internal_proc_list_size();
+ for (const auto& msg : this->proc_list_) {
+ total_size +=
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+ }
+
+ // .bhome_msg.ErrorMsg errmsg = 1;
+ if (this->_internal_has_errmsg()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *errmsg_);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void MsgQueryProcReply::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgQueryProcReply*>(
+ &from));
+}
+
+void MsgQueryProcReply::MergeFrom(const MsgQueryProcReply& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgQueryProcReply)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ proc_list_.MergeFrom(from.proc_list_);
+ if (from._internal_has_errmsg()) {
+ _internal_mutable_errmsg()->::bhome_msg::ErrorMsg::MergeFrom(from._internal_errmsg());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void MsgQueryProcReply::CopyFrom(const MsgQueryProcReply& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgQueryProcReply)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool MsgQueryProcReply::IsInitialized() const {
+ return true;
+}
+
+void MsgQueryProcReply::InternalSwap(MsgQueryProcReply* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ proc_list_.InternalSwap(&other->proc_list_);
+ swap(errmsg_, other->errmsg_);
+}
+
+std::string MsgQueryProcReply::GetTypeName() const {
+ return "bhome_msg.MsgQueryProcReply";
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+} // namespace bhome_msg
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::bhome_msg::BHAddress* Arena::CreateMaybeMessage< ::bhome_msg::BHAddress >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::BHAddress >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::ProcInfo* Arena::CreateMaybeMessage< ::bhome_msg::ProcInfo >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::ProcInfo >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::MsgTopicList* Arena::CreateMaybeMessage< ::bhome_msg::MsgTopicList >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::MsgTopicList >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::MsgPublish* Arena::CreateMaybeMessage< ::bhome_msg::MsgPublish >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::MsgPublish >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::MsgCommonReply* Arena::CreateMaybeMessage< ::bhome_msg::MsgCommonReply >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::MsgCommonReply >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::MsgRequestTopic* Arena::CreateMaybeMessage< ::bhome_msg::MsgRequestTopic >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::MsgRequestTopic >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::MsgRequestTopicReply* Arena::CreateMaybeMessage< ::bhome_msg::MsgRequestTopicReply >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::MsgRequestTopicReply >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::MsgRegister* Arena::CreateMaybeMessage< ::bhome_msg::MsgRegister >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::MsgRegister >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::MsgUnregister* Arena::CreateMaybeMessage< ::bhome_msg::MsgUnregister >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::MsgUnregister >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::MsgHeartbeat* Arena::CreateMaybeMessage< ::bhome_msg::MsgHeartbeat >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::MsgHeartbeat >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::MsgQueryTopic* Arena::CreateMaybeMessage< ::bhome_msg::MsgQueryTopic >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::MsgQueryTopic >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::MsgQueryTopicReply_BHNodeAddress* Arena::CreateMaybeMessage< ::bhome_msg::MsgQueryTopicReply_BHNodeAddress >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::MsgQueryTopicReply_BHNodeAddress >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::MsgQueryTopicReply* Arena::CreateMaybeMessage< ::bhome_msg::MsgQueryTopicReply >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::MsgQueryTopicReply >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::MsgQueryProc* Arena::CreateMaybeMessage< ::bhome_msg::MsgQueryProc >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::MsgQueryProc >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::MsgQueryProcReply_Info* Arena::CreateMaybeMessage< ::bhome_msg::MsgQueryProcReply_Info >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::MsgQueryProcReply_Info >(arena);
+}
+template<> PROTOBUF_NOINLINE ::bhome_msg::MsgQueryProcReply* Arena::CreateMaybeMessage< ::bhome_msg::MsgQueryProcReply >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::MsgQueryProcReply >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>
diff --git a/src/proto/bhome_msg_api.pb.h b/src/proto/bhome_msg_api.pb.h
new file mode 100644
index 0000000..ab0b455
--- /dev/null
+++ b/src/proto/bhome_msg_api.pb.h
@@ -0,0 +1,4283 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: bhome_msg_api.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_bhome_5fmsg_5fapi_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_bhome_5fmsg_5fapi_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/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/metadata_lite.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/repeated_field.h> // IWYU pragma: export
+#include <google/protobuf/extension_set.h> // IWYU pragma: export
+#include "error_msg.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_bhome_5fmsg_5fapi_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+} // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_bhome_5fmsg_5fapi_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[16]
+ 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[];
+};
+namespace bhome_msg {
+class BHAddress;
+struct BHAddressDefaultTypeInternal;
+extern BHAddressDefaultTypeInternal _BHAddress_default_instance_;
+class MsgCommonReply;
+struct MsgCommonReplyDefaultTypeInternal;
+extern MsgCommonReplyDefaultTypeInternal _MsgCommonReply_default_instance_;
+class MsgHeartbeat;
+struct MsgHeartbeatDefaultTypeInternal;
+extern MsgHeartbeatDefaultTypeInternal _MsgHeartbeat_default_instance_;
+class MsgPublish;
+struct MsgPublishDefaultTypeInternal;
+extern MsgPublishDefaultTypeInternal _MsgPublish_default_instance_;
+class MsgQueryProc;
+struct MsgQueryProcDefaultTypeInternal;
+extern MsgQueryProcDefaultTypeInternal _MsgQueryProc_default_instance_;
+class MsgQueryProcReply;
+struct MsgQueryProcReplyDefaultTypeInternal;
+extern MsgQueryProcReplyDefaultTypeInternal _MsgQueryProcReply_default_instance_;
+class MsgQueryProcReply_Info;
+struct MsgQueryProcReply_InfoDefaultTypeInternal;
+extern MsgQueryProcReply_InfoDefaultTypeInternal _MsgQueryProcReply_Info_default_instance_;
+class MsgQueryTopic;
+struct MsgQueryTopicDefaultTypeInternal;
+extern MsgQueryTopicDefaultTypeInternal _MsgQueryTopic_default_instance_;
+class MsgQueryTopicReply;
+struct MsgQueryTopicReplyDefaultTypeInternal;
+extern MsgQueryTopicReplyDefaultTypeInternal _MsgQueryTopicReply_default_instance_;
+class MsgQueryTopicReply_BHNodeAddress;
+struct MsgQueryTopicReply_BHNodeAddressDefaultTypeInternal;
+extern MsgQueryTopicReply_BHNodeAddressDefaultTypeInternal _MsgQueryTopicReply_BHNodeAddress_default_instance_;
+class MsgRegister;
+struct MsgRegisterDefaultTypeInternal;
+extern MsgRegisterDefaultTypeInternal _MsgRegister_default_instance_;
+class MsgRequestTopic;
+struct MsgRequestTopicDefaultTypeInternal;
+extern MsgRequestTopicDefaultTypeInternal _MsgRequestTopic_default_instance_;
+class MsgRequestTopicReply;
+struct MsgRequestTopicReplyDefaultTypeInternal;
+extern MsgRequestTopicReplyDefaultTypeInternal _MsgRequestTopicReply_default_instance_;
+class MsgTopicList;
+struct MsgTopicListDefaultTypeInternal;
+extern MsgTopicListDefaultTypeInternal _MsgTopicList_default_instance_;
+class MsgUnregister;
+struct MsgUnregisterDefaultTypeInternal;
+extern MsgUnregisterDefaultTypeInternal _MsgUnregister_default_instance_;
+class ProcInfo;
+struct ProcInfoDefaultTypeInternal;
+extern ProcInfoDefaultTypeInternal _ProcInfo_default_instance_;
+} // namespace bhome_msg
+PROTOBUF_NAMESPACE_OPEN
+template<> ::bhome_msg::BHAddress* Arena::CreateMaybeMessage<::bhome_msg::BHAddress>(Arena*);
+template<> ::bhome_msg::MsgCommonReply* Arena::CreateMaybeMessage<::bhome_msg::MsgCommonReply>(Arena*);
+template<> ::bhome_msg::MsgHeartbeat* Arena::CreateMaybeMessage<::bhome_msg::MsgHeartbeat>(Arena*);
+template<> ::bhome_msg::MsgPublish* Arena::CreateMaybeMessage<::bhome_msg::MsgPublish>(Arena*);
+template<> ::bhome_msg::MsgQueryProc* Arena::CreateMaybeMessage<::bhome_msg::MsgQueryProc>(Arena*);
+template<> ::bhome_msg::MsgQueryProcReply* Arena::CreateMaybeMessage<::bhome_msg::MsgQueryProcReply>(Arena*);
+template<> ::bhome_msg::MsgQueryProcReply_Info* Arena::CreateMaybeMessage<::bhome_msg::MsgQueryProcReply_Info>(Arena*);
+template<> ::bhome_msg::MsgQueryTopic* Arena::CreateMaybeMessage<::bhome_msg::MsgQueryTopic>(Arena*);
+template<> ::bhome_msg::MsgQueryTopicReply* Arena::CreateMaybeMessage<::bhome_msg::MsgQueryTopicReply>(Arena*);
+template<> ::bhome_msg::MsgQueryTopicReply_BHNodeAddress* Arena::CreateMaybeMessage<::bhome_msg::MsgQueryTopicReply_BHNodeAddress>(Arena*);
+template<> ::bhome_msg::MsgRegister* Arena::CreateMaybeMessage<::bhome_msg::MsgRegister>(Arena*);
+template<> ::bhome_msg::MsgRequestTopic* Arena::CreateMaybeMessage<::bhome_msg::MsgRequestTopic>(Arena*);
+template<> ::bhome_msg::MsgRequestTopicReply* Arena::CreateMaybeMessage<::bhome_msg::MsgRequestTopicReply>(Arena*);
+template<> ::bhome_msg::MsgTopicList* Arena::CreateMaybeMessage<::bhome_msg::MsgTopicList>(Arena*);
+template<> ::bhome_msg::MsgUnregister* Arena::CreateMaybeMessage<::bhome_msg::MsgUnregister>(Arena*);
+template<> ::bhome_msg::ProcInfo* Arena::CreateMaybeMessage<::bhome_msg::ProcInfo>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace bhome_msg {
+
+// ===================================================================
+
+class BHAddress final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.BHAddress) */ {
+ public:
+ inline BHAddress() : BHAddress(nullptr) {}
+ ~BHAddress() override;
+ explicit constexpr BHAddress(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ BHAddress(const BHAddress& from);
+ BHAddress(BHAddress&& from) noexcept
+ : BHAddress() {
+ *this = ::std::move(from);
+ }
+
+ inline BHAddress& operator=(const BHAddress& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline BHAddress& operator=(BHAddress&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const BHAddress& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const BHAddress* internal_default_instance() {
+ return reinterpret_cast<const BHAddress*>(
+ &_BHAddress_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 0;
+
+ friend void swap(BHAddress& a, BHAddress& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(BHAddress* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(BHAddress* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline BHAddress* New() const final {
+ return new BHAddress();
+ }
+
+ BHAddress* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<BHAddress>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const BHAddress& from);
+ void MergeFrom(const BHAddress& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(BHAddress* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.BHAddress";
+ }
+ protected:
+ explicit BHAddress(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kIpFieldNumber = 3,
+ kMqIdFieldNumber = 1,
+ kAbsAddrFieldNumber = 2,
+ kPortFieldNumber = 4,
+ };
+ // bytes ip = 3;
+ void clear_ip();
+ const std::string& ip() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_ip(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_ip();
+ PROTOBUF_MUST_USE_RESULT std::string* release_ip();
+ void set_allocated_ip(std::string* ip);
+ private:
+ const std::string& _internal_ip() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_ip(const std::string& value);
+ std::string* _internal_mutable_ip();
+ public:
+
+ // uint64 mq_id = 1;
+ void clear_mq_id();
+ ::PROTOBUF_NAMESPACE_ID::uint64 mq_id() const;
+ void set_mq_id(::PROTOBUF_NAMESPACE_ID::uint64 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::uint64 _internal_mq_id() const;
+ void _internal_set_mq_id(::PROTOBUF_NAMESPACE_ID::uint64 value);
+ public:
+
+ // int64 abs_addr = 2;
+ void clear_abs_addr();
+ ::PROTOBUF_NAMESPACE_ID::int64 abs_addr() const;
+ void set_abs_addr(::PROTOBUF_NAMESPACE_ID::int64 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int64 _internal_abs_addr() const;
+ void _internal_set_abs_addr(::PROTOBUF_NAMESPACE_ID::int64 value);
+ public:
+
+ // int32 port = 4;
+ void clear_port();
+ ::PROTOBUF_NAMESPACE_ID::int32 port() const;
+ void set_port(::PROTOBUF_NAMESPACE_ID::int32 value);
+ private:
+ ::PROTOBUF_NAMESPACE_ID::int32 _internal_port() const;
+ void _internal_set_port(::PROTOBUF_NAMESPACE_ID::int32 value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.BHAddress)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ip_;
+ ::PROTOBUF_NAMESPACE_ID::uint64 mq_id_;
+ ::PROTOBUF_NAMESPACE_ID::int64 abs_addr_;
+ ::PROTOBUF_NAMESPACE_ID::int32 port_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProcInfo final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.ProcInfo) */ {
+ public:
+ inline ProcInfo() : ProcInfo(nullptr) {}
+ ~ProcInfo() override;
+ explicit constexpr ProcInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ ProcInfo(const ProcInfo& from);
+ ProcInfo(ProcInfo&& from) noexcept
+ : ProcInfo() {
+ *this = ::std::move(from);
+ }
+
+ inline ProcInfo& operator=(const ProcInfo& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline ProcInfo& operator=(ProcInfo&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ProcInfo& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const ProcInfo* internal_default_instance() {
+ return reinterpret_cast<const ProcInfo*>(
+ &_ProcInfo_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 1;
+
+ friend void swap(ProcInfo& a, ProcInfo& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(ProcInfo* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(ProcInfo* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline ProcInfo* New() const final {
+ return new ProcInfo();
+ }
+
+ ProcInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<ProcInfo>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const ProcInfo& from);
+ void MergeFrom(const ProcInfo& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(ProcInfo* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.ProcInfo";
+ }
+ protected:
+ explicit ProcInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kProcIdFieldNumber = 1,
+ kNameFieldNumber = 2,
+ kPublicInfoFieldNumber = 3,
+ kPrivateInfoFieldNumber = 4,
+ };
+ // bytes proc_id = 1;
+ void clear_proc_id();
+ const std::string& proc_id() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_proc_id(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_proc_id();
+ PROTOBUF_MUST_USE_RESULT std::string* release_proc_id();
+ void set_allocated_proc_id(std::string* proc_id);
+ private:
+ const std::string& _internal_proc_id() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_proc_id(const std::string& value);
+ std::string* _internal_mutable_proc_id();
+ public:
+
+ // bytes name = 2;
+ void clear_name();
+ const std::string& name() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_name(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_name();
+ PROTOBUF_MUST_USE_RESULT std::string* release_name();
+ void set_allocated_name(std::string* name);
+ private:
+ const std::string& _internal_name() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+ std::string* _internal_mutable_name();
+ public:
+
+ // bytes public_info = 3;
+ void clear_public_info();
+ const std::string& public_info() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_public_info(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_public_info();
+ PROTOBUF_MUST_USE_RESULT std::string* release_public_info();
+ void set_allocated_public_info(std::string* public_info);
+ private:
+ const std::string& _internal_public_info() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_public_info(const std::string& value);
+ std::string* _internal_mutable_public_info();
+ public:
+
+ // bytes private_info = 4;
+ void clear_private_info();
+ const std::string& private_info() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_private_info(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_private_info();
+ PROTOBUF_MUST_USE_RESULT std::string* release_private_info();
+ void set_allocated_private_info(std::string* private_info);
+ private:
+ const std::string& _internal_private_info() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_private_info(const std::string& value);
+ std::string* _internal_mutable_private_info();
+ public:
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.ProcInfo)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr proc_id_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr public_info_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr private_info_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgTopicList final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgTopicList) */ {
+ public:
+ inline MsgTopicList() : MsgTopicList(nullptr) {}
+ ~MsgTopicList() override;
+ explicit constexpr MsgTopicList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ MsgTopicList(const MsgTopicList& from);
+ MsgTopicList(MsgTopicList&& from) noexcept
+ : MsgTopicList() {
+ *this = ::std::move(from);
+ }
+
+ inline MsgTopicList& operator=(const MsgTopicList& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MsgTopicList& operator=(MsgTopicList&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const MsgTopicList& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const MsgTopicList* internal_default_instance() {
+ return reinterpret_cast<const MsgTopicList*>(
+ &_MsgTopicList_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 2;
+
+ friend void swap(MsgTopicList& a, MsgTopicList& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MsgTopicList* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(MsgTopicList* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MsgTopicList* New() const final {
+ return new MsgTopicList();
+ }
+
+ MsgTopicList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MsgTopicList>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const MsgTopicList& from);
+ void MergeFrom(const MsgTopicList& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(MsgTopicList* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.MsgTopicList";
+ }
+ protected:
+ explicit MsgTopicList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kTopicListFieldNumber = 1,
+ };
+ // repeated bytes topic_list = 1;
+ int topic_list_size() const;
+ private:
+ int _internal_topic_list_size() const;
+ public:
+ void clear_topic_list();
+ const std::string& topic_list(int index) const;
+ std::string* mutable_topic_list(int index);
+ void set_topic_list(int index, const std::string& value);
+ void set_topic_list(int index, std::string&& value);
+ void set_topic_list(int index, const char* value);
+ void set_topic_list(int index, const void* value, size_t size);
+ std::string* add_topic_list();
+ void add_topic_list(const std::string& value);
+ void add_topic_list(std::string&& value);
+ void add_topic_list(const char* value);
+ void add_topic_list(const void* value, size_t size);
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& topic_list() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_topic_list();
+ private:
+ const std::string& _internal_topic_list(int index) const;
+ std::string* _internal_add_topic_list();
+ public:
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.MsgTopicList)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> topic_list_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgPublish final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgPublish) */ {
+ public:
+ inline MsgPublish() : MsgPublish(nullptr) {}
+ ~MsgPublish() override;
+ explicit constexpr MsgPublish(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ MsgPublish(const MsgPublish& from);
+ MsgPublish(MsgPublish&& from) noexcept
+ : MsgPublish() {
+ *this = ::std::move(from);
+ }
+
+ inline MsgPublish& operator=(const MsgPublish& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MsgPublish& operator=(MsgPublish&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const MsgPublish& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const MsgPublish* internal_default_instance() {
+ return reinterpret_cast<const MsgPublish*>(
+ &_MsgPublish_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 3;
+
+ friend void swap(MsgPublish& a, MsgPublish& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MsgPublish* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(MsgPublish* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MsgPublish* New() const final {
+ return new MsgPublish();
+ }
+
+ MsgPublish* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MsgPublish>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const MsgPublish& from);
+ void MergeFrom(const MsgPublish& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(MsgPublish* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.MsgPublish";
+ }
+ protected:
+ explicit MsgPublish(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kTopicFieldNumber = 1,
+ kDataFieldNumber = 2,
+ };
+ // bytes topic = 1;
+ void clear_topic();
+ const std::string& topic() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_topic(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_topic();
+ PROTOBUF_MUST_USE_RESULT std::string* release_topic();
+ void set_allocated_topic(std::string* topic);
+ private:
+ const std::string& _internal_topic() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_topic(const std::string& value);
+ std::string* _internal_mutable_topic();
+ public:
+
+ // bytes data = 2;
+ void clear_data();
+ const std::string& data() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_data(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_data();
+ PROTOBUF_MUST_USE_RESULT std::string* release_data();
+ void set_allocated_data(std::string* data);
+ private:
+ const std::string& _internal_data() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
+ std::string* _internal_mutable_data();
+ public:
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.MsgPublish)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr topic_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgCommonReply final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgCommonReply) */ {
+ public:
+ inline MsgCommonReply() : MsgCommonReply(nullptr) {}
+ ~MsgCommonReply() override;
+ explicit constexpr MsgCommonReply(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ MsgCommonReply(const MsgCommonReply& from);
+ MsgCommonReply(MsgCommonReply&& from) noexcept
+ : MsgCommonReply() {
+ *this = ::std::move(from);
+ }
+
+ inline MsgCommonReply& operator=(const MsgCommonReply& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MsgCommonReply& operator=(MsgCommonReply&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const MsgCommonReply& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const MsgCommonReply* internal_default_instance() {
+ return reinterpret_cast<const MsgCommonReply*>(
+ &_MsgCommonReply_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 4;
+
+ friend void swap(MsgCommonReply& a, MsgCommonReply& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MsgCommonReply* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(MsgCommonReply* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MsgCommonReply* New() const final {
+ return new MsgCommonReply();
+ }
+
+ MsgCommonReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MsgCommonReply>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const MsgCommonReply& from);
+ void MergeFrom(const MsgCommonReply& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(MsgCommonReply* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.MsgCommonReply";
+ }
+ protected:
+ explicit MsgCommonReply(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kErrmsgFieldNumber = 1,
+ };
+ // .bhome_msg.ErrorMsg errmsg = 1;
+ bool has_errmsg() const;
+ private:
+ bool _internal_has_errmsg() const;
+ public:
+ void clear_errmsg();
+ const ::bhome_msg::ErrorMsg& errmsg() const;
+ PROTOBUF_MUST_USE_RESULT ::bhome_msg::ErrorMsg* release_errmsg();
+ ::bhome_msg::ErrorMsg* mutable_errmsg();
+ void set_allocated_errmsg(::bhome_msg::ErrorMsg* errmsg);
+ private:
+ const ::bhome_msg::ErrorMsg& _internal_errmsg() const;
+ ::bhome_msg::ErrorMsg* _internal_mutable_errmsg();
+ public:
+ void unsafe_arena_set_allocated_errmsg(
+ ::bhome_msg::ErrorMsg* errmsg);
+ ::bhome_msg::ErrorMsg* unsafe_arena_release_errmsg();
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.MsgCommonReply)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::bhome_msg::ErrorMsg* errmsg_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgRequestTopic final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgRequestTopic) */ {
+ public:
+ inline MsgRequestTopic() : MsgRequestTopic(nullptr) {}
+ ~MsgRequestTopic() override;
+ explicit constexpr MsgRequestTopic(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ MsgRequestTopic(const MsgRequestTopic& from);
+ MsgRequestTopic(MsgRequestTopic&& from) noexcept
+ : MsgRequestTopic() {
+ *this = ::std::move(from);
+ }
+
+ inline MsgRequestTopic& operator=(const MsgRequestTopic& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MsgRequestTopic& operator=(MsgRequestTopic&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const MsgRequestTopic& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const MsgRequestTopic* internal_default_instance() {
+ return reinterpret_cast<const MsgRequestTopic*>(
+ &_MsgRequestTopic_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 5;
+
+ friend void swap(MsgRequestTopic& a, MsgRequestTopic& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MsgRequestTopic* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(MsgRequestTopic* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MsgRequestTopic* New() const final {
+ return new MsgRequestTopic();
+ }
+
+ MsgRequestTopic* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MsgRequestTopic>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const MsgRequestTopic& from);
+ void MergeFrom(const MsgRequestTopic& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(MsgRequestTopic* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.MsgRequestTopic";
+ }
+ protected:
+ explicit MsgRequestTopic(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kTopicFieldNumber = 1,
+ kDataFieldNumber = 2,
+ };
+ // bytes topic = 1;
+ void clear_topic();
+ const std::string& topic() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_topic(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_topic();
+ PROTOBUF_MUST_USE_RESULT std::string* release_topic();
+ void set_allocated_topic(std::string* topic);
+ private:
+ const std::string& _internal_topic() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_topic(const std::string& value);
+ std::string* _internal_mutable_topic();
+ public:
+
+ // bytes data = 2;
+ void clear_data();
+ const std::string& data() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_data(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_data();
+ PROTOBUF_MUST_USE_RESULT std::string* release_data();
+ void set_allocated_data(std::string* data);
+ private:
+ const std::string& _internal_data() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
+ std::string* _internal_mutable_data();
+ public:
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.MsgRequestTopic)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr topic_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgRequestTopicReply final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgRequestTopicReply) */ {
+ public:
+ inline MsgRequestTopicReply() : MsgRequestTopicReply(nullptr) {}
+ ~MsgRequestTopicReply() override;
+ explicit constexpr MsgRequestTopicReply(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ MsgRequestTopicReply(const MsgRequestTopicReply& from);
+ MsgRequestTopicReply(MsgRequestTopicReply&& from) noexcept
+ : MsgRequestTopicReply() {
+ *this = ::std::move(from);
+ }
+
+ inline MsgRequestTopicReply& operator=(const MsgRequestTopicReply& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MsgRequestTopicReply& operator=(MsgRequestTopicReply&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const MsgRequestTopicReply& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const MsgRequestTopicReply* internal_default_instance() {
+ return reinterpret_cast<const MsgRequestTopicReply*>(
+ &_MsgRequestTopicReply_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 6;
+
+ friend void swap(MsgRequestTopicReply& a, MsgRequestTopicReply& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MsgRequestTopicReply* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(MsgRequestTopicReply* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MsgRequestTopicReply* New() const final {
+ return new MsgRequestTopicReply();
+ }
+
+ MsgRequestTopicReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MsgRequestTopicReply>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const MsgRequestTopicReply& from);
+ void MergeFrom(const MsgRequestTopicReply& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(MsgRequestTopicReply* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.MsgRequestTopicReply";
+ }
+ protected:
+ explicit MsgRequestTopicReply(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kDataFieldNumber = 2,
+ kErrmsgFieldNumber = 1,
+ };
+ // bytes data = 2;
+ void clear_data();
+ const std::string& data() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_data(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_data();
+ PROTOBUF_MUST_USE_RESULT std::string* release_data();
+ void set_allocated_data(std::string* data);
+ private:
+ const std::string& _internal_data() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
+ std::string* _internal_mutable_data();
+ public:
+
+ // .bhome_msg.ErrorMsg errmsg = 1;
+ bool has_errmsg() const;
+ private:
+ bool _internal_has_errmsg() const;
+ public:
+ void clear_errmsg();
+ const ::bhome_msg::ErrorMsg& errmsg() const;
+ PROTOBUF_MUST_USE_RESULT ::bhome_msg::ErrorMsg* release_errmsg();
+ ::bhome_msg::ErrorMsg* mutable_errmsg();
+ void set_allocated_errmsg(::bhome_msg::ErrorMsg* errmsg);
+ private:
+ const ::bhome_msg::ErrorMsg& _internal_errmsg() const;
+ ::bhome_msg::ErrorMsg* _internal_mutable_errmsg();
+ public:
+ void unsafe_arena_set_allocated_errmsg(
+ ::bhome_msg::ErrorMsg* errmsg);
+ ::bhome_msg::ErrorMsg* unsafe_arena_release_errmsg();
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.MsgRequestTopicReply)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
+ ::bhome_msg::ErrorMsg* errmsg_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgRegister final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgRegister) */ {
+ public:
+ inline MsgRegister() : MsgRegister(nullptr) {}
+ ~MsgRegister() override;
+ explicit constexpr MsgRegister(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ MsgRegister(const MsgRegister& from);
+ MsgRegister(MsgRegister&& from) noexcept
+ : MsgRegister() {
+ *this = ::std::move(from);
+ }
+
+ inline MsgRegister& operator=(const MsgRegister& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MsgRegister& operator=(MsgRegister&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const MsgRegister& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const MsgRegister* internal_default_instance() {
+ return reinterpret_cast<const MsgRegister*>(
+ &_MsgRegister_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 7;
+
+ friend void swap(MsgRegister& a, MsgRegister& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MsgRegister* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(MsgRegister* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MsgRegister* New() const final {
+ return new MsgRegister();
+ }
+
+ MsgRegister* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MsgRegister>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const MsgRegister& from);
+ void MergeFrom(const MsgRegister& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(MsgRegister* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.MsgRegister";
+ }
+ protected:
+ explicit MsgRegister(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kProcFieldNumber = 1,
+ };
+ // .bhome_msg.ProcInfo proc = 1;
+ bool has_proc() const;
+ private:
+ bool _internal_has_proc() const;
+ public:
+ void clear_proc();
+ const ::bhome_msg::ProcInfo& proc() const;
+ PROTOBUF_MUST_USE_RESULT ::bhome_msg::ProcInfo* release_proc();
+ ::bhome_msg::ProcInfo* mutable_proc();
+ void set_allocated_proc(::bhome_msg::ProcInfo* proc);
+ private:
+ const ::bhome_msg::ProcInfo& _internal_proc() const;
+ ::bhome_msg::ProcInfo* _internal_mutable_proc();
+ public:
+ void unsafe_arena_set_allocated_proc(
+ ::bhome_msg::ProcInfo* proc);
+ ::bhome_msg::ProcInfo* unsafe_arena_release_proc();
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.MsgRegister)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::bhome_msg::ProcInfo* proc_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgUnregister final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgUnregister) */ {
+ public:
+ inline MsgUnregister() : MsgUnregister(nullptr) {}
+ ~MsgUnregister() override;
+ explicit constexpr MsgUnregister(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ MsgUnregister(const MsgUnregister& from);
+ MsgUnregister(MsgUnregister&& from) noexcept
+ : MsgUnregister() {
+ *this = ::std::move(from);
+ }
+
+ inline MsgUnregister& operator=(const MsgUnregister& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MsgUnregister& operator=(MsgUnregister&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const MsgUnregister& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const MsgUnregister* internal_default_instance() {
+ return reinterpret_cast<const MsgUnregister*>(
+ &_MsgUnregister_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 8;
+
+ friend void swap(MsgUnregister& a, MsgUnregister& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MsgUnregister* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(MsgUnregister* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MsgUnregister* New() const final {
+ return new MsgUnregister();
+ }
+
+ MsgUnregister* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MsgUnregister>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const MsgUnregister& from);
+ void MergeFrom(const MsgUnregister& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(MsgUnregister* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.MsgUnregister";
+ }
+ protected:
+ explicit MsgUnregister(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kProcFieldNumber = 1,
+ };
+ // .bhome_msg.ProcInfo proc = 1;
+ bool has_proc() const;
+ private:
+ bool _internal_has_proc() const;
+ public:
+ void clear_proc();
+ const ::bhome_msg::ProcInfo& proc() const;
+ PROTOBUF_MUST_USE_RESULT ::bhome_msg::ProcInfo* release_proc();
+ ::bhome_msg::ProcInfo* mutable_proc();
+ void set_allocated_proc(::bhome_msg::ProcInfo* proc);
+ private:
+ const ::bhome_msg::ProcInfo& _internal_proc() const;
+ ::bhome_msg::ProcInfo* _internal_mutable_proc();
+ public:
+ void unsafe_arena_set_allocated_proc(
+ ::bhome_msg::ProcInfo* proc);
+ ::bhome_msg::ProcInfo* unsafe_arena_release_proc();
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.MsgUnregister)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::bhome_msg::ProcInfo* proc_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgHeartbeat final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgHeartbeat) */ {
+ public:
+ inline MsgHeartbeat() : MsgHeartbeat(nullptr) {}
+ ~MsgHeartbeat() override;
+ explicit constexpr MsgHeartbeat(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ MsgHeartbeat(const MsgHeartbeat& from);
+ MsgHeartbeat(MsgHeartbeat&& from) noexcept
+ : MsgHeartbeat() {
+ *this = ::std::move(from);
+ }
+
+ inline MsgHeartbeat& operator=(const MsgHeartbeat& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MsgHeartbeat& operator=(MsgHeartbeat&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const MsgHeartbeat& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const MsgHeartbeat* internal_default_instance() {
+ return reinterpret_cast<const MsgHeartbeat*>(
+ &_MsgHeartbeat_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 9;
+
+ friend void swap(MsgHeartbeat& a, MsgHeartbeat& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MsgHeartbeat* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(MsgHeartbeat* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MsgHeartbeat* New() const final {
+ return new MsgHeartbeat();
+ }
+
+ MsgHeartbeat* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MsgHeartbeat>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const MsgHeartbeat& from);
+ void MergeFrom(const MsgHeartbeat& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(MsgHeartbeat* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.MsgHeartbeat";
+ }
+ protected:
+ explicit MsgHeartbeat(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kProcFieldNumber = 1,
+ };
+ // .bhome_msg.ProcInfo proc = 1;
+ bool has_proc() const;
+ private:
+ bool _internal_has_proc() const;
+ public:
+ void clear_proc();
+ const ::bhome_msg::ProcInfo& proc() const;
+ PROTOBUF_MUST_USE_RESULT ::bhome_msg::ProcInfo* release_proc();
+ ::bhome_msg::ProcInfo* mutable_proc();
+ void set_allocated_proc(::bhome_msg::ProcInfo* proc);
+ private:
+ const ::bhome_msg::ProcInfo& _internal_proc() const;
+ ::bhome_msg::ProcInfo* _internal_mutable_proc();
+ public:
+ void unsafe_arena_set_allocated_proc(
+ ::bhome_msg::ProcInfo* proc);
+ ::bhome_msg::ProcInfo* unsafe_arena_release_proc();
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.MsgHeartbeat)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::bhome_msg::ProcInfo* proc_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgQueryTopic final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgQueryTopic) */ {
+ public:
+ inline MsgQueryTopic() : MsgQueryTopic(nullptr) {}
+ ~MsgQueryTopic() override;
+ explicit constexpr MsgQueryTopic(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ MsgQueryTopic(const MsgQueryTopic& from);
+ MsgQueryTopic(MsgQueryTopic&& from) noexcept
+ : MsgQueryTopic() {
+ *this = ::std::move(from);
+ }
+
+ inline MsgQueryTopic& operator=(const MsgQueryTopic& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MsgQueryTopic& operator=(MsgQueryTopic&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const MsgQueryTopic& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const MsgQueryTopic* internal_default_instance() {
+ return reinterpret_cast<const MsgQueryTopic*>(
+ &_MsgQueryTopic_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 10;
+
+ friend void swap(MsgQueryTopic& a, MsgQueryTopic& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MsgQueryTopic* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(MsgQueryTopic* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MsgQueryTopic* New() const final {
+ return new MsgQueryTopic();
+ }
+
+ MsgQueryTopic* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MsgQueryTopic>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const MsgQueryTopic& from);
+ void MergeFrom(const MsgQueryTopic& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(MsgQueryTopic* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.MsgQueryTopic";
+ }
+ protected:
+ explicit MsgQueryTopic(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kTopicFieldNumber = 1,
+ };
+ // bytes topic = 1;
+ void clear_topic();
+ const std::string& topic() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_topic(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_topic();
+ PROTOBUF_MUST_USE_RESULT std::string* release_topic();
+ void set_allocated_topic(std::string* topic);
+ private:
+ const std::string& _internal_topic() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_topic(const std::string& value);
+ std::string* _internal_mutable_topic();
+ public:
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.MsgQueryTopic)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr topic_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgQueryTopicReply_BHNodeAddress final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgQueryTopicReply.BHNodeAddress) */ {
+ public:
+ inline MsgQueryTopicReply_BHNodeAddress() : MsgQueryTopicReply_BHNodeAddress(nullptr) {}
+ ~MsgQueryTopicReply_BHNodeAddress() override;
+ explicit constexpr MsgQueryTopicReply_BHNodeAddress(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ MsgQueryTopicReply_BHNodeAddress(const MsgQueryTopicReply_BHNodeAddress& from);
+ MsgQueryTopicReply_BHNodeAddress(MsgQueryTopicReply_BHNodeAddress&& from) noexcept
+ : MsgQueryTopicReply_BHNodeAddress() {
+ *this = ::std::move(from);
+ }
+
+ inline MsgQueryTopicReply_BHNodeAddress& operator=(const MsgQueryTopicReply_BHNodeAddress& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MsgQueryTopicReply_BHNodeAddress& operator=(MsgQueryTopicReply_BHNodeAddress&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const MsgQueryTopicReply_BHNodeAddress& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const MsgQueryTopicReply_BHNodeAddress* internal_default_instance() {
+ return reinterpret_cast<const MsgQueryTopicReply_BHNodeAddress*>(
+ &_MsgQueryTopicReply_BHNodeAddress_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 11;
+
+ friend void swap(MsgQueryTopicReply_BHNodeAddress& a, MsgQueryTopicReply_BHNodeAddress& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MsgQueryTopicReply_BHNodeAddress* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(MsgQueryTopicReply_BHNodeAddress* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MsgQueryTopicReply_BHNodeAddress* New() const final {
+ return new MsgQueryTopicReply_BHNodeAddress();
+ }
+
+ MsgQueryTopicReply_BHNodeAddress* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MsgQueryTopicReply_BHNodeAddress>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const MsgQueryTopicReply_BHNodeAddress& from);
+ void MergeFrom(const MsgQueryTopicReply_BHNodeAddress& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(MsgQueryTopicReply_BHNodeAddress* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.MsgQueryTopicReply.BHNodeAddress";
+ }
+ protected:
+ explicit MsgQueryTopicReply_BHNodeAddress(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kProcIdFieldNumber = 1,
+ kAddrFieldNumber = 2,
+ };
+ // bytes proc_id = 1;
+ void clear_proc_id();
+ const std::string& proc_id() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_proc_id(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_proc_id();
+ PROTOBUF_MUST_USE_RESULT std::string* release_proc_id();
+ void set_allocated_proc_id(std::string* proc_id);
+ private:
+ const std::string& _internal_proc_id() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_proc_id(const std::string& value);
+ std::string* _internal_mutable_proc_id();
+ public:
+
+ // .bhome_msg.BHAddress addr = 2;
+ bool has_addr() const;
+ private:
+ bool _internal_has_addr() const;
+ public:
+ void clear_addr();
+ const ::bhome_msg::BHAddress& addr() const;
+ PROTOBUF_MUST_USE_RESULT ::bhome_msg::BHAddress* release_addr();
+ ::bhome_msg::BHAddress* mutable_addr();
+ void set_allocated_addr(::bhome_msg::BHAddress* addr);
+ private:
+ const ::bhome_msg::BHAddress& _internal_addr() const;
+ ::bhome_msg::BHAddress* _internal_mutable_addr();
+ public:
+ void unsafe_arena_set_allocated_addr(
+ ::bhome_msg::BHAddress* addr);
+ ::bhome_msg::BHAddress* unsafe_arena_release_addr();
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.MsgQueryTopicReply.BHNodeAddress)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr proc_id_;
+ ::bhome_msg::BHAddress* addr_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgQueryTopicReply final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgQueryTopicReply) */ {
+ public:
+ inline MsgQueryTopicReply() : MsgQueryTopicReply(nullptr) {}
+ ~MsgQueryTopicReply() override;
+ explicit constexpr MsgQueryTopicReply(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ MsgQueryTopicReply(const MsgQueryTopicReply& from);
+ MsgQueryTopicReply(MsgQueryTopicReply&& from) noexcept
+ : MsgQueryTopicReply() {
+ *this = ::std::move(from);
+ }
+
+ inline MsgQueryTopicReply& operator=(const MsgQueryTopicReply& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MsgQueryTopicReply& operator=(MsgQueryTopicReply&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const MsgQueryTopicReply& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const MsgQueryTopicReply* internal_default_instance() {
+ return reinterpret_cast<const MsgQueryTopicReply*>(
+ &_MsgQueryTopicReply_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 12;
+
+ friend void swap(MsgQueryTopicReply& a, MsgQueryTopicReply& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MsgQueryTopicReply* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(MsgQueryTopicReply* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MsgQueryTopicReply* New() const final {
+ return new MsgQueryTopicReply();
+ }
+
+ MsgQueryTopicReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MsgQueryTopicReply>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const MsgQueryTopicReply& from);
+ void MergeFrom(const MsgQueryTopicReply& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(MsgQueryTopicReply* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.MsgQueryTopicReply";
+ }
+ protected:
+ explicit MsgQueryTopicReply(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ typedef MsgQueryTopicReply_BHNodeAddress BHNodeAddress;
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kNodeAddressFieldNumber = 2,
+ kErrmsgFieldNumber = 1,
+ };
+ // repeated .bhome_msg.MsgQueryTopicReply.BHNodeAddress node_address = 2;
+ int node_address_size() const;
+ private:
+ int _internal_node_address_size() const;
+ public:
+ void clear_node_address();
+ ::bhome_msg::MsgQueryTopicReply_BHNodeAddress* mutable_node_address(int index);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::MsgQueryTopicReply_BHNodeAddress >*
+ mutable_node_address();
+ private:
+ const ::bhome_msg::MsgQueryTopicReply_BHNodeAddress& _internal_node_address(int index) const;
+ ::bhome_msg::MsgQueryTopicReply_BHNodeAddress* _internal_add_node_address();
+ public:
+ const ::bhome_msg::MsgQueryTopicReply_BHNodeAddress& node_address(int index) const;
+ ::bhome_msg::MsgQueryTopicReply_BHNodeAddress* add_node_address();
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::MsgQueryTopicReply_BHNodeAddress >&
+ node_address() const;
+
+ // .bhome_msg.ErrorMsg errmsg = 1;
+ bool has_errmsg() const;
+ private:
+ bool _internal_has_errmsg() const;
+ public:
+ void clear_errmsg();
+ const ::bhome_msg::ErrorMsg& errmsg() const;
+ PROTOBUF_MUST_USE_RESULT ::bhome_msg::ErrorMsg* release_errmsg();
+ ::bhome_msg::ErrorMsg* mutable_errmsg();
+ void set_allocated_errmsg(::bhome_msg::ErrorMsg* errmsg);
+ private:
+ const ::bhome_msg::ErrorMsg& _internal_errmsg() const;
+ ::bhome_msg::ErrorMsg* _internal_mutable_errmsg();
+ public:
+ void unsafe_arena_set_allocated_errmsg(
+ ::bhome_msg::ErrorMsg* errmsg);
+ ::bhome_msg::ErrorMsg* unsafe_arena_release_errmsg();
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.MsgQueryTopicReply)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::MsgQueryTopicReply_BHNodeAddress > node_address_;
+ ::bhome_msg::ErrorMsg* errmsg_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgQueryProc final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgQueryProc) */ {
+ public:
+ inline MsgQueryProc() : MsgQueryProc(nullptr) {}
+ ~MsgQueryProc() override;
+ explicit constexpr MsgQueryProc(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ MsgQueryProc(const MsgQueryProc& from);
+ MsgQueryProc(MsgQueryProc&& from) noexcept
+ : MsgQueryProc() {
+ *this = ::std::move(from);
+ }
+
+ inline MsgQueryProc& operator=(const MsgQueryProc& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MsgQueryProc& operator=(MsgQueryProc&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const MsgQueryProc& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const MsgQueryProc* internal_default_instance() {
+ return reinterpret_cast<const MsgQueryProc*>(
+ &_MsgQueryProc_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 13;
+
+ friend void swap(MsgQueryProc& a, MsgQueryProc& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MsgQueryProc* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(MsgQueryProc* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MsgQueryProc* New() const final {
+ return new MsgQueryProc();
+ }
+
+ MsgQueryProc* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MsgQueryProc>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const MsgQueryProc& from);
+ void MergeFrom(const MsgQueryProc& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(MsgQueryProc* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.MsgQueryProc";
+ }
+ protected:
+ explicit MsgQueryProc(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kProcIdFieldNumber = 1,
+ };
+ // bytes proc_id = 1;
+ void clear_proc_id();
+ const std::string& proc_id() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_proc_id(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_proc_id();
+ PROTOBUF_MUST_USE_RESULT std::string* release_proc_id();
+ void set_allocated_proc_id(std::string* proc_id);
+ private:
+ const std::string& _internal_proc_id() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_proc_id(const std::string& value);
+ std::string* _internal_mutable_proc_id();
+ public:
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.MsgQueryProc)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr proc_id_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgQueryProcReply_Info final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgQueryProcReply.Info) */ {
+ public:
+ inline MsgQueryProcReply_Info() : MsgQueryProcReply_Info(nullptr) {}
+ ~MsgQueryProcReply_Info() override;
+ explicit constexpr MsgQueryProcReply_Info(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ MsgQueryProcReply_Info(const MsgQueryProcReply_Info& from);
+ MsgQueryProcReply_Info(MsgQueryProcReply_Info&& from) noexcept
+ : MsgQueryProcReply_Info() {
+ *this = ::std::move(from);
+ }
+
+ inline MsgQueryProcReply_Info& operator=(const MsgQueryProcReply_Info& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MsgQueryProcReply_Info& operator=(MsgQueryProcReply_Info&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const MsgQueryProcReply_Info& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const MsgQueryProcReply_Info* internal_default_instance() {
+ return reinterpret_cast<const MsgQueryProcReply_Info*>(
+ &_MsgQueryProcReply_Info_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 14;
+
+ friend void swap(MsgQueryProcReply_Info& a, MsgQueryProcReply_Info& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MsgQueryProcReply_Info* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(MsgQueryProcReply_Info* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MsgQueryProcReply_Info* New() const final {
+ return new MsgQueryProcReply_Info();
+ }
+
+ MsgQueryProcReply_Info* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MsgQueryProcReply_Info>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const MsgQueryProcReply_Info& from);
+ void MergeFrom(const MsgQueryProcReply_Info& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(MsgQueryProcReply_Info* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.MsgQueryProcReply.Info";
+ }
+ protected:
+ explicit MsgQueryProcReply_Info(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kProcFieldNumber = 1,
+ kTopicsFieldNumber = 3,
+ kOnlineFieldNumber = 2,
+ };
+ // .bhome_msg.ProcInfo proc = 1;
+ bool has_proc() const;
+ private:
+ bool _internal_has_proc() const;
+ public:
+ void clear_proc();
+ const ::bhome_msg::ProcInfo& proc() const;
+ PROTOBUF_MUST_USE_RESULT ::bhome_msg::ProcInfo* release_proc();
+ ::bhome_msg::ProcInfo* mutable_proc();
+ void set_allocated_proc(::bhome_msg::ProcInfo* proc);
+ private:
+ const ::bhome_msg::ProcInfo& _internal_proc() const;
+ ::bhome_msg::ProcInfo* _internal_mutable_proc();
+ public:
+ void unsafe_arena_set_allocated_proc(
+ ::bhome_msg::ProcInfo* proc);
+ ::bhome_msg::ProcInfo* unsafe_arena_release_proc();
+
+ // .bhome_msg.MsgTopicList topics = 3;
+ bool has_topics() const;
+ private:
+ bool _internal_has_topics() const;
+ public:
+ void clear_topics();
+ const ::bhome_msg::MsgTopicList& topics() const;
+ PROTOBUF_MUST_USE_RESULT ::bhome_msg::MsgTopicList* release_topics();
+ ::bhome_msg::MsgTopicList* mutable_topics();
+ void set_allocated_topics(::bhome_msg::MsgTopicList* topics);
+ private:
+ const ::bhome_msg::MsgTopicList& _internal_topics() const;
+ ::bhome_msg::MsgTopicList* _internal_mutable_topics();
+ public:
+ void unsafe_arena_set_allocated_topics(
+ ::bhome_msg::MsgTopicList* topics);
+ ::bhome_msg::MsgTopicList* unsafe_arena_release_topics();
+
+ // bool online = 2;
+ void clear_online();
+ bool online() const;
+ void set_online(bool value);
+ private:
+ bool _internal_online() const;
+ void _internal_set_online(bool value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.MsgQueryProcReply.Info)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::bhome_msg::ProcInfo* proc_;
+ ::bhome_msg::MsgTopicList* topics_;
+ bool online_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MsgQueryProcReply final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgQueryProcReply) */ {
+ public:
+ inline MsgQueryProcReply() : MsgQueryProcReply(nullptr) {}
+ ~MsgQueryProcReply() override;
+ explicit constexpr MsgQueryProcReply(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ MsgQueryProcReply(const MsgQueryProcReply& from);
+ MsgQueryProcReply(MsgQueryProcReply&& from) noexcept
+ : MsgQueryProcReply() {
+ *this = ::std::move(from);
+ }
+
+ inline MsgQueryProcReply& operator=(const MsgQueryProcReply& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline MsgQueryProcReply& operator=(MsgQueryProcReply&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const MsgQueryProcReply& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const MsgQueryProcReply* internal_default_instance() {
+ return reinterpret_cast<const MsgQueryProcReply*>(
+ &_MsgQueryProcReply_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 15;
+
+ friend void swap(MsgQueryProcReply& a, MsgQueryProcReply& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(MsgQueryProcReply* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(MsgQueryProcReply* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline MsgQueryProcReply* New() const final {
+ return new MsgQueryProcReply();
+ }
+
+ MsgQueryProcReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<MsgQueryProcReply>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const MsgQueryProcReply& from);
+ void MergeFrom(const MsgQueryProcReply& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(MsgQueryProcReply* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.MsgQueryProcReply";
+ }
+ protected:
+ explicit MsgQueryProcReply(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ typedef MsgQueryProcReply_Info Info;
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kProcListFieldNumber = 2,
+ kErrmsgFieldNumber = 1,
+ };
+ // repeated .bhome_msg.MsgQueryProcReply.Info proc_list = 2;
+ int proc_list_size() const;
+ private:
+ int _internal_proc_list_size() const;
+ public:
+ void clear_proc_list();
+ ::bhome_msg::MsgQueryProcReply_Info* mutable_proc_list(int index);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::MsgQueryProcReply_Info >*
+ mutable_proc_list();
+ private:
+ const ::bhome_msg::MsgQueryProcReply_Info& _internal_proc_list(int index) const;
+ ::bhome_msg::MsgQueryProcReply_Info* _internal_add_proc_list();
+ public:
+ const ::bhome_msg::MsgQueryProcReply_Info& proc_list(int index) const;
+ ::bhome_msg::MsgQueryProcReply_Info* add_proc_list();
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::MsgQueryProcReply_Info >&
+ proc_list() const;
+
+ // .bhome_msg.ErrorMsg errmsg = 1;
+ bool has_errmsg() const;
+ private:
+ bool _internal_has_errmsg() const;
+ public:
+ void clear_errmsg();
+ const ::bhome_msg::ErrorMsg& errmsg() const;
+ PROTOBUF_MUST_USE_RESULT ::bhome_msg::ErrorMsg* release_errmsg();
+ ::bhome_msg::ErrorMsg* mutable_errmsg();
+ void set_allocated_errmsg(::bhome_msg::ErrorMsg* errmsg);
+ private:
+ const ::bhome_msg::ErrorMsg& _internal_errmsg() const;
+ ::bhome_msg::ErrorMsg* _internal_mutable_errmsg();
+ public:
+ void unsafe_arena_set_allocated_errmsg(
+ ::bhome_msg::ErrorMsg* errmsg);
+ ::bhome_msg::ErrorMsg* unsafe_arena_release_errmsg();
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.MsgQueryProcReply)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::MsgQueryProcReply_Info > proc_list_;
+ ::bhome_msg::ErrorMsg* errmsg_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+ #pragma GCC diagnostic push
+ #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif // __GNUC__
+// BHAddress
+
+// uint64 mq_id = 1;
+inline void BHAddress::clear_mq_id() {
+ mq_id_ = uint64_t{0u};
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 BHAddress::_internal_mq_id() const {
+ return mq_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 BHAddress::mq_id() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.BHAddress.mq_id)
+ return _internal_mq_id();
+}
+inline void BHAddress::_internal_set_mq_id(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+
+ mq_id_ = value;
+}
+inline void BHAddress::set_mq_id(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+ _internal_set_mq_id(value);
+ // @@protoc_insertion_point(field_set:bhome_msg.BHAddress.mq_id)
+}
+
+// int64 abs_addr = 2;
+inline void BHAddress::clear_abs_addr() {
+ abs_addr_ = int64_t{0};
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 BHAddress::_internal_abs_addr() const {
+ return abs_addr_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 BHAddress::abs_addr() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.BHAddress.abs_addr)
+ return _internal_abs_addr();
+}
+inline void BHAddress::_internal_set_abs_addr(::PROTOBUF_NAMESPACE_ID::int64 value) {
+
+ abs_addr_ = value;
+}
+inline void BHAddress::set_abs_addr(::PROTOBUF_NAMESPACE_ID::int64 value) {
+ _internal_set_abs_addr(value);
+ // @@protoc_insertion_point(field_set:bhome_msg.BHAddress.abs_addr)
+}
+
+// bytes ip = 3;
+inline void BHAddress::clear_ip() {
+ ip_.ClearToEmpty();
+}
+inline const std::string& BHAddress::ip() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.BHAddress.ip)
+ return _internal_ip();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void BHAddress::set_ip(ArgT0&& arg0, ArgT... args) {
+
+ ip_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:bhome_msg.BHAddress.ip)
+}
+inline std::string* BHAddress::mutable_ip() {
+ std::string* _s = _internal_mutable_ip();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.BHAddress.ip)
+ return _s;
+}
+inline const std::string& BHAddress::_internal_ip() const {
+ return ip_.Get();
+}
+inline void BHAddress::_internal_set_ip(const std::string& value) {
+
+ ip_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* BHAddress::_internal_mutable_ip() {
+
+ return ip_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* BHAddress::release_ip() {
+ // @@protoc_insertion_point(field_release:bhome_msg.BHAddress.ip)
+ return ip_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void BHAddress::set_allocated_ip(std::string* ip) {
+ if (ip != nullptr) {
+
+ } else {
+
+ }
+ ip_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ip,
+ GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.BHAddress.ip)
+}
+
+// int32 port = 4;
+inline void BHAddress::clear_port() {
+ port_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 BHAddress::_internal_port() const {
+ return port_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 BHAddress::port() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.BHAddress.port)
+ return _internal_port();
+}
+inline void BHAddress::_internal_set_port(::PROTOBUF_NAMESPACE_ID::int32 value) {
+
+ port_ = value;
+}
+inline void BHAddress::set_port(::PROTOBUF_NAMESPACE_ID::int32 value) {
+ _internal_set_port(value);
+ // @@protoc_insertion_point(field_set:bhome_msg.BHAddress.port)
+}
+
+// -------------------------------------------------------------------
+
+// ProcInfo
+
+// bytes proc_id = 1;
+inline void ProcInfo::clear_proc_id() {
+ proc_id_.ClearToEmpty();
+}
+inline const std::string& ProcInfo::proc_id() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.ProcInfo.proc_id)
+ return _internal_proc_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProcInfo::set_proc_id(ArgT0&& arg0, ArgT... args) {
+
+ proc_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:bhome_msg.ProcInfo.proc_id)
+}
+inline std::string* ProcInfo::mutable_proc_id() {
+ std::string* _s = _internal_mutable_proc_id();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.ProcInfo.proc_id)
+ return _s;
+}
+inline const std::string& ProcInfo::_internal_proc_id() const {
+ return proc_id_.Get();
+}
+inline void ProcInfo::_internal_set_proc_id(const std::string& value) {
+
+ proc_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProcInfo::_internal_mutable_proc_id() {
+
+ return proc_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProcInfo::release_proc_id() {
+ // @@protoc_insertion_point(field_release:bhome_msg.ProcInfo.proc_id)
+ return proc_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProcInfo::set_allocated_proc_id(std::string* proc_id) {
+ if (proc_id != nullptr) {
+
+ } else {
+
+ }
+ proc_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), proc_id,
+ GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.ProcInfo.proc_id)
+}
+
+// bytes name = 2;
+inline void ProcInfo::clear_name() {
+ name_.ClearToEmpty();
+}
+inline const std::string& ProcInfo::name() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.ProcInfo.name)
+ return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProcInfo::set_name(ArgT0&& arg0, ArgT... args) {
+
+ name_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:bhome_msg.ProcInfo.name)
+}
+inline std::string* ProcInfo::mutable_name() {
+ std::string* _s = _internal_mutable_name();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.ProcInfo.name)
+ return _s;
+}
+inline const std::string& ProcInfo::_internal_name() const {
+ return name_.Get();
+}
+inline void ProcInfo::_internal_set_name(const std::string& value) {
+
+ name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProcInfo::_internal_mutable_name() {
+
+ return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProcInfo::release_name() {
+ // @@protoc_insertion_point(field_release:bhome_msg.ProcInfo.name)
+ return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProcInfo::set_allocated_name(std::string* name) {
+ if (name != nullptr) {
+
+ } else {
+
+ }
+ name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
+ GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.ProcInfo.name)
+}
+
+// bytes public_info = 3;
+inline void ProcInfo::clear_public_info() {
+ public_info_.ClearToEmpty();
+}
+inline const std::string& ProcInfo::public_info() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.ProcInfo.public_info)
+ return _internal_public_info();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProcInfo::set_public_info(ArgT0&& arg0, ArgT... args) {
+
+ public_info_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:bhome_msg.ProcInfo.public_info)
+}
+inline std::string* ProcInfo::mutable_public_info() {
+ std::string* _s = _internal_mutable_public_info();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.ProcInfo.public_info)
+ return _s;
+}
+inline const std::string& ProcInfo::_internal_public_info() const {
+ return public_info_.Get();
+}
+inline void ProcInfo::_internal_set_public_info(const std::string& value) {
+
+ public_info_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProcInfo::_internal_mutable_public_info() {
+
+ return public_info_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProcInfo::release_public_info() {
+ // @@protoc_insertion_point(field_release:bhome_msg.ProcInfo.public_info)
+ return public_info_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProcInfo::set_allocated_public_info(std::string* public_info) {
+ if (public_info != nullptr) {
+
+ } else {
+
+ }
+ public_info_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), public_info,
+ GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.ProcInfo.public_info)
+}
+
+// bytes private_info = 4;
+inline void ProcInfo::clear_private_info() {
+ private_info_.ClearToEmpty();
+}
+inline const std::string& ProcInfo::private_info() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.ProcInfo.private_info)
+ return _internal_private_info();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProcInfo::set_private_info(ArgT0&& arg0, ArgT... args) {
+
+ private_info_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:bhome_msg.ProcInfo.private_info)
+}
+inline std::string* ProcInfo::mutable_private_info() {
+ std::string* _s = _internal_mutable_private_info();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.ProcInfo.private_info)
+ return _s;
+}
+inline const std::string& ProcInfo::_internal_private_info() const {
+ return private_info_.Get();
+}
+inline void ProcInfo::_internal_set_private_info(const std::string& value) {
+
+ private_info_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProcInfo::_internal_mutable_private_info() {
+
+ return private_info_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProcInfo::release_private_info() {
+ // @@protoc_insertion_point(field_release:bhome_msg.ProcInfo.private_info)
+ return private_info_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProcInfo::set_allocated_private_info(std::string* private_info) {
+ if (private_info != nullptr) {
+
+ } else {
+
+ }
+ private_info_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), private_info,
+ GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.ProcInfo.private_info)
+}
+
+// -------------------------------------------------------------------
+
+// MsgTopicList
+
+// repeated bytes topic_list = 1;
+inline int MsgTopicList::_internal_topic_list_size() const {
+ return topic_list_.size();
+}
+inline int MsgTopicList::topic_list_size() const {
+ return _internal_topic_list_size();
+}
+inline void MsgTopicList::clear_topic_list() {
+ topic_list_.Clear();
+}
+inline std::string* MsgTopicList::add_topic_list() {
+ std::string* _s = _internal_add_topic_list();
+ // @@protoc_insertion_point(field_add_mutable:bhome_msg.MsgTopicList.topic_list)
+ return _s;
+}
+inline const std::string& MsgTopicList::_internal_topic_list(int index) const {
+ return topic_list_.Get(index);
+}
+inline const std::string& MsgTopicList::topic_list(int index) const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgTopicList.topic_list)
+ return _internal_topic_list(index);
+}
+inline std::string* MsgTopicList::mutable_topic_list(int index) {
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgTopicList.topic_list)
+ return topic_list_.Mutable(index);
+}
+inline void MsgTopicList::set_topic_list(int index, const std::string& value) {
+ topic_list_.Mutable(index)->assign(value);
+ // @@protoc_insertion_point(field_set:bhome_msg.MsgTopicList.topic_list)
+}
+inline void MsgTopicList::set_topic_list(int index, std::string&& value) {
+ topic_list_.Mutable(index)->assign(std::move(value));
+ // @@protoc_insertion_point(field_set:bhome_msg.MsgTopicList.topic_list)
+}
+inline void MsgTopicList::set_topic_list(int index, const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+ topic_list_.Mutable(index)->assign(value);
+ // @@protoc_insertion_point(field_set_char:bhome_msg.MsgTopicList.topic_list)
+}
+inline void MsgTopicList::set_topic_list(int index, const void* value, size_t size) {
+ topic_list_.Mutable(index)->assign(
+ reinterpret_cast<const char*>(value), size);
+ // @@protoc_insertion_point(field_set_pointer:bhome_msg.MsgTopicList.topic_list)
+}
+inline std::string* MsgTopicList::_internal_add_topic_list() {
+ return topic_list_.Add();
+}
+inline void MsgTopicList::add_topic_list(const std::string& value) {
+ topic_list_.Add()->assign(value);
+ // @@protoc_insertion_point(field_add:bhome_msg.MsgTopicList.topic_list)
+}
+inline void MsgTopicList::add_topic_list(std::string&& value) {
+ topic_list_.Add(std::move(value));
+ // @@protoc_insertion_point(field_add:bhome_msg.MsgTopicList.topic_list)
+}
+inline void MsgTopicList::add_topic_list(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+ topic_list_.Add()->assign(value);
+ // @@protoc_insertion_point(field_add_char:bhome_msg.MsgTopicList.topic_list)
+}
+inline void MsgTopicList::add_topic_list(const void* value, size_t size) {
+ topic_list_.Add()->assign(reinterpret_cast<const char*>(value), size);
+ // @@protoc_insertion_point(field_add_pointer:bhome_msg.MsgTopicList.topic_list)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+MsgTopicList::topic_list() const {
+ // @@protoc_insertion_point(field_list:bhome_msg.MsgTopicList.topic_list)
+ return topic_list_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+MsgTopicList::mutable_topic_list() {
+ // @@protoc_insertion_point(field_mutable_list:bhome_msg.MsgTopicList.topic_list)
+ return &topic_list_;
+}
+
+// -------------------------------------------------------------------
+
+// MsgPublish
+
+// bytes topic = 1;
+inline void MsgPublish::clear_topic() {
+ topic_.ClearToEmpty();
+}
+inline const std::string& MsgPublish::topic() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgPublish.topic)
+ return _internal_topic();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgPublish::set_topic(ArgT0&& arg0, ArgT... args) {
+
+ topic_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:bhome_msg.MsgPublish.topic)
+}
+inline std::string* MsgPublish::mutable_topic() {
+ std::string* _s = _internal_mutable_topic();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgPublish.topic)
+ return _s;
+}
+inline const std::string& MsgPublish::_internal_topic() const {
+ return topic_.Get();
+}
+inline void MsgPublish::_internal_set_topic(const std::string& value) {
+
+ topic_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* MsgPublish::_internal_mutable_topic() {
+
+ return topic_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* MsgPublish::release_topic() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgPublish.topic)
+ return topic_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void MsgPublish::set_allocated_topic(std::string* topic) {
+ if (topic != nullptr) {
+
+ } else {
+
+ }
+ topic_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), topic,
+ GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgPublish.topic)
+}
+
+// bytes data = 2;
+inline void MsgPublish::clear_data() {
+ data_.ClearToEmpty();
+}
+inline const std::string& MsgPublish::data() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgPublish.data)
+ return _internal_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgPublish::set_data(ArgT0&& arg0, ArgT... args) {
+
+ data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:bhome_msg.MsgPublish.data)
+}
+inline std::string* MsgPublish::mutable_data() {
+ std::string* _s = _internal_mutable_data();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgPublish.data)
+ return _s;
+}
+inline const std::string& MsgPublish::_internal_data() const {
+ return data_.Get();
+}
+inline void MsgPublish::_internal_set_data(const std::string& value) {
+
+ data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* MsgPublish::_internal_mutable_data() {
+
+ return data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* MsgPublish::release_data() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgPublish.data)
+ return data_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void MsgPublish::set_allocated_data(std::string* data) {
+ if (data != nullptr) {
+
+ } else {
+
+ }
+ data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data,
+ GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgPublish.data)
+}
+
+// -------------------------------------------------------------------
+
+// MsgCommonReply
+
+// .bhome_msg.ErrorMsg errmsg = 1;
+inline bool MsgCommonReply::_internal_has_errmsg() const {
+ return this != internal_default_instance() && errmsg_ != nullptr;
+}
+inline bool MsgCommonReply::has_errmsg() const {
+ return _internal_has_errmsg();
+}
+inline const ::bhome_msg::ErrorMsg& MsgCommonReply::_internal_errmsg() const {
+ const ::bhome_msg::ErrorMsg* p = errmsg_;
+ return p != nullptr ? *p : reinterpret_cast<const ::bhome_msg::ErrorMsg&>(
+ ::bhome_msg::_ErrorMsg_default_instance_);
+}
+inline const ::bhome_msg::ErrorMsg& MsgCommonReply::errmsg() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgCommonReply.errmsg)
+ return _internal_errmsg();
+}
+inline void MsgCommonReply::unsafe_arena_set_allocated_errmsg(
+ ::bhome_msg::ErrorMsg* errmsg) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(errmsg_);
+ }
+ errmsg_ = errmsg;
+ if (errmsg) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:bhome_msg.MsgCommonReply.errmsg)
+}
+inline ::bhome_msg::ErrorMsg* MsgCommonReply::release_errmsg() {
+
+ ::bhome_msg::ErrorMsg* temp = errmsg_;
+ errmsg_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::bhome_msg::ErrorMsg* MsgCommonReply::unsafe_arena_release_errmsg() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgCommonReply.errmsg)
+
+ ::bhome_msg::ErrorMsg* temp = errmsg_;
+ errmsg_ = nullptr;
+ return temp;
+}
+inline ::bhome_msg::ErrorMsg* MsgCommonReply::_internal_mutable_errmsg() {
+
+ if (errmsg_ == nullptr) {
+ auto* p = CreateMaybeMessage<::bhome_msg::ErrorMsg>(GetArenaForAllocation());
+ errmsg_ = p;
+ }
+ return errmsg_;
+}
+inline ::bhome_msg::ErrorMsg* MsgCommonReply::mutable_errmsg() {
+ ::bhome_msg::ErrorMsg* _msg = _internal_mutable_errmsg();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgCommonReply.errmsg)
+ return _msg;
+}
+inline void MsgCommonReply::set_allocated_errmsg(::bhome_msg::ErrorMsg* errmsg) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(errmsg_);
+ }
+ if (errmsg) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+ ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+ reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(errmsg));
+ if (message_arena != submessage_arena) {
+ errmsg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, errmsg, submessage_arena);
+ }
+
+ } else {
+
+ }
+ errmsg_ = errmsg;
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgCommonReply.errmsg)
+}
+
+// -------------------------------------------------------------------
+
+// MsgRequestTopic
+
+// bytes topic = 1;
+inline void MsgRequestTopic::clear_topic() {
+ topic_.ClearToEmpty();
+}
+inline const std::string& MsgRequestTopic::topic() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgRequestTopic.topic)
+ return _internal_topic();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgRequestTopic::set_topic(ArgT0&& arg0, ArgT... args) {
+
+ topic_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:bhome_msg.MsgRequestTopic.topic)
+}
+inline std::string* MsgRequestTopic::mutable_topic() {
+ std::string* _s = _internal_mutable_topic();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgRequestTopic.topic)
+ return _s;
+}
+inline const std::string& MsgRequestTopic::_internal_topic() const {
+ return topic_.Get();
+}
+inline void MsgRequestTopic::_internal_set_topic(const std::string& value) {
+
+ topic_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* MsgRequestTopic::_internal_mutable_topic() {
+
+ return topic_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* MsgRequestTopic::release_topic() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgRequestTopic.topic)
+ return topic_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void MsgRequestTopic::set_allocated_topic(std::string* topic) {
+ if (topic != nullptr) {
+
+ } else {
+
+ }
+ topic_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), topic,
+ GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgRequestTopic.topic)
+}
+
+// bytes data = 2;
+inline void MsgRequestTopic::clear_data() {
+ data_.ClearToEmpty();
+}
+inline const std::string& MsgRequestTopic::data() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgRequestTopic.data)
+ return _internal_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgRequestTopic::set_data(ArgT0&& arg0, ArgT... args) {
+
+ data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:bhome_msg.MsgRequestTopic.data)
+}
+inline std::string* MsgRequestTopic::mutable_data() {
+ std::string* _s = _internal_mutable_data();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgRequestTopic.data)
+ return _s;
+}
+inline const std::string& MsgRequestTopic::_internal_data() const {
+ return data_.Get();
+}
+inline void MsgRequestTopic::_internal_set_data(const std::string& value) {
+
+ data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* MsgRequestTopic::_internal_mutable_data() {
+
+ return data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* MsgRequestTopic::release_data() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgRequestTopic.data)
+ return data_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void MsgRequestTopic::set_allocated_data(std::string* data) {
+ if (data != nullptr) {
+
+ } else {
+
+ }
+ data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data,
+ GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgRequestTopic.data)
+}
+
+// -------------------------------------------------------------------
+
+// MsgRequestTopicReply
+
+// .bhome_msg.ErrorMsg errmsg = 1;
+inline bool MsgRequestTopicReply::_internal_has_errmsg() const {
+ return this != internal_default_instance() && errmsg_ != nullptr;
+}
+inline bool MsgRequestTopicReply::has_errmsg() const {
+ return _internal_has_errmsg();
+}
+inline const ::bhome_msg::ErrorMsg& MsgRequestTopicReply::_internal_errmsg() const {
+ const ::bhome_msg::ErrorMsg* p = errmsg_;
+ return p != nullptr ? *p : reinterpret_cast<const ::bhome_msg::ErrorMsg&>(
+ ::bhome_msg::_ErrorMsg_default_instance_);
+}
+inline const ::bhome_msg::ErrorMsg& MsgRequestTopicReply::errmsg() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgRequestTopicReply.errmsg)
+ return _internal_errmsg();
+}
+inline void MsgRequestTopicReply::unsafe_arena_set_allocated_errmsg(
+ ::bhome_msg::ErrorMsg* errmsg) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(errmsg_);
+ }
+ errmsg_ = errmsg;
+ if (errmsg) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:bhome_msg.MsgRequestTopicReply.errmsg)
+}
+inline ::bhome_msg::ErrorMsg* MsgRequestTopicReply::release_errmsg() {
+
+ ::bhome_msg::ErrorMsg* temp = errmsg_;
+ errmsg_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::bhome_msg::ErrorMsg* MsgRequestTopicReply::unsafe_arena_release_errmsg() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgRequestTopicReply.errmsg)
+
+ ::bhome_msg::ErrorMsg* temp = errmsg_;
+ errmsg_ = nullptr;
+ return temp;
+}
+inline ::bhome_msg::ErrorMsg* MsgRequestTopicReply::_internal_mutable_errmsg() {
+
+ if (errmsg_ == nullptr) {
+ auto* p = CreateMaybeMessage<::bhome_msg::ErrorMsg>(GetArenaForAllocation());
+ errmsg_ = p;
+ }
+ return errmsg_;
+}
+inline ::bhome_msg::ErrorMsg* MsgRequestTopicReply::mutable_errmsg() {
+ ::bhome_msg::ErrorMsg* _msg = _internal_mutable_errmsg();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgRequestTopicReply.errmsg)
+ return _msg;
+}
+inline void MsgRequestTopicReply::set_allocated_errmsg(::bhome_msg::ErrorMsg* errmsg) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(errmsg_);
+ }
+ if (errmsg) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+ ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+ reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(errmsg));
+ if (message_arena != submessage_arena) {
+ errmsg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, errmsg, submessage_arena);
+ }
+
+ } else {
+
+ }
+ errmsg_ = errmsg;
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgRequestTopicReply.errmsg)
+}
+
+// bytes data = 2;
+inline void MsgRequestTopicReply::clear_data() {
+ data_.ClearToEmpty();
+}
+inline const std::string& MsgRequestTopicReply::data() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgRequestTopicReply.data)
+ return _internal_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgRequestTopicReply::set_data(ArgT0&& arg0, ArgT... args) {
+
+ data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:bhome_msg.MsgRequestTopicReply.data)
+}
+inline std::string* MsgRequestTopicReply::mutable_data() {
+ std::string* _s = _internal_mutable_data();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgRequestTopicReply.data)
+ return _s;
+}
+inline const std::string& MsgRequestTopicReply::_internal_data() const {
+ return data_.Get();
+}
+inline void MsgRequestTopicReply::_internal_set_data(const std::string& value) {
+
+ data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* MsgRequestTopicReply::_internal_mutable_data() {
+
+ return data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* MsgRequestTopicReply::release_data() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgRequestTopicReply.data)
+ return data_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void MsgRequestTopicReply::set_allocated_data(std::string* data) {
+ if (data != nullptr) {
+
+ } else {
+
+ }
+ data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data,
+ GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgRequestTopicReply.data)
+}
+
+// -------------------------------------------------------------------
+
+// MsgRegister
+
+// .bhome_msg.ProcInfo proc = 1;
+inline bool MsgRegister::_internal_has_proc() const {
+ return this != internal_default_instance() && proc_ != nullptr;
+}
+inline bool MsgRegister::has_proc() const {
+ return _internal_has_proc();
+}
+inline void MsgRegister::clear_proc() {
+ if (GetArenaForAllocation() == nullptr && proc_ != nullptr) {
+ delete proc_;
+ }
+ proc_ = nullptr;
+}
+inline const ::bhome_msg::ProcInfo& MsgRegister::_internal_proc() const {
+ const ::bhome_msg::ProcInfo* p = proc_;
+ return p != nullptr ? *p : reinterpret_cast<const ::bhome_msg::ProcInfo&>(
+ ::bhome_msg::_ProcInfo_default_instance_);
+}
+inline const ::bhome_msg::ProcInfo& MsgRegister::proc() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgRegister.proc)
+ return _internal_proc();
+}
+inline void MsgRegister::unsafe_arena_set_allocated_proc(
+ ::bhome_msg::ProcInfo* proc) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(proc_);
+ }
+ proc_ = proc;
+ if (proc) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:bhome_msg.MsgRegister.proc)
+}
+inline ::bhome_msg::ProcInfo* MsgRegister::release_proc() {
+
+ ::bhome_msg::ProcInfo* temp = proc_;
+ proc_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::bhome_msg::ProcInfo* MsgRegister::unsafe_arena_release_proc() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgRegister.proc)
+
+ ::bhome_msg::ProcInfo* temp = proc_;
+ proc_ = nullptr;
+ return temp;
+}
+inline ::bhome_msg::ProcInfo* MsgRegister::_internal_mutable_proc() {
+
+ if (proc_ == nullptr) {
+ auto* p = CreateMaybeMessage<::bhome_msg::ProcInfo>(GetArenaForAllocation());
+ proc_ = p;
+ }
+ return proc_;
+}
+inline ::bhome_msg::ProcInfo* MsgRegister::mutable_proc() {
+ ::bhome_msg::ProcInfo* _msg = _internal_mutable_proc();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgRegister.proc)
+ return _msg;
+}
+inline void MsgRegister::set_allocated_proc(::bhome_msg::ProcInfo* proc) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete proc_;
+ }
+ if (proc) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::bhome_msg::ProcInfo>::GetOwningArena(proc);
+ if (message_arena != submessage_arena) {
+ proc = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, proc, submessage_arena);
+ }
+
+ } else {
+
+ }
+ proc_ = proc;
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgRegister.proc)
+}
+
+// -------------------------------------------------------------------
+
+// MsgUnregister
+
+// .bhome_msg.ProcInfo proc = 1;
+inline bool MsgUnregister::_internal_has_proc() const {
+ return this != internal_default_instance() && proc_ != nullptr;
+}
+inline bool MsgUnregister::has_proc() const {
+ return _internal_has_proc();
+}
+inline void MsgUnregister::clear_proc() {
+ if (GetArenaForAllocation() == nullptr && proc_ != nullptr) {
+ delete proc_;
+ }
+ proc_ = nullptr;
+}
+inline const ::bhome_msg::ProcInfo& MsgUnregister::_internal_proc() const {
+ const ::bhome_msg::ProcInfo* p = proc_;
+ return p != nullptr ? *p : reinterpret_cast<const ::bhome_msg::ProcInfo&>(
+ ::bhome_msg::_ProcInfo_default_instance_);
+}
+inline const ::bhome_msg::ProcInfo& MsgUnregister::proc() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgUnregister.proc)
+ return _internal_proc();
+}
+inline void MsgUnregister::unsafe_arena_set_allocated_proc(
+ ::bhome_msg::ProcInfo* proc) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(proc_);
+ }
+ proc_ = proc;
+ if (proc) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:bhome_msg.MsgUnregister.proc)
+}
+inline ::bhome_msg::ProcInfo* MsgUnregister::release_proc() {
+
+ ::bhome_msg::ProcInfo* temp = proc_;
+ proc_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::bhome_msg::ProcInfo* MsgUnregister::unsafe_arena_release_proc() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgUnregister.proc)
+
+ ::bhome_msg::ProcInfo* temp = proc_;
+ proc_ = nullptr;
+ return temp;
+}
+inline ::bhome_msg::ProcInfo* MsgUnregister::_internal_mutable_proc() {
+
+ if (proc_ == nullptr) {
+ auto* p = CreateMaybeMessage<::bhome_msg::ProcInfo>(GetArenaForAllocation());
+ proc_ = p;
+ }
+ return proc_;
+}
+inline ::bhome_msg::ProcInfo* MsgUnregister::mutable_proc() {
+ ::bhome_msg::ProcInfo* _msg = _internal_mutable_proc();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgUnregister.proc)
+ return _msg;
+}
+inline void MsgUnregister::set_allocated_proc(::bhome_msg::ProcInfo* proc) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete proc_;
+ }
+ if (proc) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::bhome_msg::ProcInfo>::GetOwningArena(proc);
+ if (message_arena != submessage_arena) {
+ proc = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, proc, submessage_arena);
+ }
+
+ } else {
+
+ }
+ proc_ = proc;
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgUnregister.proc)
+}
+
+// -------------------------------------------------------------------
+
+// MsgHeartbeat
+
+// .bhome_msg.ProcInfo proc = 1;
+inline bool MsgHeartbeat::_internal_has_proc() const {
+ return this != internal_default_instance() && proc_ != nullptr;
+}
+inline bool MsgHeartbeat::has_proc() const {
+ return _internal_has_proc();
+}
+inline void MsgHeartbeat::clear_proc() {
+ if (GetArenaForAllocation() == nullptr && proc_ != nullptr) {
+ delete proc_;
+ }
+ proc_ = nullptr;
+}
+inline const ::bhome_msg::ProcInfo& MsgHeartbeat::_internal_proc() const {
+ const ::bhome_msg::ProcInfo* p = proc_;
+ return p != nullptr ? *p : reinterpret_cast<const ::bhome_msg::ProcInfo&>(
+ ::bhome_msg::_ProcInfo_default_instance_);
+}
+inline const ::bhome_msg::ProcInfo& MsgHeartbeat::proc() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgHeartbeat.proc)
+ return _internal_proc();
+}
+inline void MsgHeartbeat::unsafe_arena_set_allocated_proc(
+ ::bhome_msg::ProcInfo* proc) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(proc_);
+ }
+ proc_ = proc;
+ if (proc) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:bhome_msg.MsgHeartbeat.proc)
+}
+inline ::bhome_msg::ProcInfo* MsgHeartbeat::release_proc() {
+
+ ::bhome_msg::ProcInfo* temp = proc_;
+ proc_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::bhome_msg::ProcInfo* MsgHeartbeat::unsafe_arena_release_proc() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgHeartbeat.proc)
+
+ ::bhome_msg::ProcInfo* temp = proc_;
+ proc_ = nullptr;
+ return temp;
+}
+inline ::bhome_msg::ProcInfo* MsgHeartbeat::_internal_mutable_proc() {
+
+ if (proc_ == nullptr) {
+ auto* p = CreateMaybeMessage<::bhome_msg::ProcInfo>(GetArenaForAllocation());
+ proc_ = p;
+ }
+ return proc_;
+}
+inline ::bhome_msg::ProcInfo* MsgHeartbeat::mutable_proc() {
+ ::bhome_msg::ProcInfo* _msg = _internal_mutable_proc();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgHeartbeat.proc)
+ return _msg;
+}
+inline void MsgHeartbeat::set_allocated_proc(::bhome_msg::ProcInfo* proc) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete proc_;
+ }
+ if (proc) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::bhome_msg::ProcInfo>::GetOwningArena(proc);
+ if (message_arena != submessage_arena) {
+ proc = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, proc, submessage_arena);
+ }
+
+ } else {
+
+ }
+ proc_ = proc;
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgHeartbeat.proc)
+}
+
+// -------------------------------------------------------------------
+
+// MsgQueryTopic
+
+// bytes topic = 1;
+inline void MsgQueryTopic::clear_topic() {
+ topic_.ClearToEmpty();
+}
+inline const std::string& MsgQueryTopic::topic() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryTopic.topic)
+ return _internal_topic();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgQueryTopic::set_topic(ArgT0&& arg0, ArgT... args) {
+
+ topic_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:bhome_msg.MsgQueryTopic.topic)
+}
+inline std::string* MsgQueryTopic::mutable_topic() {
+ std::string* _s = _internal_mutable_topic();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryTopic.topic)
+ return _s;
+}
+inline const std::string& MsgQueryTopic::_internal_topic() const {
+ return topic_.Get();
+}
+inline void MsgQueryTopic::_internal_set_topic(const std::string& value) {
+
+ topic_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* MsgQueryTopic::_internal_mutable_topic() {
+
+ return topic_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* MsgQueryTopic::release_topic() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgQueryTopic.topic)
+ return topic_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void MsgQueryTopic::set_allocated_topic(std::string* topic) {
+ if (topic != nullptr) {
+
+ } else {
+
+ }
+ topic_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), topic,
+ GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgQueryTopic.topic)
+}
+
+// -------------------------------------------------------------------
+
+// MsgQueryTopicReply_BHNodeAddress
+
+// bytes proc_id = 1;
+inline void MsgQueryTopicReply_BHNodeAddress::clear_proc_id() {
+ proc_id_.ClearToEmpty();
+}
+inline const std::string& MsgQueryTopicReply_BHNodeAddress::proc_id() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryTopicReply.BHNodeAddress.proc_id)
+ return _internal_proc_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgQueryTopicReply_BHNodeAddress::set_proc_id(ArgT0&& arg0, ArgT... args) {
+
+ proc_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:bhome_msg.MsgQueryTopicReply.BHNodeAddress.proc_id)
+}
+inline std::string* MsgQueryTopicReply_BHNodeAddress::mutable_proc_id() {
+ std::string* _s = _internal_mutable_proc_id();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryTopicReply.BHNodeAddress.proc_id)
+ return _s;
+}
+inline const std::string& MsgQueryTopicReply_BHNodeAddress::_internal_proc_id() const {
+ return proc_id_.Get();
+}
+inline void MsgQueryTopicReply_BHNodeAddress::_internal_set_proc_id(const std::string& value) {
+
+ proc_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* MsgQueryTopicReply_BHNodeAddress::_internal_mutable_proc_id() {
+
+ return proc_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* MsgQueryTopicReply_BHNodeAddress::release_proc_id() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgQueryTopicReply.BHNodeAddress.proc_id)
+ return proc_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void MsgQueryTopicReply_BHNodeAddress::set_allocated_proc_id(std::string* proc_id) {
+ if (proc_id != nullptr) {
+
+ } else {
+
+ }
+ proc_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), proc_id,
+ GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgQueryTopicReply.BHNodeAddress.proc_id)
+}
+
+// .bhome_msg.BHAddress addr = 2;
+inline bool MsgQueryTopicReply_BHNodeAddress::_internal_has_addr() const {
+ return this != internal_default_instance() && addr_ != nullptr;
+}
+inline bool MsgQueryTopicReply_BHNodeAddress::has_addr() const {
+ return _internal_has_addr();
+}
+inline void MsgQueryTopicReply_BHNodeAddress::clear_addr() {
+ if (GetArenaForAllocation() == nullptr && addr_ != nullptr) {
+ delete addr_;
+ }
+ addr_ = nullptr;
+}
+inline const ::bhome_msg::BHAddress& MsgQueryTopicReply_BHNodeAddress::_internal_addr() const {
+ const ::bhome_msg::BHAddress* p = addr_;
+ return p != nullptr ? *p : reinterpret_cast<const ::bhome_msg::BHAddress&>(
+ ::bhome_msg::_BHAddress_default_instance_);
+}
+inline const ::bhome_msg::BHAddress& MsgQueryTopicReply_BHNodeAddress::addr() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryTopicReply.BHNodeAddress.addr)
+ return _internal_addr();
+}
+inline void MsgQueryTopicReply_BHNodeAddress::unsafe_arena_set_allocated_addr(
+ ::bhome_msg::BHAddress* addr) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(addr_);
+ }
+ addr_ = addr;
+ if (addr) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:bhome_msg.MsgQueryTopicReply.BHNodeAddress.addr)
+}
+inline ::bhome_msg::BHAddress* MsgQueryTopicReply_BHNodeAddress::release_addr() {
+
+ ::bhome_msg::BHAddress* temp = addr_;
+ addr_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::bhome_msg::BHAddress* MsgQueryTopicReply_BHNodeAddress::unsafe_arena_release_addr() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgQueryTopicReply.BHNodeAddress.addr)
+
+ ::bhome_msg::BHAddress* temp = addr_;
+ addr_ = nullptr;
+ return temp;
+}
+inline ::bhome_msg::BHAddress* MsgQueryTopicReply_BHNodeAddress::_internal_mutable_addr() {
+
+ if (addr_ == nullptr) {
+ auto* p = CreateMaybeMessage<::bhome_msg::BHAddress>(GetArenaForAllocation());
+ addr_ = p;
+ }
+ return addr_;
+}
+inline ::bhome_msg::BHAddress* MsgQueryTopicReply_BHNodeAddress::mutable_addr() {
+ ::bhome_msg::BHAddress* _msg = _internal_mutable_addr();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryTopicReply.BHNodeAddress.addr)
+ return _msg;
+}
+inline void MsgQueryTopicReply_BHNodeAddress::set_allocated_addr(::bhome_msg::BHAddress* addr) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete addr_;
+ }
+ if (addr) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::bhome_msg::BHAddress>::GetOwningArena(addr);
+ if (message_arena != submessage_arena) {
+ addr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, addr, submessage_arena);
+ }
+
+ } else {
+
+ }
+ addr_ = addr;
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgQueryTopicReply.BHNodeAddress.addr)
+}
+
+// -------------------------------------------------------------------
+
+// MsgQueryTopicReply
+
+// .bhome_msg.ErrorMsg errmsg = 1;
+inline bool MsgQueryTopicReply::_internal_has_errmsg() const {
+ return this != internal_default_instance() && errmsg_ != nullptr;
+}
+inline bool MsgQueryTopicReply::has_errmsg() const {
+ return _internal_has_errmsg();
+}
+inline const ::bhome_msg::ErrorMsg& MsgQueryTopicReply::_internal_errmsg() const {
+ const ::bhome_msg::ErrorMsg* p = errmsg_;
+ return p != nullptr ? *p : reinterpret_cast<const ::bhome_msg::ErrorMsg&>(
+ ::bhome_msg::_ErrorMsg_default_instance_);
+}
+inline const ::bhome_msg::ErrorMsg& MsgQueryTopicReply::errmsg() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryTopicReply.errmsg)
+ return _internal_errmsg();
+}
+inline void MsgQueryTopicReply::unsafe_arena_set_allocated_errmsg(
+ ::bhome_msg::ErrorMsg* errmsg) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(errmsg_);
+ }
+ errmsg_ = errmsg;
+ if (errmsg) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:bhome_msg.MsgQueryTopicReply.errmsg)
+}
+inline ::bhome_msg::ErrorMsg* MsgQueryTopicReply::release_errmsg() {
+
+ ::bhome_msg::ErrorMsg* temp = errmsg_;
+ errmsg_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::bhome_msg::ErrorMsg* MsgQueryTopicReply::unsafe_arena_release_errmsg() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgQueryTopicReply.errmsg)
+
+ ::bhome_msg::ErrorMsg* temp = errmsg_;
+ errmsg_ = nullptr;
+ return temp;
+}
+inline ::bhome_msg::ErrorMsg* MsgQueryTopicReply::_internal_mutable_errmsg() {
+
+ if (errmsg_ == nullptr) {
+ auto* p = CreateMaybeMessage<::bhome_msg::ErrorMsg>(GetArenaForAllocation());
+ errmsg_ = p;
+ }
+ return errmsg_;
+}
+inline ::bhome_msg::ErrorMsg* MsgQueryTopicReply::mutable_errmsg() {
+ ::bhome_msg::ErrorMsg* _msg = _internal_mutable_errmsg();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryTopicReply.errmsg)
+ return _msg;
+}
+inline void MsgQueryTopicReply::set_allocated_errmsg(::bhome_msg::ErrorMsg* errmsg) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(errmsg_);
+ }
+ if (errmsg) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+ ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+ reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(errmsg));
+ if (message_arena != submessage_arena) {
+ errmsg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, errmsg, submessage_arena);
+ }
+
+ } else {
+
+ }
+ errmsg_ = errmsg;
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgQueryTopicReply.errmsg)
+}
+
+// repeated .bhome_msg.MsgQueryTopicReply.BHNodeAddress node_address = 2;
+inline int MsgQueryTopicReply::_internal_node_address_size() const {
+ return node_address_.size();
+}
+inline int MsgQueryTopicReply::node_address_size() const {
+ return _internal_node_address_size();
+}
+inline void MsgQueryTopicReply::clear_node_address() {
+ node_address_.Clear();
+}
+inline ::bhome_msg::MsgQueryTopicReply_BHNodeAddress* MsgQueryTopicReply::mutable_node_address(int index) {
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryTopicReply.node_address)
+ return node_address_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::MsgQueryTopicReply_BHNodeAddress >*
+MsgQueryTopicReply::mutable_node_address() {
+ // @@protoc_insertion_point(field_mutable_list:bhome_msg.MsgQueryTopicReply.node_address)
+ return &node_address_;
+}
+inline const ::bhome_msg::MsgQueryTopicReply_BHNodeAddress& MsgQueryTopicReply::_internal_node_address(int index) const {
+ return node_address_.Get(index);
+}
+inline const ::bhome_msg::MsgQueryTopicReply_BHNodeAddress& MsgQueryTopicReply::node_address(int index) const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryTopicReply.node_address)
+ return _internal_node_address(index);
+}
+inline ::bhome_msg::MsgQueryTopicReply_BHNodeAddress* MsgQueryTopicReply::_internal_add_node_address() {
+ return node_address_.Add();
+}
+inline ::bhome_msg::MsgQueryTopicReply_BHNodeAddress* MsgQueryTopicReply::add_node_address() {
+ ::bhome_msg::MsgQueryTopicReply_BHNodeAddress* _add = _internal_add_node_address();
+ // @@protoc_insertion_point(field_add:bhome_msg.MsgQueryTopicReply.node_address)
+ return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::MsgQueryTopicReply_BHNodeAddress >&
+MsgQueryTopicReply::node_address() const {
+ // @@protoc_insertion_point(field_list:bhome_msg.MsgQueryTopicReply.node_address)
+ return node_address_;
+}
+
+// -------------------------------------------------------------------
+
+// MsgQueryProc
+
+// bytes proc_id = 1;
+inline void MsgQueryProc::clear_proc_id() {
+ proc_id_.ClearToEmpty();
+}
+inline const std::string& MsgQueryProc::proc_id() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryProc.proc_id)
+ return _internal_proc_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MsgQueryProc::set_proc_id(ArgT0&& arg0, ArgT... args) {
+
+ proc_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:bhome_msg.MsgQueryProc.proc_id)
+}
+inline std::string* MsgQueryProc::mutable_proc_id() {
+ std::string* _s = _internal_mutable_proc_id();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryProc.proc_id)
+ return _s;
+}
+inline const std::string& MsgQueryProc::_internal_proc_id() const {
+ return proc_id_.Get();
+}
+inline void MsgQueryProc::_internal_set_proc_id(const std::string& value) {
+
+ proc_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* MsgQueryProc::_internal_mutable_proc_id() {
+
+ return proc_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* MsgQueryProc::release_proc_id() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgQueryProc.proc_id)
+ return proc_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void MsgQueryProc::set_allocated_proc_id(std::string* proc_id) {
+ if (proc_id != nullptr) {
+
+ } else {
+
+ }
+ proc_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), proc_id,
+ GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgQueryProc.proc_id)
+}
+
+// -------------------------------------------------------------------
+
+// MsgQueryProcReply_Info
+
+// .bhome_msg.ProcInfo proc = 1;
+inline bool MsgQueryProcReply_Info::_internal_has_proc() const {
+ return this != internal_default_instance() && proc_ != nullptr;
+}
+inline bool MsgQueryProcReply_Info::has_proc() const {
+ return _internal_has_proc();
+}
+inline void MsgQueryProcReply_Info::clear_proc() {
+ if (GetArenaForAllocation() == nullptr && proc_ != nullptr) {
+ delete proc_;
+ }
+ proc_ = nullptr;
+}
+inline const ::bhome_msg::ProcInfo& MsgQueryProcReply_Info::_internal_proc() const {
+ const ::bhome_msg::ProcInfo* p = proc_;
+ return p != nullptr ? *p : reinterpret_cast<const ::bhome_msg::ProcInfo&>(
+ ::bhome_msg::_ProcInfo_default_instance_);
+}
+inline const ::bhome_msg::ProcInfo& MsgQueryProcReply_Info::proc() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryProcReply.Info.proc)
+ return _internal_proc();
+}
+inline void MsgQueryProcReply_Info::unsafe_arena_set_allocated_proc(
+ ::bhome_msg::ProcInfo* proc) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(proc_);
+ }
+ proc_ = proc;
+ if (proc) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:bhome_msg.MsgQueryProcReply.Info.proc)
+}
+inline ::bhome_msg::ProcInfo* MsgQueryProcReply_Info::release_proc() {
+
+ ::bhome_msg::ProcInfo* temp = proc_;
+ proc_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::bhome_msg::ProcInfo* MsgQueryProcReply_Info::unsafe_arena_release_proc() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgQueryProcReply.Info.proc)
+
+ ::bhome_msg::ProcInfo* temp = proc_;
+ proc_ = nullptr;
+ return temp;
+}
+inline ::bhome_msg::ProcInfo* MsgQueryProcReply_Info::_internal_mutable_proc() {
+
+ if (proc_ == nullptr) {
+ auto* p = CreateMaybeMessage<::bhome_msg::ProcInfo>(GetArenaForAllocation());
+ proc_ = p;
+ }
+ return proc_;
+}
+inline ::bhome_msg::ProcInfo* MsgQueryProcReply_Info::mutable_proc() {
+ ::bhome_msg::ProcInfo* _msg = _internal_mutable_proc();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryProcReply.Info.proc)
+ return _msg;
+}
+inline void MsgQueryProcReply_Info::set_allocated_proc(::bhome_msg::ProcInfo* proc) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete proc_;
+ }
+ if (proc) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::bhome_msg::ProcInfo>::GetOwningArena(proc);
+ if (message_arena != submessage_arena) {
+ proc = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, proc, submessage_arena);
+ }
+
+ } else {
+
+ }
+ proc_ = proc;
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgQueryProcReply.Info.proc)
+}
+
+// bool online = 2;
+inline void MsgQueryProcReply_Info::clear_online() {
+ online_ = false;
+}
+inline bool MsgQueryProcReply_Info::_internal_online() const {
+ return online_;
+}
+inline bool MsgQueryProcReply_Info::online() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryProcReply.Info.online)
+ return _internal_online();
+}
+inline void MsgQueryProcReply_Info::_internal_set_online(bool value) {
+
+ online_ = value;
+}
+inline void MsgQueryProcReply_Info::set_online(bool value) {
+ _internal_set_online(value);
+ // @@protoc_insertion_point(field_set:bhome_msg.MsgQueryProcReply.Info.online)
+}
+
+// .bhome_msg.MsgTopicList topics = 3;
+inline bool MsgQueryProcReply_Info::_internal_has_topics() const {
+ return this != internal_default_instance() && topics_ != nullptr;
+}
+inline bool MsgQueryProcReply_Info::has_topics() const {
+ return _internal_has_topics();
+}
+inline void MsgQueryProcReply_Info::clear_topics() {
+ if (GetArenaForAllocation() == nullptr && topics_ != nullptr) {
+ delete topics_;
+ }
+ topics_ = nullptr;
+}
+inline const ::bhome_msg::MsgTopicList& MsgQueryProcReply_Info::_internal_topics() const {
+ const ::bhome_msg::MsgTopicList* p = topics_;
+ return p != nullptr ? *p : reinterpret_cast<const ::bhome_msg::MsgTopicList&>(
+ ::bhome_msg::_MsgTopicList_default_instance_);
+}
+inline const ::bhome_msg::MsgTopicList& MsgQueryProcReply_Info::topics() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryProcReply.Info.topics)
+ return _internal_topics();
+}
+inline void MsgQueryProcReply_Info::unsafe_arena_set_allocated_topics(
+ ::bhome_msg::MsgTopicList* topics) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(topics_);
+ }
+ topics_ = topics;
+ if (topics) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:bhome_msg.MsgQueryProcReply.Info.topics)
+}
+inline ::bhome_msg::MsgTopicList* MsgQueryProcReply_Info::release_topics() {
+
+ ::bhome_msg::MsgTopicList* temp = topics_;
+ topics_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::bhome_msg::MsgTopicList* MsgQueryProcReply_Info::unsafe_arena_release_topics() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgQueryProcReply.Info.topics)
+
+ ::bhome_msg::MsgTopicList* temp = topics_;
+ topics_ = nullptr;
+ return temp;
+}
+inline ::bhome_msg::MsgTopicList* MsgQueryProcReply_Info::_internal_mutable_topics() {
+
+ if (topics_ == nullptr) {
+ auto* p = CreateMaybeMessage<::bhome_msg::MsgTopicList>(GetArenaForAllocation());
+ topics_ = p;
+ }
+ return topics_;
+}
+inline ::bhome_msg::MsgTopicList* MsgQueryProcReply_Info::mutable_topics() {
+ ::bhome_msg::MsgTopicList* _msg = _internal_mutable_topics();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryProcReply.Info.topics)
+ return _msg;
+}
+inline void MsgQueryProcReply_Info::set_allocated_topics(::bhome_msg::MsgTopicList* topics) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete topics_;
+ }
+ if (topics) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::bhome_msg::MsgTopicList>::GetOwningArena(topics);
+ if (message_arena != submessage_arena) {
+ topics = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, topics, submessage_arena);
+ }
+
+ } else {
+
+ }
+ topics_ = topics;
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgQueryProcReply.Info.topics)
+}
+
+// -------------------------------------------------------------------
+
+// MsgQueryProcReply
+
+// .bhome_msg.ErrorMsg errmsg = 1;
+inline bool MsgQueryProcReply::_internal_has_errmsg() const {
+ return this != internal_default_instance() && errmsg_ != nullptr;
+}
+inline bool MsgQueryProcReply::has_errmsg() const {
+ return _internal_has_errmsg();
+}
+inline const ::bhome_msg::ErrorMsg& MsgQueryProcReply::_internal_errmsg() const {
+ const ::bhome_msg::ErrorMsg* p = errmsg_;
+ return p != nullptr ? *p : reinterpret_cast<const ::bhome_msg::ErrorMsg&>(
+ ::bhome_msg::_ErrorMsg_default_instance_);
+}
+inline const ::bhome_msg::ErrorMsg& MsgQueryProcReply::errmsg() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryProcReply.errmsg)
+ return _internal_errmsg();
+}
+inline void MsgQueryProcReply::unsafe_arena_set_allocated_errmsg(
+ ::bhome_msg::ErrorMsg* errmsg) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(errmsg_);
+ }
+ errmsg_ = errmsg;
+ if (errmsg) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:bhome_msg.MsgQueryProcReply.errmsg)
+}
+inline ::bhome_msg::ErrorMsg* MsgQueryProcReply::release_errmsg() {
+
+ ::bhome_msg::ErrorMsg* temp = errmsg_;
+ errmsg_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::bhome_msg::ErrorMsg* MsgQueryProcReply::unsafe_arena_release_errmsg() {
+ // @@protoc_insertion_point(field_release:bhome_msg.MsgQueryProcReply.errmsg)
+
+ ::bhome_msg::ErrorMsg* temp = errmsg_;
+ errmsg_ = nullptr;
+ return temp;
+}
+inline ::bhome_msg::ErrorMsg* MsgQueryProcReply::_internal_mutable_errmsg() {
+
+ if (errmsg_ == nullptr) {
+ auto* p = CreateMaybeMessage<::bhome_msg::ErrorMsg>(GetArenaForAllocation());
+ errmsg_ = p;
+ }
+ return errmsg_;
+}
+inline ::bhome_msg::ErrorMsg* MsgQueryProcReply::mutable_errmsg() {
+ ::bhome_msg::ErrorMsg* _msg = _internal_mutable_errmsg();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryProcReply.errmsg)
+ return _msg;
+}
+inline void MsgQueryProcReply::set_allocated_errmsg(::bhome_msg::ErrorMsg* errmsg) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(errmsg_);
+ }
+ if (errmsg) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+ ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+ reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(errmsg));
+ if (message_arena != submessage_arena) {
+ errmsg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, errmsg, submessage_arena);
+ }
+
+ } else {
+
+ }
+ errmsg_ = errmsg;
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgQueryProcReply.errmsg)
+}
+
+// repeated .bhome_msg.MsgQueryProcReply.Info proc_list = 2;
+inline int MsgQueryProcReply::_internal_proc_list_size() const {
+ return proc_list_.size();
+}
+inline int MsgQueryProcReply::proc_list_size() const {
+ return _internal_proc_list_size();
+}
+inline void MsgQueryProcReply::clear_proc_list() {
+ proc_list_.Clear();
+}
+inline ::bhome_msg::MsgQueryProcReply_Info* MsgQueryProcReply::mutable_proc_list(int index) {
+ // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryProcReply.proc_list)
+ return proc_list_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::MsgQueryProcReply_Info >*
+MsgQueryProcReply::mutable_proc_list() {
+ // @@protoc_insertion_point(field_mutable_list:bhome_msg.MsgQueryProcReply.proc_list)
+ return &proc_list_;
+}
+inline const ::bhome_msg::MsgQueryProcReply_Info& MsgQueryProcReply::_internal_proc_list(int index) const {
+ return proc_list_.Get(index);
+}
+inline const ::bhome_msg::MsgQueryProcReply_Info& MsgQueryProcReply::proc_list(int index) const {
+ // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryProcReply.proc_list)
+ return _internal_proc_list(index);
+}
+inline ::bhome_msg::MsgQueryProcReply_Info* MsgQueryProcReply::_internal_add_proc_list() {
+ return proc_list_.Add();
+}
+inline ::bhome_msg::MsgQueryProcReply_Info* MsgQueryProcReply::add_proc_list() {
+ ::bhome_msg::MsgQueryProcReply_Info* _add = _internal_add_proc_list();
+ // @@protoc_insertion_point(field_add:bhome_msg.MsgQueryProcReply.proc_list)
+ return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::MsgQueryProcReply_Info >&
+MsgQueryProcReply::proc_list() const {
+ // @@protoc_insertion_point(field_list:bhome_msg.MsgQueryProcReply.proc_list)
+ return proc_list_;
+}
+
+#ifdef __GNUC__
+ #pragma GCC diagnostic pop
+#endif // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+} // namespace bhome_msg
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_bhome_5fmsg_5fapi_2eproto
diff --git a/src/proto/bhome_msg_api.proto b/src/proto/bhome_msg_api.proto
new file mode 100644
index 0000000..6a20aa7
--- /dev/null
+++ b/src/proto/bhome_msg_api.proto
@@ -0,0 +1,90 @@
+syntax = "proto3";
+option optimize_for = LITE_RUNTIME;
+option go_package="./bhome_msg";
+
+// public messages
+import "error_msg.proto";
+
+package bhome_msg;
+
+message BHAddress {
+ uint64 mq_id = 1;
+ int64 abs_addr = 2;
+ bytes ip = 3;
+ int32 port = 4;
+}
+
+message ProcInfo
+{
+ bytes proc_id = 1; // serial number, maybe managed
+ bytes name = 2;
+ bytes public_info = 3; // maybe json.
+ bytes private_info = 4;
+}
+
+message MsgTopicList {
+ repeated bytes topic_list = 1;
+}
+
+
+message MsgPublish {
+ bytes topic = 1;
+ bytes data = 2;
+}
+
+message MsgCommonReply {
+ ErrorMsg errmsg = 1;
+}
+
+message MsgRequestTopic {
+ bytes topic = 1;
+ bytes data = 2;
+}
+
+message MsgRequestTopicReply {
+ ErrorMsg errmsg = 1;
+ bytes data = 2;
+}
+
+message MsgRegister
+{
+ ProcInfo proc = 1;
+}
+
+message MsgUnregister
+{
+ ProcInfo proc = 1;
+}
+
+message MsgHeartbeat
+{
+ ProcInfo proc = 1;
+}
+
+message MsgQueryTopic {
+ bytes topic = 1;
+}
+
+message MsgQueryTopicReply {
+ ErrorMsg errmsg = 1;
+
+message BHNodeAddress {
+ bytes proc_id = 1;
+ BHAddress addr = 2;
+}
+ repeated BHNodeAddress node_address = 2;
+}
+
+message MsgQueryProc {
+ bytes proc_id = 1;
+}
+
+message MsgQueryProcReply {
+ ErrorMsg errmsg = 1;
+ message Info {
+ ProcInfo proc = 1;
+ bool online = 2;
+ MsgTopicList topics = 3;
+ }
+ repeated Info proc_list = 2;
+}
diff --git a/src/proto/error_msg.pb.cc b/src/proto/error_msg.pb.cc
new file mode 100644
index 0000000..ff15c9d
--- /dev/null
+++ b/src/proto/error_msg.pb.cc
@@ -0,0 +1,332 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: error_msg.proto
+
+#include "error_msg.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+namespace bhome_msg {
+constexpr ErrorMsg::ErrorMsg(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : errstring_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+ , errcode_(0)
+{}
+struct ErrorMsgDefaultTypeInternal {
+ constexpr ErrorMsgDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~ErrorMsgDefaultTypeInternal() {}
+ union {
+ ErrorMsg _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ErrorMsgDefaultTypeInternal _ErrorMsg_default_instance_;
+} // namespace bhome_msg
+namespace bhome_msg {
+bool ErrorCode_IsValid(int value) {
+ switch (value) {
+ case 0:
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ case 6:
+ case 7:
+ return true;
+ default:
+ return false;
+ }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ErrorCode_strings[8] = {};
+
+static const char ErrorCode_names[] =
+ "eAddressNotMatch"
+ "eError"
+ "eInvalidInput"
+ "eNoRespond"
+ "eNotFound"
+ "eNotRegistered"
+ "eOffline"
+ "eSuccess";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ErrorCode_entries[] = {
+ { {ErrorCode_names + 0, 16}, 7 },
+ { {ErrorCode_names + 16, 6}, 1 },
+ { {ErrorCode_names + 22, 13}, 2 },
+ { {ErrorCode_names + 35, 10}, 6 },
+ { {ErrorCode_names + 45, 9}, 4 },
+ { {ErrorCode_names + 54, 14}, 3 },
+ { {ErrorCode_names + 68, 8}, 5 },
+ { {ErrorCode_names + 76, 8}, 0 },
+};
+
+static const int ErrorCode_entries_by_number[] = {
+ 7, // 0 -> eSuccess
+ 1, // 1 -> eError
+ 2, // 2 -> eInvalidInput
+ 5, // 3 -> eNotRegistered
+ 4, // 4 -> eNotFound
+ 6, // 5 -> eOffline
+ 3, // 6 -> eNoRespond
+ 0, // 7 -> eAddressNotMatch
+};
+
+const std::string& ErrorCode_Name(
+ ErrorCode value) {
+ static const bool dummy =
+ ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+ ErrorCode_entries,
+ ErrorCode_entries_by_number,
+ 8, ErrorCode_strings);
+ (void) dummy;
+ int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+ ErrorCode_entries,
+ ErrorCode_entries_by_number,
+ 8, value);
+ return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+ ErrorCode_strings[idx].get();
+}
+bool ErrorCode_Parse(
+ ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ErrorCode* value) {
+ int int_value;
+ bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+ ErrorCode_entries, 8, name, &int_value);
+ if (success) {
+ *value = static_cast<ErrorCode>(int_value);
+ }
+ return success;
+}
+
+// ===================================================================
+
+class ErrorMsg::_Internal {
+ public:
+};
+
+ErrorMsg::ErrorMsg(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:bhome_msg.ErrorMsg)
+}
+ErrorMsg::ErrorMsg(const ErrorMsg& from)
+ : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+ errstring_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_errstring().empty()) {
+ errstring_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_errstring(),
+ GetArenaForAllocation());
+ }
+ errcode_ = from.errcode_;
+ // @@protoc_insertion_point(copy_constructor:bhome_msg.ErrorMsg)
+}
+
+inline void ErrorMsg::SharedCtor() {
+errstring_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+errcode_ = 0;
+}
+
+ErrorMsg::~ErrorMsg() {
+ // @@protoc_insertion_point(destructor:bhome_msg.ErrorMsg)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<std::string>();
+}
+
+inline void ErrorMsg::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ errstring_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void ErrorMsg::ArenaDtor(void* object) {
+ ErrorMsg* _this = reinterpret_cast< ErrorMsg* >(object);
+ (void)_this;
+}
+void ErrorMsg::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ErrorMsg::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void ErrorMsg::Clear() {
+// @@protoc_insertion_point(message_clear_start:bhome_msg.ErrorMsg)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ errstring_.ClearToEmpty();
+ errcode_ = 0;
+ _internal_metadata_.Clear<std::string>();
+}
+
+const char* ErrorMsg::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .bhome_msg.ErrorCode errCode = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
+ ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+ CHK_(ptr);
+ _internal_set_errcode(static_cast<::bhome_msg::ErrorCode>(val));
+ } else goto handle_unusual;
+ continue;
+ // bytes errString = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ auto str = _internal_mutable_errstring();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<std::string>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* ErrorMsg::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.ErrorMsg)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .bhome_msg.ErrorCode errCode = 1;
+ if (this->_internal_errcode() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+ 1, this->_internal_errcode(), target);
+ }
+
+ // bytes errString = 2;
+ if (!this->_internal_errstring().empty()) {
+ target = stream->WriteBytesMaybeAliased(
+ 2, this->_internal_errstring(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+ static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.ErrorMsg)
+ return target;
+}
+
+size_t ErrorMsg::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:bhome_msg.ErrorMsg)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // bytes errString = 2;
+ if (!this->_internal_errstring().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_errstring());
+ }
+
+ // .bhome_msg.ErrorCode errCode = 1;
+ if (this->_internal_errcode() != 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_errcode());
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void ErrorMsg::CheckTypeAndMergeFrom(
+ const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+ MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ErrorMsg*>(
+ &from));
+}
+
+void ErrorMsg::MergeFrom(const ErrorMsg& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.ErrorMsg)
+ GOOGLE_DCHECK_NE(&from, this);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (!from._internal_errstring().empty()) {
+ _internal_set_errstring(from._internal_errstring());
+ }
+ if (from._internal_errcode() != 0) {
+ _internal_set_errcode(from._internal_errcode());
+ }
+ _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ErrorMsg::CopyFrom(const ErrorMsg& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.ErrorMsg)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool ErrorMsg::IsInitialized() const {
+ return true;
+}
+
+void ErrorMsg::InternalSwap(ErrorMsg* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &errstring_, GetArenaForAllocation(),
+ &other->errstring_, other->GetArenaForAllocation()
+ );
+ swap(errcode_, other->errcode_);
+}
+
+std::string ErrorMsg::GetTypeName() const {
+ return "bhome_msg.ErrorMsg";
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+} // namespace bhome_msg
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::bhome_msg::ErrorMsg* Arena::CreateMaybeMessage< ::bhome_msg::ErrorMsg >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::bhome_msg::ErrorMsg >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>
diff --git a/src/proto/error_msg.pb.h b/src/proto/error_msg.pb.h
new file mode 100644
index 0000000..4119dd5
--- /dev/null
+++ b/src/proto/error_msg.pb.h
@@ -0,0 +1,325 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: error_msg.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_error_5fmsg_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_error_5fmsg_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/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/metadata_lite.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/repeated_field.h> // IWYU pragma: export
+#include <google/protobuf/extension_set.h> // IWYU pragma: export
+#include <google/protobuf/generated_enum_util.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_error_5fmsg_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+} // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_error_5fmsg_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[];
+};
+namespace bhome_msg {
+class ErrorMsg;
+struct ErrorMsgDefaultTypeInternal;
+extern ErrorMsgDefaultTypeInternal _ErrorMsg_default_instance_;
+} // namespace bhome_msg
+PROTOBUF_NAMESPACE_OPEN
+template<> ::bhome_msg::ErrorMsg* Arena::CreateMaybeMessage<::bhome_msg::ErrorMsg>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace bhome_msg {
+
+enum ErrorCode : int {
+ eSuccess = 0,
+ eError = 1,
+ eInvalidInput = 2,
+ eNotRegistered = 3,
+ eNotFound = 4,
+ eOffline = 5,
+ eNoRespond = 6,
+ eAddressNotMatch = 7,
+ ErrorCode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+ ErrorCode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool ErrorCode_IsValid(int value);
+constexpr ErrorCode ErrorCode_MIN = eSuccess;
+constexpr ErrorCode ErrorCode_MAX = eAddressNotMatch;
+constexpr int ErrorCode_ARRAYSIZE = ErrorCode_MAX + 1;
+
+const std::string& ErrorCode_Name(ErrorCode value);
+template<typename T>
+inline const std::string& ErrorCode_Name(T enum_t_value) {
+ static_assert(::std::is_same<T, ErrorCode>::value ||
+ ::std::is_integral<T>::value,
+ "Incorrect type passed to function ErrorCode_Name.");
+ return ErrorCode_Name(static_cast<ErrorCode>(enum_t_value));
+}
+bool ErrorCode_Parse(
+ ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ErrorCode* value);
+// ===================================================================
+
+class ErrorMsg final :
+ public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.ErrorMsg) */ {
+ public:
+ inline ErrorMsg() : ErrorMsg(nullptr) {}
+ ~ErrorMsg() override;
+ explicit constexpr ErrorMsg(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ ErrorMsg(const ErrorMsg& from);
+ ErrorMsg(ErrorMsg&& from) noexcept
+ : ErrorMsg() {
+ *this = ::std::move(from);
+ }
+
+ inline ErrorMsg& operator=(const ErrorMsg& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline ErrorMsg& operator=(ErrorMsg&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ErrorMsg& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const ErrorMsg* internal_default_instance() {
+ return reinterpret_cast<const ErrorMsg*>(
+ &_ErrorMsg_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 0;
+
+ friend void swap(ErrorMsg& a, ErrorMsg& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(ErrorMsg* other) {
+ if (other == this) return;
+ if (GetOwningArena() == other->GetOwningArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(ErrorMsg* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline ErrorMsg* New() const final {
+ return new ErrorMsg();
+ }
+
+ ErrorMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<ErrorMsg>(arena);
+ }
+ void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
+ void CopyFrom(const ErrorMsg& from);
+ void MergeFrom(const ErrorMsg& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() 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;
+ void DiscardUnknownFields();
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const;
+ void InternalSwap(ErrorMsg* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "bhome_msg.ErrorMsg";
+ }
+ protected:
+ explicit ErrorMsg(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ std::string GetTypeName() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kErrStringFieldNumber = 2,
+ kErrCodeFieldNumber = 1,
+ };
+ // bytes errString = 2;
+ void clear_errstring();
+ const std::string& errstring() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_errstring(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_errstring();
+ PROTOBUF_MUST_USE_RESULT std::string* release_errstring();
+ void set_allocated_errstring(std::string* errstring);
+ private:
+ const std::string& _internal_errstring() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_errstring(const std::string& value);
+ std::string* _internal_mutable_errstring();
+ public:
+
+ // .bhome_msg.ErrorCode errCode = 1;
+ void clear_errcode();
+ ::bhome_msg::ErrorCode errcode() const;
+ void set_errcode(::bhome_msg::ErrorCode value);
+ private:
+ ::bhome_msg::ErrorCode _internal_errcode() const;
+ void _internal_set_errcode(::bhome_msg::ErrorCode value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:bhome_msg.ErrorMsg)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr errstring_;
+ int errcode_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_error_5fmsg_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+ #pragma GCC diagnostic push
+ #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif // __GNUC__
+// ErrorMsg
+
+// .bhome_msg.ErrorCode errCode = 1;
+inline void ErrorMsg::clear_errcode() {
+ errcode_ = 0;
+}
+inline ::bhome_msg::ErrorCode ErrorMsg::_internal_errcode() const {
+ return static_cast< ::bhome_msg::ErrorCode >(errcode_);
+}
+inline ::bhome_msg::ErrorCode ErrorMsg::errcode() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.ErrorMsg.errCode)
+ return _internal_errcode();
+}
+inline void ErrorMsg::_internal_set_errcode(::bhome_msg::ErrorCode value) {
+
+ errcode_ = value;
+}
+inline void ErrorMsg::set_errcode(::bhome_msg::ErrorCode value) {
+ _internal_set_errcode(value);
+ // @@protoc_insertion_point(field_set:bhome_msg.ErrorMsg.errCode)
+}
+
+// bytes errString = 2;
+inline void ErrorMsg::clear_errstring() {
+ errstring_.ClearToEmpty();
+}
+inline const std::string& ErrorMsg::errstring() const {
+ // @@protoc_insertion_point(field_get:bhome_msg.ErrorMsg.errString)
+ return _internal_errstring();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ErrorMsg::set_errstring(ArgT0&& arg0, ArgT... args) {
+
+ errstring_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:bhome_msg.ErrorMsg.errString)
+}
+inline std::string* ErrorMsg::mutable_errstring() {
+ std::string* _s = _internal_mutable_errstring();
+ // @@protoc_insertion_point(field_mutable:bhome_msg.ErrorMsg.errString)
+ return _s;
+}
+inline const std::string& ErrorMsg::_internal_errstring() const {
+ return errstring_.Get();
+}
+inline void ErrorMsg::_internal_set_errstring(const std::string& value) {
+
+ errstring_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ErrorMsg::_internal_mutable_errstring() {
+
+ return errstring_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ErrorMsg::release_errstring() {
+ // @@protoc_insertion_point(field_release:bhome_msg.ErrorMsg.errString)
+ return errstring_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ErrorMsg::set_allocated_errstring(std::string* errstring) {
+ if (errstring != nullptr) {
+
+ } else {
+
+ }
+ errstring_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), errstring,
+ GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set_allocated:bhome_msg.ErrorMsg.errString)
+}
+
+#ifdef __GNUC__
+ #pragma GCC diagnostic pop
+#endif // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+} // namespace bhome_msg
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::bhome_msg::ErrorCode> : ::std::true_type {};
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_error_5fmsg_2eproto
diff --git a/src/proto/error_msg.proto b/src/proto/error_msg.proto
new file mode 100644
index 0000000..6496c67
--- /dev/null
+++ b/src/proto/error_msg.proto
@@ -0,0 +1,22 @@
+syntax = "proto3";
+
+option optimize_for = LITE_RUNTIME;
+option go_package="./bhome_msg";
+
+package bhome_msg;
+
+enum ErrorCode {
+ eSuccess = 0;
+ eError = 1;
+ eInvalidInput = 2;
+ eNotRegistered = 3;
+ eNotFound = 4;
+ eOffline = 5;
+ eNoRespond = 6;
+ eAddressNotMatch = 7;
+}
+
+message ErrorMsg {
+ ErrorCode errCode = 1;
+ bytes errString = 2;
+}
--
Gitblit v1.8.0