From 36a4930ef0fb9d27b0af033f8d3ded194d42fa51 Mon Sep 17 00:00:00 2001 From: Dan Buch Date: Mon, 7 May 2012 22:07:19 -0400 Subject: [PATCH] Generating c++ code, starting a Makefile --- protobuf/Makefile | 9 + protobuf/src/tutorial/addressbook.pb.cc | 1023 +++++++++++++++++++++++ protobuf/src/tutorial/addressbook.pb.h | 694 +++++++++++++++ 3 files changed, 1726 insertions(+) create mode 100644 protobuf/Makefile create mode 100644 protobuf/src/tutorial/addressbook.pb.cc create mode 100644 protobuf/src/tutorial/addressbook.pb.h diff --git a/protobuf/Makefile b/protobuf/Makefile new file mode 100644 index 0000000..c3771cc --- /dev/null +++ b/protobuf/Makefile @@ -0,0 +1,9 @@ +PROTOC := $(PWD)/bin/protoc +TARGETS := $(patsubst %.proto,%.pb.cc,$(shell find src -name '*.proto')) + + +%.pb.cc:%.proto + $(PROTOC) -I=$(shell dirname $^) --cpp_out=$(shell dirname $^) $^ + + +all: $(TARGETS) diff --git a/protobuf/src/tutorial/addressbook.pb.cc b/protobuf/src/tutorial/addressbook.pb.cc new file mode 100644 index 0000000..9b34141 --- /dev/null +++ b/protobuf/src/tutorial/addressbook.pb.cc @@ -0,0 +1,1023 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "addressbook.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace tutorial { + +namespace { + +const ::google::protobuf::Descriptor* Person_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Person_reflection_ = NULL; +const ::google::protobuf::Descriptor* Person_PhoneNumber_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + Person_PhoneNumber_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* Person_PhoneType_descriptor_ = NULL; +const ::google::protobuf::Descriptor* AddressBook_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + AddressBook_reflection_ = NULL; + +} // namespace + + +void protobuf_AssignDesc_addressbook_2eproto() { + protobuf_AddDesc_addressbook_2eproto(); + const ::google::protobuf::FileDescriptor* file = + ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( + "addressbook.proto"); + GOOGLE_CHECK(file != NULL); + Person_descriptor_ = file->message_type(0); + static const int Person_offsets_[4] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Person, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Person, id_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Person, email_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Person, phone_), + }; + Person_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Person_descriptor_, + Person::default_instance_, + Person_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Person, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Person, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Person)); + Person_PhoneNumber_descriptor_ = Person_descriptor_->nested_type(0); + static const int Person_PhoneNumber_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Person_PhoneNumber, number_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Person_PhoneNumber, type_), + }; + Person_PhoneNumber_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + Person_PhoneNumber_descriptor_, + Person_PhoneNumber::default_instance_, + Person_PhoneNumber_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Person_PhoneNumber, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Person_PhoneNumber, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(Person_PhoneNumber)); + Person_PhoneType_descriptor_ = Person_descriptor_->enum_type(0); + AddressBook_descriptor_ = file->message_type(1); + static const int AddressBook_offsets_[1] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressBook, person_), + }; + AddressBook_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + AddressBook_descriptor_, + AddressBook::default_instance_, + AddressBook_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressBook, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressBook, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(AddressBook)); +} + +namespace { + +GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); +inline void protobuf_AssignDescriptorsOnce() { + ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, + &protobuf_AssignDesc_addressbook_2eproto); +} + +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Person_descriptor_, &Person::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + Person_PhoneNumber_descriptor_, &Person_PhoneNumber::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + AddressBook_descriptor_, &AddressBook::default_instance()); +} + +} // namespace + +void protobuf_ShutdownFile_addressbook_2eproto() { + delete Person::default_instance_; + delete Person_reflection_; + delete Person_PhoneNumber::default_instance_; + delete Person_PhoneNumber_reflection_; + delete AddressBook::default_instance_; + delete AddressBook_reflection_; +} + +void protobuf_AddDesc_addressbook_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + "\n\021addressbook.proto\022\010tutorial\"\332\001\n\006Person" + "\022\014\n\004name\030\001 \002(\t\022\n\n\002id\030\002 \002(\005\022\r\n\005email\030\003 \001(" + "\t\022+\n\005phone\030\004 \003(\0132\034.tutorial.Person.Phone" + "Number\032M\n\013PhoneNumber\022\016\n\006number\030\001 \002(\t\022.\n" + "\004type\030\002 \001(\0162\032.tutorial.Person.PhoneType:" + "\004HOME\"+\n\tPhoneType\022\n\n\006MOBILE\020\000\022\010\n\004HOME\020\001" + "\022\010\n\004WORK\020\002\"/\n\013AddressBook\022 \n\006person\030\001 \003(" + "\0132\020.tutorial.Person", 299); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "addressbook.proto", &protobuf_RegisterTypes); + Person::default_instance_ = new Person(); + Person_PhoneNumber::default_instance_ = new Person_PhoneNumber(); + AddressBook::default_instance_ = new AddressBook(); + Person::default_instance_->InitAsDefaultInstance(); + Person_PhoneNumber::default_instance_->InitAsDefaultInstance(); + AddressBook::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_addressbook_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_addressbook_2eproto { + StaticDescriptorInitializer_addressbook_2eproto() { + protobuf_AddDesc_addressbook_2eproto(); + } +} static_descriptor_initializer_addressbook_2eproto_; + + +// =================================================================== + +const ::google::protobuf::EnumDescriptor* Person_PhoneType_descriptor() { + protobuf_AssignDescriptorsOnce(); + return Person_PhoneType_descriptor_; +} +bool Person_PhoneType_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#ifndef _MSC_VER +const Person_PhoneType Person::MOBILE; +const Person_PhoneType Person::HOME; +const Person_PhoneType Person::WORK; +const Person_PhoneType Person::PhoneType_MIN; +const Person_PhoneType Person::PhoneType_MAX; +const int Person::PhoneType_ARRAYSIZE; +#endif // _MSC_VER +#ifndef _MSC_VER +const int Person_PhoneNumber::kNumberFieldNumber; +const int Person_PhoneNumber::kTypeFieldNumber; +#endif // !_MSC_VER + +Person_PhoneNumber::Person_PhoneNumber() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void Person_PhoneNumber::InitAsDefaultInstance() { +} + +Person_PhoneNumber::Person_PhoneNumber(const Person_PhoneNumber& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void Person_PhoneNumber::SharedCtor() { + _cached_size_ = 0; + number_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + type_ = 1; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Person_PhoneNumber::~Person_PhoneNumber() { + SharedDtor(); +} + +void Person_PhoneNumber::SharedDtor() { + if (number_ != &::google::protobuf::internal::kEmptyString) { + delete number_; + } + if (this != default_instance_) { + } +} + +void Person_PhoneNumber::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* Person_PhoneNumber::descriptor() { + protobuf_AssignDescriptorsOnce(); + return Person_PhoneNumber_descriptor_; +} + +const Person_PhoneNumber& Person_PhoneNumber::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_addressbook_2eproto(); return *default_instance_; +} + +Person_PhoneNumber* Person_PhoneNumber::default_instance_ = NULL; + +Person_PhoneNumber* Person_PhoneNumber::New() const { + return new Person_PhoneNumber; +} + +void Person_PhoneNumber::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_number()) { + if (number_ != &::google::protobuf::internal::kEmptyString) { + number_->clear(); + } + } + type_ = 1; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Person_PhoneNumber::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string number = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_number())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->number().data(), this->number().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_type; + break; + } + + // optional .tutorial.Person.PhoneType type = 2 [default = HOME]; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_type: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::tutorial::Person_PhoneType_IsValid(value)) { + set_type(static_cast< ::tutorial::Person_PhoneType >(value)); + } else { + mutable_unknown_fields()->AddVarint(2, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void Person_PhoneNumber::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string number = 1; + if (has_number()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->number().data(), this->number().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->number(), output); + } + + // optional .tutorial.Person.PhoneType type = 2 [default = HOME]; + if (has_type()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 2, this->type(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* Person_PhoneNumber::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string number = 1; + if (has_number()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->number().data(), this->number().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->number(), target); + } + + // optional .tutorial.Person.PhoneType type = 2 [default = HOME]; + if (has_type()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 2, this->type(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int Person_PhoneNumber::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string number = 1; + if (has_number()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->number()); + } + + // optional .tutorial.Person.PhoneType type = 2 [default = HOME]; + if (has_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->type()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void Person_PhoneNumber::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const Person_PhoneNumber* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Person_PhoneNumber::MergeFrom(const Person_PhoneNumber& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_number()) { + set_number(from.number()); + } + if (from.has_type()) { + set_type(from.type()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void Person_PhoneNumber::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Person_PhoneNumber::CopyFrom(const Person_PhoneNumber& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Person_PhoneNumber::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void Person_PhoneNumber::Swap(Person_PhoneNumber* other) { + if (other != this) { + std::swap(number_, other->number_); + std::swap(type_, other->type_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata Person_PhoneNumber::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = Person_PhoneNumber_descriptor_; + metadata.reflection = Person_PhoneNumber_reflection_; + return metadata; +} + + +// ------------------------------------------------------------------- + +#ifndef _MSC_VER +const int Person::kNameFieldNumber; +const int Person::kIdFieldNumber; +const int Person::kEmailFieldNumber; +const int Person::kPhoneFieldNumber; +#endif // !_MSC_VER + +Person::Person() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void Person::InitAsDefaultInstance() { +} + +Person::Person(const Person& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void Person::SharedCtor() { + _cached_size_ = 0; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + id_ = 0; + email_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +Person::~Person() { + SharedDtor(); +} + +void Person::SharedDtor() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (email_ != &::google::protobuf::internal::kEmptyString) { + delete email_; + } + 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_addressbook_2eproto(); return *default_instance_; +} + +Person* Person::default_instance_ = NULL; + +Person* Person::New() const { + return new Person; +} + +void Person::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_name()) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + } + id_ = 0; + if (has_email()) { + if (email_ != &::google::protobuf::internal::kEmptyString) { + email_->clear(); + } + } + } + phone_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool Person::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_id; + break; + } + + // required int32 id = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_id: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &id_))); + set_has_id(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_email; + break; + } + + // optional string email = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_email: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_email())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->email().data(), this->email().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(34)) goto parse_phone; + break; + } + + // repeated .tutorial.Person.PhoneNumber phone = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_phone: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_phone())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(34)) goto parse_phone; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void Person::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->name(), output); + } + + // required int32 id = 2; + if (has_id()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->id(), output); + } + + // optional string email = 3; + if (has_email()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->email().data(), this->email().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->email(), output); + } + + // repeated .tutorial.Person.PhoneNumber phone = 4; + for (int i = 0; i < this->phone_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->phone(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* Person::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->name(), target); + } + + // required int32 id = 2; + if (has_id()) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->id(), target); + } + + // optional string email = 3; + if (has_email()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->email().data(), this->email().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->email(), target); + } + + // repeated .tutorial.Person.PhoneNumber phone = 4; + for (int i = 0; i < this->phone_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->phone(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int Person::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string name = 1; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // required int32 id = 2; + if (has_id()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->id()); + } + + // optional string email = 3; + if (has_email()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->email()); + } + + } + // repeated .tutorial.Person.PhoneNumber phone = 4; + total_size += 1 * this->phone_size(); + for (int i = 0; i < this->phone_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->phone(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + 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) { + GOOGLE_CHECK_NE(&from, this); + const Person* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void Person::MergeFrom(const Person& from) { + GOOGLE_CHECK_NE(&from, this); + phone_.MergeFrom(from.phone_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_name()) { + set_name(from.name()); + } + if (from.has_id()) { + set_id(from.id()); + } + if (from.has_email()) { + set_email(from.email()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +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 { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + for (int i = 0; i < phone_size(); i++) { + if (!this->phone(i).IsInitialized()) return false; + } + return true; +} + +void Person::Swap(Person* other) { + if (other != this) { + std::swap(name_, other->name_); + std::swap(id_, other->id_); + std::swap(email_, other->email_); + phone_.Swap(&other->phone_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + 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; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AddressBook::kPersonFieldNumber; +#endif // !_MSC_VER + +AddressBook::AddressBook() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void AddressBook::InitAsDefaultInstance() { +} + +AddressBook::AddressBook(const AddressBook& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void AddressBook::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AddressBook::~AddressBook() { + SharedDtor(); +} + +void AddressBook::SharedDtor() { + if (this != default_instance_) { + } +} + +void AddressBook::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AddressBook::descriptor() { + protobuf_AssignDescriptorsOnce(); + return AddressBook_descriptor_; +} + +const AddressBook& AddressBook::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_addressbook_2eproto(); return *default_instance_; +} + +AddressBook* AddressBook::default_instance_ = NULL; + +AddressBook* AddressBook::New() const { + return new AddressBook; +} + +void AddressBook::Clear() { + person_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool AddressBook::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .tutorial.Person person = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_person: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_person())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(10)) goto parse_person; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void AddressBook::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // repeated .tutorial.Person person = 1; + for (int i = 0; i < this->person_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->person(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* AddressBook::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // repeated .tutorial.Person person = 1; + for (int i = 0; i < this->person_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 1, this->person(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int AddressBook::ByteSize() const { + int total_size = 0; + + // repeated .tutorial.Person person = 1; + total_size += 1 * this->person_size(); + for (int i = 0; i < this->person_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->person(i)); + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void AddressBook::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const AddressBook* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void AddressBook::MergeFrom(const AddressBook& from) { + GOOGLE_CHECK_NE(&from, this); + person_.MergeFrom(from.person_); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void AddressBook::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AddressBook::CopyFrom(const AddressBook& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AddressBook::IsInitialized() const { + + for (int i = 0; i < person_size(); i++) { + if (!this->person(i).IsInitialized()) return false; + } + return true; +} + +void AddressBook::Swap(AddressBook* other) { + if (other != this) { + person_.Swap(&other->person_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata AddressBook::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = AddressBook_descriptor_; + metadata.reflection = AddressBook_reflection_; + return metadata; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace tutorial + +// @@protoc_insertion_point(global_scope) diff --git a/protobuf/src/tutorial/addressbook.pb.h b/protobuf/src/tutorial/addressbook.pb.h new file mode 100644 index 0000000..479a1fa --- /dev/null +++ b/protobuf/src/tutorial/addressbook.pb.h @@ -0,0 +1,694 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: addressbook.proto + +#ifndef PROTOBUF_addressbook_2eproto__INCLUDED +#define PROTOBUF_addressbook_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2004000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2004001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +// @@protoc_insertion_point(includes) + +namespace tutorial { + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_addressbook_2eproto(); +void protobuf_AssignDesc_addressbook_2eproto(); +void protobuf_ShutdownFile_addressbook_2eproto(); + +class Person; +class Person_PhoneNumber; +class AddressBook; + +enum Person_PhoneType { + Person_PhoneType_MOBILE = 0, + Person_PhoneType_HOME = 1, + Person_PhoneType_WORK = 2 +}; +bool Person_PhoneType_IsValid(int value); +const Person_PhoneType Person_PhoneType_PhoneType_MIN = Person_PhoneType_MOBILE; +const Person_PhoneType Person_PhoneType_PhoneType_MAX = Person_PhoneType_WORK; +const int Person_PhoneType_PhoneType_ARRAYSIZE = Person_PhoneType_PhoneType_MAX + 1; + +const ::google::protobuf::EnumDescriptor* Person_PhoneType_descriptor(); +inline const ::std::string& Person_PhoneType_Name(Person_PhoneType value) { + return ::google::protobuf::internal::NameOfEnum( + Person_PhoneType_descriptor(), value); +} +inline bool Person_PhoneType_Parse( + const ::std::string& name, Person_PhoneType* value) { + return ::google::protobuf::internal::ParseNamedEnum( + Person_PhoneType_descriptor(), name, value); +} +// =================================================================== + +class Person_PhoneNumber : public ::google::protobuf::Message { + public: + Person_PhoneNumber(); + virtual ~Person_PhoneNumber(); + + Person_PhoneNumber(const Person_PhoneNumber& from); + + inline Person_PhoneNumber& operator=(const Person_PhoneNumber& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Person_PhoneNumber& default_instance(); + + void Swap(Person_PhoneNumber* other); + + // implements Message ---------------------------------------------- + + Person_PhoneNumber* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Person_PhoneNumber& from); + void MergeFrom(const Person_PhoneNumber& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string number = 1; + inline bool has_number() const; + inline void clear_number(); + static const int kNumberFieldNumber = 1; + inline const ::std::string& number() const; + inline void set_number(const ::std::string& value); + inline void set_number(const char* value); + inline void set_number(const char* value, size_t size); + inline ::std::string* mutable_number(); + inline ::std::string* release_number(); + + // optional .tutorial.Person.PhoneType type = 2 [default = HOME]; + inline bool has_type() const; + inline void clear_type(); + static const int kTypeFieldNumber = 2; + inline ::tutorial::Person_PhoneType type() const; + inline void set_type(::tutorial::Person_PhoneType value); + + // @@protoc_insertion_point(class_scope:tutorial.Person.PhoneNumber) + private: + inline void set_has_number(); + inline void clear_has_number(); + inline void set_has_type(); + inline void clear_has_type(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* number_; + int type_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_addressbook_2eproto(); + friend void protobuf_AssignDesc_addressbook_2eproto(); + friend void protobuf_ShutdownFile_addressbook_2eproto(); + + void InitAsDefaultInstance(); + static Person_PhoneNumber* default_instance_; +}; +// ------------------------------------------------------------------- + +class Person : public ::google::protobuf::Message { + public: + Person(); + virtual ~Person(); + + Person(const Person& from); + + inline Person& operator=(const Person& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const Person& default_instance(); + + void Swap(Person* other); + + // implements Message ---------------------------------------------- + + Person* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const Person& from); + void MergeFrom(const Person& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + typedef Person_PhoneNumber PhoneNumber; + + typedef Person_PhoneType PhoneType; + static const PhoneType MOBILE = Person_PhoneType_MOBILE; + static const PhoneType HOME = Person_PhoneType_HOME; + static const PhoneType WORK = Person_PhoneType_WORK; + static inline bool PhoneType_IsValid(int value) { + return Person_PhoneType_IsValid(value); + } + static const PhoneType PhoneType_MIN = + Person_PhoneType_PhoneType_MIN; + static const PhoneType PhoneType_MAX = + Person_PhoneType_PhoneType_MAX; + static const int PhoneType_ARRAYSIZE = + Person_PhoneType_PhoneType_ARRAYSIZE; + static inline const ::google::protobuf::EnumDescriptor* + PhoneType_descriptor() { + return Person_PhoneType_descriptor(); + } + static inline const ::std::string& PhoneType_Name(PhoneType value) { + return Person_PhoneType_Name(value); + } + static inline bool PhoneType_Parse(const ::std::string& name, + PhoneType* value) { + return Person_PhoneType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // required string name = 1; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 1; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + + // required int32 id = 2; + inline bool has_id() const; + inline void clear_id(); + static const int kIdFieldNumber = 2; + inline ::google::protobuf::int32 id() const; + inline void set_id(::google::protobuf::int32 value); + + // optional string email = 3; + inline bool has_email() const; + inline void clear_email(); + static const int kEmailFieldNumber = 3; + inline const ::std::string& email() const; + inline void set_email(const ::std::string& value); + inline void set_email(const char* value); + inline void set_email(const char* value, size_t size); + inline ::std::string* mutable_email(); + inline ::std::string* release_email(); + + // repeated .tutorial.Person.PhoneNumber phone = 4; + inline int phone_size() const; + inline void clear_phone(); + static const int kPhoneFieldNumber = 4; + inline const ::tutorial::Person_PhoneNumber& phone(int index) const; + inline ::tutorial::Person_PhoneNumber* mutable_phone(int index); + inline ::tutorial::Person_PhoneNumber* add_phone(); + inline const ::google::protobuf::RepeatedPtrField< ::tutorial::Person_PhoneNumber >& + phone() const; + inline ::google::protobuf::RepeatedPtrField< ::tutorial::Person_PhoneNumber >* + mutable_phone(); + + // @@protoc_insertion_point(class_scope:tutorial.Person) + private: + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_id(); + inline void clear_has_id(); + inline void set_has_email(); + inline void clear_has_email(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* name_; + ::std::string* email_; + ::google::protobuf::RepeatedPtrField< ::tutorial::Person_PhoneNumber > phone_; + ::google::protobuf::int32 id_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + friend void protobuf_AddDesc_addressbook_2eproto(); + friend void protobuf_AssignDesc_addressbook_2eproto(); + friend void protobuf_ShutdownFile_addressbook_2eproto(); + + void InitAsDefaultInstance(); + static Person* default_instance_; +}; +// ------------------------------------------------------------------- + +class AddressBook : public ::google::protobuf::Message { + public: + AddressBook(); + virtual ~AddressBook(); + + AddressBook(const AddressBook& from); + + inline AddressBook& operator=(const AddressBook& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const AddressBook& default_instance(); + + void Swap(AddressBook* other); + + // implements Message ---------------------------------------------- + + AddressBook* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const AddressBook& from); + void MergeFrom(const AddressBook& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .tutorial.Person person = 1; + inline int person_size() const; + inline void clear_person(); + static const int kPersonFieldNumber = 1; + inline const ::tutorial::Person& person(int index) const; + inline ::tutorial::Person* mutable_person(int index); + inline ::tutorial::Person* add_person(); + inline const ::google::protobuf::RepeatedPtrField< ::tutorial::Person >& + person() const; + inline ::google::protobuf::RepeatedPtrField< ::tutorial::Person >* + mutable_person(); + + // @@protoc_insertion_point(class_scope:tutorial.AddressBook) + private: + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::google::protobuf::RepeatedPtrField< ::tutorial::Person > person_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_addressbook_2eproto(); + friend void protobuf_AssignDesc_addressbook_2eproto(); + friend void protobuf_ShutdownFile_addressbook_2eproto(); + + void InitAsDefaultInstance(); + static AddressBook* default_instance_; +}; +// =================================================================== + + +// =================================================================== + +// Person_PhoneNumber + +// required string number = 1; +inline bool Person_PhoneNumber::has_number() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Person_PhoneNumber::set_has_number() { + _has_bits_[0] |= 0x00000001u; +} +inline void Person_PhoneNumber::clear_has_number() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Person_PhoneNumber::clear_number() { + if (number_ != &::google::protobuf::internal::kEmptyString) { + number_->clear(); + } + clear_has_number(); +} +inline const ::std::string& Person_PhoneNumber::number() const { + return *number_; +} +inline void Person_PhoneNumber::set_number(const ::std::string& value) { + set_has_number(); + if (number_ == &::google::protobuf::internal::kEmptyString) { + number_ = new ::std::string; + } + number_->assign(value); +} +inline void Person_PhoneNumber::set_number(const char* value) { + set_has_number(); + if (number_ == &::google::protobuf::internal::kEmptyString) { + number_ = new ::std::string; + } + number_->assign(value); +} +inline void Person_PhoneNumber::set_number(const char* value, size_t size) { + set_has_number(); + if (number_ == &::google::protobuf::internal::kEmptyString) { + number_ = new ::std::string; + } + number_->assign(reinterpret_cast(value), size); +} +inline ::std::string* Person_PhoneNumber::mutable_number() { + set_has_number(); + if (number_ == &::google::protobuf::internal::kEmptyString) { + number_ = new ::std::string; + } + return number_; +} +inline ::std::string* Person_PhoneNumber::release_number() { + clear_has_number(); + if (number_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = number_; + number_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} + +// optional .tutorial.Person.PhoneType type = 2 [default = HOME]; +inline bool Person_PhoneNumber::has_type() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Person_PhoneNumber::set_has_type() { + _has_bits_[0] |= 0x00000002u; +} +inline void Person_PhoneNumber::clear_has_type() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Person_PhoneNumber::clear_type() { + type_ = 1; + clear_has_type(); +} +inline ::tutorial::Person_PhoneType Person_PhoneNumber::type() const { + return static_cast< ::tutorial::Person_PhoneType >(type_); +} +inline void Person_PhoneNumber::set_type(::tutorial::Person_PhoneType value) { + GOOGLE_DCHECK(::tutorial::Person_PhoneType_IsValid(value)); + set_has_type(); + type_ = value; +} + +// ------------------------------------------------------------------- + +// Person + +// required string name = 1; +inline bool Person::has_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Person::set_has_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void Person::clear_has_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Person::clear_name() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& Person::name() const { + return *name_; +} +inline void Person::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void Person::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void Person::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* Person::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + return name_; +} +inline ::std::string* Person::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} + +// required int32 id = 2; +inline bool Person::has_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Person::set_has_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void Person::clear_has_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Person::clear_id() { + id_ = 0; + clear_has_id(); +} +inline ::google::protobuf::int32 Person::id() const { + return id_; +} +inline void Person::set_id(::google::protobuf::int32 value) { + set_has_id(); + id_ = value; +} + +// optional string email = 3; +inline bool Person::has_email() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void Person::set_has_email() { + _has_bits_[0] |= 0x00000004u; +} +inline void Person::clear_has_email() { + _has_bits_[0] &= ~0x00000004u; +} +inline void Person::clear_email() { + if (email_ != &::google::protobuf::internal::kEmptyString) { + email_->clear(); + } + clear_has_email(); +} +inline const ::std::string& Person::email() const { + return *email_; +} +inline void Person::set_email(const ::std::string& value) { + set_has_email(); + if (email_ == &::google::protobuf::internal::kEmptyString) { + email_ = new ::std::string; + } + email_->assign(value); +} +inline void Person::set_email(const char* value) { + set_has_email(); + if (email_ == &::google::protobuf::internal::kEmptyString) { + email_ = new ::std::string; + } + email_->assign(value); +} +inline void Person::set_email(const char* value, size_t size) { + set_has_email(); + if (email_ == &::google::protobuf::internal::kEmptyString) { + email_ = new ::std::string; + } + email_->assign(reinterpret_cast(value), size); +} +inline ::std::string* Person::mutable_email() { + set_has_email(); + if (email_ == &::google::protobuf::internal::kEmptyString) { + email_ = new ::std::string; + } + return email_; +} +inline ::std::string* Person::release_email() { + clear_has_email(); + if (email_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = email_; + email_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} + +// repeated .tutorial.Person.PhoneNumber phone = 4; +inline int Person::phone_size() const { + return phone_.size(); +} +inline void Person::clear_phone() { + phone_.Clear(); +} +inline const ::tutorial::Person_PhoneNumber& Person::phone(int index) const { + return phone_.Get(index); +} +inline ::tutorial::Person_PhoneNumber* Person::mutable_phone(int index) { + return phone_.Mutable(index); +} +inline ::tutorial::Person_PhoneNumber* Person::add_phone() { + return phone_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::tutorial::Person_PhoneNumber >& +Person::phone() const { + return phone_; +} +inline ::google::protobuf::RepeatedPtrField< ::tutorial::Person_PhoneNumber >* +Person::mutable_phone() { + return &phone_; +} + +// ------------------------------------------------------------------- + +// AddressBook + +// repeated .tutorial.Person person = 1; +inline int AddressBook::person_size() const { + return person_.size(); +} +inline void AddressBook::clear_person() { + person_.Clear(); +} +inline const ::tutorial::Person& AddressBook::person(int index) const { + return person_.Get(index); +} +inline ::tutorial::Person* AddressBook::mutable_person(int index) { + return person_.Mutable(index); +} +inline ::tutorial::Person* AddressBook::add_person() { + return person_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::tutorial::Person >& +AddressBook::person() const { + return person_; +} +inline ::google::protobuf::RepeatedPtrField< ::tutorial::Person >* +AddressBook::mutable_person() { + return &person_; +} + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace tutorial + +#ifndef SWIG +namespace google { +namespace protobuf { + +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::tutorial::Person_PhoneType>() { + return ::tutorial::Person_PhoneType_descriptor(); +} + +} // namespace google +} // namespace protobuf +#endif // SWIG + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_addressbook_2eproto__INCLUDED