CT_project/测量节点/rabbitmq/rabbitmq.pb.cc

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

#include "rabbitmq.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/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
extern PROTOBUF_INTERNAL_EXPORT_rabbitmq_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Rabbitmq_channel_queue_consume_rabbitmq_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rabbitmq_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_Rabbitmq_parameter_rabbitmq_2eproto;
namespace Rabbitmq_proto {
class Rabbitmq_channel_queue_consumeDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Rabbitmq_channel_queue_consume> _instance;
} _Rabbitmq_channel_queue_consume_default_instance_;
class Rabbitmq_parameterDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Rabbitmq_parameter> _instance;
} _Rabbitmq_parameter_default_instance_;
class Rabbitmq_parameter_allDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Rabbitmq_parameter_all> _instance;
} _Rabbitmq_parameter_all_default_instance_;
}  // namespace Rabbitmq_proto
static void InitDefaultsscc_info_Rabbitmq_channel_queue_consume_rabbitmq_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::Rabbitmq_proto::_Rabbitmq_channel_queue_consume_default_instance_;
    new (ptr) ::Rabbitmq_proto::Rabbitmq_channel_queue_consume();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::Rabbitmq_proto::Rabbitmq_channel_queue_consume::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Rabbitmq_channel_queue_consume_rabbitmq_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_Rabbitmq_channel_queue_consume_rabbitmq_2eproto}, {}};

static void InitDefaultsscc_info_Rabbitmq_parameter_rabbitmq_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::Rabbitmq_proto::_Rabbitmq_parameter_default_instance_;
    new (ptr) ::Rabbitmq_proto::Rabbitmq_parameter();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::Rabbitmq_proto::Rabbitmq_parameter::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_Rabbitmq_parameter_rabbitmq_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_Rabbitmq_parameter_rabbitmq_2eproto}, {
      &scc_info_Rabbitmq_channel_queue_consume_rabbitmq_2eproto.base,}};

static void InitDefaultsscc_info_Rabbitmq_parameter_all_rabbitmq_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::Rabbitmq_proto::_Rabbitmq_parameter_all_default_instance_;
    new (ptr) ::Rabbitmq_proto::Rabbitmq_parameter_all();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::Rabbitmq_proto::Rabbitmq_parameter_all::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_Rabbitmq_parameter_all_rabbitmq_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_Rabbitmq_parameter_all_rabbitmq_2eproto}, {
      &scc_info_Rabbitmq_parameter_rabbitmq_2eproto.base,}};

static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_rabbitmq_2eproto[3];
static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_rabbitmq_2eproto = nullptr;
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_rabbitmq_2eproto = nullptr;

const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_rabbitmq_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_channel_queue_consume, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_channel_queue_consume, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_channel_queue_consume, channel_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_channel_queue_consume, exchange_name_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_channel_queue_consume, routing_key_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_channel_queue_consume, timeout_ms_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_channel_queue_consume, binding_key_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_channel_queue_consume, queue_name_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_channel_queue_consume, queue_passive_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_channel_queue_consume, queue_durable_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_channel_queue_consume, queue_exclusive_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_channel_queue_consume, queue_auto_delete_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_channel_queue_consume, queue_meassage_ttl_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_channel_queue_consume, consume_name_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_channel_queue_consume, consume_no_local_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_channel_queue_consume, consume_no_ack_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_channel_queue_consume, consume_exclusive_),
  5,
  0,
  1,
  6,
  2,
  3,
  7,
  8,
  9,
  10,
  11,
  4,
  12,
  13,
  14,
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_parameter, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_parameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_parameter, ip_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_parameter, port_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_parameter, user_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_parameter, password_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_parameter, rabbitmq_reciever_vector_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_parameter, rabbitmq_sender_request_vector_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_parameter, rabbitmq_sender_status_vector_),
  0,
  3,
  1,
  2,
  ~0u,
  ~0u,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_parameter_all, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_parameter_all, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::Rabbitmq_proto::Rabbitmq_parameter_all, rabbitmq_parameters_),
  0,
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 20, sizeof(::Rabbitmq_proto::Rabbitmq_channel_queue_consume)},
  { 35, 47, sizeof(::Rabbitmq_proto::Rabbitmq_parameter)},
  { 54, 60, sizeof(::Rabbitmq_proto::Rabbitmq_parameter_all)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::Rabbitmq_proto::_Rabbitmq_channel_queue_consume_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::Rabbitmq_proto::_Rabbitmq_parameter_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::Rabbitmq_proto::_Rabbitmq_parameter_all_default_instance_),
};

const char descriptor_table_protodef_rabbitmq_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\016rabbitmq.proto\022\016Rabbitmq_proto\"\215\003\n\036Rab"
  "bitmq_channel_queue_consume\022\017\n\007channel\030\001"
  " \001(\005\022\025\n\rexchange_name\030\002 \001(\t\022\023\n\013routing_k"
  "ey\030\003 \001(\t\022\022\n\ntimeout_ms\030\004 \001(\005\022\023\n\013binding_"
  "key\030\005 \001(\t\022\022\n\nqueue_name\030\006 \001(\t\022\030\n\rqueue_p"
  "assive\030\007 \001(\005:\0010\022\025\n\rqueue_durable\030\010 \001(\005\022\032"
  "\n\017queue_exclusive\030\t \001(\005:\0010\022\034\n\021queue_auto"
  "_delete\030\n \001(\005:\0010\022\035\n\022queue_meassage_ttl\030\013"
  " \001(\005:\0010\022\024\n\014consume_name\030\014 \001(\t\022\033\n\020consume"
  "_no_local\030\r \001(\005:\0010\022\031\n\016consume_no_ack\030\016 \001"
  "(\005:\0010\022\031\n\021consume_exclusive\030\017 \001(\005\"\317\002\n\022Rab"
  "bitmq_parameter\022\n\n\002ip\030\001 \001(\t\022\014\n\004port\030\002 \001("
  "\005\022\014\n\004user\030\003 \001(\t\022\020\n\010password\030\004 \001(\t\022P\n\030rab"
  "bitmq_reciever_vector\030\005 \003(\0132..Rabbitmq_p"
  "roto.Rabbitmq_channel_queue_consume\022V\n\036r"
  "abbitmq_sender_request_vector\030\006 \003(\0132..Ra"
  "bbitmq_proto.Rabbitmq_channel_queue_cons"
  "ume\022U\n\035rabbitmq_sender_status_vector\030\007 \003"
  "(\0132..Rabbitmq_proto.Rabbitmq_channel_que"
  "ue_consume\"Y\n\026Rabbitmq_parameter_all\022\?\n\023"
  "rabbitmq_parameters\030\001 \001(\0132\".Rabbitmq_pro"
  "to.Rabbitmq_parameter"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_rabbitmq_2eproto_deps[1] = {
};
static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_rabbitmq_2eproto_sccs[3] = {
  &scc_info_Rabbitmq_channel_queue_consume_rabbitmq_2eproto.base,
  &scc_info_Rabbitmq_parameter_rabbitmq_2eproto.base,
  &scc_info_Rabbitmq_parameter_all_rabbitmq_2eproto.base,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_rabbitmq_2eproto_once;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_rabbitmq_2eproto = {
  false, false, descriptor_table_protodef_rabbitmq_2eproto, "rabbitmq.proto", 861,
  &descriptor_table_rabbitmq_2eproto_once, descriptor_table_rabbitmq_2eproto_sccs, descriptor_table_rabbitmq_2eproto_deps, 3, 0,
  schemas, file_default_instances, TableStruct_rabbitmq_2eproto::offsets,
  file_level_metadata_rabbitmq_2eproto, 3, file_level_enum_descriptors_rabbitmq_2eproto, file_level_service_descriptors_rabbitmq_2eproto,
};

// Force running AddDescriptors() at dynamic initialization time.
static bool dynamic_init_dummy_rabbitmq_2eproto = (static_cast<void>(::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_rabbitmq_2eproto)), true);
namespace Rabbitmq_proto {

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

void Rabbitmq_channel_queue_consume::InitAsDefaultInstance() {
}
class Rabbitmq_channel_queue_consume::_Internal {
 public:
  using HasBits = decltype(std::declval<Rabbitmq_channel_queue_consume>()._has_bits_);
  static void set_has_channel(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_exchange_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_routing_key(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_timeout_ms(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_binding_key(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_queue_name(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_queue_passive(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_queue_durable(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static void set_has_queue_exclusive(HasBits* has_bits) {
    (*has_bits)[0] |= 512u;
  }
  static void set_has_queue_auto_delete(HasBits* has_bits) {
    (*has_bits)[0] |= 1024u;
  }
  static void set_has_queue_meassage_ttl(HasBits* has_bits) {
    (*has_bits)[0] |= 2048u;
  }
  static void set_has_consume_name(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_consume_no_local(HasBits* has_bits) {
    (*has_bits)[0] |= 4096u;
  }
  static void set_has_consume_no_ack(HasBits* has_bits) {
    (*has_bits)[0] |= 8192u;
  }
  static void set_has_consume_exclusive(HasBits* has_bits) {
    (*has_bits)[0] |= 16384u;
  }
};

Rabbitmq_channel_queue_consume::Rabbitmq_channel_queue_consume(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:Rabbitmq_proto.Rabbitmq_channel_queue_consume)
}
Rabbitmq_channel_queue_consume::Rabbitmq_channel_queue_consume(const Rabbitmq_channel_queue_consume& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  exchange_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_exchange_name()) {
    exchange_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_exchange_name(),
      GetArena());
  }
  routing_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_routing_key()) {
    routing_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_routing_key(),
      GetArena());
  }
  binding_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_binding_key()) {
    binding_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_binding_key(),
      GetArena());
  }
  queue_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_queue_name()) {
    queue_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_queue_name(),
      GetArena());
  }
  consume_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_consume_name()) {
    consume_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_consume_name(),
      GetArena());
  }
  ::memcpy(&channel_, &from.channel_,
    static_cast<size_t>(reinterpret_cast<char*>(&consume_exclusive_) -
    reinterpret_cast<char*>(&channel_)) + sizeof(consume_exclusive_));
  // @@protoc_insertion_point(copy_constructor:Rabbitmq_proto.Rabbitmq_channel_queue_consume)
}

void Rabbitmq_channel_queue_consume::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Rabbitmq_channel_queue_consume_rabbitmq_2eproto.base);
  exchange_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  routing_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  binding_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  queue_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  consume_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&channel_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&consume_exclusive_) -
      reinterpret_cast<char*>(&channel_)) + sizeof(consume_exclusive_));
}

Rabbitmq_channel_queue_consume::~Rabbitmq_channel_queue_consume() {
  // @@protoc_insertion_point(destructor:Rabbitmq_proto.Rabbitmq_channel_queue_consume)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void Rabbitmq_channel_queue_consume::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  exchange_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  routing_key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  binding_key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  queue_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  consume_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void Rabbitmq_channel_queue_consume::ArenaDtor(void* object) {
  Rabbitmq_channel_queue_consume* _this = reinterpret_cast< Rabbitmq_channel_queue_consume* >(object);
  (void)_this;
}
void Rabbitmq_channel_queue_consume::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Rabbitmq_channel_queue_consume::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const Rabbitmq_channel_queue_consume& Rabbitmq_channel_queue_consume::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Rabbitmq_channel_queue_consume_rabbitmq_2eproto.base);
  return *internal_default_instance();
}


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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      exchange_name_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      routing_key_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000004u) {
      binding_key_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000008u) {
      queue_name_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000010u) {
      consume_name_.ClearNonDefaultToEmpty();
    }
  }
  if (cached_has_bits & 0x000000e0u) {
    ::memset(&channel_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&queue_passive_) -
        reinterpret_cast<char*>(&channel_)) + sizeof(queue_passive_));
  }
  if (cached_has_bits & 0x00007f00u) {
    ::memset(&queue_durable_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&consume_exclusive_) -
        reinterpret_cast<char*>(&queue_durable_)) + sizeof(consume_exclusive_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Rabbitmq_channel_queue_consume::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional int32 channel = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_channel(&has_bits);
          channel_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string exchange_name = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_exchange_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "Rabbitmq_proto.Rabbitmq_channel_queue_consume.exchange_name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string routing_key = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_routing_key();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "Rabbitmq_proto.Rabbitmq_channel_queue_consume.routing_key");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 timeout_ms = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_timeout_ms(&has_bits);
          timeout_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string binding_key = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          auto str = _internal_mutable_binding_key();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "Rabbitmq_proto.Rabbitmq_channel_queue_consume.binding_key");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string queue_name = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          auto str = _internal_mutable_queue_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "Rabbitmq_proto.Rabbitmq_channel_queue_consume.queue_name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 queue_passive = 7 [default = 0];
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_queue_passive(&has_bits);
          queue_passive_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 queue_durable = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
          _Internal::set_has_queue_durable(&has_bits);
          queue_durable_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 queue_exclusive = 9 [default = 0];
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
          _Internal::set_has_queue_exclusive(&has_bits);
          queue_exclusive_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 queue_auto_delete = 10 [default = 0];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) {
          _Internal::set_has_queue_auto_delete(&has_bits);
          queue_auto_delete_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 queue_meassage_ttl = 11 [default = 0];
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) {
          _Internal::set_has_queue_meassage_ttl(&has_bits);
          queue_meassage_ttl_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string consume_name = 12;
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) {
          auto str = _internal_mutable_consume_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "Rabbitmq_proto.Rabbitmq_channel_queue_consume.consume_name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 consume_no_local = 13 [default = 0];
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 104)) {
          _Internal::set_has_consume_no_local(&has_bits);
          consume_no_local_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 consume_no_ack = 14 [default = 0];
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 112)) {
          _Internal::set_has_consume_no_ack(&has_bits);
          consume_no_ack_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 consume_exclusive = 15;
      case 15:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 120)) {
          _Internal::set_has_consume_exclusive(&has_bits);
          consume_exclusive_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional int32 channel = 1;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_channel(), target);
  }

  // optional string exchange_name = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_exchange_name().data(), static_cast<int>(this->_internal_exchange_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "Rabbitmq_proto.Rabbitmq_channel_queue_consume.exchange_name");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_exchange_name(), target);
  }

  // optional string routing_key = 3;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_routing_key().data(), static_cast<int>(this->_internal_routing_key().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "Rabbitmq_proto.Rabbitmq_channel_queue_consume.routing_key");
    target = stream->WriteStringMaybeAliased(
        3, this->_internal_routing_key(), target);
  }

  // optional int32 timeout_ms = 4;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_timeout_ms(), target);
  }

  // optional string binding_key = 5;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_binding_key().data(), static_cast<int>(this->_internal_binding_key().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "Rabbitmq_proto.Rabbitmq_channel_queue_consume.binding_key");
    target = stream->WriteStringMaybeAliased(
        5, this->_internal_binding_key(), target);
  }

  // optional string queue_name = 6;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_queue_name().data(), static_cast<int>(this->_internal_queue_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "Rabbitmq_proto.Rabbitmq_channel_queue_consume.queue_name");
    target = stream->WriteStringMaybeAliased(
        6, this->_internal_queue_name(), target);
  }

  // optional int32 queue_passive = 7 [default = 0];
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(7, this->_internal_queue_passive(), target);
  }

  // optional int32 queue_durable = 8;
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(8, this->_internal_queue_durable(), target);
  }

  // optional int32 queue_exclusive = 9 [default = 0];
  if (cached_has_bits & 0x00000200u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(9, this->_internal_queue_exclusive(), target);
  }

  // optional int32 queue_auto_delete = 10 [default = 0];
  if (cached_has_bits & 0x00000400u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(10, this->_internal_queue_auto_delete(), target);
  }

  // optional int32 queue_meassage_ttl = 11 [default = 0];
  if (cached_has_bits & 0x00000800u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(11, this->_internal_queue_meassage_ttl(), target);
  }

  // optional string consume_name = 12;
  if (cached_has_bits & 0x00000010u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_consume_name().data(), static_cast<int>(this->_internal_consume_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "Rabbitmq_proto.Rabbitmq_channel_queue_consume.consume_name");
    target = stream->WriteStringMaybeAliased(
        12, this->_internal_consume_name(), target);
  }

  // optional int32 consume_no_local = 13 [default = 0];
  if (cached_has_bits & 0x00001000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(13, this->_internal_consume_no_local(), target);
  }

  // optional int32 consume_no_ack = 14 [default = 0];
  if (cached_has_bits & 0x00002000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(14, this->_internal_consume_no_ack(), target);
  }

  // optional int32 consume_exclusive = 15;
  if (cached_has_bits & 0x00004000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(15, this->_internal_consume_exclusive(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Rabbitmq_proto.Rabbitmq_channel_queue_consume)
  return target;
}

size_t Rabbitmq_channel_queue_consume::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Rabbitmq_proto.Rabbitmq_channel_queue_consume)
  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;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional string exchange_name = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_exchange_name());
    }

    // optional string routing_key = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_routing_key());
    }

    // optional string binding_key = 5;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_binding_key());
    }

    // optional string queue_name = 6;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_queue_name());
    }

    // optional string consume_name = 12;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_consume_name());
    }

    // optional int32 channel = 1;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_channel());
    }

    // optional int32 timeout_ms = 4;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_timeout_ms());
    }

    // optional int32 queue_passive = 7 [default = 0];
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_queue_passive());
    }

  }
  if (cached_has_bits & 0x00007f00u) {
    // optional int32 queue_durable = 8;
    if (cached_has_bits & 0x00000100u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_queue_durable());
    }

    // optional int32 queue_exclusive = 9 [default = 0];
    if (cached_has_bits & 0x00000200u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_queue_exclusive());
    }

    // optional int32 queue_auto_delete = 10 [default = 0];
    if (cached_has_bits & 0x00000400u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_queue_auto_delete());
    }

    // optional int32 queue_meassage_ttl = 11 [default = 0];
    if (cached_has_bits & 0x00000800u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_queue_meassage_ttl());
    }

    // optional int32 consume_no_local = 13 [default = 0];
    if (cached_has_bits & 0x00001000u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_consume_no_local());
    }

    // optional int32 consume_no_ack = 14 [default = 0];
    if (cached_has_bits & 0x00002000u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_consume_no_ack());
    }

    // optional int32 consume_exclusive = 15;
    if (cached_has_bits & 0x00004000u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_consume_exclusive());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Rabbitmq_channel_queue_consume::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:Rabbitmq_proto.Rabbitmq_channel_queue_consume)
  GOOGLE_DCHECK_NE(&from, this);
  const Rabbitmq_channel_queue_consume* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Rabbitmq_channel_queue_consume>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:Rabbitmq_proto.Rabbitmq_channel_queue_consume)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:Rabbitmq_proto.Rabbitmq_channel_queue_consume)
    MergeFrom(*source);
  }
}

void Rabbitmq_channel_queue_consume::MergeFrom(const Rabbitmq_channel_queue_consume& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Rabbitmq_proto.Rabbitmq_channel_queue_consume)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_exchange_name(from._internal_exchange_name());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_set_routing_key(from._internal_routing_key());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_set_binding_key(from._internal_binding_key());
    }
    if (cached_has_bits & 0x00000008u) {
      _internal_set_queue_name(from._internal_queue_name());
    }
    if (cached_has_bits & 0x00000010u) {
      _internal_set_consume_name(from._internal_consume_name());
    }
    if (cached_has_bits & 0x00000020u) {
      channel_ = from.channel_;
    }
    if (cached_has_bits & 0x00000040u) {
      timeout_ms_ = from.timeout_ms_;
    }
    if (cached_has_bits & 0x00000080u) {
      queue_passive_ = from.queue_passive_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00007f00u) {
    if (cached_has_bits & 0x00000100u) {
      queue_durable_ = from.queue_durable_;
    }
    if (cached_has_bits & 0x00000200u) {
      queue_exclusive_ = from.queue_exclusive_;
    }
    if (cached_has_bits & 0x00000400u) {
      queue_auto_delete_ = from.queue_auto_delete_;
    }
    if (cached_has_bits & 0x00000800u) {
      queue_meassage_ttl_ = from.queue_meassage_ttl_;
    }
    if (cached_has_bits & 0x00001000u) {
      consume_no_local_ = from.consume_no_local_;
    }
    if (cached_has_bits & 0x00002000u) {
      consume_no_ack_ = from.consume_no_ack_;
    }
    if (cached_has_bits & 0x00004000u) {
      consume_exclusive_ = from.consume_exclusive_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void Rabbitmq_channel_queue_consume::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:Rabbitmq_proto.Rabbitmq_channel_queue_consume)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void Rabbitmq_channel_queue_consume::InternalSwap(Rabbitmq_channel_queue_consume* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  exchange_name_.Swap(&other->exchange_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  routing_key_.Swap(&other->routing_key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  binding_key_.Swap(&other->binding_key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  queue_name_.Swap(&other->queue_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  consume_name_.Swap(&other->consume_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Rabbitmq_channel_queue_consume, consume_exclusive_)
      + sizeof(Rabbitmq_channel_queue_consume::consume_exclusive_)
      - PROTOBUF_FIELD_OFFSET(Rabbitmq_channel_queue_consume, channel_)>(
          reinterpret_cast<char*>(&channel_),
          reinterpret_cast<char*>(&other->channel_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Rabbitmq_channel_queue_consume::GetMetadata() const {
  return GetMetadataStatic();
}


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

void Rabbitmq_parameter::InitAsDefaultInstance() {
}
class Rabbitmq_parameter::_Internal {
 public:
  using HasBits = decltype(std::declval<Rabbitmq_parameter>()._has_bits_);
  static void set_has_ip(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_port(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_user(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_password(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

Rabbitmq_parameter::Rabbitmq_parameter(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena),
  rabbitmq_reciever_vector_(arena),
  rabbitmq_sender_request_vector_(arena),
  rabbitmq_sender_status_vector_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:Rabbitmq_proto.Rabbitmq_parameter)
}
Rabbitmq_parameter::Rabbitmq_parameter(const Rabbitmq_parameter& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      rabbitmq_reciever_vector_(from.rabbitmq_reciever_vector_),
      rabbitmq_sender_request_vector_(from.rabbitmq_sender_request_vector_),
      rabbitmq_sender_status_vector_(from.rabbitmq_sender_status_vector_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_ip()) {
    ip_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_ip(),
      GetArena());
  }
  user_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_user()) {
    user_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_user(),
      GetArena());
  }
  password_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_password()) {
    password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_password(),
      GetArena());
  }
  port_ = from.port_;
  // @@protoc_insertion_point(copy_constructor:Rabbitmq_proto.Rabbitmq_parameter)
}

void Rabbitmq_parameter::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Rabbitmq_parameter_rabbitmq_2eproto.base);
  ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  user_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  password_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  port_ = 0;
}

Rabbitmq_parameter::~Rabbitmq_parameter() {
  // @@protoc_insertion_point(destructor:Rabbitmq_proto.Rabbitmq_parameter)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void Rabbitmq_parameter::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  ip_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  user_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  password_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void Rabbitmq_parameter::ArenaDtor(void* object) {
  Rabbitmq_parameter* _this = reinterpret_cast< Rabbitmq_parameter* >(object);
  (void)_this;
}
void Rabbitmq_parameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Rabbitmq_parameter::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const Rabbitmq_parameter& Rabbitmq_parameter::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Rabbitmq_parameter_rabbitmq_2eproto.base);
  return *internal_default_instance();
}


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

  rabbitmq_reciever_vector_.Clear();
  rabbitmq_sender_request_vector_.Clear();
  rabbitmq_sender_status_vector_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      ip_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      user_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000004u) {
      password_.ClearNonDefaultToEmpty();
    }
  }
  port_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Rabbitmq_parameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string ip = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_ip();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "Rabbitmq_proto.Rabbitmq_parameter.ip");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 port = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_port(&has_bits);
          port_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string user = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          auto str = _internal_mutable_user();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "Rabbitmq_proto.Rabbitmq_parameter.user");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string password = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          auto str = _internal_mutable_password();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "Rabbitmq_proto.Rabbitmq_parameter.password");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .Rabbitmq_proto.Rabbitmq_channel_queue_consume rabbitmq_reciever_vector = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_rabbitmq_reciever_vector(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .Rabbitmq_proto.Rabbitmq_channel_queue_consume rabbitmq_sender_request_vector = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_rabbitmq_sender_request_vector(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .Rabbitmq_proto.Rabbitmq_channel_queue_consume rabbitmq_sender_status_vector = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_rabbitmq_sender_status_vector(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional string ip = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_ip().data(), static_cast<int>(this->_internal_ip().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "Rabbitmq_proto.Rabbitmq_parameter.ip");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_ip(), target);
  }

  // optional int32 port = 2;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_port(), target);
  }

  // optional string user = 3;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_user().data(), static_cast<int>(this->_internal_user().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "Rabbitmq_proto.Rabbitmq_parameter.user");
    target = stream->WriteStringMaybeAliased(
        3, this->_internal_user(), target);
  }

  // optional string password = 4;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_password().data(), static_cast<int>(this->_internal_password().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "Rabbitmq_proto.Rabbitmq_parameter.password");
    target = stream->WriteStringMaybeAliased(
        4, this->_internal_password(), target);
  }

  // repeated .Rabbitmq_proto.Rabbitmq_channel_queue_consume rabbitmq_reciever_vector = 5;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_rabbitmq_reciever_vector_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, this->_internal_rabbitmq_reciever_vector(i), target, stream);
  }

  // repeated .Rabbitmq_proto.Rabbitmq_channel_queue_consume rabbitmq_sender_request_vector = 6;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_rabbitmq_sender_request_vector_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(6, this->_internal_rabbitmq_sender_request_vector(i), target, stream);
  }

  // repeated .Rabbitmq_proto.Rabbitmq_channel_queue_consume rabbitmq_sender_status_vector = 7;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_rabbitmq_sender_status_vector_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(7, this->_internal_rabbitmq_sender_status_vector(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Rabbitmq_proto.Rabbitmq_parameter)
  return target;
}

size_t Rabbitmq_parameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Rabbitmq_proto.Rabbitmq_parameter)
  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 .Rabbitmq_proto.Rabbitmq_channel_queue_consume rabbitmq_reciever_vector = 5;
  total_size += 1UL * this->_internal_rabbitmq_reciever_vector_size();
  for (const auto& msg : this->rabbitmq_reciever_vector_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .Rabbitmq_proto.Rabbitmq_channel_queue_consume rabbitmq_sender_request_vector = 6;
  total_size += 1UL * this->_internal_rabbitmq_sender_request_vector_size();
  for (const auto& msg : this->rabbitmq_sender_request_vector_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .Rabbitmq_proto.Rabbitmq_channel_queue_consume rabbitmq_sender_status_vector = 7;
  total_size += 1UL * this->_internal_rabbitmq_sender_status_vector_size();
  for (const auto& msg : this->rabbitmq_sender_status_vector_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional string ip = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_ip());
    }

    // optional string user = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_user());
    }

    // optional string password = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_password());
    }

    // optional int32 port = 2;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_port());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Rabbitmq_parameter::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:Rabbitmq_proto.Rabbitmq_parameter)
  GOOGLE_DCHECK_NE(&from, this);
  const Rabbitmq_parameter* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Rabbitmq_parameter>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:Rabbitmq_proto.Rabbitmq_parameter)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:Rabbitmq_proto.Rabbitmq_parameter)
    MergeFrom(*source);
  }
}

void Rabbitmq_parameter::MergeFrom(const Rabbitmq_parameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Rabbitmq_proto.Rabbitmq_parameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  rabbitmq_reciever_vector_.MergeFrom(from.rabbitmq_reciever_vector_);
  rabbitmq_sender_request_vector_.MergeFrom(from.rabbitmq_sender_request_vector_);
  rabbitmq_sender_status_vector_.MergeFrom(from.rabbitmq_sender_status_vector_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_ip(from._internal_ip());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_set_user(from._internal_user());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_set_password(from._internal_password());
    }
    if (cached_has_bits & 0x00000008u) {
      port_ = from.port_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void Rabbitmq_parameter::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:Rabbitmq_proto.Rabbitmq_parameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void Rabbitmq_parameter::InternalSwap(Rabbitmq_parameter* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  rabbitmq_reciever_vector_.InternalSwap(&other->rabbitmq_reciever_vector_);
  rabbitmq_sender_request_vector_.InternalSwap(&other->rabbitmq_sender_request_vector_);
  rabbitmq_sender_status_vector_.InternalSwap(&other->rabbitmq_sender_status_vector_);
  ip_.Swap(&other->ip_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  user_.Swap(&other->user_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  password_.Swap(&other->password_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  swap(port_, other->port_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Rabbitmq_parameter::GetMetadata() const {
  return GetMetadataStatic();
}


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

void Rabbitmq_parameter_all::InitAsDefaultInstance() {
  ::Rabbitmq_proto::_Rabbitmq_parameter_all_default_instance_._instance.get_mutable()->rabbitmq_parameters_ = const_cast< ::Rabbitmq_proto::Rabbitmq_parameter*>(
      ::Rabbitmq_proto::Rabbitmq_parameter::internal_default_instance());
}
class Rabbitmq_parameter_all::_Internal {
 public:
  using HasBits = decltype(std::declval<Rabbitmq_parameter_all>()._has_bits_);
  static const ::Rabbitmq_proto::Rabbitmq_parameter& rabbitmq_parameters(const Rabbitmq_parameter_all* msg);
  static void set_has_rabbitmq_parameters(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::Rabbitmq_proto::Rabbitmq_parameter&
Rabbitmq_parameter_all::_Internal::rabbitmq_parameters(const Rabbitmq_parameter_all* msg) {
  return *msg->rabbitmq_parameters_;
}
Rabbitmq_parameter_all::Rabbitmq_parameter_all(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:Rabbitmq_proto.Rabbitmq_parameter_all)
}
Rabbitmq_parameter_all::Rabbitmq_parameter_all(const Rabbitmq_parameter_all& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_rabbitmq_parameters()) {
    rabbitmq_parameters_ = new ::Rabbitmq_proto::Rabbitmq_parameter(*from.rabbitmq_parameters_);
  } else {
    rabbitmq_parameters_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:Rabbitmq_proto.Rabbitmq_parameter_all)
}

void Rabbitmq_parameter_all::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Rabbitmq_parameter_all_rabbitmq_2eproto.base);
  rabbitmq_parameters_ = nullptr;
}

Rabbitmq_parameter_all::~Rabbitmq_parameter_all() {
  // @@protoc_insertion_point(destructor:Rabbitmq_proto.Rabbitmq_parameter_all)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void Rabbitmq_parameter_all::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete rabbitmq_parameters_;
}

void Rabbitmq_parameter_all::ArenaDtor(void* object) {
  Rabbitmq_parameter_all* _this = reinterpret_cast< Rabbitmq_parameter_all* >(object);
  (void)_this;
}
void Rabbitmq_parameter_all::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Rabbitmq_parameter_all::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const Rabbitmq_parameter_all& Rabbitmq_parameter_all::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Rabbitmq_parameter_all_rabbitmq_2eproto.base);
  return *internal_default_instance();
}


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

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(rabbitmq_parameters_ != nullptr);
    rabbitmq_parameters_->Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Rabbitmq_parameter_all::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .Rabbitmq_proto.Rabbitmq_parameter rabbitmq_parameters = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_rabbitmq_parameters(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  cached_has_bits = _has_bits_[0];
  // optional .Rabbitmq_proto.Rabbitmq_parameter rabbitmq_parameters = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::rabbitmq_parameters(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Rabbitmq_proto.Rabbitmq_parameter_all)
  return target;
}

size_t Rabbitmq_parameter_all::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Rabbitmq_proto.Rabbitmq_parameter_all)
  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;

  // optional .Rabbitmq_proto.Rabbitmq_parameter rabbitmq_parameters = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *rabbitmq_parameters_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Rabbitmq_parameter_all::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:Rabbitmq_proto.Rabbitmq_parameter_all)
  GOOGLE_DCHECK_NE(&from, this);
  const Rabbitmq_parameter_all* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Rabbitmq_parameter_all>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:Rabbitmq_proto.Rabbitmq_parameter_all)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:Rabbitmq_proto.Rabbitmq_parameter_all)
    MergeFrom(*source);
  }
}

void Rabbitmq_parameter_all::MergeFrom(const Rabbitmq_parameter_all& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Rabbitmq_proto.Rabbitmq_parameter_all)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_rabbitmq_parameters()) {
    _internal_mutable_rabbitmq_parameters()->::Rabbitmq_proto::Rabbitmq_parameter::MergeFrom(from._internal_rabbitmq_parameters());
  }
}

void Rabbitmq_parameter_all::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:Rabbitmq_proto.Rabbitmq_parameter_all)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

void Rabbitmq_parameter_all::InternalSwap(Rabbitmq_parameter_all* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(rabbitmq_parameters_, other->rabbitmq_parameters_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Rabbitmq_parameter_all::GetMetadata() const {
  return GetMetadataStatic();
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace Rabbitmq_proto
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::Rabbitmq_proto::Rabbitmq_channel_queue_consume* Arena::CreateMaybeMessage< ::Rabbitmq_proto::Rabbitmq_channel_queue_consume >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Rabbitmq_proto::Rabbitmq_channel_queue_consume >(arena);
}
template<> PROTOBUF_NOINLINE ::Rabbitmq_proto::Rabbitmq_parameter* Arena::CreateMaybeMessage< ::Rabbitmq_proto::Rabbitmq_parameter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Rabbitmq_proto::Rabbitmq_parameter >(arena);
}
template<> PROTOBUF_NOINLINE ::Rabbitmq_proto::Rabbitmq_parameter_all* Arena::CreateMaybeMessage< ::Rabbitmq_proto::Rabbitmq_parameter_all >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Rabbitmq_proto::Rabbitmq_parameter_all >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

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