/src/brpc/build/test/addressbook.pb.h

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_addressbook_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_addressbook_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#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 3021012 < 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 <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_addressbook_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_addressbook_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_addressbook_2eproto;
namespace addressbook {
class AddressBook;
struct AddressBookDefaultTypeInternal;
extern AddressBookDefaultTypeInternal _AddressBook_default_instance_;
class Person;
struct PersonDefaultTypeInternal;
extern PersonDefaultTypeInternal _Person_default_instance_;
class Person_PhoneNumber;
struct Person_PhoneNumberDefaultTypeInternal;
extern Person_PhoneNumberDefaultTypeInternal _Person_PhoneNumber_default_instance_;
}  // namespace addressbook
PROTOBUF_NAMESPACE_OPEN
template<> ::addressbook::AddressBook* Arena::CreateMaybeMessage<::addressbook::AddressBook>(Arena*);
template<> ::addressbook::Person* Arena::CreateMaybeMessage<::addressbook::Person>(Arena*);
template<> ::addressbook::Person_PhoneNumber* Arena::CreateMaybeMessage<::addressbook::Person_PhoneNumber>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace addressbook {

enum Person_PhoneType : int {
  Person_PhoneType_MOBILE = 0,
  Person_PhoneType_HOME = 1,
  Person_PhoneType_WORK = 2
};
bool Person_PhoneType_IsValid(int value);
constexpr Person_PhoneType Person_PhoneType_PhoneType_MIN = Person_PhoneType_MOBILE;
constexpr Person_PhoneType Person_PhoneType_PhoneType_MAX = Person_PhoneType_WORK;
constexpr int Person_PhoneType_PhoneType_ARRAYSIZE = Person_PhoneType_PhoneType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Person_PhoneType_descriptor();
template<typename T>
inline const std::string& Person_PhoneType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Person_PhoneType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Person_PhoneType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Person_PhoneType_descriptor(), enum_t_value);
}
inline bool Person_PhoneType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Person_PhoneType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Person_PhoneType>(
    Person_PhoneType_descriptor(), name, value);
}
// ===================================================================

class Person_PhoneNumber final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:addressbook.Person.PhoneNumber) */ {
 public:
  inline Person_PhoneNumber() : Person_PhoneNumber(nullptr) {}
  ~Person_PhoneNumber() override;
  explicit PROTOBUF_CONSTEXPR Person_PhoneNumber(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Person_PhoneNumber(const Person_PhoneNumber& from);
  Person_PhoneNumber(Person_PhoneNumber&& from) noexcept
    : Person_PhoneNumber() {
    *this = ::std::move(from);
  }

  inline Person_PhoneNumber& operator=(const Person_PhoneNumber& from) {
    CopyFrom(from);
    return *this;
  }
  inline Person_PhoneNumber& operator=(Person_PhoneNumber&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Person_PhoneNumber& default_instance() {
    return *internal_default_instance();
  }
  static inline const Person_PhoneNumber* internal_default_instance() {
    return reinterpret_cast<const Person_PhoneNumber*>(
               &_Person_PhoneNumber_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(Person_PhoneNumber& a, Person_PhoneNumber& b) {
    a.Swap(&b);
  }
  inline void Swap(Person_PhoneNumber* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Person_PhoneNumber* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Person_PhoneNumber* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Person_PhoneNumber>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Person_PhoneNumber& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Person_PhoneNumber& from) {
    Person_PhoneNumber::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Person_PhoneNumber* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "addressbook.Person.PhoneNumber";
  }
  protected:
  explicit Person_PhoneNumber(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNumberFieldNumber = 1,
    kTypeFieldNumber = 2,
  };
  // required string number = 1;
  bool has_number() const;
  private:
  bool _internal_has_number() const;
  public:
  void clear_number();
  const std::string& number() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_number(ArgT0&& arg0, ArgT... args);
  std::string* mutable_number();
  PROTOBUF_NODISCARD std::string* release_number();
  void set_allocated_number(std::string* number);
  private:
  const std::string& _internal_number() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_number(const std::string& value);
  std::string* _internal_mutable_number();
  public:

  // optional .addressbook.Person.PhoneType type = 2 [default = HOME];
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::addressbook::Person_PhoneType type() const;
  void set_type(::addressbook::Person_PhoneType value);
  private:
  ::addressbook::Person_PhoneType _internal_type() const;
  void _internal_set_type(::addressbook::Person_PhoneType value);
  public:

  // @@protoc_insertion_point(class_scope:addressbook.Person.PhoneNumber)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr number_;
    int type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_addressbook_2eproto;
};
// -------------------------------------------------------------------

class Person final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:addressbook.Person) */ {
 public:
  inline Person() : Person(nullptr) {}
  ~Person() override;
  explicit PROTOBUF_CONSTEXPR Person(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Person(const Person& from);
  Person(Person&& from) noexcept
    : Person() {
    *this = ::std::move(from);
  }

  inline Person& operator=(const Person& from) {
    CopyFrom(from);
    return *this;
  }
  inline Person& operator=(Person&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Person& default_instance() {
    return *internal_default_instance();
  }
  static inline const Person* internal_default_instance() {
    return reinterpret_cast<const Person*>(
               &_Person_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(Person& a, Person& b) {
    a.Swap(&b);
  }
  inline void Swap(Person* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Person* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Person* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Person>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Person& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Person& from) {
    Person::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Person* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "addressbook.Person";
  }
  protected:
  explicit Person(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Person_PhoneNumber PhoneNumber;

  typedef Person_PhoneType PhoneType;
  static constexpr PhoneType MOBILE =
    Person_PhoneType_MOBILE;
  static constexpr PhoneType HOME =
    Person_PhoneType_HOME;
  static constexpr PhoneType WORK =
    Person_PhoneType_WORK;
  static inline bool PhoneType_IsValid(int value) {
    return Person_PhoneType_IsValid(value);
  }
  static constexpr PhoneType PhoneType_MIN =
    Person_PhoneType_PhoneType_MIN;
  static constexpr PhoneType PhoneType_MAX =
    Person_PhoneType_PhoneType_MAX;
  static constexpr int PhoneType_ARRAYSIZE =
    Person_PhoneType_PhoneType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  PhoneType_descriptor() {
    return Person_PhoneType_descriptor();
  }
  template<typename T>
  static inline const std::string& PhoneType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, PhoneType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function PhoneType_Name.");
    return Person_PhoneType_Name(enum_t_value);
  }
  static inline bool PhoneType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      PhoneType* value) {
    return Person_PhoneType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kPhoneFieldNumber = 4,
    kNameFieldNumber = 1,
    kEmailFieldNumber = 3,
    kDatabyteFieldNumber = 13,
    kIdFieldNumber = 2,
    kData32FieldNumber = 6,
    kDataFieldNumber = 5,
    kData64FieldNumber = 7,
    kDatadoubleFieldNumber = 8,
    kDatafloatFieldNumber = 9,
    kDatau32FieldNumber = 10,
    kDatau64FieldNumber = 11,
    kDataboolFieldNumber = 12,
    kDatafix32FieldNumber = 14,
    kDatafix64FieldNumber = 15,
    kDatasfix64FieldNumber = 17,
    kDatasfix32FieldNumber = 16,
    kDatafloatScientificFieldNumber = 18,
    kDatadoubleScientificFieldNumber = 19,
  };
  // repeated .addressbook.Person.PhoneNumber phone = 4;
  int phone_size() const;
  private:
  int _internal_phone_size() const;
  public:
  void clear_phone();
  ::addressbook::Person_PhoneNumber* mutable_phone(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::addressbook::Person_PhoneNumber >*
      mutable_phone();
  private:
  const ::addressbook::Person_PhoneNumber& _internal_phone(int index) const;
  ::addressbook::Person_PhoneNumber* _internal_add_phone();
  public:
  const ::addressbook::Person_PhoneNumber& phone(int index) const;
  ::addressbook::Person_PhoneNumber* add_phone();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::addressbook::Person_PhoneNumber >&
      phone() const;

  // required string name = 1;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // optional string email = 3;
  bool has_email() const;
  private:
  bool _internal_has_email() const;
  public:
  void clear_email();
  const std::string& email() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_email(ArgT0&& arg0, ArgT... args);
  std::string* mutable_email();
  PROTOBUF_NODISCARD std::string* release_email();
  void set_allocated_email(std::string* email);
  private:
  const std::string& _internal_email() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_email(const std::string& value);
  std::string* _internal_mutable_email();
  public:

  // optional bytes databyte = 13;
  bool has_databyte() const;
  private:
  bool _internal_has_databyte() const;
  public:
  void clear_databyte();
  const std::string& databyte() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_databyte(ArgT0&& arg0, ArgT... args);
  std::string* mutable_databyte();
  PROTOBUF_NODISCARD std::string* release_databyte();
  void set_allocated_databyte(std::string* databyte);
  private:
  const std::string& _internal_databyte() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_databyte(const std::string& value);
  std::string* _internal_mutable_databyte();
  public:

  // required int32 id = 2;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  int32_t id() const;
  void set_id(int32_t value);
  private:
  int32_t _internal_id() const;
  void _internal_set_id(int32_t value);
  public:

  // optional sint32 data32 = 6;
  bool has_data32() const;
  private:
  bool _internal_has_data32() const;
  public:
  void clear_data32();
  int32_t data32() const;
  void set_data32(int32_t value);
  private:
  int32_t _internal_data32() const;
  void _internal_set_data32(int32_t value);
  public:

  // optional int64 data = 5;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  int64_t data() const;
  void set_data(int64_t value);
  private:
  int64_t _internal_data() const;
  void _internal_set_data(int64_t value);
  public:

  // optional sint64 data64 = 7;
  bool has_data64() const;
  private:
  bool _internal_has_data64() const;
  public:
  void clear_data64();
  int64_t data64() const;
  void set_data64(int64_t value);
  private:
  int64_t _internal_data64() const;
  void _internal_set_data64(int64_t value);
  public:

  // required double datadouble = 8;
  bool has_datadouble() const;
  private:
  bool _internal_has_datadouble() const;
  public:
  void clear_datadouble();
  double datadouble() const;
  void set_datadouble(double value);
  private:
  double _internal_datadouble() const;
  void _internal_set_datadouble(double value);
  public:

  // optional float datafloat = 9;
  bool has_datafloat() const;
  private:
  bool _internal_has_datafloat() const;
  public:
  void clear_datafloat();
  float datafloat() const;
  void set_datafloat(float value);
  private:
  float _internal_datafloat() const;
  void _internal_set_datafloat(float value);
  public:

  // optional uint32 datau32 = 10;
  bool has_datau32() const;
  private:
  bool _internal_has_datau32() const;
  public:
  void clear_datau32();
  uint32_t datau32() const;
  void set_datau32(uint32_t value);
  private:
  uint32_t _internal_datau32() const;
  void _internal_set_datau32(uint32_t value);
  public:

  // optional uint64 datau64 = 11;
  bool has_datau64() const;
  private:
  bool _internal_has_datau64() const;
  public:
  void clear_datau64();
  uint64_t datau64() const;
  void set_datau64(uint64_t value);
  private:
  uint64_t _internal_datau64() const;
  void _internal_set_datau64(uint64_t value);
  public:

  // optional bool databool = 12;
  bool has_databool() const;
  private:
  bool _internal_has_databool() const;
  public:
  void clear_databool();
  bool databool() const;
  void set_databool(bool value);
  private:
  bool _internal_databool() const;
  void _internal_set_databool(bool value);
  public:

  // optional fixed32 datafix32 = 14;
  bool has_datafix32() const;
  private:
  bool _internal_has_datafix32() const;
  public:
  void clear_datafix32();
  uint32_t datafix32() const;
  void set_datafix32(uint32_t value);
  private:
  uint32_t _internal_datafix32() const;
  void _internal_set_datafix32(uint32_t value);
  public:

  // optional fixed64 datafix64 = 15;
  bool has_datafix64() const;
  private:
  bool _internal_has_datafix64() const;
  public:
  void clear_datafix64();
  uint64_t datafix64() const;
  void set_datafix64(uint64_t value);
  private:
  uint64_t _internal_datafix64() const;
  void _internal_set_datafix64(uint64_t value);
  public:

  // optional sfixed64 datasfix64 = 17;
  bool has_datasfix64() const;
  private:
  bool _internal_has_datasfix64() const;
  public:
  void clear_datasfix64();
  int64_t datasfix64() const;
  void set_datasfix64(int64_t value);
  private:
  int64_t _internal_datasfix64() const;
  void _internal_set_datasfix64(int64_t value);
  public:

  // optional sfixed32 datasfix32 = 16;
  bool has_datasfix32() const;
  private:
  bool _internal_has_datasfix32() const;
  public:
  void clear_datasfix32();
  int32_t datasfix32() const;
  void set_datasfix32(int32_t value);
  private:
  int32_t _internal_datasfix32() const;
  void _internal_set_datasfix32(int32_t value);
  public:

  // optional float datafloat_scientific = 18;
  bool has_datafloat_scientific() const;
  private:
  bool _internal_has_datafloat_scientific() const;
  public:
  void clear_datafloat_scientific();
  float datafloat_scientific() const;
  void set_datafloat_scientific(float value);
  private:
  float _internal_datafloat_scientific() const;
  void _internal_set_datafloat_scientific(float value);
  public:

  // optional double datadouble_scientific = 19;
  bool has_datadouble_scientific() const;
  private:
  bool _internal_has_datadouble_scientific() const;
  public:
  void clear_datadouble_scientific();
  double datadouble_scientific() const;
  void set_datadouble_scientific(double value);
  private:
  double _internal_datadouble_scientific() const;
  void _internal_set_datadouble_scientific(double value);
  public:


  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline bool HasExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Person, _proto_TypeTraits, _field_type, _is_packed>& id) const {

    return _impl_._extensions_.Has(id.number());
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void ClearExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Person, _proto_TypeTraits, _field_type, _is_packed>& id) {
    _impl_._extensions_.ClearExtension(id.number());

  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline int ExtensionSize(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Person, _proto_TypeTraits, _field_type, _is_packed>& id) const {

    return _impl_._extensions_.ExtensionSize(id.number());
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Person, _proto_TypeTraits, _field_type, _is_packed>& id) const {

    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
                                  id.default_value());
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Person, _proto_TypeTraits, _field_type, _is_packed>& id) {

    return _proto_TypeTraits::Mutable(id.number(), _field_type,
                                      &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Person, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::ConstType value) {
    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);

  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetAllocatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Person, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
                                    &_impl_._extensions_);

  }
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void UnsafeArenaSetAllocatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Person, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
                                               value, &_impl_._extensions_);

  }
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  PROTOBUF_NODISCARD inline
      typename _proto_TypeTraits::Singular::MutableType
      ReleaseExtension(
          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
              Person, _proto_TypeTraits, _field_type, _is_packed>& id) {

    return _proto_TypeTraits::Release(id.number(), _field_type,
                                      &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType
  UnsafeArenaReleaseExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Person, _proto_TypeTraits, _field_type, _is_packed>& id) {

    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
                                                 &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Person, _proto_TypeTraits, _field_type, _is_packed>& id,
      int index) const {

    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Person, _proto_TypeTraits, _field_type, _is_packed>& id,
      int index) {

    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Person, _proto_TypeTraits, _field_type, _is_packed>& id,
      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);

  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Person, _proto_TypeTraits, _field_type, _is_packed>& id) {
    typename _proto_TypeTraits::Repeated::MutableType to_add =
        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);

    return to_add;
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void AddExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Person, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
                           &_impl_._extensions_);

  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
  GetRepeatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Person, _proto_TypeTraits, _field_type, _is_packed>& id) const {

    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
  MutableRepeatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Person, _proto_TypeTraits, _field_type, _is_packed>& id) {

    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
                                              _is_packed, &_impl_._extensions_);
  }

  // @@protoc_insertion_point(class_scope:addressbook.Person)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;

    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::addressbook::Person_PhoneNumber > phone_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr email_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr databyte_;
    int32_t id_;
    int32_t data32_;
    int64_t data_;
    int64_t data64_;
    double datadouble_;
    float datafloat_;
    uint32_t datau32_;
    uint64_t datau64_;
    bool databool_;
    uint32_t datafix32_;
    uint64_t datafix64_;
    int64_t datasfix64_;
    int32_t datasfix32_;
    float datafloat_scientific_;
    double datadouble_scientific_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_addressbook_2eproto;
};
// -------------------------------------------------------------------

class AddressBook final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:addressbook.AddressBook) */ {
 public:
  inline AddressBook() : AddressBook(nullptr) {}
  ~AddressBook() override;
  explicit PROTOBUF_CONSTEXPR AddressBook(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  AddressBook(const AddressBook& from);
  AddressBook(AddressBook&& from) noexcept
    : AddressBook() {
    *this = ::std::move(from);
  }

  inline AddressBook& operator=(const AddressBook& from) {
    CopyFrom(from);
    return *this;
  }
  inline AddressBook& operator=(AddressBook&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AddressBook& default_instance() {
    return *internal_default_instance();
  }
  static inline const AddressBook* internal_default_instance() {
    return reinterpret_cast<const AddressBook*>(
               &_AddressBook_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(AddressBook& a, AddressBook& b) {
    a.Swap(&b);
  }
  inline void Swap(AddressBook* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AddressBook* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  AddressBook* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AddressBook>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const AddressBook& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const AddressBook& from) {
    AddressBook::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AddressBook* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "addressbook.AddressBook";
  }
  protected:
  explicit AddressBook(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPersonFieldNumber = 1,
  };
  // repeated .addressbook.Person person = 1;
  int person_size() const;
  private:
  int _internal_person_size() const;
  public:
  void clear_person();
  ::addressbook::Person* mutable_person(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::addressbook::Person >*
      mutable_person();
  private:
  const ::addressbook::Person& _internal_person(int index) const;
  ::addressbook::Person* _internal_add_person();
  public:
  const ::addressbook::Person& person(int index) const;
  ::addressbook::Person* add_person();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::addressbook::Person >&
      person() const;

  // @@protoc_insertion_point(class_scope:addressbook.AddressBook)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::addressbook::Person > person_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_addressbook_2eproto;
};
// ===================================================================

static const int kHobbyFieldNumber = 100;
extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::addressbook::Person,
    ::PROTOBUF_NAMESPACE_ID::internal::StringTypeTraits, 9, false >
  hobby;

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

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// Person_PhoneNumber

// required string number = 1;
inline bool Person_PhoneNumber::_internal_has_number() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Person_PhoneNumber::has_number() const {
  return _internal_has_number();
}
inline void Person_PhoneNumber::clear_number() {
  _impl_.number_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Person_PhoneNumber::number() const {
  // @@protoc_insertion_point(field_get:addressbook.Person.PhoneNumber.number)
  return _internal_number();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Person_PhoneNumber::set_number(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.number_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:addressbook.Person.PhoneNumber.number)
}
inline std::string* Person_PhoneNumber::mutable_number() {
  std::string* _s = _internal_mutable_number();
  // @@protoc_insertion_point(field_mutable:addressbook.Person.PhoneNumber.number)
  return _s;
}
inline const std::string& Person_PhoneNumber::_internal_number() const {
  return _impl_.number_.Get();
}
inline void Person_PhoneNumber::_internal_set_number(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.number_.Set(value, GetArenaForAllocation());
}
inline std::string* Person_PhoneNumber::_internal_mutable_number() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.number_.Mutable(GetArenaForAllocation());
}
inline std::string* Person_PhoneNumber::release_number() {
  // @@protoc_insertion_point(field_release:addressbook.Person.PhoneNumber.number)
  if (!_internal_has_number()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.number_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.number_.IsDefault()) {
    _impl_.number_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Person_PhoneNumber::set_allocated_number(std::string* number) {
  if (number != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.number_.SetAllocated(number, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.number_.IsDefault()) {
    _impl_.number_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:addressbook.Person.PhoneNumber.number)
}

// optional .addressbook.Person.PhoneType type = 2 [default = HOME];
inline bool Person_PhoneNumber::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Person_PhoneNumber::has_type() const {
  return _internal_has_type();
}
inline void Person_PhoneNumber::clear_type() {
  _impl_.type_ = 1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::addressbook::Person_PhoneType Person_PhoneNumber::_internal_type() const {
  return static_cast< ::addressbook::Person_PhoneType >(_impl_.type_);
}
inline ::addressbook::Person_PhoneType Person_PhoneNumber::type() const {
  // @@protoc_insertion_point(field_get:addressbook.Person.PhoneNumber.type)
  return _internal_type();
}
inline void Person_PhoneNumber::_internal_set_type(::addressbook::Person_PhoneType value) {
  assert(::addressbook::Person_PhoneType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.type_ = value;
}
inline void Person_PhoneNumber::set_type(::addressbook::Person_PhoneType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:addressbook.Person.PhoneNumber.type)
}

// -------------------------------------------------------------------

// Person

// required string name = 1;
inline bool Person::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Person::has_name() const {
  return _internal_has_name();
}
inline void Person::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Person::name() const {
  // @@protoc_insertion_point(field_get:addressbook.Person.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Person::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:addressbook.Person.name)
}
inline std::string* Person::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:addressbook.Person.name)
  return _s;
}
inline const std::string& Person::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Person::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Person::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Person::release_name() {
  // @@protoc_insertion_point(field_release:addressbook.Person.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Person::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:addressbook.Person.name)
}

// required int32 id = 2;
inline bool Person::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Person::has_id() const {
  return _internal_has_id();
}
inline void Person::clear_id() {
  _impl_.id_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t Person::_internal_id() const {
  return _impl_.id_;
}
inline int32_t Person::id() const {
  // @@protoc_insertion_point(field_get:addressbook.Person.id)
  return _internal_id();
}
inline void Person::_internal_set_id(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.id_ = value;
}
inline void Person::set_id(int32_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:addressbook.Person.id)
}

// optional string email = 3;
inline bool Person::_internal_has_email() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Person::has_email() const {
  return _internal_has_email();
}
inline void Person::clear_email() {
  _impl_.email_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Person::email() const {
  // @@protoc_insertion_point(field_get:addressbook.Person.email)
  return _internal_email();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Person::set_email(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.email_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:addressbook.Person.email)
}
inline std::string* Person::mutable_email() {
  std::string* _s = _internal_mutable_email();
  // @@protoc_insertion_point(field_mutable:addressbook.Person.email)
  return _s;
}
inline const std::string& Person::_internal_email() const {
  return _impl_.email_.Get();
}
inline void Person::_internal_set_email(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.email_.Set(value, GetArenaForAllocation());
}
inline std::string* Person::_internal_mutable_email() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.email_.Mutable(GetArenaForAllocation());
}
inline std::string* Person::release_email() {
  // @@protoc_insertion_point(field_release:addressbook.Person.email)
  if (!_internal_has_email()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.email_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.email_.IsDefault()) {
    _impl_.email_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Person::set_allocated_email(std::string* email) {
  if (email != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.email_.SetAllocated(email, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.email_.IsDefault()) {
    _impl_.email_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:addressbook.Person.email)
}

// repeated .addressbook.Person.PhoneNumber phone = 4;
inline int Person::_internal_phone_size() const {
  return _impl_.phone_.size();
}
inline int Person::phone_size() const {
  return _internal_phone_size();
}
inline void Person::clear_phone() {
  _impl_.phone_.Clear();
}
inline ::addressbook::Person_PhoneNumber* Person::mutable_phone(int index) {
  // @@protoc_insertion_point(field_mutable:addressbook.Person.phone)
  return _impl_.phone_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::addressbook::Person_PhoneNumber >*
Person::mutable_phone() {
  // @@protoc_insertion_point(field_mutable_list:addressbook.Person.phone)
  return &_impl_.phone_;
}
inline const ::addressbook::Person_PhoneNumber& Person::_internal_phone(int index) const {
  return _impl_.phone_.Get(index);
}
inline const ::addressbook::Person_PhoneNumber& Person::phone(int index) const {
  // @@protoc_insertion_point(field_get:addressbook.Person.phone)
  return _internal_phone(index);
}
inline ::addressbook::Person_PhoneNumber* Person::_internal_add_phone() {
  return _impl_.phone_.Add();
}
inline ::addressbook::Person_PhoneNumber* Person::add_phone() {
  ::addressbook::Person_PhoneNumber* _add = _internal_add_phone();
  // @@protoc_insertion_point(field_add:addressbook.Person.phone)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::addressbook::Person_PhoneNumber >&
Person::phone() const {
  // @@protoc_insertion_point(field_list:addressbook.Person.phone)
  return _impl_.phone_;
}

// optional int64 data = 5;
inline bool Person::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Person::has_data() const {
  return _internal_has_data();
}
inline void Person::clear_data() {
  _impl_.data_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int64_t Person::_internal_data() const {
  return _impl_.data_;
}
inline int64_t Person::data() const {
  // @@protoc_insertion_point(field_get:addressbook.Person.data)
  return _internal_data();
}
inline void Person::_internal_set_data(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.data_ = value;
}
inline void Person::set_data(int64_t value) {
  _internal_set_data(value);
  // @@protoc_insertion_point(field_set:addressbook.Person.data)
}

// optional sint32 data32 = 6;
inline bool Person::_internal_has_data32() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Person::has_data32() const {
  return _internal_has_data32();
}
inline void Person::clear_data32() {
  _impl_.data32_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t Person::_internal_data32() const {
  return _impl_.data32_;
}
inline int32_t Person::data32() const {
  // @@protoc_insertion_point(field_get:addressbook.Person.data32)
  return _internal_data32();
}
inline void Person::_internal_set_data32(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.data32_ = value;
}
inline void Person::set_data32(int32_t value) {
  _internal_set_data32(value);
  // @@protoc_insertion_point(field_set:addressbook.Person.data32)
}

// optional sint64 data64 = 7;
inline bool Person::_internal_has_data64() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Person::has_data64() const {
  return _internal_has_data64();
}
inline void Person::clear_data64() {
  _impl_.data64_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int64_t Person::_internal_data64() const {
  return _impl_.data64_;
}
inline int64_t Person::data64() const {
  // @@protoc_insertion_point(field_get:addressbook.Person.data64)
  return _internal_data64();
}
inline void Person::_internal_set_data64(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.data64_ = value;
}
inline void Person::set_data64(int64_t value) {
  _internal_set_data64(value);
  // @@protoc_insertion_point(field_set:addressbook.Person.data64)
}

// required double datadouble = 8;
inline bool Person::_internal_has_datadouble() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Person::has_datadouble() const {
  return _internal_has_datadouble();
}
inline void Person::clear_datadouble() {
  _impl_.datadouble_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline double Person::_internal_datadouble() const {
  return _impl_.datadouble_;
}
inline double Person::datadouble() const {
  // @@protoc_insertion_point(field_get:addressbook.Person.datadouble)
  return _internal_datadouble();
}
inline void Person::_internal_set_datadouble(double value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.datadouble_ = value;
}
inline void Person::set_datadouble(double value) {
  _internal_set_datadouble(value);
  // @@protoc_insertion_point(field_set:addressbook.Person.datadouble)
}

// optional float datafloat = 9;
inline bool Person::_internal_has_datafloat() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Person::has_datafloat() const {
  return _internal_has_datafloat();
}
inline void Person::clear_datafloat() {
  _impl_.datafloat_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline float Person::_internal_datafloat() const {
  return _impl_.datafloat_;
}
inline float Person::datafloat() const {
  // @@protoc_insertion_point(field_get:addressbook.Person.datafloat)
  return _internal_datafloat();
}
inline void Person::_internal_set_datafloat(float value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.datafloat_ = value;
}
inline void Person::set_datafloat(float value) {
  _internal_set_datafloat(value);
  // @@protoc_insertion_point(field_set:addressbook.Person.datafloat)
}

// optional uint32 datau32 = 10;
inline bool Person::_internal_has_datau32() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Person::has_datau32() const {
  return _internal_has_datau32();
}
inline void Person::clear_datau32() {
  _impl_.datau32_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t Person::_internal_datau32() const {
  return _impl_.datau32_;
}
inline uint32_t Person::datau32() const {
  // @@protoc_insertion_point(field_get:addressbook.Person.datau32)
  return _internal_datau32();
}
inline void Person::_internal_set_datau32(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.datau32_ = value;
}
inline void Person::set_datau32(uint32_t value) {
  _internal_set_datau32(value);
  // @@protoc_insertion_point(field_set:addressbook.Person.datau32)
}

// optional uint64 datau64 = 11;
inline bool Person::_internal_has_datau64() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Person::has_datau64() const {
  return _internal_has_datau64();
}
inline void Person::clear_datau64() {
  _impl_.datau64_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint64_t Person::_internal_datau64() const {
  return _impl_.datau64_;
}
inline uint64_t Person::datau64() const {
  // @@protoc_insertion_point(field_get:addressbook.Person.datau64)
  return _internal_datau64();
}
inline void Person::_internal_set_datau64(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.datau64_ = value;
}
inline void Person::set_datau64(uint64_t value) {
  _internal_set_datau64(value);
  // @@protoc_insertion_point(field_set:addressbook.Person.datau64)
}

// optional bool databool = 12;
inline bool Person::_internal_has_databool() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool Person::has_databool() const {
  return _internal_has_databool();
}
inline void Person::clear_databool() {
  _impl_.databool_ = false;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline bool Person::_internal_databool() const {
  return _impl_.databool_;
}
inline bool Person::databool() const {
  // @@protoc_insertion_point(field_get:addressbook.Person.databool)
  return _internal_databool();
}
inline void Person::_internal_set_databool(bool value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.databool_ = value;
}
inline void Person::set_databool(bool value) {
  _internal_set_databool(value);
  // @@protoc_insertion_point(field_set:addressbook.Person.databool)
}

// optional bytes databyte = 13;
inline bool Person::_internal_has_databyte() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Person::has_databyte() const {
  return _internal_has_databyte();
}
inline void Person::clear_databyte() {
  _impl_.databyte_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Person::databyte() const {
  // @@protoc_insertion_point(field_get:addressbook.Person.databyte)
  return _internal_databyte();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Person::set_databyte(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.databyte_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:addressbook.Person.databyte)
}
inline std::string* Person::mutable_databyte() {
  std::string* _s = _internal_mutable_databyte();
  // @@protoc_insertion_point(field_mutable:addressbook.Person.databyte)
  return _s;
}
inline const std::string& Person::_internal_databyte() const {
  return _impl_.databyte_.Get();
}
inline void Person::_internal_set_databyte(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.databyte_.Set(value, GetArenaForAllocation());
}
inline std::string* Person::_internal_mutable_databyte() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.databyte_.Mutable(GetArenaForAllocation());
}
inline std::string* Person::release_databyte() {
  // @@protoc_insertion_point(field_release:addressbook.Person.databyte)
  if (!_internal_has_databyte()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.databyte_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.databyte_.IsDefault()) {
    _impl_.databyte_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Person::set_allocated_databyte(std::string* databyte) {
  if (databyte != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.databyte_.SetAllocated(databyte, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.databyte_.IsDefault()) {
    _impl_.databyte_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:addressbook.Person.databyte)
}

// optional fixed32 datafix32 = 14;
inline bool Person::_internal_has_datafix32() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool Person::has_datafix32() const {
  return _internal_has_datafix32();
}
inline void Person::clear_datafix32() {
  _impl_.datafix32_ = 0u;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline uint32_t Person::_internal_datafix32() const {
  return _impl_.datafix32_;
}
inline uint32_t Person::datafix32() const {
  // @@protoc_insertion_point(field_get:addressbook.Person.datafix32)
  return _internal_datafix32();
}
inline void Person::_internal_set_datafix32(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.datafix32_ = value;
}
inline void Person::set_datafix32(uint32_t value) {
  _internal_set_datafix32(value);
  // @@protoc_insertion_point(field_set:addressbook.Person.datafix32)
}

// optional fixed64 datafix64 = 15;
inline bool Person::_internal_has_datafix64() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool Person::has_datafix64() const {
  return _internal_has_datafix64();
}
inline void Person::clear_datafix64() {
  _impl_.datafix64_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline uint64_t Person::_internal_datafix64() const {
  return _impl_.datafix64_;
}
inline uint64_t Person::datafix64() const {
  // @@protoc_insertion_point(field_get:addressbook.Person.datafix64)
  return _internal_datafix64();
}
inline void Person::_internal_set_datafix64(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.datafix64_ = value;
}
inline void Person::set_datafix64(uint64_t value) {
  _internal_set_datafix64(value);
  // @@protoc_insertion_point(field_set:addressbook.Person.datafix64)
}

// optional sfixed32 datasfix32 = 16;
inline bool Person::_internal_has_datasfix32() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool Person::has_datasfix32() const {
  return _internal_has_datasfix32();
}
inline void Person::clear_datasfix32() {
  _impl_.datasfix32_ = 0;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline int32_t Person::_internal_datasfix32() const {
  return _impl_.datasfix32_;
}
inline int32_t Person::datasfix32() const {
  // @@protoc_insertion_point(field_get:addressbook.Person.datasfix32)
  return _internal_datasfix32();
}
inline void Person::_internal_set_datasfix32(int32_t value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.datasfix32_ = value;
}
inline void Person::set_datasfix32(int32_t value) {
  _internal_set_datasfix32(value);
  // @@protoc_insertion_point(field_set:addressbook.Person.datasfix32)
}

// optional sfixed64 datasfix64 = 17;
inline bool Person::_internal_has_datasfix64() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool Person::has_datasfix64() const {
  return _internal_has_datasfix64();
}
inline void Person::clear_datasfix64() {
  _impl_.datasfix64_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline int64_t Person::_internal_datasfix64() const {
  return _impl_.datasfix64_;
}
inline int64_t Person::datasfix64() const {
  // @@protoc_insertion_point(field_get:addressbook.Person.datasfix64)
  return _internal_datasfix64();
}
inline void Person::_internal_set_datasfix64(int64_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.datasfix64_ = value;
}
inline void Person::set_datasfix64(int64_t value) {
  _internal_set_datasfix64(value);
  // @@protoc_insertion_point(field_set:addressbook.Person.datasfix64)
}

// optional float datafloat_scientific = 18;
inline bool Person::_internal_has_datafloat_scientific() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool Person::has_datafloat_scientific() const {
  return _internal_has_datafloat_scientific();
}
inline void Person::clear_datafloat_scientific() {
  _impl_.datafloat_scientific_ = 0;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline float Person::_internal_datafloat_scientific() const {
  return _impl_.datafloat_scientific_;
}
inline float Person::datafloat_scientific() const {
  // @@protoc_insertion_point(field_get:addressbook.Person.datafloat_scientific)
  return _internal_datafloat_scientific();
}
inline void Person::_internal_set_datafloat_scientific(float value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.datafloat_scientific_ = value;
}
inline void Person::set_datafloat_scientific(float value) {
  _internal_set_datafloat_scientific(value);
  // @@protoc_insertion_point(field_set:addressbook.Person.datafloat_scientific)
}

// optional double datadouble_scientific = 19;
inline bool Person::_internal_has_datadouble_scientific() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool Person::has_datadouble_scientific() const {
  return _internal_has_datadouble_scientific();
}
inline void Person::clear_datadouble_scientific() {
  _impl_.datadouble_scientific_ = 0;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline double Person::_internal_datadouble_scientific() const {
  return _impl_.datadouble_scientific_;
}
inline double Person::datadouble_scientific() const {
  // @@protoc_insertion_point(field_get:addressbook.Person.datadouble_scientific)
  return _internal_datadouble_scientific();
}
inline void Person::_internal_set_datadouble_scientific(double value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.datadouble_scientific_ = value;
}
inline void Person::set_datadouble_scientific(double value) {
  _internal_set_datadouble_scientific(value);
  // @@protoc_insertion_point(field_set:addressbook.Person.datadouble_scientific)
}

// -------------------------------------------------------------------

// AddressBook

// repeated .addressbook.Person person = 1;
inline int AddressBook::_internal_person_size() const {
  return _impl_.person_.size();
}
inline int AddressBook::person_size() const {
  return _internal_person_size();
}
inline void AddressBook::clear_person() {
  _impl_.person_.Clear();
}
inline ::addressbook::Person* AddressBook::mutable_person(int index) {
  // @@protoc_insertion_point(field_mutable:addressbook.AddressBook.person)
  return _impl_.person_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::addressbook::Person >*
AddressBook::mutable_person() {
  // @@protoc_insertion_point(field_mutable_list:addressbook.AddressBook.person)
  return &_impl_.person_;
}
inline const ::addressbook::Person& AddressBook::_internal_person(int index) const {
  return _impl_.person_.Get(index);
}
inline const ::addressbook::Person& AddressBook::person(int index) const {
  // @@protoc_insertion_point(field_get:addressbook.AddressBook.person)
  return _internal_person(index);
}
inline ::addressbook::Person* AddressBook::_internal_add_person() {
  return _impl_.person_.Add();
}
inline ::addressbook::Person* AddressBook::add_person() {
  ::addressbook::Person* _add = _internal_add_person();
  // @@protoc_insertion_point(field_add:addressbook.AddressBook.person)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::addressbook::Person >&
AddressBook::person() const {
  // @@protoc_insertion_point(field_list:addressbook.AddressBook.person)
  return _impl_.person_;
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace addressbook

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::addressbook::Person_PhoneType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::addressbook::Person_PhoneType>() {
  return ::addressbook::Person_PhoneType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_addressbook_2eproto

Coverage Report

Created: 2025-12-17 06:32