chroot/var/cache/portage/chromeos-base/libbrillo/out/Default/gen/include/bindings/private_membership.pb.cc

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

#include "private_membership.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>
namespace private_membership {
class DoublyEncryptedIdDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<DoublyEncryptedId> _instance;
} _DoublyEncryptedId_default_instance_;
class MembershipResponseDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MembershipResponse> _instance;
} _MembershipResponse_default_instance_;
}  // namespace private_membership
static void InitDefaultsscc_info_DoublyEncryptedId_private_5fmembership_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::private_membership::_DoublyEncryptedId_default_instance_;
    new (ptr) ::private_membership::DoublyEncryptedId();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::private_membership::DoublyEncryptedId::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_MembershipResponse_private_5fmembership_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::private_membership::_MembershipResponse_default_instance_;
    new (ptr) ::private_membership::MembershipResponse();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::private_membership::MembershipResponse::InitAsDefaultInstance();
}

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

namespace private_membership {
bool HashType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> HashType_strings[3] = {};

static const char HashType_names[] =
  "HASH_TYPE_UNDEFINED"
  "SHA256"
  "TEST_HASH_TYPE";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry HashType_entries[] = {
  { {HashType_names + 0, 19}, 0 },
  { {HashType_names + 19, 6}, 2 },
  { {HashType_names + 25, 14}, 1 },
};

static const int HashType_entries_by_number[] = {
  0, // 0 -> HASH_TYPE_UNDEFINED
  2, // 1 -> TEST_HASH_TYPE
  1, // 2 -> SHA256
};

const std::string& HashType_Name(
    HashType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          HashType_entries,
          HashType_entries_by_number,
          3, HashType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      HashType_entries,
      HashType_entries_by_number,
      3, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     HashType_strings[idx].get();
}
bool HashType_Parse(
    const std::string& name, HashType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      HashType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<HashType>(int_value);
  }
  return success;
}
bool EncryptedBucketHashType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 3:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> EncryptedBucketHashType_strings[3] = {};

static const char EncryptedBucketHashType_names[] =
  "ENCRYPTED_BUCKET_HASH_TYPE_UNDEFINED"
  "ENCRYPTED_BUCKET_TEST_HASH_TYPE"
  "SHA256_NON_SENSITIVE_AND_SENSITIVE_ID";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry EncryptedBucketHashType_entries[] = {
  { {EncryptedBucketHashType_names + 0, 36}, 0 },
  { {EncryptedBucketHashType_names + 36, 31}, 3 },
  { {EncryptedBucketHashType_names + 67, 37}, 1 },
};

static const int EncryptedBucketHashType_entries_by_number[] = {
  0, // 0 -> ENCRYPTED_BUCKET_HASH_TYPE_UNDEFINED
  2, // 1 -> SHA256_NON_SENSITIVE_AND_SENSITIVE_ID
  1, // 3 -> ENCRYPTED_BUCKET_TEST_HASH_TYPE
};

const std::string& EncryptedBucketHashType_Name(
    EncryptedBucketHashType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          EncryptedBucketHashType_entries,
          EncryptedBucketHashType_entries_by_number,
          3, EncryptedBucketHashType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      EncryptedBucketHashType_entries,
      EncryptedBucketHashType_entries_by_number,
      3, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     EncryptedBucketHashType_strings[idx].get();
}
bool EncryptedBucketHashType_Parse(
    const std::string& name, EncryptedBucketHashType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      EncryptedBucketHashType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<EncryptedBucketHashType>(int_value);
  }
  return success;
}

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

void DoublyEncryptedId::InitAsDefaultInstance() {
}
class DoublyEncryptedId::_Internal {
 public:
};

DoublyEncryptedId::DoublyEncryptedId()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:private_membership.DoublyEncryptedId)
}
DoublyEncryptedId::DoublyEncryptedId(const DoublyEncryptedId& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  queried_encrypted_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_queried_encrypted_id().empty()) {
    queried_encrypted_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.queried_encrypted_id_);
  }
  doubly_encrypted_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_doubly_encrypted_id().empty()) {
    doubly_encrypted_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.doubly_encrypted_id_);
  }
  // @@protoc_insertion_point(copy_constructor:private_membership.DoublyEncryptedId)
}

void DoublyEncryptedId::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DoublyEncryptedId_private_5fmembership_2eproto.base);
  queried_encrypted_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  doubly_encrypted_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

DoublyEncryptedId::~DoublyEncryptedId() {
  // @@protoc_insertion_point(destructor:private_membership.DoublyEncryptedId)
  SharedDtor();
}

void DoublyEncryptedId::SharedDtor() {
  queried_encrypted_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  doubly_encrypted_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void DoublyEncryptedId::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const DoublyEncryptedId& DoublyEncryptedId::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_DoublyEncryptedId_private_5fmembership_2eproto.base);
  return *internal_default_instance();
}


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

  queried_encrypted_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  doubly_encrypted_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _internal_metadata_.Clear();
}

const char* DoublyEncryptedId::_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);
    CHK_(ptr);
    switch (tag >> 3) {
      // bytes queried_encrypted_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_queried_encrypted_id();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // bytes doubly_encrypted_id = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_doubly_encrypted_id();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          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_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  // bytes queried_encrypted_id = 1;
  if (this->queried_encrypted_id().size() > 0) {
    target = stream->WriteBytesMaybeAliased(
        1, this->_internal_queried_encrypted_id(), target);
  }

  // bytes doubly_encrypted_id = 2;
  if (this->doubly_encrypted_id().size() > 0) {
    target = stream->WriteBytesMaybeAliased(
        2, this->_internal_doubly_encrypted_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:private_membership.DoublyEncryptedId)
  return target;
}

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

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

  // bytes queried_encrypted_id = 1;
  if (this->queried_encrypted_id().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_queried_encrypted_id());
  }

  // bytes doubly_encrypted_id = 2;
  if (this->doubly_encrypted_id().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_doubly_encrypted_id());
  }

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

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

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

  if (from.queried_encrypted_id().size() > 0) {

    queried_encrypted_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.queried_encrypted_id_);
  }
  if (from.doubly_encrypted_id().size() > 0) {

    doubly_encrypted_id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.doubly_encrypted_id_);
  }
}

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

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

void DoublyEncryptedId::InternalSwap(DoublyEncryptedId* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  queried_encrypted_id_.Swap(&other->queried_encrypted_id_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  doubly_encrypted_id_.Swap(&other->doubly_encrypted_id_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
}

std::string DoublyEncryptedId::GetTypeName() const {
  return "private_membership.DoublyEncryptedId";
}


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

void MembershipResponse::InitAsDefaultInstance() {
}
class MembershipResponse::_Internal {
 public:
};

MembershipResponse::MembershipResponse()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:private_membership.MembershipResponse)
}
MembershipResponse::MembershipResponse(const MembershipResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_value().empty()) {
    value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_);
  }
  is_member_ = from.is_member_;
  // @@protoc_insertion_point(copy_constructor:private_membership.MembershipResponse)
}

void MembershipResponse::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_MembershipResponse_private_5fmembership_2eproto.base);
  value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  is_member_ = false;
}

MembershipResponse::~MembershipResponse() {
  // @@protoc_insertion_point(destructor:private_membership.MembershipResponse)
  SharedDtor();
}

void MembershipResponse::SharedDtor() {
  value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void MembershipResponse::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const MembershipResponse& MembershipResponse::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_MembershipResponse_private_5fmembership_2eproto.base);
  return *internal_default_instance();
}


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

  value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  is_member_ = false;
  _internal_metadata_.Clear();
}

const char* MembershipResponse::_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);
    CHK_(ptr);
    switch (tag >> 3) {
      // bool is_member = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          is_member_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // string value = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_value();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr));
          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_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  // bool is_member = 1;
  if (this->is_member() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_is_member(), target);
  }

  // string value = 2;
  if (this->value().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_value().data(), static_cast<int>(this->_internal_value().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "private_membership.MembershipResponse.value");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_value(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(),
        static_cast<int>(_internal_metadata_.unknown_fields().size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:private_membership.MembershipResponse)
  return target;
}

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

  // string value = 2;
  if (this->value().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_value());
  }

  // bool is_member = 1;
  if (this->is_member() != 0) {
    total_size += 1 + 1;
  }

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

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

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

  if (from.value().size() > 0) {

    value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_);
  }
  if (from.is_member() != 0) {
    _internal_set_is_member(from._internal_is_member());
  }
}

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

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

void MembershipResponse::InternalSwap(MembershipResponse* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(is_member_, other->is_member_);
}

std::string MembershipResponse::GetTypeName() const {
  return "private_membership.MembershipResponse";
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace private_membership
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::private_membership::DoublyEncryptedId* Arena::CreateMaybeMessage< ::private_membership::DoublyEncryptedId >(Arena* arena) {
  return Arena::CreateInternal< ::private_membership::DoublyEncryptedId >(arena);
}
template<> PROTOBUF_NOINLINE ::private_membership::MembershipResponse* Arena::CreateMaybeMessage< ::private_membership::MembershipResponse >(Arena* arena) {
  return Arena::CreateInternal< ::private_membership::MembershipResponse >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

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