// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: bhome_msg_api.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_bhome_5fmsg_5fapi_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_bhome_5fmsg_5fapi_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3011000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3011002 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include "error_msg.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_bhome_5fmsg_5fapi_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_bhome_5fmsg_5fapi_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[16]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
namespace bhome_msg {
class BHAddress;
class BHAddressDefaultTypeInternal;
extern BHAddressDefaultTypeInternal _BHAddress_default_instance_;
class MsgCommonReply;
class MsgCommonReplyDefaultTypeInternal;
extern MsgCommonReplyDefaultTypeInternal _MsgCommonReply_default_instance_;
class MsgHeartbeat;
class MsgHeartbeatDefaultTypeInternal;
extern MsgHeartbeatDefaultTypeInternal _MsgHeartbeat_default_instance_;
class MsgPublish;
class MsgPublishDefaultTypeInternal;
extern MsgPublishDefaultTypeInternal _MsgPublish_default_instance_;
class MsgQueryProc;
class MsgQueryProcDefaultTypeInternal;
extern MsgQueryProcDefaultTypeInternal _MsgQueryProc_default_instance_;
class MsgQueryProcReply;
class MsgQueryProcReplyDefaultTypeInternal;
extern MsgQueryProcReplyDefaultTypeInternal _MsgQueryProcReply_default_instance_;
class MsgQueryProcReply_Info;
class MsgQueryProcReply_InfoDefaultTypeInternal;
extern MsgQueryProcReply_InfoDefaultTypeInternal _MsgQueryProcReply_Info_default_instance_;
class MsgQueryTopic;
class MsgQueryTopicDefaultTypeInternal;
extern MsgQueryTopicDefaultTypeInternal _MsgQueryTopic_default_instance_;
class MsgQueryTopicReply;
class MsgQueryTopicReplyDefaultTypeInternal;
extern MsgQueryTopicReplyDefaultTypeInternal _MsgQueryTopicReply_default_instance_;
class MsgQueryTopicReply_BHNodeAddress;
class MsgQueryTopicReply_BHNodeAddressDefaultTypeInternal;
extern MsgQueryTopicReply_BHNodeAddressDefaultTypeInternal _MsgQueryTopicReply_BHNodeAddress_default_instance_;
class MsgRegister;
class MsgRegisterDefaultTypeInternal;
extern MsgRegisterDefaultTypeInternal _MsgRegister_default_instance_;
class MsgRequestTopic;
class MsgRequestTopicDefaultTypeInternal;
extern MsgRequestTopicDefaultTypeInternal _MsgRequestTopic_default_instance_;
class MsgRequestTopicReply;
class MsgRequestTopicReplyDefaultTypeInternal;
extern MsgRequestTopicReplyDefaultTypeInternal _MsgRequestTopicReply_default_instance_;
class MsgTopicList;
class MsgTopicListDefaultTypeInternal;
extern MsgTopicListDefaultTypeInternal _MsgTopicList_default_instance_;
class MsgUnregister;
class MsgUnregisterDefaultTypeInternal;
extern MsgUnregisterDefaultTypeInternal _MsgUnregister_default_instance_;
class ProcInfo;
class ProcInfoDefaultTypeInternal;
extern ProcInfoDefaultTypeInternal _ProcInfo_default_instance_;
}  // namespace bhome_msg
PROTOBUF_NAMESPACE_OPEN
template<> ::bhome_msg::BHAddress* Arena::CreateMaybeMessage<::bhome_msg::BHAddress>(Arena*);
template<> ::bhome_msg::MsgCommonReply* Arena::CreateMaybeMessage<::bhome_msg::MsgCommonReply>(Arena*);
template<> ::bhome_msg::MsgHeartbeat* Arena::CreateMaybeMessage<::bhome_msg::MsgHeartbeat>(Arena*);
template<> ::bhome_msg::MsgPublish* Arena::CreateMaybeMessage<::bhome_msg::MsgPublish>(Arena*);
template<> ::bhome_msg::MsgQueryProc* Arena::CreateMaybeMessage<::bhome_msg::MsgQueryProc>(Arena*);
template<> ::bhome_msg::MsgQueryProcReply* Arena::CreateMaybeMessage<::bhome_msg::MsgQueryProcReply>(Arena*);
template<> ::bhome_msg::MsgQueryProcReply_Info* Arena::CreateMaybeMessage<::bhome_msg::MsgQueryProcReply_Info>(Arena*);
template<> ::bhome_msg::MsgQueryTopic* Arena::CreateMaybeMessage<::bhome_msg::MsgQueryTopic>(Arena*);
template<> ::bhome_msg::MsgQueryTopicReply* Arena::CreateMaybeMessage<::bhome_msg::MsgQueryTopicReply>(Arena*);
template<> ::bhome_msg::MsgQueryTopicReply_BHNodeAddress* Arena::CreateMaybeMessage<::bhome_msg::MsgQueryTopicReply_BHNodeAddress>(Arena*);
template<> ::bhome_msg::MsgRegister* Arena::CreateMaybeMessage<::bhome_msg::MsgRegister>(Arena*);
template<> ::bhome_msg::MsgRequestTopic* Arena::CreateMaybeMessage<::bhome_msg::MsgRequestTopic>(Arena*);
template<> ::bhome_msg::MsgRequestTopicReply* Arena::CreateMaybeMessage<::bhome_msg::MsgRequestTopicReply>(Arena*);
template<> ::bhome_msg::MsgTopicList* Arena::CreateMaybeMessage<::bhome_msg::MsgTopicList>(Arena*);
template<> ::bhome_msg::MsgUnregister* Arena::CreateMaybeMessage<::bhome_msg::MsgUnregister>(Arena*);
template<> ::bhome_msg::ProcInfo* Arena::CreateMaybeMessage<::bhome_msg::ProcInfo>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace bhome_msg {

// ===================================================================

class BHAddress :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.BHAddress) */ {
 public:
  BHAddress();
  virtual ~BHAddress();

  BHAddress(const BHAddress& from);
  BHAddress(BHAddress&& from) noexcept
    : BHAddress() {
    *this = ::std::move(from);
  }

  inline BHAddress& operator=(const BHAddress& from) {
    CopyFrom(from);
    return *this;
  }
  inline BHAddress& operator=(BHAddress&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const BHAddress& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BHAddress* internal_default_instance() {
    return reinterpret_cast<const BHAddress*>(
               &_BHAddress_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(BHAddress& a, BHAddress& b) {
    a.Swap(&b);
  }
  inline void Swap(BHAddress* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline BHAddress* New() const final {
    return CreateMaybeMessage<BHAddress>(nullptr);
  }

  BHAddress* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BHAddress>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const BHAddress& from);
  void MergeFrom(const BHAddress& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(BHAddress* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "bhome_msg.BHAddress";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kIpFieldNumber = 3,
    kMqIdFieldNumber = 1,
    kAbsAddrFieldNumber = 2,
    kPortFieldNumber = 4,
  };
  // bytes ip = 3;
  void clear_ip();
  const std::string& ip() const;
  void set_ip(const std::string& value);
  void set_ip(std::string&& value);
  void set_ip(const char* value);
  void set_ip(const void* value, size_t size);
  std::string* mutable_ip();
  std::string* release_ip();
  void set_allocated_ip(std::string* ip);
  private:
  const std::string& _internal_ip() const;
  void _internal_set_ip(const std::string& value);
  std::string* _internal_mutable_ip();
  public:

  // uint64 mq_id = 1;
  void clear_mq_id();
  ::PROTOBUF_NAMESPACE_ID::uint64 mq_id() const;
  void set_mq_id(::PROTOBUF_NAMESPACE_ID::uint64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_mq_id() const;
  void _internal_set_mq_id(::PROTOBUF_NAMESPACE_ID::uint64 value);
  public:

  // int64 abs_addr = 2;
  void clear_abs_addr();
  ::PROTOBUF_NAMESPACE_ID::int64 abs_addr() const;
  void set_abs_addr(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_abs_addr() const;
  void _internal_set_abs_addr(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // int32 port = 4;
  void clear_port();
  ::PROTOBUF_NAMESPACE_ID::int32 port() const;
  void set_port(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_port() const;
  void _internal_set_port(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:bhome_msg.BHAddress)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ip_;
  ::PROTOBUF_NAMESPACE_ID::uint64 mq_id_;
  ::PROTOBUF_NAMESPACE_ID::int64 abs_addr_;
  ::PROTOBUF_NAMESPACE_ID::int32 port_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
};
// -------------------------------------------------------------------

class ProcInfo :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.ProcInfo) */ {
 public:
  ProcInfo();
  virtual ~ProcInfo();

  ProcInfo(const ProcInfo& from);
  ProcInfo(ProcInfo&& from) noexcept
    : ProcInfo() {
    *this = ::std::move(from);
  }

  inline ProcInfo& operator=(const ProcInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline ProcInfo& operator=(ProcInfo&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ProcInfo& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ProcInfo* internal_default_instance() {
    return reinterpret_cast<const ProcInfo*>(
               &_ProcInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(ProcInfo& a, ProcInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(ProcInfo* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ProcInfo* New() const final {
    return CreateMaybeMessage<ProcInfo>(nullptr);
  }

  ProcInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ProcInfo>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const ProcInfo& from);
  void MergeFrom(const ProcInfo& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ProcInfo* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "bhome_msg.ProcInfo";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kProcIdFieldNumber = 1,
    kNameFieldNumber = 2,
    kPublicInfoFieldNumber = 3,
    kPrivateInfoFieldNumber = 4,
  };
  // bytes proc_id = 1;
  void clear_proc_id();
  const std::string& proc_id() const;
  void set_proc_id(const std::string& value);
  void set_proc_id(std::string&& value);
  void set_proc_id(const char* value);
  void set_proc_id(const void* value, size_t size);
  std::string* mutable_proc_id();
  std::string* release_proc_id();
  void set_allocated_proc_id(std::string* proc_id);
  private:
  const std::string& _internal_proc_id() const;
  void _internal_set_proc_id(const std::string& value);
  std::string* _internal_mutable_proc_id();
  public:

  // bytes name = 2;
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const void* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // bytes public_info = 3;
  void clear_public_info();
  const std::string& public_info() const;
  void set_public_info(const std::string& value);
  void set_public_info(std::string&& value);
  void set_public_info(const char* value);
  void set_public_info(const void* value, size_t size);
  std::string* mutable_public_info();
  std::string* release_public_info();
  void set_allocated_public_info(std::string* public_info);
  private:
  const std::string& _internal_public_info() const;
  void _internal_set_public_info(const std::string& value);
  std::string* _internal_mutable_public_info();
  public:

  // bytes private_info = 4;
  void clear_private_info();
  const std::string& private_info() const;
  void set_private_info(const std::string& value);
  void set_private_info(std::string&& value);
  void set_private_info(const char* value);
  void set_private_info(const void* value, size_t size);
  std::string* mutable_private_info();
  std::string* release_private_info();
  void set_allocated_private_info(std::string* private_info);
  private:
  const std::string& _internal_private_info() const;
  void _internal_set_private_info(const std::string& value);
  std::string* _internal_mutable_private_info();
  public:

  // @@protoc_insertion_point(class_scope:bhome_msg.ProcInfo)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr proc_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr public_info_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr private_info_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
};
// -------------------------------------------------------------------

class MsgTopicList :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgTopicList) */ {
 public:
  MsgTopicList();
  virtual ~MsgTopicList();

  MsgTopicList(const MsgTopicList& from);
  MsgTopicList(MsgTopicList&& from) noexcept
    : MsgTopicList() {
    *this = ::std::move(from);
  }

  inline MsgTopicList& operator=(const MsgTopicList& from) {
    CopyFrom(from);
    return *this;
  }
  inline MsgTopicList& operator=(MsgTopicList&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const MsgTopicList& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MsgTopicList* internal_default_instance() {
    return reinterpret_cast<const MsgTopicList*>(
               &_MsgTopicList_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(MsgTopicList& a, MsgTopicList& b) {
    a.Swap(&b);
  }
  inline void Swap(MsgTopicList* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline MsgTopicList* New() const final {
    return CreateMaybeMessage<MsgTopicList>(nullptr);
  }

  MsgTopicList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MsgTopicList>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const MsgTopicList& from);
  void MergeFrom(const MsgTopicList& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MsgTopicList* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "bhome_msg.MsgTopicList";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTopicListFieldNumber = 1,
  };
  // repeated bytes topic_list = 1;
  int topic_list_size() const;
  private:
  int _internal_topic_list_size() const;
  public:
  void clear_topic_list();
  const std::string& topic_list(int index) const;
  std::string* mutable_topic_list(int index);
  void set_topic_list(int index, const std::string& value);
  void set_topic_list(int index, std::string&& value);
  void set_topic_list(int index, const char* value);
  void set_topic_list(int index, const void* value, size_t size);
  std::string* add_topic_list();
  void add_topic_list(const std::string& value);
  void add_topic_list(std::string&& value);
  void add_topic_list(const char* value);
  void add_topic_list(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& topic_list() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_topic_list();
  private:
  const std::string& _internal_topic_list(int index) const;
  std::string* _internal_add_topic_list();
  public:

  // @@protoc_insertion_point(class_scope:bhome_msg.MsgTopicList)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> topic_list_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
};
// -------------------------------------------------------------------

class MsgPublish :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgPublish) */ {
 public:
  MsgPublish();
  virtual ~MsgPublish();

  MsgPublish(const MsgPublish& from);
  MsgPublish(MsgPublish&& from) noexcept
    : MsgPublish() {
    *this = ::std::move(from);
  }

  inline MsgPublish& operator=(const MsgPublish& from) {
    CopyFrom(from);
    return *this;
  }
  inline MsgPublish& operator=(MsgPublish&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const MsgPublish& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MsgPublish* internal_default_instance() {
    return reinterpret_cast<const MsgPublish*>(
               &_MsgPublish_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(MsgPublish& a, MsgPublish& b) {
    a.Swap(&b);
  }
  inline void Swap(MsgPublish* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline MsgPublish* New() const final {
    return CreateMaybeMessage<MsgPublish>(nullptr);
  }

  MsgPublish* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MsgPublish>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const MsgPublish& from);
  void MergeFrom(const MsgPublish& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MsgPublish* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "bhome_msg.MsgPublish";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTopicFieldNumber = 1,
    kDataFieldNumber = 2,
  };
  // bytes topic = 1;
  void clear_topic();
  const std::string& topic() const;
  void set_topic(const std::string& value);
  void set_topic(std::string&& value);
  void set_topic(const char* value);
  void set_topic(const void* value, size_t size);
  std::string* mutable_topic();
  std::string* release_topic();
  void set_allocated_topic(std::string* topic);
  private:
  const std::string& _internal_topic() const;
  void _internal_set_topic(const std::string& value);
  std::string* _internal_mutable_topic();
  public:

  // bytes data = 2;
  void clear_data();
  const std::string& data() const;
  void set_data(const std::string& value);
  void set_data(std::string&& value);
  void set_data(const char* value);
  void set_data(const void* value, size_t size);
  std::string* mutable_data();
  std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:

  // @@protoc_insertion_point(class_scope:bhome_msg.MsgPublish)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr topic_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
};
// -------------------------------------------------------------------

class MsgCommonReply :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgCommonReply) */ {
 public:
  MsgCommonReply();
  virtual ~MsgCommonReply();

  MsgCommonReply(const MsgCommonReply& from);
  MsgCommonReply(MsgCommonReply&& from) noexcept
    : MsgCommonReply() {
    *this = ::std::move(from);
  }

  inline MsgCommonReply& operator=(const MsgCommonReply& from) {
    CopyFrom(from);
    return *this;
  }
  inline MsgCommonReply& operator=(MsgCommonReply&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const MsgCommonReply& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MsgCommonReply* internal_default_instance() {
    return reinterpret_cast<const MsgCommonReply*>(
               &_MsgCommonReply_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(MsgCommonReply& a, MsgCommonReply& b) {
    a.Swap(&b);
  }
  inline void Swap(MsgCommonReply* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline MsgCommonReply* New() const final {
    return CreateMaybeMessage<MsgCommonReply>(nullptr);
  }

  MsgCommonReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MsgCommonReply>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const MsgCommonReply& from);
  void MergeFrom(const MsgCommonReply& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MsgCommonReply* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "bhome_msg.MsgCommonReply";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kErrmsgFieldNumber = 1,
  };
  // .bhome_msg.ErrorMsg errmsg = 1;
  bool has_errmsg() const;
  private:
  bool _internal_has_errmsg() const;
  public:
  void clear_errmsg();
  const ::bhome_msg::ErrorMsg& errmsg() const;
  ::bhome_msg::ErrorMsg* release_errmsg();
  ::bhome_msg::ErrorMsg* mutable_errmsg();
  void set_allocated_errmsg(::bhome_msg::ErrorMsg* errmsg);
  private:
  const ::bhome_msg::ErrorMsg& _internal_errmsg() const;
  ::bhome_msg::ErrorMsg* _internal_mutable_errmsg();
  public:

  // @@protoc_insertion_point(class_scope:bhome_msg.MsgCommonReply)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::bhome_msg::ErrorMsg* errmsg_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
};
// -------------------------------------------------------------------

class MsgRequestTopic :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgRequestTopic) */ {
 public:
  MsgRequestTopic();
  virtual ~MsgRequestTopic();

  MsgRequestTopic(const MsgRequestTopic& from);
  MsgRequestTopic(MsgRequestTopic&& from) noexcept
    : MsgRequestTopic() {
    *this = ::std::move(from);
  }

  inline MsgRequestTopic& operator=(const MsgRequestTopic& from) {
    CopyFrom(from);
    return *this;
  }
  inline MsgRequestTopic& operator=(MsgRequestTopic&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const MsgRequestTopic& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MsgRequestTopic* internal_default_instance() {
    return reinterpret_cast<const MsgRequestTopic*>(
               &_MsgRequestTopic_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(MsgRequestTopic& a, MsgRequestTopic& b) {
    a.Swap(&b);
  }
  inline void Swap(MsgRequestTopic* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline MsgRequestTopic* New() const final {
    return CreateMaybeMessage<MsgRequestTopic>(nullptr);
  }

  MsgRequestTopic* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MsgRequestTopic>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const MsgRequestTopic& from);
  void MergeFrom(const MsgRequestTopic& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MsgRequestTopic* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "bhome_msg.MsgRequestTopic";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTopicFieldNumber = 1,
    kDataFieldNumber = 2,
  };
  // bytes topic = 1;
  void clear_topic();
  const std::string& topic() const;
  void set_topic(const std::string& value);
  void set_topic(std::string&& value);
  void set_topic(const char* value);
  void set_topic(const void* value, size_t size);
  std::string* mutable_topic();
  std::string* release_topic();
  void set_allocated_topic(std::string* topic);
  private:
  const std::string& _internal_topic() const;
  void _internal_set_topic(const std::string& value);
  std::string* _internal_mutable_topic();
  public:

  // bytes data = 2;
  void clear_data();
  const std::string& data() const;
  void set_data(const std::string& value);
  void set_data(std::string&& value);
  void set_data(const char* value);
  void set_data(const void* value, size_t size);
  std::string* mutable_data();
  std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:

  // @@protoc_insertion_point(class_scope:bhome_msg.MsgRequestTopic)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr topic_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
};
// -------------------------------------------------------------------

class MsgRequestTopicReply :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgRequestTopicReply) */ {
 public:
  MsgRequestTopicReply();
  virtual ~MsgRequestTopicReply();

  MsgRequestTopicReply(const MsgRequestTopicReply& from);
  MsgRequestTopicReply(MsgRequestTopicReply&& from) noexcept
    : MsgRequestTopicReply() {
    *this = ::std::move(from);
  }

  inline MsgRequestTopicReply& operator=(const MsgRequestTopicReply& from) {
    CopyFrom(from);
    return *this;
  }
  inline MsgRequestTopicReply& operator=(MsgRequestTopicReply&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const MsgRequestTopicReply& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MsgRequestTopicReply* internal_default_instance() {
    return reinterpret_cast<const MsgRequestTopicReply*>(
               &_MsgRequestTopicReply_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(MsgRequestTopicReply& a, MsgRequestTopicReply& b) {
    a.Swap(&b);
  }
  inline void Swap(MsgRequestTopicReply* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline MsgRequestTopicReply* New() const final {
    return CreateMaybeMessage<MsgRequestTopicReply>(nullptr);
  }

  MsgRequestTopicReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MsgRequestTopicReply>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const MsgRequestTopicReply& from);
  void MergeFrom(const MsgRequestTopicReply& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MsgRequestTopicReply* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "bhome_msg.MsgRequestTopicReply";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 2,
    kErrmsgFieldNumber = 1,
  };
  // bytes data = 2;
  void clear_data();
  const std::string& data() const;
  void set_data(const std::string& value);
  void set_data(std::string&& value);
  void set_data(const char* value);
  void set_data(const void* value, size_t size);
  std::string* mutable_data();
  std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:

  // .bhome_msg.ErrorMsg errmsg = 1;
  bool has_errmsg() const;
  private:
  bool _internal_has_errmsg() const;
  public:
  void clear_errmsg();
  const ::bhome_msg::ErrorMsg& errmsg() const;
  ::bhome_msg::ErrorMsg* release_errmsg();
  ::bhome_msg::ErrorMsg* mutable_errmsg();
  void set_allocated_errmsg(::bhome_msg::ErrorMsg* errmsg);
  private:
  const ::bhome_msg::ErrorMsg& _internal_errmsg() const;
  ::bhome_msg::ErrorMsg* _internal_mutable_errmsg();
  public:

  // @@protoc_insertion_point(class_scope:bhome_msg.MsgRequestTopicReply)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
  ::bhome_msg::ErrorMsg* errmsg_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
};
// -------------------------------------------------------------------

class MsgRegister :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgRegister) */ {
 public:
  MsgRegister();
  virtual ~MsgRegister();

  MsgRegister(const MsgRegister& from);
  MsgRegister(MsgRegister&& from) noexcept
    : MsgRegister() {
    *this = ::std::move(from);
  }

  inline MsgRegister& operator=(const MsgRegister& from) {
    CopyFrom(from);
    return *this;
  }
  inline MsgRegister& operator=(MsgRegister&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const MsgRegister& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MsgRegister* internal_default_instance() {
    return reinterpret_cast<const MsgRegister*>(
               &_MsgRegister_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(MsgRegister& a, MsgRegister& b) {
    a.Swap(&b);
  }
  inline void Swap(MsgRegister* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline MsgRegister* New() const final {
    return CreateMaybeMessage<MsgRegister>(nullptr);
  }

  MsgRegister* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MsgRegister>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const MsgRegister& from);
  void MergeFrom(const MsgRegister& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MsgRegister* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "bhome_msg.MsgRegister";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kProcFieldNumber = 1,
  };
  // .bhome_msg.ProcInfo proc = 1;
  bool has_proc() const;
  private:
  bool _internal_has_proc() const;
  public:
  void clear_proc();
  const ::bhome_msg::ProcInfo& proc() const;
  ::bhome_msg::ProcInfo* release_proc();
  ::bhome_msg::ProcInfo* mutable_proc();
  void set_allocated_proc(::bhome_msg::ProcInfo* proc);
  private:
  const ::bhome_msg::ProcInfo& _internal_proc() const;
  ::bhome_msg::ProcInfo* _internal_mutable_proc();
  public:

  // @@protoc_insertion_point(class_scope:bhome_msg.MsgRegister)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::bhome_msg::ProcInfo* proc_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
};
// -------------------------------------------------------------------

class MsgUnregister :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgUnregister) */ {
 public:
  MsgUnregister();
  virtual ~MsgUnregister();

  MsgUnregister(const MsgUnregister& from);
  MsgUnregister(MsgUnregister&& from) noexcept
    : MsgUnregister() {
    *this = ::std::move(from);
  }

  inline MsgUnregister& operator=(const MsgUnregister& from) {
    CopyFrom(from);
    return *this;
  }
  inline MsgUnregister& operator=(MsgUnregister&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const MsgUnregister& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MsgUnregister* internal_default_instance() {
    return reinterpret_cast<const MsgUnregister*>(
               &_MsgUnregister_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(MsgUnregister& a, MsgUnregister& b) {
    a.Swap(&b);
  }
  inline void Swap(MsgUnregister* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline MsgUnregister* New() const final {
    return CreateMaybeMessage<MsgUnregister>(nullptr);
  }

  MsgUnregister* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MsgUnregister>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const MsgUnregister& from);
  void MergeFrom(const MsgUnregister& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MsgUnregister* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "bhome_msg.MsgUnregister";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kProcFieldNumber = 1,
  };
  // .bhome_msg.ProcInfo proc = 1;
  bool has_proc() const;
  private:
  bool _internal_has_proc() const;
  public:
  void clear_proc();
  const ::bhome_msg::ProcInfo& proc() const;
  ::bhome_msg::ProcInfo* release_proc();
  ::bhome_msg::ProcInfo* mutable_proc();
  void set_allocated_proc(::bhome_msg::ProcInfo* proc);
  private:
  const ::bhome_msg::ProcInfo& _internal_proc() const;
  ::bhome_msg::ProcInfo* _internal_mutable_proc();
  public:

  // @@protoc_insertion_point(class_scope:bhome_msg.MsgUnregister)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::bhome_msg::ProcInfo* proc_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
};
// -------------------------------------------------------------------

class MsgHeartbeat :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgHeartbeat) */ {
 public:
  MsgHeartbeat();
  virtual ~MsgHeartbeat();

  MsgHeartbeat(const MsgHeartbeat& from);
  MsgHeartbeat(MsgHeartbeat&& from) noexcept
    : MsgHeartbeat() {
    *this = ::std::move(from);
  }

  inline MsgHeartbeat& operator=(const MsgHeartbeat& from) {
    CopyFrom(from);
    return *this;
  }
  inline MsgHeartbeat& operator=(MsgHeartbeat&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const MsgHeartbeat& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MsgHeartbeat* internal_default_instance() {
    return reinterpret_cast<const MsgHeartbeat*>(
               &_MsgHeartbeat_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(MsgHeartbeat& a, MsgHeartbeat& b) {
    a.Swap(&b);
  }
  inline void Swap(MsgHeartbeat* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline MsgHeartbeat* New() const final {
    return CreateMaybeMessage<MsgHeartbeat>(nullptr);
  }

  MsgHeartbeat* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MsgHeartbeat>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const MsgHeartbeat& from);
  void MergeFrom(const MsgHeartbeat& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MsgHeartbeat* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "bhome_msg.MsgHeartbeat";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kProcFieldNumber = 1,
  };
  // .bhome_msg.ProcInfo proc = 1;
  bool has_proc() const;
  private:
  bool _internal_has_proc() const;
  public:
  void clear_proc();
  const ::bhome_msg::ProcInfo& proc() const;
  ::bhome_msg::ProcInfo* release_proc();
  ::bhome_msg::ProcInfo* mutable_proc();
  void set_allocated_proc(::bhome_msg::ProcInfo* proc);
  private:
  const ::bhome_msg::ProcInfo& _internal_proc() const;
  ::bhome_msg::ProcInfo* _internal_mutable_proc();
  public:

  // @@protoc_insertion_point(class_scope:bhome_msg.MsgHeartbeat)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::bhome_msg::ProcInfo* proc_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
};
// -------------------------------------------------------------------

class MsgQueryTopic :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgQueryTopic) */ {
 public:
  MsgQueryTopic();
  virtual ~MsgQueryTopic();

  MsgQueryTopic(const MsgQueryTopic& from);
  MsgQueryTopic(MsgQueryTopic&& from) noexcept
    : MsgQueryTopic() {
    *this = ::std::move(from);
  }

  inline MsgQueryTopic& operator=(const MsgQueryTopic& from) {
    CopyFrom(from);
    return *this;
  }
  inline MsgQueryTopic& operator=(MsgQueryTopic&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const MsgQueryTopic& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MsgQueryTopic* internal_default_instance() {
    return reinterpret_cast<const MsgQueryTopic*>(
               &_MsgQueryTopic_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(MsgQueryTopic& a, MsgQueryTopic& b) {
    a.Swap(&b);
  }
  inline void Swap(MsgQueryTopic* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline MsgQueryTopic* New() const final {
    return CreateMaybeMessage<MsgQueryTopic>(nullptr);
  }

  MsgQueryTopic* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MsgQueryTopic>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const MsgQueryTopic& from);
  void MergeFrom(const MsgQueryTopic& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MsgQueryTopic* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "bhome_msg.MsgQueryTopic";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTopicFieldNumber = 1,
  };
  // bytes topic = 1;
  void clear_topic();
  const std::string& topic() const;
  void set_topic(const std::string& value);
  void set_topic(std::string&& value);
  void set_topic(const char* value);
  void set_topic(const void* value, size_t size);
  std::string* mutable_topic();
  std::string* release_topic();
  void set_allocated_topic(std::string* topic);
  private:
  const std::string& _internal_topic() const;
  void _internal_set_topic(const std::string& value);
  std::string* _internal_mutable_topic();
  public:

  // @@protoc_insertion_point(class_scope:bhome_msg.MsgQueryTopic)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr topic_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
};
// -------------------------------------------------------------------

class MsgQueryTopicReply_BHNodeAddress :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgQueryTopicReply.BHNodeAddress) */ {
 public:
  MsgQueryTopicReply_BHNodeAddress();
  virtual ~MsgQueryTopicReply_BHNodeAddress();

  MsgQueryTopicReply_BHNodeAddress(const MsgQueryTopicReply_BHNodeAddress& from);
  MsgQueryTopicReply_BHNodeAddress(MsgQueryTopicReply_BHNodeAddress&& from) noexcept
    : MsgQueryTopicReply_BHNodeAddress() {
    *this = ::std::move(from);
  }

  inline MsgQueryTopicReply_BHNodeAddress& operator=(const MsgQueryTopicReply_BHNodeAddress& from) {
    CopyFrom(from);
    return *this;
  }
  inline MsgQueryTopicReply_BHNodeAddress& operator=(MsgQueryTopicReply_BHNodeAddress&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const MsgQueryTopicReply_BHNodeAddress& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MsgQueryTopicReply_BHNodeAddress* internal_default_instance() {
    return reinterpret_cast<const MsgQueryTopicReply_BHNodeAddress*>(
               &_MsgQueryTopicReply_BHNodeAddress_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(MsgQueryTopicReply_BHNodeAddress& a, MsgQueryTopicReply_BHNodeAddress& b) {
    a.Swap(&b);
  }
  inline void Swap(MsgQueryTopicReply_BHNodeAddress* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline MsgQueryTopicReply_BHNodeAddress* New() const final {
    return CreateMaybeMessage<MsgQueryTopicReply_BHNodeAddress>(nullptr);
  }

  MsgQueryTopicReply_BHNodeAddress* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MsgQueryTopicReply_BHNodeAddress>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const MsgQueryTopicReply_BHNodeAddress& from);
  void MergeFrom(const MsgQueryTopicReply_BHNodeAddress& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MsgQueryTopicReply_BHNodeAddress* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "bhome_msg.MsgQueryTopicReply.BHNodeAddress";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kProcIdFieldNumber = 1,
    kAddrFieldNumber = 2,
  };
  // bytes proc_id = 1;
  void clear_proc_id();
  const std::string& proc_id() const;
  void set_proc_id(const std::string& value);
  void set_proc_id(std::string&& value);
  void set_proc_id(const char* value);
  void set_proc_id(const void* value, size_t size);
  std::string* mutable_proc_id();
  std::string* release_proc_id();
  void set_allocated_proc_id(std::string* proc_id);
  private:
  const std::string& _internal_proc_id() const;
  void _internal_set_proc_id(const std::string& value);
  std::string* _internal_mutable_proc_id();
  public:

  // .bhome_msg.BHAddress addr = 2;
  bool has_addr() const;
  private:
  bool _internal_has_addr() const;
  public:
  void clear_addr();
  const ::bhome_msg::BHAddress& addr() const;
  ::bhome_msg::BHAddress* release_addr();
  ::bhome_msg::BHAddress* mutable_addr();
  void set_allocated_addr(::bhome_msg::BHAddress* addr);
  private:
  const ::bhome_msg::BHAddress& _internal_addr() const;
  ::bhome_msg::BHAddress* _internal_mutable_addr();
  public:

  // @@protoc_insertion_point(class_scope:bhome_msg.MsgQueryTopicReply.BHNodeAddress)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr proc_id_;
  ::bhome_msg::BHAddress* addr_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
};
// -------------------------------------------------------------------

class MsgQueryTopicReply :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgQueryTopicReply) */ {
 public:
  MsgQueryTopicReply();
  virtual ~MsgQueryTopicReply();

  MsgQueryTopicReply(const MsgQueryTopicReply& from);
  MsgQueryTopicReply(MsgQueryTopicReply&& from) noexcept
    : MsgQueryTopicReply() {
    *this = ::std::move(from);
  }

  inline MsgQueryTopicReply& operator=(const MsgQueryTopicReply& from) {
    CopyFrom(from);
    return *this;
  }
  inline MsgQueryTopicReply& operator=(MsgQueryTopicReply&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const MsgQueryTopicReply& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MsgQueryTopicReply* internal_default_instance() {
    return reinterpret_cast<const MsgQueryTopicReply*>(
               &_MsgQueryTopicReply_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(MsgQueryTopicReply& a, MsgQueryTopicReply& b) {
    a.Swap(&b);
  }
  inline void Swap(MsgQueryTopicReply* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline MsgQueryTopicReply* New() const final {
    return CreateMaybeMessage<MsgQueryTopicReply>(nullptr);
  }

  MsgQueryTopicReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MsgQueryTopicReply>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const MsgQueryTopicReply& from);
  void MergeFrom(const MsgQueryTopicReply& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MsgQueryTopicReply* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "bhome_msg.MsgQueryTopicReply";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef MsgQueryTopicReply_BHNodeAddress BHNodeAddress;

  // accessors -------------------------------------------------------

  enum : int {
    kNodeAddressFieldNumber = 2,
    kErrmsgFieldNumber = 1,
  };
  // repeated .bhome_msg.MsgQueryTopicReply.BHNodeAddress node_address = 2;
  int node_address_size() const;
  private:
  int _internal_node_address_size() const;
  public:
  void clear_node_address();
  ::bhome_msg::MsgQueryTopicReply_BHNodeAddress* mutable_node_address(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::MsgQueryTopicReply_BHNodeAddress >*
      mutable_node_address();
  private:
  const ::bhome_msg::MsgQueryTopicReply_BHNodeAddress& _internal_node_address(int index) const;
  ::bhome_msg::MsgQueryTopicReply_BHNodeAddress* _internal_add_node_address();
  public:
  const ::bhome_msg::MsgQueryTopicReply_BHNodeAddress& node_address(int index) const;
  ::bhome_msg::MsgQueryTopicReply_BHNodeAddress* add_node_address();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::MsgQueryTopicReply_BHNodeAddress >&
      node_address() const;

  // .bhome_msg.ErrorMsg errmsg = 1;
  bool has_errmsg() const;
  private:
  bool _internal_has_errmsg() const;
  public:
  void clear_errmsg();
  const ::bhome_msg::ErrorMsg& errmsg() const;
  ::bhome_msg::ErrorMsg* release_errmsg();
  ::bhome_msg::ErrorMsg* mutable_errmsg();
  void set_allocated_errmsg(::bhome_msg::ErrorMsg* errmsg);
  private:
  const ::bhome_msg::ErrorMsg& _internal_errmsg() const;
  ::bhome_msg::ErrorMsg* _internal_mutable_errmsg();
  public:

  // @@protoc_insertion_point(class_scope:bhome_msg.MsgQueryTopicReply)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::MsgQueryTopicReply_BHNodeAddress > node_address_;
  ::bhome_msg::ErrorMsg* errmsg_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
};
// -------------------------------------------------------------------

class MsgQueryProc :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgQueryProc) */ {
 public:
  MsgQueryProc();
  virtual ~MsgQueryProc();

  MsgQueryProc(const MsgQueryProc& from);
  MsgQueryProc(MsgQueryProc&& from) noexcept
    : MsgQueryProc() {
    *this = ::std::move(from);
  }

  inline MsgQueryProc& operator=(const MsgQueryProc& from) {
    CopyFrom(from);
    return *this;
  }
  inline MsgQueryProc& operator=(MsgQueryProc&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const MsgQueryProc& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MsgQueryProc* internal_default_instance() {
    return reinterpret_cast<const MsgQueryProc*>(
               &_MsgQueryProc_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(MsgQueryProc& a, MsgQueryProc& b) {
    a.Swap(&b);
  }
  inline void Swap(MsgQueryProc* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline MsgQueryProc* New() const final {
    return CreateMaybeMessage<MsgQueryProc>(nullptr);
  }

  MsgQueryProc* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MsgQueryProc>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const MsgQueryProc& from);
  void MergeFrom(const MsgQueryProc& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MsgQueryProc* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "bhome_msg.MsgQueryProc";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kProcIdFieldNumber = 1,
  };
  // bytes proc_id = 1;
  void clear_proc_id();
  const std::string& proc_id() const;
  void set_proc_id(const std::string& value);
  void set_proc_id(std::string&& value);
  void set_proc_id(const char* value);
  void set_proc_id(const void* value, size_t size);
  std::string* mutable_proc_id();
  std::string* release_proc_id();
  void set_allocated_proc_id(std::string* proc_id);
  private:
  const std::string& _internal_proc_id() const;
  void _internal_set_proc_id(const std::string& value);
  std::string* _internal_mutable_proc_id();
  public:

  // @@protoc_insertion_point(class_scope:bhome_msg.MsgQueryProc)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr proc_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
};
// -------------------------------------------------------------------

class MsgQueryProcReply_Info :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgQueryProcReply.Info) */ {
 public:
  MsgQueryProcReply_Info();
  virtual ~MsgQueryProcReply_Info();

  MsgQueryProcReply_Info(const MsgQueryProcReply_Info& from);
  MsgQueryProcReply_Info(MsgQueryProcReply_Info&& from) noexcept
    : MsgQueryProcReply_Info() {
    *this = ::std::move(from);
  }

  inline MsgQueryProcReply_Info& operator=(const MsgQueryProcReply_Info& from) {
    CopyFrom(from);
    return *this;
  }
  inline MsgQueryProcReply_Info& operator=(MsgQueryProcReply_Info&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const MsgQueryProcReply_Info& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MsgQueryProcReply_Info* internal_default_instance() {
    return reinterpret_cast<const MsgQueryProcReply_Info*>(
               &_MsgQueryProcReply_Info_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(MsgQueryProcReply_Info& a, MsgQueryProcReply_Info& b) {
    a.Swap(&b);
  }
  inline void Swap(MsgQueryProcReply_Info* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline MsgQueryProcReply_Info* New() const final {
    return CreateMaybeMessage<MsgQueryProcReply_Info>(nullptr);
  }

  MsgQueryProcReply_Info* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MsgQueryProcReply_Info>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const MsgQueryProcReply_Info& from);
  void MergeFrom(const MsgQueryProcReply_Info& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MsgQueryProcReply_Info* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "bhome_msg.MsgQueryProcReply.Info";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kProcFieldNumber = 1,
    kServiceFieldNumber = 3,
    kLocalSubFieldNumber = 4,
    kNetSubFieldNumber = 5,
    kOnlineFieldNumber = 2,
  };
  // .bhome_msg.ProcInfo proc = 1;
  bool has_proc() const;
  private:
  bool _internal_has_proc() const;
  public:
  void clear_proc();
  const ::bhome_msg::ProcInfo& proc() const;
  ::bhome_msg::ProcInfo* release_proc();
  ::bhome_msg::ProcInfo* mutable_proc();
  void set_allocated_proc(::bhome_msg::ProcInfo* proc);
  private:
  const ::bhome_msg::ProcInfo& _internal_proc() const;
  ::bhome_msg::ProcInfo* _internal_mutable_proc();
  public:

  // .bhome_msg.MsgTopicList service = 3;
  bool has_service() const;
  private:
  bool _internal_has_service() const;
  public:
  void clear_service();
  const ::bhome_msg::MsgTopicList& service() const;
  ::bhome_msg::MsgTopicList* release_service();
  ::bhome_msg::MsgTopicList* mutable_service();
  void set_allocated_service(::bhome_msg::MsgTopicList* service);
  private:
  const ::bhome_msg::MsgTopicList& _internal_service() const;
  ::bhome_msg::MsgTopicList* _internal_mutable_service();
  public:

  // .bhome_msg.MsgTopicList local_sub = 4;
  bool has_local_sub() const;
  private:
  bool _internal_has_local_sub() const;
  public:
  void clear_local_sub();
  const ::bhome_msg::MsgTopicList& local_sub() const;
  ::bhome_msg::MsgTopicList* release_local_sub();
  ::bhome_msg::MsgTopicList* mutable_local_sub();
  void set_allocated_local_sub(::bhome_msg::MsgTopicList* local_sub);
  private:
  const ::bhome_msg::MsgTopicList& _internal_local_sub() const;
  ::bhome_msg::MsgTopicList* _internal_mutable_local_sub();
  public:

  // .bhome_msg.MsgTopicList net_sub = 5;
  bool has_net_sub() const;
  private:
  bool _internal_has_net_sub() const;
  public:
  void clear_net_sub();
  const ::bhome_msg::MsgTopicList& net_sub() const;
  ::bhome_msg::MsgTopicList* release_net_sub();
  ::bhome_msg::MsgTopicList* mutable_net_sub();
  void set_allocated_net_sub(::bhome_msg::MsgTopicList* net_sub);
  private:
  const ::bhome_msg::MsgTopicList& _internal_net_sub() const;
  ::bhome_msg::MsgTopicList* _internal_mutable_net_sub();
  public:

  // bool online = 2;
  void clear_online();
  bool online() const;
  void set_online(bool value);
  private:
  bool _internal_online() const;
  void _internal_set_online(bool value);
  public:

  // @@protoc_insertion_point(class_scope:bhome_msg.MsgQueryProcReply.Info)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::bhome_msg::ProcInfo* proc_;
  ::bhome_msg::MsgTopicList* service_;
  ::bhome_msg::MsgTopicList* local_sub_;
  ::bhome_msg::MsgTopicList* net_sub_;
  bool online_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
};
// -------------------------------------------------------------------

class MsgQueryProcReply :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:bhome_msg.MsgQueryProcReply) */ {
 public:
  MsgQueryProcReply();
  virtual ~MsgQueryProcReply();

  MsgQueryProcReply(const MsgQueryProcReply& from);
  MsgQueryProcReply(MsgQueryProcReply&& from) noexcept
    : MsgQueryProcReply() {
    *this = ::std::move(from);
  }

  inline MsgQueryProcReply& operator=(const MsgQueryProcReply& from) {
    CopyFrom(from);
    return *this;
  }
  inline MsgQueryProcReply& operator=(MsgQueryProcReply&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const MsgQueryProcReply& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MsgQueryProcReply* internal_default_instance() {
    return reinterpret_cast<const MsgQueryProcReply*>(
               &_MsgQueryProcReply_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(MsgQueryProcReply& a, MsgQueryProcReply& b) {
    a.Swap(&b);
  }
  inline void Swap(MsgQueryProcReply* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline MsgQueryProcReply* New() const final {
    return CreateMaybeMessage<MsgQueryProcReply>(nullptr);
  }

  MsgQueryProcReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MsgQueryProcReply>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const MsgQueryProcReply& from);
  void MergeFrom(const MsgQueryProcReply& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MsgQueryProcReply* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "bhome_msg.MsgQueryProcReply";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef MsgQueryProcReply_Info Info;

  // accessors -------------------------------------------------------

  enum : int {
    kProcListFieldNumber = 2,
    kErrmsgFieldNumber = 1,
  };
  // repeated .bhome_msg.MsgQueryProcReply.Info proc_list = 2;
  int proc_list_size() const;
  private:
  int _internal_proc_list_size() const;
  public:
  void clear_proc_list();
  ::bhome_msg::MsgQueryProcReply_Info* mutable_proc_list(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::MsgQueryProcReply_Info >*
      mutable_proc_list();
  private:
  const ::bhome_msg::MsgQueryProcReply_Info& _internal_proc_list(int index) const;
  ::bhome_msg::MsgQueryProcReply_Info* _internal_add_proc_list();
  public:
  const ::bhome_msg::MsgQueryProcReply_Info& proc_list(int index) const;
  ::bhome_msg::MsgQueryProcReply_Info* add_proc_list();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::MsgQueryProcReply_Info >&
      proc_list() const;

  // .bhome_msg.ErrorMsg errmsg = 1;
  bool has_errmsg() const;
  private:
  bool _internal_has_errmsg() const;
  public:
  void clear_errmsg();
  const ::bhome_msg::ErrorMsg& errmsg() const;
  ::bhome_msg::ErrorMsg* release_errmsg();
  ::bhome_msg::ErrorMsg* mutable_errmsg();
  void set_allocated_errmsg(::bhome_msg::ErrorMsg* errmsg);
  private:
  const ::bhome_msg::ErrorMsg& _internal_errmsg() const;
  ::bhome_msg::ErrorMsg* _internal_mutable_errmsg();
  public:

  // @@protoc_insertion_point(class_scope:bhome_msg.MsgQueryProcReply)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::MsgQueryProcReply_Info > proc_list_;
  ::bhome_msg::ErrorMsg* errmsg_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_bhome_5fmsg_5fapi_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// BHAddress

// uint64 mq_id = 1;
inline void BHAddress::clear_mq_id() {
  mq_id_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 BHAddress::_internal_mq_id() const {
  return mq_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 BHAddress::mq_id() const {
  // @@protoc_insertion_point(field_get:bhome_msg.BHAddress.mq_id)
  return _internal_mq_id();
}
inline void BHAddress::_internal_set_mq_id(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  mq_id_ = value;
}
inline void BHAddress::set_mq_id(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _internal_set_mq_id(value);
  // @@protoc_insertion_point(field_set:bhome_msg.BHAddress.mq_id)
}

// int64 abs_addr = 2;
inline void BHAddress::clear_abs_addr() {
  abs_addr_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 BHAddress::_internal_abs_addr() const {
  return abs_addr_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 BHAddress::abs_addr() const {
  // @@protoc_insertion_point(field_get:bhome_msg.BHAddress.abs_addr)
  return _internal_abs_addr();
}
inline void BHAddress::_internal_set_abs_addr(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  abs_addr_ = value;
}
inline void BHAddress::set_abs_addr(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_abs_addr(value);
  // @@protoc_insertion_point(field_set:bhome_msg.BHAddress.abs_addr)
}

// bytes ip = 3;
inline void BHAddress::clear_ip() {
  ip_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& BHAddress::ip() const {
  // @@protoc_insertion_point(field_get:bhome_msg.BHAddress.ip)
  return _internal_ip();
}
inline void BHAddress::set_ip(const std::string& value) {
  _internal_set_ip(value);
  // @@protoc_insertion_point(field_set:bhome_msg.BHAddress.ip)
}
inline std::string* BHAddress::mutable_ip() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.BHAddress.ip)
  return _internal_mutable_ip();
}
inline const std::string& BHAddress::_internal_ip() const {
  return ip_.GetNoArena();
}
inline void BHAddress::_internal_set_ip(const std::string& value) {
  
  ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void BHAddress::set_ip(std::string&& value) {
  
  ip_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:bhome_msg.BHAddress.ip)
}
inline void BHAddress::set_ip(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:bhome_msg.BHAddress.ip)
}
inline void BHAddress::set_ip(const void* value, size_t size) {
  
  ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:bhome_msg.BHAddress.ip)
}
inline std::string* BHAddress::_internal_mutable_ip() {
  
  return ip_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* BHAddress::release_ip() {
  // @@protoc_insertion_point(field_release:bhome_msg.BHAddress.ip)
  
  return ip_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void BHAddress::set_allocated_ip(std::string* ip) {
  if (ip != nullptr) {
    
  } else {
    
  }
  ip_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ip);
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.BHAddress.ip)
}

// int32 port = 4;
inline void BHAddress::clear_port() {
  port_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 BHAddress::_internal_port() const {
  return port_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 BHAddress::port() const {
  // @@protoc_insertion_point(field_get:bhome_msg.BHAddress.port)
  return _internal_port();
}
inline void BHAddress::_internal_set_port(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  port_ = value;
}
inline void BHAddress::set_port(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_port(value);
  // @@protoc_insertion_point(field_set:bhome_msg.BHAddress.port)
}

// -------------------------------------------------------------------

// ProcInfo

// bytes proc_id = 1;
inline void ProcInfo::clear_proc_id() {
  proc_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& ProcInfo::proc_id() const {
  // @@protoc_insertion_point(field_get:bhome_msg.ProcInfo.proc_id)
  return _internal_proc_id();
}
inline void ProcInfo::set_proc_id(const std::string& value) {
  _internal_set_proc_id(value);
  // @@protoc_insertion_point(field_set:bhome_msg.ProcInfo.proc_id)
}
inline std::string* ProcInfo::mutable_proc_id() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.ProcInfo.proc_id)
  return _internal_mutable_proc_id();
}
inline const std::string& ProcInfo::_internal_proc_id() const {
  return proc_id_.GetNoArena();
}
inline void ProcInfo::_internal_set_proc_id(const std::string& value) {
  
  proc_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void ProcInfo::set_proc_id(std::string&& value) {
  
  proc_id_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:bhome_msg.ProcInfo.proc_id)
}
inline void ProcInfo::set_proc_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  proc_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:bhome_msg.ProcInfo.proc_id)
}
inline void ProcInfo::set_proc_id(const void* value, size_t size) {
  
  proc_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:bhome_msg.ProcInfo.proc_id)
}
inline std::string* ProcInfo::_internal_mutable_proc_id() {
  
  return proc_id_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* ProcInfo::release_proc_id() {
  // @@protoc_insertion_point(field_release:bhome_msg.ProcInfo.proc_id)
  
  return proc_id_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void ProcInfo::set_allocated_proc_id(std::string* proc_id) {
  if (proc_id != nullptr) {
    
  } else {
    
  }
  proc_id_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), proc_id);
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.ProcInfo.proc_id)
}

// bytes name = 2;
inline void ProcInfo::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& ProcInfo::name() const {
  // @@protoc_insertion_point(field_get:bhome_msg.ProcInfo.name)
  return _internal_name();
}
inline void ProcInfo::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:bhome_msg.ProcInfo.name)
}
inline std::string* ProcInfo::mutable_name() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.ProcInfo.name)
  return _internal_mutable_name();
}
inline const std::string& ProcInfo::_internal_name() const {
  return name_.GetNoArena();
}
inline void ProcInfo::_internal_set_name(const std::string& value) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void ProcInfo::set_name(std::string&& value) {
  
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:bhome_msg.ProcInfo.name)
}
inline void ProcInfo::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:bhome_msg.ProcInfo.name)
}
inline void ProcInfo::set_name(const void* value, size_t size) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:bhome_msg.ProcInfo.name)
}
inline std::string* ProcInfo::_internal_mutable_name() {
  
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* ProcInfo::release_name() {
  // @@protoc_insertion_point(field_release:bhome_msg.ProcInfo.name)
  
  return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void ProcInfo::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.ProcInfo.name)
}

// bytes public_info = 3;
inline void ProcInfo::clear_public_info() {
  public_info_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& ProcInfo::public_info() const {
  // @@protoc_insertion_point(field_get:bhome_msg.ProcInfo.public_info)
  return _internal_public_info();
}
inline void ProcInfo::set_public_info(const std::string& value) {
  _internal_set_public_info(value);
  // @@protoc_insertion_point(field_set:bhome_msg.ProcInfo.public_info)
}
inline std::string* ProcInfo::mutable_public_info() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.ProcInfo.public_info)
  return _internal_mutable_public_info();
}
inline const std::string& ProcInfo::_internal_public_info() const {
  return public_info_.GetNoArena();
}
inline void ProcInfo::_internal_set_public_info(const std::string& value) {
  
  public_info_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void ProcInfo::set_public_info(std::string&& value) {
  
  public_info_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:bhome_msg.ProcInfo.public_info)
}
inline void ProcInfo::set_public_info(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  public_info_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:bhome_msg.ProcInfo.public_info)
}
inline void ProcInfo::set_public_info(const void* value, size_t size) {
  
  public_info_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:bhome_msg.ProcInfo.public_info)
}
inline std::string* ProcInfo::_internal_mutable_public_info() {
  
  return public_info_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* ProcInfo::release_public_info() {
  // @@protoc_insertion_point(field_release:bhome_msg.ProcInfo.public_info)
  
  return public_info_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void ProcInfo::set_allocated_public_info(std::string* public_info) {
  if (public_info != nullptr) {
    
  } else {
    
  }
  public_info_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), public_info);
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.ProcInfo.public_info)
}

// bytes private_info = 4;
inline void ProcInfo::clear_private_info() {
  private_info_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& ProcInfo::private_info() const {
  // @@protoc_insertion_point(field_get:bhome_msg.ProcInfo.private_info)
  return _internal_private_info();
}
inline void ProcInfo::set_private_info(const std::string& value) {
  _internal_set_private_info(value);
  // @@protoc_insertion_point(field_set:bhome_msg.ProcInfo.private_info)
}
inline std::string* ProcInfo::mutable_private_info() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.ProcInfo.private_info)
  return _internal_mutable_private_info();
}
inline const std::string& ProcInfo::_internal_private_info() const {
  return private_info_.GetNoArena();
}
inline void ProcInfo::_internal_set_private_info(const std::string& value) {
  
  private_info_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void ProcInfo::set_private_info(std::string&& value) {
  
  private_info_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:bhome_msg.ProcInfo.private_info)
}
inline void ProcInfo::set_private_info(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  private_info_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:bhome_msg.ProcInfo.private_info)
}
inline void ProcInfo::set_private_info(const void* value, size_t size) {
  
  private_info_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:bhome_msg.ProcInfo.private_info)
}
inline std::string* ProcInfo::_internal_mutable_private_info() {
  
  return private_info_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* ProcInfo::release_private_info() {
  // @@protoc_insertion_point(field_release:bhome_msg.ProcInfo.private_info)
  
  return private_info_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void ProcInfo::set_allocated_private_info(std::string* private_info) {
  if (private_info != nullptr) {
    
  } else {
    
  }
  private_info_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), private_info);
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.ProcInfo.private_info)
}

// -------------------------------------------------------------------

// MsgTopicList

// repeated bytes topic_list = 1;
inline int MsgTopicList::_internal_topic_list_size() const {
  return topic_list_.size();
}
inline int MsgTopicList::topic_list_size() const {
  return _internal_topic_list_size();
}
inline void MsgTopicList::clear_topic_list() {
  topic_list_.Clear();
}
inline std::string* MsgTopicList::add_topic_list() {
  // @@protoc_insertion_point(field_add_mutable:bhome_msg.MsgTopicList.topic_list)
  return _internal_add_topic_list();
}
inline const std::string& MsgTopicList::_internal_topic_list(int index) const {
  return topic_list_.Get(index);
}
inline const std::string& MsgTopicList::topic_list(int index) const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgTopicList.topic_list)
  return _internal_topic_list(index);
}
inline std::string* MsgTopicList::mutable_topic_list(int index) {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgTopicList.topic_list)
  return topic_list_.Mutable(index);
}
inline void MsgTopicList::set_topic_list(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:bhome_msg.MsgTopicList.topic_list)
  topic_list_.Mutable(index)->assign(value);
}
inline void MsgTopicList::set_topic_list(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:bhome_msg.MsgTopicList.topic_list)
  topic_list_.Mutable(index)->assign(std::move(value));
}
inline void MsgTopicList::set_topic_list(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  topic_list_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:bhome_msg.MsgTopicList.topic_list)
}
inline void MsgTopicList::set_topic_list(int index, const void* value, size_t size) {
  topic_list_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bhome_msg.MsgTopicList.topic_list)
}
inline std::string* MsgTopicList::_internal_add_topic_list() {
  return topic_list_.Add();
}
inline void MsgTopicList::add_topic_list(const std::string& value) {
  topic_list_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:bhome_msg.MsgTopicList.topic_list)
}
inline void MsgTopicList::add_topic_list(std::string&& value) {
  topic_list_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:bhome_msg.MsgTopicList.topic_list)
}
inline void MsgTopicList::add_topic_list(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  topic_list_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:bhome_msg.MsgTopicList.topic_list)
}
inline void MsgTopicList::add_topic_list(const void* value, size_t size) {
  topic_list_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:bhome_msg.MsgTopicList.topic_list)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
MsgTopicList::topic_list() const {
  // @@protoc_insertion_point(field_list:bhome_msg.MsgTopicList.topic_list)
  return topic_list_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
MsgTopicList::mutable_topic_list() {
  // @@protoc_insertion_point(field_mutable_list:bhome_msg.MsgTopicList.topic_list)
  return &topic_list_;
}

// -------------------------------------------------------------------

// MsgPublish

// bytes topic = 1;
inline void MsgPublish::clear_topic() {
  topic_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& MsgPublish::topic() const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgPublish.topic)
  return _internal_topic();
}
inline void MsgPublish::set_topic(const std::string& value) {
  _internal_set_topic(value);
  // @@protoc_insertion_point(field_set:bhome_msg.MsgPublish.topic)
}
inline std::string* MsgPublish::mutable_topic() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgPublish.topic)
  return _internal_mutable_topic();
}
inline const std::string& MsgPublish::_internal_topic() const {
  return topic_.GetNoArena();
}
inline void MsgPublish::_internal_set_topic(const std::string& value) {
  
  topic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void MsgPublish::set_topic(std::string&& value) {
  
  topic_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:bhome_msg.MsgPublish.topic)
}
inline void MsgPublish::set_topic(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  topic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:bhome_msg.MsgPublish.topic)
}
inline void MsgPublish::set_topic(const void* value, size_t size) {
  
  topic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:bhome_msg.MsgPublish.topic)
}
inline std::string* MsgPublish::_internal_mutable_topic() {
  
  return topic_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* MsgPublish::release_topic() {
  // @@protoc_insertion_point(field_release:bhome_msg.MsgPublish.topic)
  
  return topic_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void MsgPublish::set_allocated_topic(std::string* topic) {
  if (topic != nullptr) {
    
  } else {
    
  }
  topic_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), topic);
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgPublish.topic)
}

// bytes data = 2;
inline void MsgPublish::clear_data() {
  data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& MsgPublish::data() const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgPublish.data)
  return _internal_data();
}
inline void MsgPublish::set_data(const std::string& value) {
  _internal_set_data(value);
  // @@protoc_insertion_point(field_set:bhome_msg.MsgPublish.data)
}
inline std::string* MsgPublish::mutable_data() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgPublish.data)
  return _internal_mutable_data();
}
inline const std::string& MsgPublish::_internal_data() const {
  return data_.GetNoArena();
}
inline void MsgPublish::_internal_set_data(const std::string& value) {
  
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void MsgPublish::set_data(std::string&& value) {
  
  data_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:bhome_msg.MsgPublish.data)
}
inline void MsgPublish::set_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:bhome_msg.MsgPublish.data)
}
inline void MsgPublish::set_data(const void* value, size_t size) {
  
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:bhome_msg.MsgPublish.data)
}
inline std::string* MsgPublish::_internal_mutable_data() {
  
  return data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* MsgPublish::release_data() {
  // @@protoc_insertion_point(field_release:bhome_msg.MsgPublish.data)
  
  return data_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void MsgPublish::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    
  } else {
    
  }
  data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data);
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgPublish.data)
}

// -------------------------------------------------------------------

// MsgCommonReply

// .bhome_msg.ErrorMsg errmsg = 1;
inline bool MsgCommonReply::_internal_has_errmsg() const {
  return this != internal_default_instance() && errmsg_ != nullptr;
}
inline bool MsgCommonReply::has_errmsg() const {
  return _internal_has_errmsg();
}
inline const ::bhome_msg::ErrorMsg& MsgCommonReply::_internal_errmsg() const {
  const ::bhome_msg::ErrorMsg* p = errmsg_;
  return p != nullptr ? *p : *reinterpret_cast<const ::bhome_msg::ErrorMsg*>(
      &::bhome_msg::_ErrorMsg_default_instance_);
}
inline const ::bhome_msg::ErrorMsg& MsgCommonReply::errmsg() const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgCommonReply.errmsg)
  return _internal_errmsg();
}
inline ::bhome_msg::ErrorMsg* MsgCommonReply::release_errmsg() {
  // @@protoc_insertion_point(field_release:bhome_msg.MsgCommonReply.errmsg)
  
  ::bhome_msg::ErrorMsg* temp = errmsg_;
  errmsg_ = nullptr;
  return temp;
}
inline ::bhome_msg::ErrorMsg* MsgCommonReply::_internal_mutable_errmsg() {
  
  if (errmsg_ == nullptr) {
    auto* p = CreateMaybeMessage<::bhome_msg::ErrorMsg>(GetArenaNoVirtual());
    errmsg_ = p;
  }
  return errmsg_;
}
inline ::bhome_msg::ErrorMsg* MsgCommonReply::mutable_errmsg() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgCommonReply.errmsg)
  return _internal_mutable_errmsg();
}
inline void MsgCommonReply::set_allocated_errmsg(::bhome_msg::ErrorMsg* errmsg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(errmsg_);
  }
  if (errmsg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      errmsg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, errmsg, submessage_arena);
    }
    
  } else {
    
  }
  errmsg_ = errmsg;
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgCommonReply.errmsg)
}

// -------------------------------------------------------------------

// MsgRequestTopic

// bytes topic = 1;
inline void MsgRequestTopic::clear_topic() {
  topic_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& MsgRequestTopic::topic() const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgRequestTopic.topic)
  return _internal_topic();
}
inline void MsgRequestTopic::set_topic(const std::string& value) {
  _internal_set_topic(value);
  // @@protoc_insertion_point(field_set:bhome_msg.MsgRequestTopic.topic)
}
inline std::string* MsgRequestTopic::mutable_topic() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgRequestTopic.topic)
  return _internal_mutable_topic();
}
inline const std::string& MsgRequestTopic::_internal_topic() const {
  return topic_.GetNoArena();
}
inline void MsgRequestTopic::_internal_set_topic(const std::string& value) {
  
  topic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void MsgRequestTopic::set_topic(std::string&& value) {
  
  topic_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:bhome_msg.MsgRequestTopic.topic)
}
inline void MsgRequestTopic::set_topic(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  topic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:bhome_msg.MsgRequestTopic.topic)
}
inline void MsgRequestTopic::set_topic(const void* value, size_t size) {
  
  topic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:bhome_msg.MsgRequestTopic.topic)
}
inline std::string* MsgRequestTopic::_internal_mutable_topic() {
  
  return topic_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* MsgRequestTopic::release_topic() {
  // @@protoc_insertion_point(field_release:bhome_msg.MsgRequestTopic.topic)
  
  return topic_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void MsgRequestTopic::set_allocated_topic(std::string* topic) {
  if (topic != nullptr) {
    
  } else {
    
  }
  topic_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), topic);
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgRequestTopic.topic)
}

// bytes data = 2;
inline void MsgRequestTopic::clear_data() {
  data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& MsgRequestTopic::data() const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgRequestTopic.data)
  return _internal_data();
}
inline void MsgRequestTopic::set_data(const std::string& value) {
  _internal_set_data(value);
  // @@protoc_insertion_point(field_set:bhome_msg.MsgRequestTopic.data)
}
inline std::string* MsgRequestTopic::mutable_data() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgRequestTopic.data)
  return _internal_mutable_data();
}
inline const std::string& MsgRequestTopic::_internal_data() const {
  return data_.GetNoArena();
}
inline void MsgRequestTopic::_internal_set_data(const std::string& value) {
  
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void MsgRequestTopic::set_data(std::string&& value) {
  
  data_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:bhome_msg.MsgRequestTopic.data)
}
inline void MsgRequestTopic::set_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:bhome_msg.MsgRequestTopic.data)
}
inline void MsgRequestTopic::set_data(const void* value, size_t size) {
  
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:bhome_msg.MsgRequestTopic.data)
}
inline std::string* MsgRequestTopic::_internal_mutable_data() {
  
  return data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* MsgRequestTopic::release_data() {
  // @@protoc_insertion_point(field_release:bhome_msg.MsgRequestTopic.data)
  
  return data_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void MsgRequestTopic::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    
  } else {
    
  }
  data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data);
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgRequestTopic.data)
}

// -------------------------------------------------------------------

// MsgRequestTopicReply

// .bhome_msg.ErrorMsg errmsg = 1;
inline bool MsgRequestTopicReply::_internal_has_errmsg() const {
  return this != internal_default_instance() && errmsg_ != nullptr;
}
inline bool MsgRequestTopicReply::has_errmsg() const {
  return _internal_has_errmsg();
}
inline const ::bhome_msg::ErrorMsg& MsgRequestTopicReply::_internal_errmsg() const {
  const ::bhome_msg::ErrorMsg* p = errmsg_;
  return p != nullptr ? *p : *reinterpret_cast<const ::bhome_msg::ErrorMsg*>(
      &::bhome_msg::_ErrorMsg_default_instance_);
}
inline const ::bhome_msg::ErrorMsg& MsgRequestTopicReply::errmsg() const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgRequestTopicReply.errmsg)
  return _internal_errmsg();
}
inline ::bhome_msg::ErrorMsg* MsgRequestTopicReply::release_errmsg() {
  // @@protoc_insertion_point(field_release:bhome_msg.MsgRequestTopicReply.errmsg)
  
  ::bhome_msg::ErrorMsg* temp = errmsg_;
  errmsg_ = nullptr;
  return temp;
}
inline ::bhome_msg::ErrorMsg* MsgRequestTopicReply::_internal_mutable_errmsg() {
  
  if (errmsg_ == nullptr) {
    auto* p = CreateMaybeMessage<::bhome_msg::ErrorMsg>(GetArenaNoVirtual());
    errmsg_ = p;
  }
  return errmsg_;
}
inline ::bhome_msg::ErrorMsg* MsgRequestTopicReply::mutable_errmsg() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgRequestTopicReply.errmsg)
  return _internal_mutable_errmsg();
}
inline void MsgRequestTopicReply::set_allocated_errmsg(::bhome_msg::ErrorMsg* errmsg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(errmsg_);
  }
  if (errmsg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      errmsg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, errmsg, submessage_arena);
    }
    
  } else {
    
  }
  errmsg_ = errmsg;
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgRequestTopicReply.errmsg)
}

// bytes data = 2;
inline void MsgRequestTopicReply::clear_data() {
  data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& MsgRequestTopicReply::data() const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgRequestTopicReply.data)
  return _internal_data();
}
inline void MsgRequestTopicReply::set_data(const std::string& value) {
  _internal_set_data(value);
  // @@protoc_insertion_point(field_set:bhome_msg.MsgRequestTopicReply.data)
}
inline std::string* MsgRequestTopicReply::mutable_data() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgRequestTopicReply.data)
  return _internal_mutable_data();
}
inline const std::string& MsgRequestTopicReply::_internal_data() const {
  return data_.GetNoArena();
}
inline void MsgRequestTopicReply::_internal_set_data(const std::string& value) {
  
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void MsgRequestTopicReply::set_data(std::string&& value) {
  
  data_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:bhome_msg.MsgRequestTopicReply.data)
}
inline void MsgRequestTopicReply::set_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:bhome_msg.MsgRequestTopicReply.data)
}
inline void MsgRequestTopicReply::set_data(const void* value, size_t size) {
  
  data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:bhome_msg.MsgRequestTopicReply.data)
}
inline std::string* MsgRequestTopicReply::_internal_mutable_data() {
  
  return data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* MsgRequestTopicReply::release_data() {
  // @@protoc_insertion_point(field_release:bhome_msg.MsgRequestTopicReply.data)
  
  return data_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void MsgRequestTopicReply::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    
  } else {
    
  }
  data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data);
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgRequestTopicReply.data)
}

// -------------------------------------------------------------------

// MsgRegister

// .bhome_msg.ProcInfo proc = 1;
inline bool MsgRegister::_internal_has_proc() const {
  return this != internal_default_instance() && proc_ != nullptr;
}
inline bool MsgRegister::has_proc() const {
  return _internal_has_proc();
}
inline void MsgRegister::clear_proc() {
  if (GetArenaNoVirtual() == nullptr && proc_ != nullptr) {
    delete proc_;
  }
  proc_ = nullptr;
}
inline const ::bhome_msg::ProcInfo& MsgRegister::_internal_proc() const {
  const ::bhome_msg::ProcInfo* p = proc_;
  return p != nullptr ? *p : *reinterpret_cast<const ::bhome_msg::ProcInfo*>(
      &::bhome_msg::_ProcInfo_default_instance_);
}
inline const ::bhome_msg::ProcInfo& MsgRegister::proc() const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgRegister.proc)
  return _internal_proc();
}
inline ::bhome_msg::ProcInfo* MsgRegister::release_proc() {
  // @@protoc_insertion_point(field_release:bhome_msg.MsgRegister.proc)
  
  ::bhome_msg::ProcInfo* temp = proc_;
  proc_ = nullptr;
  return temp;
}
inline ::bhome_msg::ProcInfo* MsgRegister::_internal_mutable_proc() {
  
  if (proc_ == nullptr) {
    auto* p = CreateMaybeMessage<::bhome_msg::ProcInfo>(GetArenaNoVirtual());
    proc_ = p;
  }
  return proc_;
}
inline ::bhome_msg::ProcInfo* MsgRegister::mutable_proc() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgRegister.proc)
  return _internal_mutable_proc();
}
inline void MsgRegister::set_allocated_proc(::bhome_msg::ProcInfo* proc) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete proc_;
  }
  if (proc) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      proc = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, proc, submessage_arena);
    }
    
  } else {
    
  }
  proc_ = proc;
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgRegister.proc)
}

// -------------------------------------------------------------------

// MsgUnregister

// .bhome_msg.ProcInfo proc = 1;
inline bool MsgUnregister::_internal_has_proc() const {
  return this != internal_default_instance() && proc_ != nullptr;
}
inline bool MsgUnregister::has_proc() const {
  return _internal_has_proc();
}
inline void MsgUnregister::clear_proc() {
  if (GetArenaNoVirtual() == nullptr && proc_ != nullptr) {
    delete proc_;
  }
  proc_ = nullptr;
}
inline const ::bhome_msg::ProcInfo& MsgUnregister::_internal_proc() const {
  const ::bhome_msg::ProcInfo* p = proc_;
  return p != nullptr ? *p : *reinterpret_cast<const ::bhome_msg::ProcInfo*>(
      &::bhome_msg::_ProcInfo_default_instance_);
}
inline const ::bhome_msg::ProcInfo& MsgUnregister::proc() const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgUnregister.proc)
  return _internal_proc();
}
inline ::bhome_msg::ProcInfo* MsgUnregister::release_proc() {
  // @@protoc_insertion_point(field_release:bhome_msg.MsgUnregister.proc)
  
  ::bhome_msg::ProcInfo* temp = proc_;
  proc_ = nullptr;
  return temp;
}
inline ::bhome_msg::ProcInfo* MsgUnregister::_internal_mutable_proc() {
  
  if (proc_ == nullptr) {
    auto* p = CreateMaybeMessage<::bhome_msg::ProcInfo>(GetArenaNoVirtual());
    proc_ = p;
  }
  return proc_;
}
inline ::bhome_msg::ProcInfo* MsgUnregister::mutable_proc() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgUnregister.proc)
  return _internal_mutable_proc();
}
inline void MsgUnregister::set_allocated_proc(::bhome_msg::ProcInfo* proc) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete proc_;
  }
  if (proc) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      proc = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, proc, submessage_arena);
    }
    
  } else {
    
  }
  proc_ = proc;
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgUnregister.proc)
}

// -------------------------------------------------------------------

// MsgHeartbeat

// .bhome_msg.ProcInfo proc = 1;
inline bool MsgHeartbeat::_internal_has_proc() const {
  return this != internal_default_instance() && proc_ != nullptr;
}
inline bool MsgHeartbeat::has_proc() const {
  return _internal_has_proc();
}
inline void MsgHeartbeat::clear_proc() {
  if (GetArenaNoVirtual() == nullptr && proc_ != nullptr) {
    delete proc_;
  }
  proc_ = nullptr;
}
inline const ::bhome_msg::ProcInfo& MsgHeartbeat::_internal_proc() const {
  const ::bhome_msg::ProcInfo* p = proc_;
  return p != nullptr ? *p : *reinterpret_cast<const ::bhome_msg::ProcInfo*>(
      &::bhome_msg::_ProcInfo_default_instance_);
}
inline const ::bhome_msg::ProcInfo& MsgHeartbeat::proc() const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgHeartbeat.proc)
  return _internal_proc();
}
inline ::bhome_msg::ProcInfo* MsgHeartbeat::release_proc() {
  // @@protoc_insertion_point(field_release:bhome_msg.MsgHeartbeat.proc)
  
  ::bhome_msg::ProcInfo* temp = proc_;
  proc_ = nullptr;
  return temp;
}
inline ::bhome_msg::ProcInfo* MsgHeartbeat::_internal_mutable_proc() {
  
  if (proc_ == nullptr) {
    auto* p = CreateMaybeMessage<::bhome_msg::ProcInfo>(GetArenaNoVirtual());
    proc_ = p;
  }
  return proc_;
}
inline ::bhome_msg::ProcInfo* MsgHeartbeat::mutable_proc() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgHeartbeat.proc)
  return _internal_mutable_proc();
}
inline void MsgHeartbeat::set_allocated_proc(::bhome_msg::ProcInfo* proc) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete proc_;
  }
  if (proc) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      proc = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, proc, submessage_arena);
    }
    
  } else {
    
  }
  proc_ = proc;
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgHeartbeat.proc)
}

// -------------------------------------------------------------------

// MsgQueryTopic

// bytes topic = 1;
inline void MsgQueryTopic::clear_topic() {
  topic_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& MsgQueryTopic::topic() const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryTopic.topic)
  return _internal_topic();
}
inline void MsgQueryTopic::set_topic(const std::string& value) {
  _internal_set_topic(value);
  // @@protoc_insertion_point(field_set:bhome_msg.MsgQueryTopic.topic)
}
inline std::string* MsgQueryTopic::mutable_topic() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryTopic.topic)
  return _internal_mutable_topic();
}
inline const std::string& MsgQueryTopic::_internal_topic() const {
  return topic_.GetNoArena();
}
inline void MsgQueryTopic::_internal_set_topic(const std::string& value) {
  
  topic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void MsgQueryTopic::set_topic(std::string&& value) {
  
  topic_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:bhome_msg.MsgQueryTopic.topic)
}
inline void MsgQueryTopic::set_topic(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  topic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:bhome_msg.MsgQueryTopic.topic)
}
inline void MsgQueryTopic::set_topic(const void* value, size_t size) {
  
  topic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:bhome_msg.MsgQueryTopic.topic)
}
inline std::string* MsgQueryTopic::_internal_mutable_topic() {
  
  return topic_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* MsgQueryTopic::release_topic() {
  // @@protoc_insertion_point(field_release:bhome_msg.MsgQueryTopic.topic)
  
  return topic_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void MsgQueryTopic::set_allocated_topic(std::string* topic) {
  if (topic != nullptr) {
    
  } else {
    
  }
  topic_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), topic);
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgQueryTopic.topic)
}

// -------------------------------------------------------------------

// MsgQueryTopicReply_BHNodeAddress

// bytes proc_id = 1;
inline void MsgQueryTopicReply_BHNodeAddress::clear_proc_id() {
  proc_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& MsgQueryTopicReply_BHNodeAddress::proc_id() const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryTopicReply.BHNodeAddress.proc_id)
  return _internal_proc_id();
}
inline void MsgQueryTopicReply_BHNodeAddress::set_proc_id(const std::string& value) {
  _internal_set_proc_id(value);
  // @@protoc_insertion_point(field_set:bhome_msg.MsgQueryTopicReply.BHNodeAddress.proc_id)
}
inline std::string* MsgQueryTopicReply_BHNodeAddress::mutable_proc_id() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryTopicReply.BHNodeAddress.proc_id)
  return _internal_mutable_proc_id();
}
inline const std::string& MsgQueryTopicReply_BHNodeAddress::_internal_proc_id() const {
  return proc_id_.GetNoArena();
}
inline void MsgQueryTopicReply_BHNodeAddress::_internal_set_proc_id(const std::string& value) {
  
  proc_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void MsgQueryTopicReply_BHNodeAddress::set_proc_id(std::string&& value) {
  
  proc_id_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:bhome_msg.MsgQueryTopicReply.BHNodeAddress.proc_id)
}
inline void MsgQueryTopicReply_BHNodeAddress::set_proc_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  proc_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:bhome_msg.MsgQueryTopicReply.BHNodeAddress.proc_id)
}
inline void MsgQueryTopicReply_BHNodeAddress::set_proc_id(const void* value, size_t size) {
  
  proc_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:bhome_msg.MsgQueryTopicReply.BHNodeAddress.proc_id)
}
inline std::string* MsgQueryTopicReply_BHNodeAddress::_internal_mutable_proc_id() {
  
  return proc_id_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* MsgQueryTopicReply_BHNodeAddress::release_proc_id() {
  // @@protoc_insertion_point(field_release:bhome_msg.MsgQueryTopicReply.BHNodeAddress.proc_id)
  
  return proc_id_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void MsgQueryTopicReply_BHNodeAddress::set_allocated_proc_id(std::string* proc_id) {
  if (proc_id != nullptr) {
    
  } else {
    
  }
  proc_id_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), proc_id);
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgQueryTopicReply.BHNodeAddress.proc_id)
}

// .bhome_msg.BHAddress addr = 2;
inline bool MsgQueryTopicReply_BHNodeAddress::_internal_has_addr() const {
  return this != internal_default_instance() && addr_ != nullptr;
}
inline bool MsgQueryTopicReply_BHNodeAddress::has_addr() const {
  return _internal_has_addr();
}
inline void MsgQueryTopicReply_BHNodeAddress::clear_addr() {
  if (GetArenaNoVirtual() == nullptr && addr_ != nullptr) {
    delete addr_;
  }
  addr_ = nullptr;
}
inline const ::bhome_msg::BHAddress& MsgQueryTopicReply_BHNodeAddress::_internal_addr() const {
  const ::bhome_msg::BHAddress* p = addr_;
  return p != nullptr ? *p : *reinterpret_cast<const ::bhome_msg::BHAddress*>(
      &::bhome_msg::_BHAddress_default_instance_);
}
inline const ::bhome_msg::BHAddress& MsgQueryTopicReply_BHNodeAddress::addr() const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryTopicReply.BHNodeAddress.addr)
  return _internal_addr();
}
inline ::bhome_msg::BHAddress* MsgQueryTopicReply_BHNodeAddress::release_addr() {
  // @@protoc_insertion_point(field_release:bhome_msg.MsgQueryTopicReply.BHNodeAddress.addr)
  
  ::bhome_msg::BHAddress* temp = addr_;
  addr_ = nullptr;
  return temp;
}
inline ::bhome_msg::BHAddress* MsgQueryTopicReply_BHNodeAddress::_internal_mutable_addr() {
  
  if (addr_ == nullptr) {
    auto* p = CreateMaybeMessage<::bhome_msg::BHAddress>(GetArenaNoVirtual());
    addr_ = p;
  }
  return addr_;
}
inline ::bhome_msg::BHAddress* MsgQueryTopicReply_BHNodeAddress::mutable_addr() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryTopicReply.BHNodeAddress.addr)
  return _internal_mutable_addr();
}
inline void MsgQueryTopicReply_BHNodeAddress::set_allocated_addr(::bhome_msg::BHAddress* addr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete addr_;
  }
  if (addr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      addr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, addr, submessage_arena);
    }
    
  } else {
    
  }
  addr_ = addr;
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgQueryTopicReply.BHNodeAddress.addr)
}

// -------------------------------------------------------------------

// MsgQueryTopicReply

// .bhome_msg.ErrorMsg errmsg = 1;
inline bool MsgQueryTopicReply::_internal_has_errmsg() const {
  return this != internal_default_instance() && errmsg_ != nullptr;
}
inline bool MsgQueryTopicReply::has_errmsg() const {
  return _internal_has_errmsg();
}
inline const ::bhome_msg::ErrorMsg& MsgQueryTopicReply::_internal_errmsg() const {
  const ::bhome_msg::ErrorMsg* p = errmsg_;
  return p != nullptr ? *p : *reinterpret_cast<const ::bhome_msg::ErrorMsg*>(
      &::bhome_msg::_ErrorMsg_default_instance_);
}
inline const ::bhome_msg::ErrorMsg& MsgQueryTopicReply::errmsg() const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryTopicReply.errmsg)
  return _internal_errmsg();
}
inline ::bhome_msg::ErrorMsg* MsgQueryTopicReply::release_errmsg() {
  // @@protoc_insertion_point(field_release:bhome_msg.MsgQueryTopicReply.errmsg)
  
  ::bhome_msg::ErrorMsg* temp = errmsg_;
  errmsg_ = nullptr;
  return temp;
}
inline ::bhome_msg::ErrorMsg* MsgQueryTopicReply::_internal_mutable_errmsg() {
  
  if (errmsg_ == nullptr) {
    auto* p = CreateMaybeMessage<::bhome_msg::ErrorMsg>(GetArenaNoVirtual());
    errmsg_ = p;
  }
  return errmsg_;
}
inline ::bhome_msg::ErrorMsg* MsgQueryTopicReply::mutable_errmsg() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryTopicReply.errmsg)
  return _internal_mutable_errmsg();
}
inline void MsgQueryTopicReply::set_allocated_errmsg(::bhome_msg::ErrorMsg* errmsg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(errmsg_);
  }
  if (errmsg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      errmsg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, errmsg, submessage_arena);
    }
    
  } else {
    
  }
  errmsg_ = errmsg;
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgQueryTopicReply.errmsg)
}

// repeated .bhome_msg.MsgQueryTopicReply.BHNodeAddress node_address = 2;
inline int MsgQueryTopicReply::_internal_node_address_size() const {
  return node_address_.size();
}
inline int MsgQueryTopicReply::node_address_size() const {
  return _internal_node_address_size();
}
inline void MsgQueryTopicReply::clear_node_address() {
  node_address_.Clear();
}
inline ::bhome_msg::MsgQueryTopicReply_BHNodeAddress* MsgQueryTopicReply::mutable_node_address(int index) {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryTopicReply.node_address)
  return node_address_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::MsgQueryTopicReply_BHNodeAddress >*
MsgQueryTopicReply::mutable_node_address() {
  // @@protoc_insertion_point(field_mutable_list:bhome_msg.MsgQueryTopicReply.node_address)
  return &node_address_;
}
inline const ::bhome_msg::MsgQueryTopicReply_BHNodeAddress& MsgQueryTopicReply::_internal_node_address(int index) const {
  return node_address_.Get(index);
}
inline const ::bhome_msg::MsgQueryTopicReply_BHNodeAddress& MsgQueryTopicReply::node_address(int index) const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryTopicReply.node_address)
  return _internal_node_address(index);
}
inline ::bhome_msg::MsgQueryTopicReply_BHNodeAddress* MsgQueryTopicReply::_internal_add_node_address() {
  return node_address_.Add();
}
inline ::bhome_msg::MsgQueryTopicReply_BHNodeAddress* MsgQueryTopicReply::add_node_address() {
  // @@protoc_insertion_point(field_add:bhome_msg.MsgQueryTopicReply.node_address)
  return _internal_add_node_address();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::MsgQueryTopicReply_BHNodeAddress >&
MsgQueryTopicReply::node_address() const {
  // @@protoc_insertion_point(field_list:bhome_msg.MsgQueryTopicReply.node_address)
  return node_address_;
}

// -------------------------------------------------------------------

// MsgQueryProc

// bytes proc_id = 1;
inline void MsgQueryProc::clear_proc_id() {
  proc_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& MsgQueryProc::proc_id() const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryProc.proc_id)
  return _internal_proc_id();
}
inline void MsgQueryProc::set_proc_id(const std::string& value) {
  _internal_set_proc_id(value);
  // @@protoc_insertion_point(field_set:bhome_msg.MsgQueryProc.proc_id)
}
inline std::string* MsgQueryProc::mutable_proc_id() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryProc.proc_id)
  return _internal_mutable_proc_id();
}
inline const std::string& MsgQueryProc::_internal_proc_id() const {
  return proc_id_.GetNoArena();
}
inline void MsgQueryProc::_internal_set_proc_id(const std::string& value) {
  
  proc_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void MsgQueryProc::set_proc_id(std::string&& value) {
  
  proc_id_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:bhome_msg.MsgQueryProc.proc_id)
}
inline void MsgQueryProc::set_proc_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  proc_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:bhome_msg.MsgQueryProc.proc_id)
}
inline void MsgQueryProc::set_proc_id(const void* value, size_t size) {
  
  proc_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:bhome_msg.MsgQueryProc.proc_id)
}
inline std::string* MsgQueryProc::_internal_mutable_proc_id() {
  
  return proc_id_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* MsgQueryProc::release_proc_id() {
  // @@protoc_insertion_point(field_release:bhome_msg.MsgQueryProc.proc_id)
  
  return proc_id_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void MsgQueryProc::set_allocated_proc_id(std::string* proc_id) {
  if (proc_id != nullptr) {
    
  } else {
    
  }
  proc_id_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), proc_id);
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgQueryProc.proc_id)
}

// -------------------------------------------------------------------

// MsgQueryProcReply_Info

// .bhome_msg.ProcInfo proc = 1;
inline bool MsgQueryProcReply_Info::_internal_has_proc() const {
  return this != internal_default_instance() && proc_ != nullptr;
}
inline bool MsgQueryProcReply_Info::has_proc() const {
  return _internal_has_proc();
}
inline void MsgQueryProcReply_Info::clear_proc() {
  if (GetArenaNoVirtual() == nullptr && proc_ != nullptr) {
    delete proc_;
  }
  proc_ = nullptr;
}
inline const ::bhome_msg::ProcInfo& MsgQueryProcReply_Info::_internal_proc() const {
  const ::bhome_msg::ProcInfo* p = proc_;
  return p != nullptr ? *p : *reinterpret_cast<const ::bhome_msg::ProcInfo*>(
      &::bhome_msg::_ProcInfo_default_instance_);
}
inline const ::bhome_msg::ProcInfo& MsgQueryProcReply_Info::proc() const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryProcReply.Info.proc)
  return _internal_proc();
}
inline ::bhome_msg::ProcInfo* MsgQueryProcReply_Info::release_proc() {
  // @@protoc_insertion_point(field_release:bhome_msg.MsgQueryProcReply.Info.proc)
  
  ::bhome_msg::ProcInfo* temp = proc_;
  proc_ = nullptr;
  return temp;
}
inline ::bhome_msg::ProcInfo* MsgQueryProcReply_Info::_internal_mutable_proc() {
  
  if (proc_ == nullptr) {
    auto* p = CreateMaybeMessage<::bhome_msg::ProcInfo>(GetArenaNoVirtual());
    proc_ = p;
  }
  return proc_;
}
inline ::bhome_msg::ProcInfo* MsgQueryProcReply_Info::mutable_proc() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryProcReply.Info.proc)
  return _internal_mutable_proc();
}
inline void MsgQueryProcReply_Info::set_allocated_proc(::bhome_msg::ProcInfo* proc) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete proc_;
  }
  if (proc) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      proc = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, proc, submessage_arena);
    }
    
  } else {
    
  }
  proc_ = proc;
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgQueryProcReply.Info.proc)
}

// bool online = 2;
inline void MsgQueryProcReply_Info::clear_online() {
  online_ = false;
}
inline bool MsgQueryProcReply_Info::_internal_online() const {
  return online_;
}
inline bool MsgQueryProcReply_Info::online() const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryProcReply.Info.online)
  return _internal_online();
}
inline void MsgQueryProcReply_Info::_internal_set_online(bool value) {
  
  online_ = value;
}
inline void MsgQueryProcReply_Info::set_online(bool value) {
  _internal_set_online(value);
  // @@protoc_insertion_point(field_set:bhome_msg.MsgQueryProcReply.Info.online)
}

// .bhome_msg.MsgTopicList service = 3;
inline bool MsgQueryProcReply_Info::_internal_has_service() const {
  return this != internal_default_instance() && service_ != nullptr;
}
inline bool MsgQueryProcReply_Info::has_service() const {
  return _internal_has_service();
}
inline void MsgQueryProcReply_Info::clear_service() {
  if (GetArenaNoVirtual() == nullptr && service_ != nullptr) {
    delete service_;
  }
  service_ = nullptr;
}
inline const ::bhome_msg::MsgTopicList& MsgQueryProcReply_Info::_internal_service() const {
  const ::bhome_msg::MsgTopicList* p = service_;
  return p != nullptr ? *p : *reinterpret_cast<const ::bhome_msg::MsgTopicList*>(
      &::bhome_msg::_MsgTopicList_default_instance_);
}
inline const ::bhome_msg::MsgTopicList& MsgQueryProcReply_Info::service() const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryProcReply.Info.service)
  return _internal_service();
}
inline ::bhome_msg::MsgTopicList* MsgQueryProcReply_Info::release_service() {
  // @@protoc_insertion_point(field_release:bhome_msg.MsgQueryProcReply.Info.service)
  
  ::bhome_msg::MsgTopicList* temp = service_;
  service_ = nullptr;
  return temp;
}
inline ::bhome_msg::MsgTopicList* MsgQueryProcReply_Info::_internal_mutable_service() {
  
  if (service_ == nullptr) {
    auto* p = CreateMaybeMessage<::bhome_msg::MsgTopicList>(GetArenaNoVirtual());
    service_ = p;
  }
  return service_;
}
inline ::bhome_msg::MsgTopicList* MsgQueryProcReply_Info::mutable_service() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryProcReply.Info.service)
  return _internal_mutable_service();
}
inline void MsgQueryProcReply_Info::set_allocated_service(::bhome_msg::MsgTopicList* service) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete service_;
  }
  if (service) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      service = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, service, submessage_arena);
    }
    
  } else {
    
  }
  service_ = service;
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgQueryProcReply.Info.service)
}

// .bhome_msg.MsgTopicList local_sub = 4;
inline bool MsgQueryProcReply_Info::_internal_has_local_sub() const {
  return this != internal_default_instance() && local_sub_ != nullptr;
}
inline bool MsgQueryProcReply_Info::has_local_sub() const {
  return _internal_has_local_sub();
}
inline void MsgQueryProcReply_Info::clear_local_sub() {
  if (GetArenaNoVirtual() == nullptr && local_sub_ != nullptr) {
    delete local_sub_;
  }
  local_sub_ = nullptr;
}
inline const ::bhome_msg::MsgTopicList& MsgQueryProcReply_Info::_internal_local_sub() const {
  const ::bhome_msg::MsgTopicList* p = local_sub_;
  return p != nullptr ? *p : *reinterpret_cast<const ::bhome_msg::MsgTopicList*>(
      &::bhome_msg::_MsgTopicList_default_instance_);
}
inline const ::bhome_msg::MsgTopicList& MsgQueryProcReply_Info::local_sub() const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryProcReply.Info.local_sub)
  return _internal_local_sub();
}
inline ::bhome_msg::MsgTopicList* MsgQueryProcReply_Info::release_local_sub() {
  // @@protoc_insertion_point(field_release:bhome_msg.MsgQueryProcReply.Info.local_sub)
  
  ::bhome_msg::MsgTopicList* temp = local_sub_;
  local_sub_ = nullptr;
  return temp;
}
inline ::bhome_msg::MsgTopicList* MsgQueryProcReply_Info::_internal_mutable_local_sub() {
  
  if (local_sub_ == nullptr) {
    auto* p = CreateMaybeMessage<::bhome_msg::MsgTopicList>(GetArenaNoVirtual());
    local_sub_ = p;
  }
  return local_sub_;
}
inline ::bhome_msg::MsgTopicList* MsgQueryProcReply_Info::mutable_local_sub() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryProcReply.Info.local_sub)
  return _internal_mutable_local_sub();
}
inline void MsgQueryProcReply_Info::set_allocated_local_sub(::bhome_msg::MsgTopicList* local_sub) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete local_sub_;
  }
  if (local_sub) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      local_sub = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, local_sub, submessage_arena);
    }
    
  } else {
    
  }
  local_sub_ = local_sub;
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgQueryProcReply.Info.local_sub)
}

// .bhome_msg.MsgTopicList net_sub = 5;
inline bool MsgQueryProcReply_Info::_internal_has_net_sub() const {
  return this != internal_default_instance() && net_sub_ != nullptr;
}
inline bool MsgQueryProcReply_Info::has_net_sub() const {
  return _internal_has_net_sub();
}
inline void MsgQueryProcReply_Info::clear_net_sub() {
  if (GetArenaNoVirtual() == nullptr && net_sub_ != nullptr) {
    delete net_sub_;
  }
  net_sub_ = nullptr;
}
inline const ::bhome_msg::MsgTopicList& MsgQueryProcReply_Info::_internal_net_sub() const {
  const ::bhome_msg::MsgTopicList* p = net_sub_;
  return p != nullptr ? *p : *reinterpret_cast<const ::bhome_msg::MsgTopicList*>(
      &::bhome_msg::_MsgTopicList_default_instance_);
}
inline const ::bhome_msg::MsgTopicList& MsgQueryProcReply_Info::net_sub() const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryProcReply.Info.net_sub)
  return _internal_net_sub();
}
inline ::bhome_msg::MsgTopicList* MsgQueryProcReply_Info::release_net_sub() {
  // @@protoc_insertion_point(field_release:bhome_msg.MsgQueryProcReply.Info.net_sub)
  
  ::bhome_msg::MsgTopicList* temp = net_sub_;
  net_sub_ = nullptr;
  return temp;
}
inline ::bhome_msg::MsgTopicList* MsgQueryProcReply_Info::_internal_mutable_net_sub() {
  
  if (net_sub_ == nullptr) {
    auto* p = CreateMaybeMessage<::bhome_msg::MsgTopicList>(GetArenaNoVirtual());
    net_sub_ = p;
  }
  return net_sub_;
}
inline ::bhome_msg::MsgTopicList* MsgQueryProcReply_Info::mutable_net_sub() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryProcReply.Info.net_sub)
  return _internal_mutable_net_sub();
}
inline void MsgQueryProcReply_Info::set_allocated_net_sub(::bhome_msg::MsgTopicList* net_sub) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete net_sub_;
  }
  if (net_sub) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      net_sub = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, net_sub, submessage_arena);
    }
    
  } else {
    
  }
  net_sub_ = net_sub;
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgQueryProcReply.Info.net_sub)
}

// -------------------------------------------------------------------

// MsgQueryProcReply

// .bhome_msg.ErrorMsg errmsg = 1;
inline bool MsgQueryProcReply::_internal_has_errmsg() const {
  return this != internal_default_instance() && errmsg_ != nullptr;
}
inline bool MsgQueryProcReply::has_errmsg() const {
  return _internal_has_errmsg();
}
inline const ::bhome_msg::ErrorMsg& MsgQueryProcReply::_internal_errmsg() const {
  const ::bhome_msg::ErrorMsg* p = errmsg_;
  return p != nullptr ? *p : *reinterpret_cast<const ::bhome_msg::ErrorMsg*>(
      &::bhome_msg::_ErrorMsg_default_instance_);
}
inline const ::bhome_msg::ErrorMsg& MsgQueryProcReply::errmsg() const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryProcReply.errmsg)
  return _internal_errmsg();
}
inline ::bhome_msg::ErrorMsg* MsgQueryProcReply::release_errmsg() {
  // @@protoc_insertion_point(field_release:bhome_msg.MsgQueryProcReply.errmsg)
  
  ::bhome_msg::ErrorMsg* temp = errmsg_;
  errmsg_ = nullptr;
  return temp;
}
inline ::bhome_msg::ErrorMsg* MsgQueryProcReply::_internal_mutable_errmsg() {
  
  if (errmsg_ == nullptr) {
    auto* p = CreateMaybeMessage<::bhome_msg::ErrorMsg>(GetArenaNoVirtual());
    errmsg_ = p;
  }
  return errmsg_;
}
inline ::bhome_msg::ErrorMsg* MsgQueryProcReply::mutable_errmsg() {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryProcReply.errmsg)
  return _internal_mutable_errmsg();
}
inline void MsgQueryProcReply::set_allocated_errmsg(::bhome_msg::ErrorMsg* errmsg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(errmsg_);
  }
  if (errmsg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      errmsg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, errmsg, submessage_arena);
    }
    
  } else {
    
  }
  errmsg_ = errmsg;
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgQueryProcReply.errmsg)
}

// repeated .bhome_msg.MsgQueryProcReply.Info proc_list = 2;
inline int MsgQueryProcReply::_internal_proc_list_size() const {
  return proc_list_.size();
}
inline int MsgQueryProcReply::proc_list_size() const {
  return _internal_proc_list_size();
}
inline void MsgQueryProcReply::clear_proc_list() {
  proc_list_.Clear();
}
inline ::bhome_msg::MsgQueryProcReply_Info* MsgQueryProcReply::mutable_proc_list(int index) {
  // @@protoc_insertion_point(field_mutable:bhome_msg.MsgQueryProcReply.proc_list)
  return proc_list_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::MsgQueryProcReply_Info >*
MsgQueryProcReply::mutable_proc_list() {
  // @@protoc_insertion_point(field_mutable_list:bhome_msg.MsgQueryProcReply.proc_list)
  return &proc_list_;
}
inline const ::bhome_msg::MsgQueryProcReply_Info& MsgQueryProcReply::_internal_proc_list(int index) const {
  return proc_list_.Get(index);
}
inline const ::bhome_msg::MsgQueryProcReply_Info& MsgQueryProcReply::proc_list(int index) const {
  // @@protoc_insertion_point(field_get:bhome_msg.MsgQueryProcReply.proc_list)
  return _internal_proc_list(index);
}
inline ::bhome_msg::MsgQueryProcReply_Info* MsgQueryProcReply::_internal_add_proc_list() {
  return proc_list_.Add();
}
inline ::bhome_msg::MsgQueryProcReply_Info* MsgQueryProcReply::add_proc_list() {
  // @@protoc_insertion_point(field_add:bhome_msg.MsgQueryProcReply.proc_list)
  return _internal_add_proc_list();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::bhome_msg::MsgQueryProcReply_Info >&
MsgQueryProcReply::proc_list() const {
  // @@protoc_insertion_point(field_list:bhome_msg.MsgQueryProcReply.proc_list)
  return proc_list_;
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace bhome_msg

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_bhome_5fmsg_5fapi_2eproto