customer_service.pb.cc

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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "customer_service.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.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>
#include <grpc++/async_unary_call.h>
#include <grpc++/channel_interface.h>
#include <grpc++/impl/client_unary_call.h>
#include <grpc++/impl/rpc_method.h>
#include <grpc++/impl/rpc_service_method.h>
#include <grpc++/impl/service_type.h>
#include <grpc++/stream.h>
// @@protoc_insertion_point(includes)

namespace proto {

namespace {

const ::google::protobuf::Descriptor* ResponseType_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ResponseType_reflection_ = NULL;
const ::google::protobuf::Descriptor* RequestType_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  RequestType_reflection_ = NULL;
const ::google::protobuf::Descriptor* Person_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Person_reflection_ = NULL;

}  // namespace


void protobuf_AssignDesc_customer_5fservice_2eproto() {
  protobuf_AddDesc_customer_5fservice_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "customer_service.proto");
  GOOGLE_CHECK(file != NULL);
  ResponseType_descriptor_ = file->message_type(0);
  static const int ResponseType_offsets_[1] = {
  };
  ResponseType_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      ResponseType_descriptor_,
      ResponseType::default_instance_,
      ResponseType_offsets_,
      -1,
      -1,
      -1,
      sizeof(ResponseType),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResponseType, _internal_metadata_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResponseType, _is_default_instance_));
  RequestType_descriptor_ = file->message_type(1);
  static const int RequestType_offsets_[1] = {
  };
  RequestType_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      RequestType_descriptor_,
      RequestType::default_instance_,
      RequestType_offsets_,
      -1,
      -1,
      -1,
      sizeof(RequestType),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RequestType, _internal_metadata_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RequestType, _is_default_instance_));
  Person_descriptor_ = file->message_type(2);
  static const int Person_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Person, name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Person, age_),
  };
  Person_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      Person_descriptor_,
      Person::default_instance_,
      Person_offsets_,
      -1,
      -1,
      -1,
      sizeof(Person),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Person, _internal_metadata_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Person, _is_default_instance_));
}

namespace {

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
inline void protobuf_AssignDescriptorsOnce() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                 &protobuf_AssignDesc_customer_5fservice_2eproto);
}

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      ResponseType_descriptor_, &ResponseType::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      RequestType_descriptor_, &RequestType::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      Person_descriptor_, &Person::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_customer_5fservice_2eproto() {
  delete ResponseType::default_instance_;
  delete ResponseType_reflection_;
  delete RequestType::default_instance_;
  delete RequestType_reflection_;
  delete Person::default_instance_;
  delete Person_reflection_;
}

void protobuf_AddDesc_customer_5fservice_2eproto() {
  static bool already_here = false;
  if (already_here) return;
  already_here = true;
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\026customer_service.proto\022\005proto\"\016\n\014Respo"
    "nseType\"\r\n\013RequestType\"#\n\006Person\022\014\n\004name"
    "\030\001 \001(\t\022\013\n\003age\030\002 \001(\0052y\n\017CustomerService\0223"
    "\n\nListPerson\022\022.proto.RequestType\032\r.proto"
    ".Person\"\0000\001\0221\n\tAddPerson\022\r.proto.Person\032"
    "\023.proto.ResponseType\"\000b\006proto3", 230);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "customer_service.proto", &protobuf_RegisterTypes);
  ResponseType::default_instance_ = new ResponseType();
  RequestType::default_instance_ = new RequestType();
  Person::default_instance_ = new Person();
  ResponseType::default_instance_->InitAsDefaultInstance();
  RequestType::default_instance_->InitAsDefaultInstance();
  Person::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_customer_5fservice_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_customer_5fservice_2eproto {
  StaticDescriptorInitializer_customer_5fservice_2eproto() {
    protobuf_AddDesc_customer_5fservice_2eproto();
  }
} static_descriptor_initializer_customer_5fservice_2eproto_;

namespace {

static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD;
static void MergeFromFail(int line) {
  GOOGLE_CHECK(false) << __FILE__ << ":" << line;
}

}  // namespace


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

#ifndef _MSC_VER
#endif  // !_MSC_VER

ResponseType::ResponseType()
  : ::google::protobuf::Message() , _internal_metadata_(NULL)  {
  SharedCtor();
  // @@protoc_insertion_point(constructor:proto.ResponseType)
}

void ResponseType::InitAsDefaultInstance() {
  _is_default_instance_ = true;
}

ResponseType::ResponseType(const ResponseType& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:proto.ResponseType)
}

void ResponseType::SharedCtor() {
    _is_default_instance_ = false;
  _cached_size_ = 0;
}

ResponseType::~ResponseType() {
  // @@protoc_insertion_point(destructor:proto.ResponseType)
  SharedDtor();
}

void ResponseType::SharedDtor() {
  if (this != default_instance_) {
  }
}

void ResponseType::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ResponseType::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ResponseType_descriptor_;
}

const ResponseType& ResponseType::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_customer_5fservice_2eproto();
  return *default_instance_;
}

ResponseType* ResponseType::default_instance_ = NULL;

ResponseType* ResponseType::New(::google::protobuf::Arena* arena) const {
  ResponseType* n = new ResponseType;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ResponseType::Clear() {
}

bool ResponseType::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:proto.ResponseType)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0 ||
        ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
        ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
  }
success:
  // @@protoc_insertion_point(parse_success:proto.ResponseType)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:proto.ResponseType)
  return false;
#undef DO_
}

void ResponseType::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:proto.ResponseType)
  // @@protoc_insertion_point(serialize_end:proto.ResponseType)
}

::google::protobuf::uint8* ResponseType::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:proto.ResponseType)
  // @@protoc_insertion_point(serialize_to_array_end:proto.ResponseType)
  return target;
}

int ResponseType::ByteSize() const {
  int total_size = 0;

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ResponseType::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const ResponseType* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ResponseType*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ResponseType::MergeFrom(const ResponseType& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
}

void ResponseType::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ResponseType::CopyFrom(const ResponseType& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ResponseType::IsInitialized() const {

  return true;
}

void ResponseType::Swap(ResponseType* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ResponseType::InternalSwap(ResponseType* other) {
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ResponseType::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ResponseType_descriptor_;
  metadata.reflection = ResponseType_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
#endif  // !_MSC_VER

RequestType::RequestType()
  : ::google::protobuf::Message() , _internal_metadata_(NULL)  {
  SharedCtor();
  // @@protoc_insertion_point(constructor:proto.RequestType)
}

void RequestType::InitAsDefaultInstance() {
  _is_default_instance_ = true;
}

RequestType::RequestType(const RequestType& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:proto.RequestType)
}

void RequestType::SharedCtor() {
    _is_default_instance_ = false;
  _cached_size_ = 0;
}

RequestType::~RequestType() {
  // @@protoc_insertion_point(destructor:proto.RequestType)
  SharedDtor();
}

void RequestType::SharedDtor() {
  if (this != default_instance_) {
  }
}

void RequestType::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RequestType::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return RequestType_descriptor_;
}

const RequestType& RequestType::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_customer_5fservice_2eproto();
  return *default_instance_;
}

RequestType* RequestType::default_instance_ = NULL;

RequestType* RequestType::New(::google::protobuf::Arena* arena) const {
  RequestType* n = new RequestType;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RequestType::Clear() {
}

bool RequestType::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:proto.RequestType)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0 ||
        ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
        ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
  }
success:
  // @@protoc_insertion_point(parse_success:proto.RequestType)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:proto.RequestType)
  return false;
#undef DO_
}

void RequestType::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:proto.RequestType)
  // @@protoc_insertion_point(serialize_end:proto.RequestType)
}

::google::protobuf::uint8* RequestType::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:proto.RequestType)
  // @@protoc_insertion_point(serialize_to_array_end:proto.RequestType)
  return target;
}

int RequestType::ByteSize() const {
  int total_size = 0;

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RequestType::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const RequestType* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const RequestType*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void RequestType::MergeFrom(const RequestType& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
}

void RequestType::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RequestType::CopyFrom(const RequestType& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RequestType::IsInitialized() const {

  return true;
}

void RequestType::Swap(RequestType* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RequestType::InternalSwap(RequestType* other) {
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RequestType::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = RequestType_descriptor_;
  metadata.reflection = RequestType_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int Person::kNameFieldNumber;
const int Person::kAgeFieldNumber;
#endif  // !_MSC_VER

Person::Person()
  : ::google::protobuf::Message() , _internal_metadata_(NULL)  {
  SharedCtor();
  // @@protoc_insertion_point(constructor:proto.Person)
}

void Person::InitAsDefaultInstance() {
  _is_default_instance_ = true;
}

Person::Person(const Person& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:proto.Person)
}

void Person::SharedCtor() {
    _is_default_instance_ = false;
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  age_ = 0;
}

Person::~Person() {
  // @@protoc_insertion_point(destructor:proto.Person)
  SharedDtor();
}

void Person::SharedDtor() {
  name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != default_instance_) {
  }
}

void Person::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Person::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Person_descriptor_;
}

const Person& Person::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_customer_5fservice_2eproto();
  return *default_instance_;
}

Person* Person::default_instance_ = NULL;

Person* Person::New(::google::protobuf::Arena* arena) const {
  Person* n = new Person;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void Person::Clear() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  age_ = 0;
}

bool Person::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:proto.Person)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string name = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "proto.Person.name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_age;
        break;
      }

      // optional int32 age = 2;
      case 2: {
        if (tag == 16) {
         parse_age:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &age_)));

        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:proto.Person)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:proto.Person)
  return false;
#undef DO_
}

void Person::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:proto.Person)
  // optional string name = 1;
  if (this->name().size() > 0) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "proto.Person.name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

  // optional int32 age = 2;
  if (this->age() != 0) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->age(), output);
  }

  // @@protoc_insertion_point(serialize_end:proto.Person)
}

::google::protobuf::uint8* Person::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:proto.Person)
  // optional string name = 1;
  if (this->name().size() > 0) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "proto.Person.name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->name(), target);
  }

  // optional int32 age = 2;
  if (this->age() != 0) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->age(), target);
  }

  // @@protoc_insertion_point(serialize_to_array_end:proto.Person)
  return target;
}

int Person::ByteSize() const {
  int total_size = 0;

  // optional string name = 1;
  if (this->name().size() > 0) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->name());
  }

  // optional int32 age = 2;
  if (this->age() != 0) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->age());
  }

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Person::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const Person* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Person*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Person::MergeFrom(const Person& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from.name().size() > 0) {

    name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  if (from.age() != 0) {
    set_age(from.age());
  }
}

void Person::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Person::CopyFrom(const Person& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Person::IsInitialized() const {

  return true;
}

void Person::Swap(Person* other) {
  if (other == this) return;
  InternalSwap(other);
}
void Person::InternalSwap(Person* other) {
  name_.Swap(&other->name_);
  std::swap(age_, other->age_);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata Person::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Person_descriptor_;
  metadata.reflection = Person_reflection_;
  return metadata;
}


static const char* CustomerService_method_names[] = {
  "/proto.CustomerService/ListPerson",
  "/proto.CustomerService/AddPerson",
};

std::unique_ptr< CustomerService::Stub> CustomerService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel) {
  std::unique_ptr< CustomerService::Stub> stub(new CustomerService::Stub());
  stub->set_channel(channel);
  return stub;
}

std::unique_ptr< ::grpc::ClientReader< ::proto::Person>> CustomerService::Stub::ListPerson(::grpc::ClientContext* context, const ::proto::RequestType& request) {
  return std::unique_ptr< ::grpc::ClientReader< ::proto::Person>>(new ::grpc::ClientReader< ::proto::Person>(channel(),::grpc::RpcMethod(CustomerService_method_names[0], ::grpc::RpcMethod::RpcType::SERVER_STREAMING), context, request));
}

std::unique_ptr< ::grpc::ClientAsyncReader< ::proto::Person>> CustomerService::Stub::AsyncListPerson(::grpc::ClientContext* context, const ::proto::RequestType& request, ::grpc::CompletionQueue* cq, void* tag) {
  return std::unique_ptr< ::grpc::ClientAsyncReader< ::proto::Person>>(new ::grpc::ClientAsyncReader< ::proto::Person>(channel(), cq, ::grpc::RpcMethod(CustomerService_method_names[0], ::grpc::RpcMethod::RpcType::SERVER_STREAMING), context, request, tag));
}

::grpc::Status CustomerService::Stub::AddPerson(::grpc::ClientContext* context, const ::proto::Person& request, ::proto::ResponseType* response) {
  return ::grpc::BlockingUnaryCall(channel(),::grpc::RpcMethod(CustomerService_method_names[1]), context, request, response);
}

std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::proto::ResponseType>> CustomerService::Stub::AsyncAddPerson(::grpc::ClientContext* context, const ::proto::Person& request, ::grpc::CompletionQueue* cq, void* tag) {
  return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::proto::ResponseType>>(new ::grpc::ClientAsyncResponseReader< ::proto::ResponseType>(channel(), cq, ::grpc::RpcMethod(CustomerService_method_names[1]), context, request, tag));
}

CustomerService::AsyncService::AsyncService(::grpc::CompletionQueue* cq) : ::grpc::AsynchronousService(cq, CustomerService_method_names, 2) {}

CustomerService::Service::~Service() {
  delete service_;
}

::grpc::Status CustomerService::Service::ListPerson(::grpc::ServerContext* context, const ::proto::RequestType* request, ::grpc::ServerWriter< ::proto::Person>* writer) {
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED);
}

void CustomerService::AsyncService::RequestListPerson(::grpc::ServerContext* context, ::proto::RequestType* request, ::grpc::ServerAsyncWriter< ::proto::Person>* writer, ::grpc::CompletionQueue* cq, void* tag) {
  AsynchronousService::RequestServerStreaming(0, context, request, writer, cq, tag);
}

::grpc::Status CustomerService::Service::AddPerson(::grpc::ServerContext* context, const ::proto::Person* request, ::proto::ResponseType* response) {
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED);
}

void CustomerService::AsyncService::RequestAddPerson(::grpc::ServerContext* context, ::proto::Person* request, ::grpc::ServerAsyncResponseWriter< ::proto::ResponseType>* response, ::grpc::CompletionQueue* cq, void* tag) {
  AsynchronousService::RequestAsyncUnary(1, context, request, response, cq, tag);
}

::grpc::RpcService* CustomerService::Service::service() {
  if (service_ != nullptr) {
    return service_;
  }
  service_ = new ::grpc::RpcService();
  service_->AddMethod(new ::grpc::RpcServiceMethod(
      CustomerService_method_names[0],
      ::grpc::RpcMethod::SERVER_STREAMING,
      new ::grpc::ServerStreamingHandler< CustomerService::Service, ::proto::RequestType, ::proto::Person>(
          std::function< ::grpc::Status(CustomerService::Service*, ::grpc::ServerContext*, const ::proto::RequestType*, ::grpc::ServerWriter< ::proto::Person>*)>(&CustomerService::Service::ListPerson), this),
      new ::proto::RequestType, new ::proto::Person));
  service_->AddMethod(new ::grpc::RpcServiceMethod(
      CustomerService_method_names[1],
      ::grpc::RpcMethod::NORMAL_RPC,
      new ::grpc::RpcMethodHandler< CustomerService::Service, ::proto::Person, ::proto::ResponseType>(
          std::function< ::grpc::Status(CustomerService::Service*, ::grpc::ServerContext*, const ::proto::Person*, ::proto::ResponseType*)>(&CustomerService::Service::AddPerson), this),
      new ::proto::Person, new ::proto::ResponseType));
  return service_;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace proto

// @@protoc_insertion_point(global_scope)