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

#include "bhome_msg.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG
namespace bhome_msg {
constexpr BHMsgHead::BHMsgHead(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : route_()
  , msg_id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , proc_id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , topic_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , dest_(nullptr)
  , timestamp_(int64_t{0})
  , ssn_id_(uint64_t{0u})
  , type_(0){}
struct BHMsgHeadDefaultTypeInternal {
  constexpr BHMsgHeadDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~BHMsgHeadDefaultTypeInternal() {}
  union {
    BHMsgHead _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BHMsgHeadDefaultTypeInternal _BHMsgHead_default_instance_;
constexpr MsgSubscribe::MsgSubscribe(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : topics_(nullptr){}
struct MsgSubscribeDefaultTypeInternal {
  constexpr MsgSubscribeDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MsgSubscribeDefaultTypeInternal() {}
  union {
    MsgSubscribe _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgSubscribeDefaultTypeInternal _MsgSubscribe_default_instance_;
constexpr MsgUnsubscribe::MsgUnsubscribe(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : topics_(nullptr){}
struct MsgUnsubscribeDefaultTypeInternal {
  constexpr MsgUnsubscribeDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MsgUnsubscribeDefaultTypeInternal() {}
  union {
    MsgUnsubscribe _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgUnsubscribeDefaultTypeInternal _MsgUnsubscribe_default_instance_;
constexpr MsgRegisterRPC::MsgRegisterRPC(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : topics_(nullptr){}
struct MsgRegisterRPCDefaultTypeInternal {
  constexpr MsgRegisterRPCDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MsgRegisterRPCDefaultTypeInternal() {}
  union {
    MsgRegisterRPC _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgRegisterRPCDefaultTypeInternal _MsgRegisterRPC_default_instance_;
constexpr MsgProcInit::MsgProcInit(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : extra_mq_num_(0){}
struct MsgProcInitDefaultTypeInternal {
  constexpr MsgProcInitDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MsgProcInitDefaultTypeInternal() {}
  union {
    MsgProcInit _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgProcInitDefaultTypeInternal _MsgProcInit_default_instance_;
constexpr MsgProcInitReply::MsgProcInitReply(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : extra_mqs_()
  , errmsg_(nullptr)
  , proc_index_(0){}
struct MsgProcInitReplyDefaultTypeInternal {
  constexpr MsgProcInitReplyDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MsgProcInitReplyDefaultTypeInternal() {}
  union {
    MsgProcInitReply _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgProcInitReplyDefaultTypeInternal _MsgProcInitReply_default_instance_;
constexpr MsgRequest::MsgRequest(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct MsgRequestDefaultTypeInternal {
  constexpr MsgRequestDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MsgRequestDefaultTypeInternal() {}
  union {
    MsgRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgRequestDefaultTypeInternal _MsgRequest_default_instance_;
constexpr MsgReply::MsgReply(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : err_msg_(nullptr){}
struct MsgReplyDefaultTypeInternal {
  constexpr MsgReplyDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MsgReplyDefaultTypeInternal() {}
  union {
    MsgReply _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MsgReplyDefaultTypeInternal _MsgReply_default_instance_;
constexpr BHMsgBody::BHMsgBody(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct BHMsgBodyDefaultTypeInternal {
  constexpr BHMsgBodyDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~BHMsgBodyDefaultTypeInternal() {}
  union {
    BHMsgBody _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BHMsgBodyDefaultTypeInternal _BHMsgBody_default_instance_;
}  // namespace bhome_msg
namespace bhome_msg {
bool MsgType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 8:
    case 9:
    case 10:
    case 12:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 20:
    case 22:
    case 24:
    case 26:
    case 28:
    case 29:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> MsgType_strings[18] = {};

static const char MsgType_names[] =
  "kMsgTypeCommonReply"
  "kMsgTypeHeartbeat"
  "kMsgTypeInvalid"
  "kMsgTypeProcInit"
  "kMsgTypeProcInitReply"
  "kMsgTypePublish"
  "kMsgTypeQueryProc"
  "kMsgTypeQueryProcReply"
  "kMsgTypeQueryTopic"
  "kMsgTypeQueryTopicReply"
  "kMsgTypeRawData"
  "kMsgTypeRegister"
  "kMsgTypeRegisterRPC"
  "kMsgTypeRequestTopic"
  "kMsgTypeRequestTopicReply"
  "kMsgTypeSubscribe"
  "kMsgTypeUnregister"
  "kMsgTypeUnsubscribe";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry MsgType_entries[] = {
  { {MsgType_names + 0, 19}, 2 },
  { {MsgType_names + 19, 17}, 12 },
  { {MsgType_names + 36, 15}, 0 },
  { {MsgType_names + 51, 16}, 8 },
  { {MsgType_names + 67, 21}, 9 },
  { {MsgType_names + 88, 15}, 20 },
  { {MsgType_names + 103, 17}, 28 },
  { {MsgType_names + 120, 22}, 29 },
  { {MsgType_names + 142, 18}, 14 },
  { {MsgType_names + 160, 23}, 15 },
  { {MsgType_names + 183, 15}, 1 },
  { {MsgType_names + 198, 16}, 10 },
  { {MsgType_names + 214, 19}, 18 },
  { {MsgType_names + 233, 20}, 16 },
  { {MsgType_names + 253, 25}, 17 },
  { {MsgType_names + 278, 17}, 22 },
  { {MsgType_names + 295, 18}, 26 },
  { {MsgType_names + 313, 19}, 24 },
};

static const int MsgType_entries_by_number[] = {
  2, // 0 -> kMsgTypeInvalid
  10, // 1 -> kMsgTypeRawData
  0, // 2 -> kMsgTypeCommonReply
  3, // 8 -> kMsgTypeProcInit
  4, // 9 -> kMsgTypeProcInitReply
  11, // 10 -> kMsgTypeRegister
  1, // 12 -> kMsgTypeHeartbeat
  8, // 14 -> kMsgTypeQueryTopic
  9, // 15 -> kMsgTypeQueryTopicReply
  13, // 16 -> kMsgTypeRequestTopic
  14, // 17 -> kMsgTypeRequestTopicReply
  12, // 18 -> kMsgTypeRegisterRPC
  5, // 20 -> kMsgTypePublish
  15, // 22 -> kMsgTypeSubscribe
  17, // 24 -> kMsgTypeUnsubscribe
  16, // 26 -> kMsgTypeUnregister
  6, // 28 -> kMsgTypeQueryProc
  7, // 29 -> kMsgTypeQueryProcReply
};

const std::string& MsgType_Name(
    MsgType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          MsgType_entries,
          MsgType_entries_by_number,
          18, MsgType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      MsgType_entries,
      MsgType_entries_by_number,
      18, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     MsgType_strings[idx].get();
}
bool MsgType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MsgType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      MsgType_entries, 18, name, &int_value);
  if (success) {
    *value = static_cast<MsgType>(int_value);
  }
  return success;
}

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

class BHMsgHead::_Internal {
 public:
  static const ::bhome_msg::BHAddress& dest(const BHMsgHead* msg);
};

const ::bhome_msg::BHAddress&
BHMsgHead::_Internal::dest(const BHMsgHead* msg) {
  return *msg->dest_;
}
void BHMsgHead::clear_route() {
  route_.Clear();
}
void BHMsgHead::clear_dest() {
  if (GetArenaForAllocation() == nullptr && dest_ != nullptr) {
    delete dest_;
  }
  dest_ = nullptr;
}
BHMsgHead::BHMsgHead(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned),
  route_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:bhome_msg.BHMsgHead)
}
BHMsgHead::BHMsgHead(const BHMsgHead& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      route_(from.route_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  msg_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_msg_id().empty()) {
    msg_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_msg_id(), 
      GetArenaForAllocation());
  }
  proc_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_proc_id().empty()) {
    proc_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_proc_id(), 
      GetArenaForAllocation());
  }
  topic_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_topic().empty()) {
    topic_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_topic(), 
      GetArenaForAllocation());
  }
  if (from._internal_has_dest()) {
    dest_ = new ::bhome_msg::BHAddress(*from.dest_);
  } else {
    dest_ = nullptr;
  }
  ::memcpy(&timestamp_, &from.timestamp_,
    static_cast<size_t>(reinterpret_cast<char*>(&type_) -
    reinterpret_cast<char*>(&timestamp_)) + sizeof(type_));
  // @@protoc_insertion_point(copy_constructor:bhome_msg.BHMsgHead)
}

inline void BHMsgHead::SharedCtor() {
msg_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
proc_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
topic_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&dest_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&type_) -
    reinterpret_cast<char*>(&dest_)) + sizeof(type_));
}

BHMsgHead::~BHMsgHead() {
  // @@protoc_insertion_point(destructor:bhome_msg.BHMsgHead)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

inline void BHMsgHead::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  msg_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  proc_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  topic_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete dest_;
}

void BHMsgHead::ArenaDtor(void* object) {
  BHMsgHead* _this = reinterpret_cast< BHMsgHead* >(object);
  (void)_this;
}
void BHMsgHead::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void BHMsgHead::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void BHMsgHead::Clear() {
// @@protoc_insertion_point(message_clear_start:bhome_msg.BHMsgHead)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  route_.Clear();
  msg_id_.ClearToEmpty();
  proc_id_.ClearToEmpty();
  topic_.ClearToEmpty();
  if (GetArenaForAllocation() == nullptr && dest_ != nullptr) {
    delete dest_;
  }
  dest_ = nullptr;
  ::memset(&timestamp_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&type_) -
      reinterpret_cast<char*>(&timestamp_)) + sizeof(type_));
  _internal_metadata_.Clear<std::string>();
}

const char* BHMsgHead::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // bytes msg_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_msg_id();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .bhome_msg.BHAddress route = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_route(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      // int64 timestamp = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 type = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // uint64 ssn_id = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          ssn_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bytes proc_id = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          auto str = _internal_mutable_proc_id();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bytes topic = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          auto str = _internal_mutable_topic();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .bhome_msg.BHAddress dest = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_dest(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* BHMsgHead::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.BHMsgHead)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // bytes msg_id = 1;
  if (!this->_internal_msg_id().empty()) {
    target = stream->WriteBytesMaybeAliased(
        1, this->_internal_msg_id(), target);
  }

  // repeated .bhome_msg.BHAddress route = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_route_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, this->_internal_route(i), target, stream);
  }

  // int64 timestamp = 3;
  if (this->_internal_timestamp() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_timestamp(), target);
  }

  // int32 type = 4;
  if (this->_internal_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_type(), target);
  }

  // uint64 ssn_id = 5;
  if (this->_internal_ssn_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(5, this->_internal_ssn_id(), target);
  }

  // bytes proc_id = 6;
  if (!this->_internal_proc_id().empty()) {
    target = stream->WriteBytesMaybeAliased(
        6, this->_internal_proc_id(), target);
  }

  // bytes topic = 7;
  if (!this->_internal_topic().empty()) {
    target = stream->WriteBytesMaybeAliased(
        7, this->_internal_topic(), target);
  }

  // .bhome_msg.BHAddress dest = 8;
  if (this->_internal_has_dest()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        8, _Internal::dest(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.BHMsgHead)
  return target;
}

size_t BHMsgHead::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:bhome_msg.BHMsgHead)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .bhome_msg.BHAddress route = 2;
  total_size += 1UL * this->_internal_route_size();
  for (const auto& msg : this->route_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // bytes msg_id = 1;
  if (!this->_internal_msg_id().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_msg_id());
  }

  // bytes proc_id = 6;
  if (!this->_internal_proc_id().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_proc_id());
  }

  // bytes topic = 7;
  if (!this->_internal_topic().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_topic());
  }

  // .bhome_msg.BHAddress dest = 8;
  if (this->_internal_has_dest()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *dest_);
  }

  // int64 timestamp = 3;
  if (this->_internal_timestamp() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
        this->_internal_timestamp());
  }

  // uint64 ssn_id = 5;
  if (this->_internal_ssn_id() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->_internal_ssn_id());
  }

  // int32 type = 4;
  if (this->_internal_type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_type());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void BHMsgHead::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const BHMsgHead*>(
      &from));
}

void BHMsgHead::MergeFrom(const BHMsgHead& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.BHMsgHead)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  route_.MergeFrom(from.route_);
  if (!from._internal_msg_id().empty()) {
    _internal_set_msg_id(from._internal_msg_id());
  }
  if (!from._internal_proc_id().empty()) {
    _internal_set_proc_id(from._internal_proc_id());
  }
  if (!from._internal_topic().empty()) {
    _internal_set_topic(from._internal_topic());
  }
  if (from._internal_has_dest()) {
    _internal_mutable_dest()->::bhome_msg::BHAddress::MergeFrom(from._internal_dest());
  }
  if (from._internal_timestamp() != 0) {
    _internal_set_timestamp(from._internal_timestamp());
  }
  if (from._internal_ssn_id() != 0) {
    _internal_set_ssn_id(from._internal_ssn_id());
  }
  if (from._internal_type() != 0) {
    _internal_set_type(from._internal_type());
  }
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void BHMsgHead::CopyFrom(const BHMsgHead& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.BHMsgHead)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BHMsgHead::IsInitialized() const {
  return true;
}

void BHMsgHead::InternalSwap(BHMsgHead* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  route_.InternalSwap(&other->route_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &msg_id_, GetArenaForAllocation(),
      &other->msg_id_, other->GetArenaForAllocation()
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &proc_id_, GetArenaForAllocation(),
      &other->proc_id_, other->GetArenaForAllocation()
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &topic_, GetArenaForAllocation(),
      &other->topic_, other->GetArenaForAllocation()
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(BHMsgHead, type_)
      + sizeof(BHMsgHead::type_)
      - PROTOBUF_FIELD_OFFSET(BHMsgHead, dest_)>(
          reinterpret_cast<char*>(&dest_),
          reinterpret_cast<char*>(&other->dest_));
}

std::string BHMsgHead::GetTypeName() const {
  return "bhome_msg.BHMsgHead";
}


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

class MsgSubscribe::_Internal {
 public:
  static const ::bhome_msg::MsgTopicList& topics(const MsgSubscribe* msg);
};

const ::bhome_msg::MsgTopicList&
MsgSubscribe::_Internal::topics(const MsgSubscribe* msg) {
  return *msg->topics_;
}
void MsgSubscribe::clear_topics() {
  if (GetArenaForAllocation() == nullptr && topics_ != nullptr) {
    delete topics_;
  }
  topics_ = nullptr;
}
MsgSubscribe::MsgSubscribe(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgSubscribe)
}
MsgSubscribe::MsgSubscribe(const MsgSubscribe& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_topics()) {
    topics_ = new ::bhome_msg::MsgTopicList(*from.topics_);
  } else {
    topics_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgSubscribe)
}

inline void MsgSubscribe::SharedCtor() {
topics_ = nullptr;
}

MsgSubscribe::~MsgSubscribe() {
  // @@protoc_insertion_point(destructor:bhome_msg.MsgSubscribe)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

inline void MsgSubscribe::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete topics_;
}

void MsgSubscribe::ArenaDtor(void* object) {
  MsgSubscribe* _this = reinterpret_cast< MsgSubscribe* >(object);
  (void)_this;
}
void MsgSubscribe::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MsgSubscribe::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MsgSubscribe::Clear() {
// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgSubscribe)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && topics_ != nullptr) {
    delete topics_;
  }
  topics_ = nullptr;
  _internal_metadata_.Clear<std::string>();
}

const char* MsgSubscribe::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .bhome_msg.MsgTopicList topics = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_topics(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MsgSubscribe::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgSubscribe)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .bhome_msg.MsgTopicList topics = 1;
  if (this->_internal_has_topics()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::topics(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgSubscribe)
  return target;
}

size_t MsgSubscribe::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgSubscribe)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .bhome_msg.MsgTopicList topics = 1;
  if (this->_internal_has_topics()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *topics_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void MsgSubscribe::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgSubscribe*>(
      &from));
}

void MsgSubscribe::MergeFrom(const MsgSubscribe& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgSubscribe)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_topics()) {
    _internal_mutable_topics()->::bhome_msg::MsgTopicList::MergeFrom(from._internal_topics());
  }
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void MsgSubscribe::CopyFrom(const MsgSubscribe& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgSubscribe)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MsgSubscribe::IsInitialized() const {
  return true;
}

void MsgSubscribe::InternalSwap(MsgSubscribe* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(topics_, other->topics_);
}

std::string MsgSubscribe::GetTypeName() const {
  return "bhome_msg.MsgSubscribe";
}


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

class MsgUnsubscribe::_Internal {
 public:
  static const ::bhome_msg::MsgTopicList& topics(const MsgUnsubscribe* msg);
};

const ::bhome_msg::MsgTopicList&
MsgUnsubscribe::_Internal::topics(const MsgUnsubscribe* msg) {
  return *msg->topics_;
}
void MsgUnsubscribe::clear_topics() {
  if (GetArenaForAllocation() == nullptr && topics_ != nullptr) {
    delete topics_;
  }
  topics_ = nullptr;
}
MsgUnsubscribe::MsgUnsubscribe(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgUnsubscribe)
}
MsgUnsubscribe::MsgUnsubscribe(const MsgUnsubscribe& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_topics()) {
    topics_ = new ::bhome_msg::MsgTopicList(*from.topics_);
  } else {
    topics_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgUnsubscribe)
}

inline void MsgUnsubscribe::SharedCtor() {
topics_ = nullptr;
}

MsgUnsubscribe::~MsgUnsubscribe() {
  // @@protoc_insertion_point(destructor:bhome_msg.MsgUnsubscribe)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

inline void MsgUnsubscribe::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete topics_;
}

void MsgUnsubscribe::ArenaDtor(void* object) {
  MsgUnsubscribe* _this = reinterpret_cast< MsgUnsubscribe* >(object);
  (void)_this;
}
void MsgUnsubscribe::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MsgUnsubscribe::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MsgUnsubscribe::Clear() {
// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgUnsubscribe)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && topics_ != nullptr) {
    delete topics_;
  }
  topics_ = nullptr;
  _internal_metadata_.Clear<std::string>();
}

const char* MsgUnsubscribe::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .bhome_msg.MsgTopicList topics = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_topics(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MsgUnsubscribe::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgUnsubscribe)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .bhome_msg.MsgTopicList topics = 1;
  if (this->_internal_has_topics()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::topics(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgUnsubscribe)
  return target;
}

size_t MsgUnsubscribe::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgUnsubscribe)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .bhome_msg.MsgTopicList topics = 1;
  if (this->_internal_has_topics()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *topics_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void MsgUnsubscribe::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgUnsubscribe*>(
      &from));
}

void MsgUnsubscribe::MergeFrom(const MsgUnsubscribe& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgUnsubscribe)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_topics()) {
    _internal_mutable_topics()->::bhome_msg::MsgTopicList::MergeFrom(from._internal_topics());
  }
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void MsgUnsubscribe::CopyFrom(const MsgUnsubscribe& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgUnsubscribe)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MsgUnsubscribe::IsInitialized() const {
  return true;
}

void MsgUnsubscribe::InternalSwap(MsgUnsubscribe* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(topics_, other->topics_);
}

std::string MsgUnsubscribe::GetTypeName() const {
  return "bhome_msg.MsgUnsubscribe";
}


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

class MsgRegisterRPC::_Internal {
 public:
  static const ::bhome_msg::MsgTopicList& topics(const MsgRegisterRPC* msg);
};

const ::bhome_msg::MsgTopicList&
MsgRegisterRPC::_Internal::topics(const MsgRegisterRPC* msg) {
  return *msg->topics_;
}
void MsgRegisterRPC::clear_topics() {
  if (GetArenaForAllocation() == nullptr && topics_ != nullptr) {
    delete topics_;
  }
  topics_ = nullptr;
}
MsgRegisterRPC::MsgRegisterRPC(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgRegisterRPC)
}
MsgRegisterRPC::MsgRegisterRPC(const MsgRegisterRPC& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_topics()) {
    topics_ = new ::bhome_msg::MsgTopicList(*from.topics_);
  } else {
    topics_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgRegisterRPC)
}

inline void MsgRegisterRPC::SharedCtor() {
topics_ = nullptr;
}

MsgRegisterRPC::~MsgRegisterRPC() {
  // @@protoc_insertion_point(destructor:bhome_msg.MsgRegisterRPC)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

inline void MsgRegisterRPC::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete topics_;
}

void MsgRegisterRPC::ArenaDtor(void* object) {
  MsgRegisterRPC* _this = reinterpret_cast< MsgRegisterRPC* >(object);
  (void)_this;
}
void MsgRegisterRPC::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MsgRegisterRPC::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MsgRegisterRPC::Clear() {
// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgRegisterRPC)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && topics_ != nullptr) {
    delete topics_;
  }
  topics_ = nullptr;
  _internal_metadata_.Clear<std::string>();
}

const char* MsgRegisterRPC::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .bhome_msg.MsgTopicList topics = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_topics(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MsgRegisterRPC::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgRegisterRPC)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .bhome_msg.MsgTopicList topics = 1;
  if (this->_internal_has_topics()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::topics(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgRegisterRPC)
  return target;
}

size_t MsgRegisterRPC::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgRegisterRPC)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .bhome_msg.MsgTopicList topics = 1;
  if (this->_internal_has_topics()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *topics_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void MsgRegisterRPC::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgRegisterRPC*>(
      &from));
}

void MsgRegisterRPC::MergeFrom(const MsgRegisterRPC& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgRegisterRPC)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_topics()) {
    _internal_mutable_topics()->::bhome_msg::MsgTopicList::MergeFrom(from._internal_topics());
  }
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void MsgRegisterRPC::CopyFrom(const MsgRegisterRPC& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgRegisterRPC)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MsgRegisterRPC::IsInitialized() const {
  return true;
}

void MsgRegisterRPC::InternalSwap(MsgRegisterRPC* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(topics_, other->topics_);
}

std::string MsgRegisterRPC::GetTypeName() const {
  return "bhome_msg.MsgRegisterRPC";
}


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

class MsgProcInit::_Internal {
 public:
};

MsgProcInit::MsgProcInit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgProcInit)
}
MsgProcInit::MsgProcInit(const MsgProcInit& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  extra_mq_num_ = from.extra_mq_num_;
  // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgProcInit)
}

inline void MsgProcInit::SharedCtor() {
extra_mq_num_ = 0;
}

MsgProcInit::~MsgProcInit() {
  // @@protoc_insertion_point(destructor:bhome_msg.MsgProcInit)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

inline void MsgProcInit::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void MsgProcInit::ArenaDtor(void* object) {
  MsgProcInit* _this = reinterpret_cast< MsgProcInit* >(object);
  (void)_this;
}
void MsgProcInit::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MsgProcInit::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MsgProcInit::Clear() {
// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgProcInit)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  extra_mq_num_ = 0;
  _internal_metadata_.Clear<std::string>();
}

const char* MsgProcInit::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 extra_mq_num = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          extra_mq_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MsgProcInit::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgProcInit)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 extra_mq_num = 1;
  if (this->_internal_extra_mq_num() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_extra_mq_num(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgProcInit)
  return target;
}

size_t MsgProcInit::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgProcInit)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // int32 extra_mq_num = 1;
  if (this->_internal_extra_mq_num() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_extra_mq_num());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void MsgProcInit::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgProcInit*>(
      &from));
}

void MsgProcInit::MergeFrom(const MsgProcInit& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgProcInit)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_extra_mq_num() != 0) {
    _internal_set_extra_mq_num(from._internal_extra_mq_num());
  }
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void MsgProcInit::CopyFrom(const MsgProcInit& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgProcInit)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MsgProcInit::IsInitialized() const {
  return true;
}

void MsgProcInit::InternalSwap(MsgProcInit* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(extra_mq_num_, other->extra_mq_num_);
}

std::string MsgProcInit::GetTypeName() const {
  return "bhome_msg.MsgProcInit";
}


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

class MsgProcInitReply::_Internal {
 public:
  static const ::bhome_msg::ErrorMsg& errmsg(const MsgProcInitReply* msg);
};

const ::bhome_msg::ErrorMsg&
MsgProcInitReply::_Internal::errmsg(const MsgProcInitReply* msg) {
  return *msg->errmsg_;
}
void MsgProcInitReply::clear_errmsg() {
  if (GetArenaForAllocation() == nullptr && errmsg_ != nullptr) {
    delete errmsg_;
  }
  errmsg_ = nullptr;
}
void MsgProcInitReply::clear_extra_mqs() {
  extra_mqs_.Clear();
}
MsgProcInitReply::MsgProcInitReply(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned),
  extra_mqs_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgProcInitReply)
}
MsgProcInitReply::MsgProcInitReply(const MsgProcInitReply& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      extra_mqs_(from.extra_mqs_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_errmsg()) {
    errmsg_ = new ::bhome_msg::ErrorMsg(*from.errmsg_);
  } else {
    errmsg_ = nullptr;
  }
  proc_index_ = from.proc_index_;
  // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgProcInitReply)
}

inline void MsgProcInitReply::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&errmsg_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&proc_index_) -
    reinterpret_cast<char*>(&errmsg_)) + sizeof(proc_index_));
}

MsgProcInitReply::~MsgProcInitReply() {
  // @@protoc_insertion_point(destructor:bhome_msg.MsgProcInitReply)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

inline void MsgProcInitReply::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete errmsg_;
}

void MsgProcInitReply::ArenaDtor(void* object) {
  MsgProcInitReply* _this = reinterpret_cast< MsgProcInitReply* >(object);
  (void)_this;
}
void MsgProcInitReply::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MsgProcInitReply::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MsgProcInitReply::Clear() {
// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgProcInitReply)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  extra_mqs_.Clear();
  if (GetArenaForAllocation() == nullptr && errmsg_ != nullptr) {
    delete errmsg_;
  }
  errmsg_ = nullptr;
  proc_index_ = 0;
  _internal_metadata_.Clear<std::string>();
}

const char* MsgProcInitReply::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .bhome_msg.ErrorMsg errmsg = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_errmsg(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 proc_index = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          proc_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .bhome_msg.BHAddress extra_mqs = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_extra_mqs(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MsgProcInitReply::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgProcInitReply)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .bhome_msg.ErrorMsg errmsg = 1;
  if (this->_internal_has_errmsg()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::errmsg(this), target, stream);
  }

  // int32 proc_index = 2;
  if (this->_internal_proc_index() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_proc_index(), target);
  }

  // repeated .bhome_msg.BHAddress extra_mqs = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_extra_mqs_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, this->_internal_extra_mqs(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgProcInitReply)
  return target;
}

size_t MsgProcInitReply::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgProcInitReply)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .bhome_msg.BHAddress extra_mqs = 3;
  total_size += 1UL * this->_internal_extra_mqs_size();
  for (const auto& msg : this->extra_mqs_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .bhome_msg.ErrorMsg errmsg = 1;
  if (this->_internal_has_errmsg()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *errmsg_);
  }

  // int32 proc_index = 2;
  if (this->_internal_proc_index() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_proc_index());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void MsgProcInitReply::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgProcInitReply*>(
      &from));
}

void MsgProcInitReply::MergeFrom(const MsgProcInitReply& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgProcInitReply)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  extra_mqs_.MergeFrom(from.extra_mqs_);
  if (from._internal_has_errmsg()) {
    _internal_mutable_errmsg()->::bhome_msg::ErrorMsg::MergeFrom(from._internal_errmsg());
  }
  if (from._internal_proc_index() != 0) {
    _internal_set_proc_index(from._internal_proc_index());
  }
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void MsgProcInitReply::CopyFrom(const MsgProcInitReply& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgProcInitReply)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MsgProcInitReply::IsInitialized() const {
  return true;
}

void MsgProcInitReply::InternalSwap(MsgProcInitReply* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  extra_mqs_.InternalSwap(&other->extra_mqs_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(MsgProcInitReply, proc_index_)
      + sizeof(MsgProcInitReply::proc_index_)
      - PROTOBUF_FIELD_OFFSET(MsgProcInitReply, errmsg_)>(
          reinterpret_cast<char*>(&errmsg_),
          reinterpret_cast<char*>(&other->errmsg_));
}

std::string MsgProcInitReply::GetTypeName() const {
  return "bhome_msg.MsgProcInitReply";
}


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

class MsgRequest::_Internal {
 public:
  static const ::bhome_msg::MsgRegister& register_(const MsgRequest* msg);
  static const ::bhome_msg::MsgRequestTopic& topic_request(const MsgRequest* msg);
  static const ::bhome_msg::MsgQueryTopic& topic_query(const MsgRequest* msg);
};

const ::bhome_msg::MsgRegister&
MsgRequest::_Internal::register_(const MsgRequest* msg) {
  return *msg->request_.register__;
}
const ::bhome_msg::MsgRequestTopic&
MsgRequest::_Internal::topic_request(const MsgRequest* msg) {
  return *msg->request_.topic_request_;
}
const ::bhome_msg::MsgQueryTopic&
MsgRequest::_Internal::topic_query(const MsgRequest* msg) {
  return *msg->request_.topic_query_;
}
void MsgRequest::set_allocated_register_(::bhome_msg::MsgRegister* register_) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_request();
  if (register_) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(register_));
    if (message_arena != submessage_arena) {
      register_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, register_, submessage_arena);
    }
    set_has_register_();
    request_.register__ = register_;
  }
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgRequest.register)
}
void MsgRequest::clear_register_() {
  if (_internal_has_register_()) {
    if (GetArenaForAllocation() == nullptr) {
      delete request_.register__;
    }
    clear_has_request();
  }
}
void MsgRequest::set_allocated_topic_request(::bhome_msg::MsgRequestTopic* topic_request) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_request();
  if (topic_request) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(topic_request));
    if (message_arena != submessage_arena) {
      topic_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, topic_request, submessage_arena);
    }
    set_has_topic_request();
    request_.topic_request_ = topic_request;
  }
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgRequest.topic_request)
}
void MsgRequest::clear_topic_request() {
  if (_internal_has_topic_request()) {
    if (GetArenaForAllocation() == nullptr) {
      delete request_.topic_request_;
    }
    clear_has_request();
  }
}
void MsgRequest::set_allocated_topic_query(::bhome_msg::MsgQueryTopic* topic_query) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_request();
  if (topic_query) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(topic_query));
    if (message_arena != submessage_arena) {
      topic_query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, topic_query, submessage_arena);
    }
    set_has_topic_query();
    request_.topic_query_ = topic_query;
  }
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.MsgRequest.topic_query)
}
void MsgRequest::clear_topic_query() {
  if (_internal_has_topic_query()) {
    if (GetArenaForAllocation() == nullptr) {
      delete request_.topic_query_;
    }
    clear_has_request();
  }
}
MsgRequest::MsgRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgRequest)
}
MsgRequest::MsgRequest(const MsgRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_request();
  switch (from.request_case()) {
    case kRegister: {
      _internal_mutable_register_()->::bhome_msg::MsgRegister::MergeFrom(from._internal_register_());
      break;
    }
    case kTopicRequest: {
      _internal_mutable_topic_request()->::bhome_msg::MsgRequestTopic::MergeFrom(from._internal_topic_request());
      break;
    }
    case kTopicQuery: {
      _internal_mutable_topic_query()->::bhome_msg::MsgQueryTopic::MergeFrom(from._internal_topic_query());
      break;
    }
    case REQUEST_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgRequest)
}

inline void MsgRequest::SharedCtor() {
clear_has_request();
}

MsgRequest::~MsgRequest() {
  // @@protoc_insertion_point(destructor:bhome_msg.MsgRequest)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

inline void MsgRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_request()) {
    clear_request();
  }
}

void MsgRequest::ArenaDtor(void* object) {
  MsgRequest* _this = reinterpret_cast< MsgRequest* >(object);
  (void)_this;
}
void MsgRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MsgRequest::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MsgRequest::clear_request() {
// @@protoc_insertion_point(one_of_clear_start:bhome_msg.MsgRequest)
  switch (request_case()) {
    case kRegister: {
      if (GetArenaForAllocation() == nullptr) {
        delete request_.register__;
      }
      break;
    }
    case kTopicRequest: {
      if (GetArenaForAllocation() == nullptr) {
        delete request_.topic_request_;
      }
      break;
    }
    case kTopicQuery: {
      if (GetArenaForAllocation() == nullptr) {
        delete request_.topic_query_;
      }
      break;
    }
    case REQUEST_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = REQUEST_NOT_SET;
}


void MsgRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgRequest)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_request();
  _internal_metadata_.Clear<std::string>();
}

const char* MsgRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .bhome_msg.MsgRegister register = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_register_(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .bhome_msg.MsgRequestTopic topic_request = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_topic_request(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .bhome_msg.MsgQueryTopic topic_query = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_topic_query(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MsgRequest::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgRequest)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .bhome_msg.MsgRegister register = 1;
  if (_internal_has_register_()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::register_(this), target, stream);
  }

  // .bhome_msg.MsgRequestTopic topic_request = 2;
  if (_internal_has_topic_request()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::topic_request(this), target, stream);
  }

  // .bhome_msg.MsgQueryTopic topic_query = 3;
  if (_internal_has_topic_query()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::topic_query(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgRequest)
  return target;
}

size_t MsgRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgRequest)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (request_case()) {
    // .bhome_msg.MsgRegister register = 1;
    case kRegister: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.register__);
      break;
    }
    // .bhome_msg.MsgRequestTopic topic_request = 2;
    case kTopicRequest: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.topic_request_);
      break;
    }
    // .bhome_msg.MsgQueryTopic topic_query = 3;
    case kTopicQuery: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *request_.topic_query_);
      break;
    }
    case REQUEST_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void MsgRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgRequest*>(
      &from));
}

void MsgRequest::MergeFrom(const MsgRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgRequest)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.request_case()) {
    case kRegister: {
      _internal_mutable_register_()->::bhome_msg::MsgRegister::MergeFrom(from._internal_register_());
      break;
    }
    case kTopicRequest: {
      _internal_mutable_topic_request()->::bhome_msg::MsgRequestTopic::MergeFrom(from._internal_topic_request());
      break;
    }
    case kTopicQuery: {
      _internal_mutable_topic_query()->::bhome_msg::MsgQueryTopic::MergeFrom(from._internal_topic_query());
      break;
    }
    case REQUEST_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void MsgRequest::CopyFrom(const MsgRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MsgRequest::IsInitialized() const {
  return true;
}

void MsgRequest::InternalSwap(MsgRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(request_, other->request_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

std::string MsgRequest::GetTypeName() const {
  return "bhome_msg.MsgRequest";
}


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

class MsgReply::_Internal {
 public:
  static const ::bhome_msg::ErrorMsg& err_msg(const MsgReply* msg);
};

const ::bhome_msg::ErrorMsg&
MsgReply::_Internal::err_msg(const MsgReply* msg) {
  return *msg->err_msg_;
}
void MsgReply::clear_err_msg() {
  if (GetArenaForAllocation() == nullptr && err_msg_ != nullptr) {
    delete err_msg_;
  }
  err_msg_ = nullptr;
}
MsgReply::MsgReply(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:bhome_msg.MsgReply)
}
MsgReply::MsgReply(const MsgReply& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_err_msg()) {
    err_msg_ = new ::bhome_msg::ErrorMsg(*from.err_msg_);
  } else {
    err_msg_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:bhome_msg.MsgReply)
}

inline void MsgReply::SharedCtor() {
err_msg_ = nullptr;
}

MsgReply::~MsgReply() {
  // @@protoc_insertion_point(destructor:bhome_msg.MsgReply)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

inline void MsgReply::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete err_msg_;
}

void MsgReply::ArenaDtor(void* object) {
  MsgReply* _this = reinterpret_cast< MsgReply* >(object);
  (void)_this;
}
void MsgReply::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MsgReply::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MsgReply::Clear() {
// @@protoc_insertion_point(message_clear_start:bhome_msg.MsgReply)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && err_msg_ != nullptr) {
    delete err_msg_;
  }
  err_msg_ = nullptr;
  _internal_metadata_.Clear<std::string>();
}

const char* MsgReply::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .bhome_msg.ErrorMsg err_msg = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_err_msg(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MsgReply::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.MsgReply)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .bhome_msg.ErrorMsg err_msg = 1;
  if (this->_internal_has_err_msg()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::err_msg(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.MsgReply)
  return target;
}

size_t MsgReply::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:bhome_msg.MsgReply)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .bhome_msg.ErrorMsg err_msg = 1;
  if (this->_internal_has_err_msg()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *err_msg_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void MsgReply::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MsgReply*>(
      &from));
}

void MsgReply::MergeFrom(const MsgReply& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.MsgReply)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_err_msg()) {
    _internal_mutable_err_msg()->::bhome_msg::ErrorMsg::MergeFrom(from._internal_err_msg());
  }
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void MsgReply::CopyFrom(const MsgReply& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.MsgReply)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MsgReply::IsInitialized() const {
  return true;
}

void MsgReply::InternalSwap(MsgReply* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(err_msg_, other->err_msg_);
}

std::string MsgReply::GetTypeName() const {
  return "bhome_msg.MsgReply";
}


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

class BHMsgBody::_Internal {
 public:
  static const ::bhome_msg::MsgRequest& request(const BHMsgBody* msg);
  static const ::bhome_msg::MsgReply& reply(const BHMsgBody* msg);
};

const ::bhome_msg::MsgRequest&
BHMsgBody::_Internal::request(const BHMsgBody* msg) {
  return *msg->reqrep_.request_;
}
const ::bhome_msg::MsgReply&
BHMsgBody::_Internal::reply(const BHMsgBody* msg) {
  return *msg->reqrep_.reply_;
}
void BHMsgBody::set_allocated_request(::bhome_msg::MsgRequest* request) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reqrep();
  if (request) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::bhome_msg::MsgRequest>::GetOwningArena(request);
    if (message_arena != submessage_arena) {
      request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, request, submessage_arena);
    }
    set_has_request();
    reqrep_.request_ = request;
  }
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.BHMsgBody.request)
}
void BHMsgBody::set_allocated_reply(::bhome_msg::MsgReply* reply) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reqrep();
  if (reply) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::bhome_msg::MsgReply>::GetOwningArena(reply);
    if (message_arena != submessage_arena) {
      reply = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, reply, submessage_arena);
    }
    set_has_reply();
    reqrep_.reply_ = reply;
  }
  // @@protoc_insertion_point(field_set_allocated:bhome_msg.BHMsgBody.reply)
}
BHMsgBody::BHMsgBody(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:bhome_msg.BHMsgBody)
}
BHMsgBody::BHMsgBody(const BHMsgBody& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_reqrep();
  switch (from.reqrep_case()) {
    case kRequest: {
      _internal_mutable_request()->::bhome_msg::MsgRequest::MergeFrom(from._internal_request());
      break;
    }
    case kReply: {
      _internal_mutable_reply()->::bhome_msg::MsgReply::MergeFrom(from._internal_reply());
      break;
    }
    case REQREP_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:bhome_msg.BHMsgBody)
}

inline void BHMsgBody::SharedCtor() {
clear_has_reqrep();
}

BHMsgBody::~BHMsgBody() {
  // @@protoc_insertion_point(destructor:bhome_msg.BHMsgBody)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

inline void BHMsgBody::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_reqrep()) {
    clear_reqrep();
  }
}

void BHMsgBody::ArenaDtor(void* object) {
  BHMsgBody* _this = reinterpret_cast< BHMsgBody* >(object);
  (void)_this;
}
void BHMsgBody::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void BHMsgBody::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void BHMsgBody::clear_reqrep() {
// @@protoc_insertion_point(one_of_clear_start:bhome_msg.BHMsgBody)
  switch (reqrep_case()) {
    case kRequest: {
      if (GetArenaForAllocation() == nullptr) {
        delete reqrep_.request_;
      }
      break;
    }
    case kReply: {
      if (GetArenaForAllocation() == nullptr) {
        delete reqrep_.reply_;
      }
      break;
    }
    case REQREP_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = REQREP_NOT_SET;
}


void BHMsgBody::Clear() {
// @@protoc_insertion_point(message_clear_start:bhome_msg.BHMsgBody)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_reqrep();
  _internal_metadata_.Clear<std::string>();
}

const char* BHMsgBody::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .bhome_msg.MsgRequest request = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_request(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .bhome_msg.MsgReply reply = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_reply(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<std::string>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* BHMsgBody::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:bhome_msg.BHMsgBody)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .bhome_msg.MsgRequest request = 1;
  if (_internal_has_request()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::request(this), target, stream);
  }

  // .bhome_msg.MsgReply reply = 2;
  if (_internal_has_reply()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::reply(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:bhome_msg.BHMsgBody)
  return target;
}

size_t BHMsgBody::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:bhome_msg.BHMsgBody)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (reqrep_case()) {
    // .bhome_msg.MsgRequest request = 1;
    case kRequest: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *reqrep_.request_);
      break;
    }
    // .bhome_msg.MsgReply reply = 2;
    case kReply: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *reqrep_.reply_);
      break;
    }
    case REQREP_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void BHMsgBody::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const BHMsgBody*>(
      &from));
}

void BHMsgBody::MergeFrom(const BHMsgBody& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:bhome_msg.BHMsgBody)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.reqrep_case()) {
    case kRequest: {
      _internal_mutable_request()->::bhome_msg::MsgRequest::MergeFrom(from._internal_request());
      break;
    }
    case kReply: {
      _internal_mutable_reply()->::bhome_msg::MsgReply::MergeFrom(from._internal_reply());
      break;
    }
    case REQREP_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void BHMsgBody::CopyFrom(const BHMsgBody& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:bhome_msg.BHMsgBody)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BHMsgBody::IsInitialized() const {
  return true;
}

void BHMsgBody::InternalSwap(BHMsgBody* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(reqrep_, other->reqrep_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

std::string BHMsgBody::GetTypeName() const {
  return "bhome_msg.BHMsgBody";
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace bhome_msg
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::bhome_msg::BHMsgHead* Arena::CreateMaybeMessage< ::bhome_msg::BHMsgHead >(Arena* arena) {
  return Arena::CreateMessageInternal< ::bhome_msg::BHMsgHead >(arena);
}
template<> PROTOBUF_NOINLINE ::bhome_msg::MsgSubscribe* Arena::CreateMaybeMessage< ::bhome_msg::MsgSubscribe >(Arena* arena) {
  return Arena::CreateMessageInternal< ::bhome_msg::MsgSubscribe >(arena);
}
template<> PROTOBUF_NOINLINE ::bhome_msg::MsgUnsubscribe* Arena::CreateMaybeMessage< ::bhome_msg::MsgUnsubscribe >(Arena* arena) {
  return Arena::CreateMessageInternal< ::bhome_msg::MsgUnsubscribe >(arena);
}
template<> PROTOBUF_NOINLINE ::bhome_msg::MsgRegisterRPC* Arena::CreateMaybeMessage< ::bhome_msg::MsgRegisterRPC >(Arena* arena) {
  return Arena::CreateMessageInternal< ::bhome_msg::MsgRegisterRPC >(arena);
}
template<> PROTOBUF_NOINLINE ::bhome_msg::MsgProcInit* Arena::CreateMaybeMessage< ::bhome_msg::MsgProcInit >(Arena* arena) {
  return Arena::CreateMessageInternal< ::bhome_msg::MsgProcInit >(arena);
}
template<> PROTOBUF_NOINLINE ::bhome_msg::MsgProcInitReply* Arena::CreateMaybeMessage< ::bhome_msg::MsgProcInitReply >(Arena* arena) {
  return Arena::CreateMessageInternal< ::bhome_msg::MsgProcInitReply >(arena);
}
template<> PROTOBUF_NOINLINE ::bhome_msg::MsgRequest* Arena::CreateMaybeMessage< ::bhome_msg::MsgRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::bhome_msg::MsgRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::bhome_msg::MsgReply* Arena::CreateMaybeMessage< ::bhome_msg::MsgReply >(Arena* arena) {
  return Arena::CreateMessageInternal< ::bhome_msg::MsgReply >(arena);
}
template<> PROTOBUF_NOINLINE ::bhome_msg::BHMsgBody* Arena::CreateMaybeMessage< ::bhome_msg::BHMsgBody >(Arena* arena) {
  return Arena::CreateMessageInternal< ::bhome_msg::BHMsgBody >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>