// 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>