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>