hello.pb.cc
./code/hello.pb.cc
1// Generated by the protocol buffer compiler. DO NOT EDIT!
2// source: hello.proto
3
4#include "hello.pb.h"
5
6#include <algorithm>
7
8#include <google/protobuf/io/coded_stream.h>
9#include <google/protobuf/extension_set.h>
10#include <google/protobuf/wire_format_lite.h>
11#include <google/protobuf/descriptor.h>
12#include <google/protobuf/generated_message_reflection.h>
13#include <google/protobuf/reflection_ops.h>
14#include <google/protobuf/wire_format.h>
15// @@protoc_insertion_point(includes)
16#include <google/protobuf/port_def.inc>
17
18PROTOBUF_PRAGMA_INIT_SEG
19
20namespace _pb = ::PROTOBUF_NAMESPACE_ID;
21namespace _pbi = _pb::internal;
22
23namespace tutorial {
24PROTOBUF_CONSTEXPR Person_PhoneNumber::Person_PhoneNumber(
25 ::_pbi::ConstantInitialized)
26 : number_(&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{})
27 , type_(1)
28{}
29struct Person_PhoneNumberDefaultTypeInternal {
30 PROTOBUF_CONSTEXPR Person_PhoneNumberDefaultTypeInternal()
31 : _instance(::_pbi::ConstantInitialized{}) {}
32 ~Person_PhoneNumberDefaultTypeInternal() {}
33 union {
34 Person_PhoneNumber _instance;
35 };
36};
37PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Person_PhoneNumberDefaultTypeInternal _Person_PhoneNumber_default_instance_;
38PROTOBUF_CONSTEXPR Person::Person(
39 ::_pbi::ConstantInitialized)
40 : phones_()
41 , name_(&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{})
42 , email_(&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{})
43 , id_(0){}
44struct PersonDefaultTypeInternal {
45 PROTOBUF_CONSTEXPR PersonDefaultTypeInternal()
46 : _instance(::_pbi::ConstantInitialized{}) {}
47 ~PersonDefaultTypeInternal() {}
48 union {
49 Person _instance;
50 };
51};
52PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PersonDefaultTypeInternal _Person_default_instance_;
53PROTOBUF_CONSTEXPR AddressBook::AddressBook(
54 ::_pbi::ConstantInitialized)
55 : people_(){}
56struct AddressBookDefaultTypeInternal {
57 PROTOBUF_CONSTEXPR AddressBookDefaultTypeInternal()
58 : _instance(::_pbi::ConstantInitialized{}) {}
59 ~AddressBookDefaultTypeInternal() {}
60 union {
61 AddressBook _instance;
62 };
63};
64PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AddressBookDefaultTypeInternal _AddressBook_default_instance_;
65} // namespace tutorial
66static ::_pb::Metadata file_level_metadata_hello_2eproto[3];
67static const ::_pb::EnumDescriptor* file_level_enum_descriptors_hello_2eproto[1];
68static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_hello_2eproto = nullptr;
69
70const uint32_t TableStruct_hello_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
71 PROTOBUF_FIELD_OFFSET(::tutorial::Person_PhoneNumber, _has_bits_),
72 PROTOBUF_FIELD_OFFSET(::tutorial::Person_PhoneNumber, _internal_metadata_),
73 ~0u, // no _extensions_
74 ~0u, // no _oneof_case_
75 ~0u, // no _weak_field_map_
76 ~0u, // no _inlined_string_donated_
77 PROTOBUF_FIELD_OFFSET(::tutorial::Person_PhoneNumber, number_),
78 PROTOBUF_FIELD_OFFSET(::tutorial::Person_PhoneNumber, type_),
79 0,
80 1,
81 PROTOBUF_FIELD_OFFSET(::tutorial::Person, _has_bits_),
82 PROTOBUF_FIELD_OFFSET(::tutorial::Person, _internal_metadata_),
83 ~0u, // no _extensions_
84 ~0u, // no _oneof_case_
85 ~0u, // no _weak_field_map_
86 ~0u, // no _inlined_string_donated_
87 PROTOBUF_FIELD_OFFSET(::tutorial::Person, name_),
88 PROTOBUF_FIELD_OFFSET(::tutorial::Person, id_),
89 PROTOBUF_FIELD_OFFSET(::tutorial::Person, email_),
90 PROTOBUF_FIELD_OFFSET(::tutorial::Person, phones_),
91 0,
92 2,
93 1,
94 ~0u,
95 ~0u, // no _has_bits_
96 PROTOBUF_FIELD_OFFSET(::tutorial::AddressBook, _internal_metadata_),
97 ~0u, // no _extensions_
98 ~0u, // no _oneof_case_
99 ~0u, // no _weak_field_map_
100 ~0u, // no _inlined_string_donated_
101 PROTOBUF_FIELD_OFFSET(::tutorial::AddressBook, people_),
102};
103static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
104 { 0, 8, -1, sizeof(::tutorial::Person_PhoneNumber)},
105 { 10, 20, -1, sizeof(::tutorial::Person)},
106 { 24, -1, -1, sizeof(::tutorial::AddressBook)},
107};
108
109static const ::_pb::Message* const file_default_instances[] = {
110 &::tutorial::_Person_PhoneNumber_default_instance_._instance,
111 &::tutorial::_Person_default_instance_._instance,
112 &::tutorial::_AddressBook_default_instance_._instance,
113};
114
115const char descriptor_table_protodef_hello_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
116 "\n\013hello.proto\022\010tutorial\"\333\001\n\006Person\022\014\n\004na"
117 "me\030\001 \001(\t\022\n\n\002id\030\002 \001(\005\022\r\n\005email\030\003 \001(\t\022,\n\006p"
118 "hones\030\004 \003(\0132\034.tutorial.Person.PhoneNumbe"
119 "r\032M\n\013PhoneNumber\022\016\n\006number\030\001 \001(\t\022.\n\004type"
120 "\030\002 \001(\0162\032.tutorial.Person.PhoneType:\004HOME"
121 "\"+\n\tPhoneType\022\n\n\006MOBILE\020\000\022\010\n\004HOME\020\001\022\010\n\004W"
122 "ORK\020\002\"/\n\013AddressBook\022 \n\006people\030\001 \003(\0132\020.t"
123 "utorial.Person"
124 ;
125static ::_pbi::once_flag descriptor_table_hello_2eproto_once;
126const ::_pbi::DescriptorTable descriptor_table_hello_2eproto = {
127 false, false, 294, descriptor_table_protodef_hello_2eproto,
128 "hello.proto",
129 &descriptor_table_hello_2eproto_once, nullptr, 0, 3,
130 schemas, file_default_instances, TableStruct_hello_2eproto::offsets,
131 file_level_metadata_hello_2eproto, file_level_enum_descriptors_hello_2eproto,
132 file_level_service_descriptors_hello_2eproto,
133};
134PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_hello_2eproto_getter() {
135 return &descriptor_table_hello_2eproto;
136}
137
138// Force running AddDescriptors() at dynamic initialization time.
139PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_hello_2eproto(&descriptor_table_hello_2eproto);
140namespace tutorial {
141const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Person_PhoneType_descriptor() {
142 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_hello_2eproto);
143 return file_level_enum_descriptors_hello_2eproto[0];
144}
145bool Person_PhoneType_IsValid(int value) {
146 switch (value) {
147 case 0:
148 case 1:
149 case 2:
150 return true;
151 default:
152 return false;
153 }
154}
155
156#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
157constexpr Person_PhoneType Person::MOBILE;
158constexpr Person_PhoneType Person::HOME;
159constexpr Person_PhoneType Person::WORK;
160constexpr Person_PhoneType Person::PhoneType_MIN;
161constexpr Person_PhoneType Person::PhoneType_MAX;
162constexpr int Person::PhoneType_ARRAYSIZE;
163#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
164
165// ===================================================================
166
167class Person_PhoneNumber::_Internal {
168 public:
169 using HasBits = decltype(std::declval<Person_PhoneNumber>()._has_bits_);
170 static void set_has_number(HasBits* has_bits) {
171 (*has_bits)[0] |= 1u;
172 }
173 static void set_has_type(HasBits* has_bits) {
174 (*has_bits)[0] |= 2u;
175 }
176};
177
178Person_PhoneNumber::Person_PhoneNumber(::PROTOBUF_NAMESPACE_ID::Arena* arena,
179 bool is_message_owned)
180 : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
181 SharedCtor();
182 // @@protoc_insertion_point(arena_constructor:tutorial.Person.PhoneNumber)
183}
184Person_PhoneNumber::Person_PhoneNumber(const Person_PhoneNumber& from)
185 : ::PROTOBUF_NAMESPACE_ID::Message(),
186 _has_bits_(from._has_bits_) {
187 _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
188 number_.InitDefault();
189 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
190 number_.Set("", GetArenaForAllocation());
191 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
192 if (from._internal_has_number()) {
193 number_.Set(from._internal_number(),
194 GetArenaForAllocation());
195 }
196 type_ = from.type_;
197 // @@protoc_insertion_point(copy_constructor:tutorial.Person.PhoneNumber)
198}
199
200inline void Person_PhoneNumber::SharedCtor() {
201number_.InitDefault();
202#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
203 number_.Set("", GetArenaForAllocation());
204#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
205type_ = 1;
206}
207
208Person_PhoneNumber::~Person_PhoneNumber() {
209 // @@protoc_insertion_point(destructor:tutorial.Person.PhoneNumber)
210 if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
211 (void)arena;
212 return;
213 }
214 SharedDtor();
215}
216
217inline void Person_PhoneNumber::SharedDtor() {
218 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
219 number_.Destroy();
220}
221
222void Person_PhoneNumber::SetCachedSize(int size) const {
223 _cached_size_.Set(size);
224}
225
226void Person_PhoneNumber::Clear() {
227// @@protoc_insertion_point(message_clear_start:tutorial.Person.PhoneNumber)
228 uint32_t cached_has_bits = 0;
229 // Prevent compiler warnings about cached_has_bits being unused
230 (void) cached_has_bits;
231
232 cached_has_bits = _has_bits_[0];
233 if (cached_has_bits & 0x00000003u) {
234 if (cached_has_bits & 0x00000001u) {
235 number_.ClearNonDefaultToEmpty();
236 }
237 type_ = 1;
238 }
239 _has_bits_.Clear();
240 _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
241}
242
243const char* Person_PhoneNumber::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
244#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
245 _Internal::HasBits has_bits{};
246 while (!ctx->Done(&ptr)) {
247 uint32_t tag;
248 ptr = ::_pbi::ReadTag(ptr, &tag);
249 switch (tag >> 3) {
250 // optional string number = 1;
251 case 1:
252 if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
253 auto str = _internal_mutable_number();
254 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
255 CHK_(ptr);
256 #ifndef NDEBUG
257 ::_pbi::VerifyUTF8(str, "tutorial.Person.PhoneNumber.number");
258 #endif // !NDEBUG
259 } else
260 goto handle_unusual;
261 continue;
262 // optional .tutorial.Person.PhoneType type = 2 [default = HOME];
263 case 2:
264 if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
265 uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
266 CHK_(ptr);
267 if (PROTOBUF_PREDICT_TRUE(::tutorial::Person_PhoneType_IsValid(val))) {
268 _internal_set_type(static_cast<::tutorial::Person_PhoneType>(val));
269 } else {
270 ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
271 }
272 } else
273 goto handle_unusual;
274 continue;
275 default:
276 goto handle_unusual;
277 } // switch
278 handle_unusual:
279 if ((tag == 0) || ((tag & 7) == 4)) {
280 CHK_(ptr);
281 ctx->SetLastTag(tag);
282 goto message_done;
283 }
284 ptr = UnknownFieldParse(
285 tag,
286 _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
287 ptr, ctx);
288 CHK_(ptr != nullptr);
289 } // while
290message_done:
291 _has_bits_.Or(has_bits);
292 return ptr;
293failure:
294 ptr = nullptr;
295 goto message_done;
296#undef CHK_
297}
298
299uint8_t* Person_PhoneNumber::_InternalSerialize(
300 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
301 // @@protoc_insertion_point(serialize_to_array_start:tutorial.Person.PhoneNumber)
302 uint32_t cached_has_bits = 0;
303 (void) cached_has_bits;
304
305 cached_has_bits = _has_bits_[0];
306 // optional string number = 1;
307 if (cached_has_bits & 0x00000001u) {
308 ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
309 this->_internal_number().data(), static_cast<int>(this->_internal_number().length()),
310 ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
311 "tutorial.Person.PhoneNumber.number");
312 target = stream->WriteStringMaybeAliased(
313 1, this->_internal_number(), target);
314 }
315
316 // optional .tutorial.Person.PhoneType type = 2 [default = HOME];
317 if (cached_has_bits & 0x00000002u) {
318 target = stream->EnsureSpace(target);
319 target = ::_pbi::WireFormatLite::WriteEnumToArray(
320 2, this->_internal_type(), target);
321 }
322
323 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
324 target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
325 _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
326 }
327 // @@protoc_insertion_point(serialize_to_array_end:tutorial.Person.PhoneNumber)
328 return target;
329}
330
331size_t Person_PhoneNumber::ByteSizeLong() const {
332// @@protoc_insertion_point(message_byte_size_start:tutorial.Person.PhoneNumber)
333 size_t total_size = 0;
334
335 uint32_t cached_has_bits = 0;
336 // Prevent compiler warnings about cached_has_bits being unused
337 (void) cached_has_bits;
338
339 cached_has_bits = _has_bits_[0];
340 if (cached_has_bits & 0x00000003u) {
341 // optional string number = 1;
342 if (cached_has_bits & 0x00000001u) {
343 total_size += 1 +
344 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
345 this->_internal_number());
346 }
347
348 // optional .tutorial.Person.PhoneType type = 2 [default = HOME];
349 if (cached_has_bits & 0x00000002u) {
350 total_size += 1 +
351 ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
352 }
353
354 }
355 return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
356}
357
358const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Person_PhoneNumber::_class_data_ = {
359 ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
360 Person_PhoneNumber::MergeImpl
361};
362const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Person_PhoneNumber::GetClassData() const { return &_class_data_; }
363
364void Person_PhoneNumber::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
365 const ::PROTOBUF_NAMESPACE_ID::Message& from) {
366 static_cast<Person_PhoneNumber *>(to)->MergeFrom(
367 static_cast<const Person_PhoneNumber &>(from));
368}
369
370
371void Person_PhoneNumber::MergeFrom(const Person_PhoneNumber& from) {
372// @@protoc_insertion_point(class_specific_merge_from_start:tutorial.Person.PhoneNumber)
373 GOOGLE_DCHECK_NE(&from, this);
374 uint32_t cached_has_bits = 0;
375 (void) cached_has_bits;
376
377 cached_has_bits = from._has_bits_[0];
378 if (cached_has_bits & 0x00000003u) {
379 if (cached_has_bits & 0x00000001u) {
380 _internal_set_number(from._internal_number());
381 }
382 if (cached_has_bits & 0x00000002u) {
383 type_ = from.type_;
384 }
385 _has_bits_[0] |= cached_has_bits;
386 }
387 _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
388}
389
390void Person_PhoneNumber::CopyFrom(const Person_PhoneNumber& from) {
391// @@protoc_insertion_point(class_specific_copy_from_start:tutorial.Person.PhoneNumber)
392 if (&from == this) return;
393 Clear();
394 MergeFrom(from);
395}
396
397bool Person_PhoneNumber::IsInitialized() const {
398 return true;
399}
400
401void Person_PhoneNumber::InternalSwap(Person_PhoneNumber* other) {
402 using std::swap;
403 auto* lhs_arena = GetArenaForAllocation();
404 auto* rhs_arena = other->GetArenaForAllocation();
405 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
406 swap(_has_bits_[0], other->_has_bits_[0]);
407 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
408 &number_, lhs_arena,
409 &other->number_, rhs_arena
410 );
411 swap(type_, other->type_);
412}
413
414::PROTOBUF_NAMESPACE_ID::Metadata Person_PhoneNumber::GetMetadata() const {
415 return ::_pbi::AssignDescriptors(
416 &descriptor_table_hello_2eproto_getter, &descriptor_table_hello_2eproto_once,
417 file_level_metadata_hello_2eproto[0]);
418}
419
420// ===================================================================
421
422class Person::_Internal {
423 public:
424 using HasBits = decltype(std::declval<Person>()._has_bits_);
425 static void set_has_name(HasBits* has_bits) {
426 (*has_bits)[0] |= 1u;
427 }
428 static void set_has_id(HasBits* has_bits) {
429 (*has_bits)[0] |= 4u;
430 }
431 static void set_has_email(HasBits* has_bits) {
432 (*has_bits)[0] |= 2u;
433 }
434};
435
436Person::Person(::PROTOBUF_NAMESPACE_ID::Arena* arena,
437 bool is_message_owned)
438 : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
439 phones_(arena) {
440 SharedCtor();
441 // @@protoc_insertion_point(arena_constructor:tutorial.Person)
442}
443Person::Person(const Person& from)
444 : ::PROTOBUF_NAMESPACE_ID::Message(),
445 _has_bits_(from._has_bits_),
446 phones_(from.phones_) {
447 _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
448 name_.InitDefault();
449 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
450 name_.Set("", GetArenaForAllocation());
451 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
452 if (from._internal_has_name()) {
453 name_.Set(from._internal_name(),
454 GetArenaForAllocation());
455 }
456 email_.InitDefault();
457 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
458 email_.Set("", GetArenaForAllocation());
459 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
460 if (from._internal_has_email()) {
461 email_.Set(from._internal_email(),
462 GetArenaForAllocation());
463 }
464 id_ = from.id_;
465 // @@protoc_insertion_point(copy_constructor:tutorial.Person)
466}
467
468inline void Person::SharedCtor() {
469name_.InitDefault();
470#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
471 name_.Set("", GetArenaForAllocation());
472#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
473email_.InitDefault();
474#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
475 email_.Set("", GetArenaForAllocation());
476#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
477id_ = 0;
478}
479
480Person::~Person() {
481 // @@protoc_insertion_point(destructor:tutorial.Person)
482 if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
483 (void)arena;
484 return;
485 }
486 SharedDtor();
487}
488
489inline void Person::SharedDtor() {
490 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
491 name_.Destroy();
492 email_.Destroy();
493}
494
495void Person::SetCachedSize(int size) const {
496 _cached_size_.Set(size);
497}
498
499void Person::Clear() {
500// @@protoc_insertion_point(message_clear_start:tutorial.Person)
501 uint32_t cached_has_bits = 0;
502 // Prevent compiler warnings about cached_has_bits being unused
503 (void) cached_has_bits;
504
505 phones_.Clear();
506 cached_has_bits = _has_bits_[0];
507 if (cached_has_bits & 0x00000003u) {
508 if (cached_has_bits & 0x00000001u) {
509 name_.ClearNonDefaultToEmpty();
510 }
511 if (cached_has_bits & 0x00000002u) {
512 email_.ClearNonDefaultToEmpty();
513 }
514 }
515 id_ = 0;
516 _has_bits_.Clear();
517 _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
518}
519
520const char* Person::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
521#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
522 _Internal::HasBits has_bits{};
523 while (!ctx->Done(&ptr)) {
524 uint32_t tag;
525 ptr = ::_pbi::ReadTag(ptr, &tag);
526 switch (tag >> 3) {
527 // optional string name = 1;
528 case 1:
529 if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
530 auto str = _internal_mutable_name();
531 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
532 CHK_(ptr);
533 #ifndef NDEBUG
534 ::_pbi::VerifyUTF8(str, "tutorial.Person.name");
535 #endif // !NDEBUG
536 } else
537 goto handle_unusual;
538 continue;
539 // optional int32 id = 2;
540 case 2:
541 if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
542 _Internal::set_has_id(&has_bits);
543 id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
544 CHK_(ptr);
545 } else
546 goto handle_unusual;
547 continue;
548 // optional string email = 3;
549 case 3:
550 if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
551 auto str = _internal_mutable_email();
552 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
553 CHK_(ptr);
554 #ifndef NDEBUG
555 ::_pbi::VerifyUTF8(str, "tutorial.Person.email");
556 #endif // !NDEBUG
557 } else
558 goto handle_unusual;
559 continue;
560 // repeated .tutorial.Person.PhoneNumber phones = 4;
561 case 4:
562 if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
563 ptr -= 1;
564 do {
565 ptr += 1;
566 ptr = ctx->ParseMessage(_internal_add_phones(), ptr);
567 CHK_(ptr);
568 if (!ctx->DataAvailable(ptr)) break;
569 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
570 } else
571 goto handle_unusual;
572 continue;
573 default:
574 goto handle_unusual;
575 } // switch
576 handle_unusual:
577 if ((tag == 0) || ((tag & 7) == 4)) {
578 CHK_(ptr);
579 ctx->SetLastTag(tag);
580 goto message_done;
581 }
582 ptr = UnknownFieldParse(
583 tag,
584 _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
585 ptr, ctx);
586 CHK_(ptr != nullptr);
587 } // while
588message_done:
589 _has_bits_.Or(has_bits);
590 return ptr;
591failure:
592 ptr = nullptr;
593 goto message_done;
594#undef CHK_
595}
596
597uint8_t* Person::_InternalSerialize(
598 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
599 // @@protoc_insertion_point(serialize_to_array_start:tutorial.Person)
600 uint32_t cached_has_bits = 0;
601 (void) cached_has_bits;
602
603 cached_has_bits = _has_bits_[0];
604 // optional string name = 1;
605 if (cached_has_bits & 0x00000001u) {
606 ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
607 this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
608 ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
609 "tutorial.Person.name");
610 target = stream->WriteStringMaybeAliased(
611 1, this->_internal_name(), target);
612 }
613
614 // optional int32 id = 2;
615 if (cached_has_bits & 0x00000004u) {
616 target = stream->EnsureSpace(target);
617 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_id(), target);
618 }
619
620 // optional string email = 3;
621 if (cached_has_bits & 0x00000002u) {
622 ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
623 this->_internal_email().data(), static_cast<int>(this->_internal_email().length()),
624 ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
625 "tutorial.Person.email");
626 target = stream->WriteStringMaybeAliased(
627 3, this->_internal_email(), target);
628 }
629
630 // repeated .tutorial.Person.PhoneNumber phones = 4;
631 for (unsigned i = 0,
632 n = static_cast<unsigned>(this->_internal_phones_size()); i < n; i++) {
633 const auto& repfield = this->_internal_phones(i);
634 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
635 InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
636 }
637
638 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
639 target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
640 _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
641 }
642 // @@protoc_insertion_point(serialize_to_array_end:tutorial.Person)
643 return target;
644}
645
646size_t Person::ByteSizeLong() const {
647// @@protoc_insertion_point(message_byte_size_start:tutorial.Person)
648 size_t total_size = 0;
649
650 uint32_t cached_has_bits = 0;
651 // Prevent compiler warnings about cached_has_bits being unused
652 (void) cached_has_bits;
653
654 // repeated .tutorial.Person.PhoneNumber phones = 4;
655 total_size += 1UL * this->_internal_phones_size();
656 for (const auto& msg : this->phones_) {
657 total_size +=
658 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
659 }
660
661 cached_has_bits = _has_bits_[0];
662 if (cached_has_bits & 0x00000007u) {
663 // optional string name = 1;
664 if (cached_has_bits & 0x00000001u) {
665 total_size += 1 +
666 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
667 this->_internal_name());
668 }
669
670 // optional string email = 3;
671 if (cached_has_bits & 0x00000002u) {
672 total_size += 1 +
673 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
674 this->_internal_email());
675 }
676
677 // optional int32 id = 2;
678 if (cached_has_bits & 0x00000004u) {
679 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_id());
680 }
681
682 }
683 return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
684}
685
686const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Person::_class_data_ = {
687 ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
688 Person::MergeImpl
689};
690const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Person::GetClassData() const { return &_class_data_; }
691
692void Person::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
693 const ::PROTOBUF_NAMESPACE_ID::Message& from) {
694 static_cast<Person *>(to)->MergeFrom(
695 static_cast<const Person &>(from));
696}
697
698
699void Person::MergeFrom(const Person& from) {
700// @@protoc_insertion_point(class_specific_merge_from_start:tutorial.Person)
701 GOOGLE_DCHECK_NE(&from, this);
702 uint32_t cached_has_bits = 0;
703 (void) cached_has_bits;
704
705 phones_.MergeFrom(from.phones_);
706 cached_has_bits = from._has_bits_[0];
707 if (cached_has_bits & 0x00000007u) {
708 if (cached_has_bits & 0x00000001u) {
709 _internal_set_name(from._internal_name());
710 }
711 if (cached_has_bits & 0x00000002u) {
712 _internal_set_email(from._internal_email());
713 }
714 if (cached_has_bits & 0x00000004u) {
715 id_ = from.id_;
716 }
717 _has_bits_[0] |= cached_has_bits;
718 }
719 _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
720}
721
722void Person::CopyFrom(const Person& from) {
723// @@protoc_insertion_point(class_specific_copy_from_start:tutorial.Person)
724 if (&from == this) return;
725 Clear();
726 MergeFrom(from);
727}
728
729bool Person::IsInitialized() const {
730 return true;
731}
732
733void Person::InternalSwap(Person* other) {
734 using std::swap;
735 auto* lhs_arena = GetArenaForAllocation();
736 auto* rhs_arena = other->GetArenaForAllocation();
737 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
738 swap(_has_bits_[0], other->_has_bits_[0]);
739 phones_.InternalSwap(&other->phones_);
740 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
741 &name_, lhs_arena,
742 &other->name_, rhs_arena
743 );
744 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
745 &email_, lhs_arena,
746 &other->email_, rhs_arena
747 );
748 swap(id_, other->id_);
749}
750
751::PROTOBUF_NAMESPACE_ID::Metadata Person::GetMetadata() const {
752 return ::_pbi::AssignDescriptors(
753 &descriptor_table_hello_2eproto_getter, &descriptor_table_hello_2eproto_once,
754 file_level_metadata_hello_2eproto[1]);
755}
756
757// ===================================================================
758
759class AddressBook::_Internal {
760 public:
761};
762
763AddressBook::AddressBook(::PROTOBUF_NAMESPACE_ID::Arena* arena,
764 bool is_message_owned)
765 : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
766 people_(arena) {
767 SharedCtor();
768 // @@protoc_insertion_point(arena_constructor:tutorial.AddressBook)
769}
770AddressBook::AddressBook(const AddressBook& from)
771 : ::PROTOBUF_NAMESPACE_ID::Message(),
772 people_(from.people_) {
773 _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
774 // @@protoc_insertion_point(copy_constructor:tutorial.AddressBook)
775}
776
777inline void AddressBook::SharedCtor() {
778}
779
780AddressBook::~AddressBook() {
781 // @@protoc_insertion_point(destructor:tutorial.AddressBook)
782 if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
783 (void)arena;
784 return;
785 }
786 SharedDtor();
787}
788
789inline void AddressBook::SharedDtor() {
790 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
791}
792
793void AddressBook::SetCachedSize(int size) const {
794 _cached_size_.Set(size);
795}
796
797void AddressBook::Clear() {
798// @@protoc_insertion_point(message_clear_start:tutorial.AddressBook)
799 uint32_t cached_has_bits = 0;
800 // Prevent compiler warnings about cached_has_bits being unused
801 (void) cached_has_bits;
802
803 people_.Clear();
804 _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
805}
806
807const char* AddressBook::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
808#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
809 while (!ctx->Done(&ptr)) {
810 uint32_t tag;
811 ptr = ::_pbi::ReadTag(ptr, &tag);
812 switch (tag >> 3) {
813 // repeated .tutorial.Person people = 1;
814 case 1:
815 if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
816 ptr -= 1;
817 do {
818 ptr += 1;
819 ptr = ctx->ParseMessage(_internal_add_people(), ptr);
820 CHK_(ptr);
821 if (!ctx->DataAvailable(ptr)) break;
822 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
823 } else
824 goto handle_unusual;
825 continue;
826 default:
827 goto handle_unusual;
828 } // switch
829 handle_unusual:
830 if ((tag == 0) || ((tag & 7) == 4)) {
831 CHK_(ptr);
832 ctx->SetLastTag(tag);
833 goto message_done;
834 }
835 ptr = UnknownFieldParse(
836 tag,
837 _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
838 ptr, ctx);
839 CHK_(ptr != nullptr);
840 } // while
841message_done:
842 return ptr;
843failure:
844 ptr = nullptr;
845 goto message_done;
846#undef CHK_
847}
848
849uint8_t* AddressBook::_InternalSerialize(
850 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
851 // @@protoc_insertion_point(serialize_to_array_start:tutorial.AddressBook)
852 uint32_t cached_has_bits = 0;
853 (void) cached_has_bits;
854
855 // repeated .tutorial.Person people = 1;
856 for (unsigned i = 0,
857 n = static_cast<unsigned>(this->_internal_people_size()); i < n; i++) {
858 const auto& repfield = this->_internal_people(i);
859 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
860 InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
861 }
862
863 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
864 target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
865 _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
866 }
867 // @@protoc_insertion_point(serialize_to_array_end:tutorial.AddressBook)
868 return target;
869}
870
871size_t AddressBook::ByteSizeLong() const {
872// @@protoc_insertion_point(message_byte_size_start:tutorial.AddressBook)
873 size_t total_size = 0;
874
875 uint32_t cached_has_bits = 0;
876 // Prevent compiler warnings about cached_has_bits being unused
877 (void) cached_has_bits;
878
879 // repeated .tutorial.Person people = 1;
880 total_size += 1UL * this->_internal_people_size();
881 for (const auto& msg : this->people_) {
882 total_size +=
883 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
884 }
885
886 return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
887}
888
889const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AddressBook::_class_data_ = {
890 ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
891 AddressBook::MergeImpl
892};
893const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AddressBook::GetClassData() const { return &_class_data_; }
894
895void AddressBook::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
896 const ::PROTOBUF_NAMESPACE_ID::Message& from) {
897 static_cast<AddressBook *>(to)->MergeFrom(
898 static_cast<const AddressBook &>(from));
899}
900
901
902void AddressBook::MergeFrom(const AddressBook& from) {
903// @@protoc_insertion_point(class_specific_merge_from_start:tutorial.AddressBook)
904 GOOGLE_DCHECK_NE(&from, this);
905 uint32_t cached_has_bits = 0;
906 (void) cached_has_bits;
907
908 people_.MergeFrom(from.people_);
909 _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
910}
911
912void AddressBook::CopyFrom(const AddressBook& from) {
913// @@protoc_insertion_point(class_specific_copy_from_start:tutorial.AddressBook)
914 if (&from == this) return;
915 Clear();
916 MergeFrom(from);
917}
918
919bool AddressBook::IsInitialized() const {
920 return true;
921}
922
923void AddressBook::InternalSwap(AddressBook* other) {
924 using std::swap;
925 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
926 people_.InternalSwap(&other->people_);
927}
928
929::PROTOBUF_NAMESPACE_ID::Metadata AddressBook::GetMetadata() const {
930 return ::_pbi::AssignDescriptors(
931 &descriptor_table_hello_2eproto_getter, &descriptor_table_hello_2eproto_once,
932 file_level_metadata_hello_2eproto[2]);
933}
934
935// @@protoc_insertion_point(namespace_scope)
936} // namespace tutorial
937PROTOBUF_NAMESPACE_OPEN
938template<> PROTOBUF_NOINLINE ::tutorial::Person_PhoneNumber*
939Arena::CreateMaybeMessage< ::tutorial::Person_PhoneNumber >(Arena* arena) {
940 return Arena::CreateMessageInternal< ::tutorial::Person_PhoneNumber >(arena);
941}
942template<> PROTOBUF_NOINLINE ::tutorial::Person*
943Arena::CreateMaybeMessage< ::tutorial::Person >(Arena* arena) {
944 return Arena::CreateMessageInternal< ::tutorial::Person >(arena);
945}
946template<> PROTOBUF_NOINLINE ::tutorial::AddressBook*
947Arena::CreateMaybeMessage< ::tutorial::AddressBook >(Arena* arena) {
948 return Arena::CreateMessageInternal< ::tutorial::AddressBook >(arena);
949}
950PROTOBUF_NAMESPACE_CLOSE
951
952// @@protoc_insertion_point(global_scope)
953#include <google/protobuf/port_undef.inc>