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

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_addressbook1_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_addressbook1_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_addressbook1_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_addressbook1_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_addressbook1_2eproto;
class AddressBook;
struct AddressBookDefaultTypeInternal;
extern AddressBookDefaultTypeInternal _AddressBook_default_instance_;
class Content;
struct ContentDefaultTypeInternal;
extern ContentDefaultTypeInternal _Content_default_instance_;
class Ext;
struct ExtDefaultTypeInternal;
extern ExtDefaultTypeInternal _Ext_default_instance_;
class JsonContextBody;
struct JsonContextBodyDefaultTypeInternal;
extern JsonContextBodyDefaultTypeInternal _JsonContextBody_default_instance_;
class PersonInfo;
struct PersonInfoDefaultTypeInternal;
extern PersonInfoDefaultTypeInternal _PersonInfo_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::AddressBook* Arena::CreateMaybeMessage<::AddressBook>(Arena*);
template<> ::Content* Arena::CreateMaybeMessage<::Content>(Arena*);
template<> ::Ext* Arena::CreateMaybeMessage<::Ext>(Arena*);
template<> ::JsonContextBody* Arena::CreateMaybeMessage<::JsonContextBody>(Arena*);
template<> ::PersonInfo* Arena::CreateMaybeMessage<::PersonInfo>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

enum Ext_PhoneType : int {
  Ext_PhoneType_MOBILE = 0,
  Ext_PhoneType_HOME = 1,
  Ext_PhoneType_WORK = 2
};
bool Ext_PhoneType_IsValid(int value);
constexpr Ext_PhoneType Ext_PhoneType_PhoneType_MIN = Ext_PhoneType_MOBILE;
constexpr Ext_PhoneType Ext_PhoneType_PhoneType_MAX = Ext_PhoneType_WORK;
constexpr int Ext_PhoneType_PhoneType_ARRAYSIZE = Ext_PhoneType_PhoneType_MAX + 1;

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

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

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

  inline Ext& operator=(const Ext& from) {
    CopyFrom(from);
    return *this;
  }
  inline Ext& operator=(Ext&& 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 Ext& default_instance() {
    return *internal_default_instance();
  }
  static inline const Ext* internal_default_instance() {
    return reinterpret_cast<const Ext*>(
               &_Ext_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(Ext& a, Ext& b) {
    a.Swap(&b);
  }
  inline void Swap(Ext* 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(Ext* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Ext* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Ext>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Ext& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Ext& from) {
    Ext::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(Ext* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Ext";
  }
  protected:
  explicit Ext(::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 Ext_PhoneType PhoneType;
  static constexpr PhoneType MOBILE =
    Ext_PhoneType_MOBILE;
  static constexpr PhoneType HOME =
    Ext_PhoneType_HOME;
  static constexpr PhoneType WORK =
    Ext_PhoneType_WORK;
  static inline bool PhoneType_IsValid(int value) {
    return Ext_PhoneType_IsValid(value);
  }
  static constexpr PhoneType PhoneType_MIN =
    Ext_PhoneType_PhoneType_MIN;
  static constexpr PhoneType PhoneType_MAX =
    Ext_PhoneType_PhoneType_MAX;
  static constexpr int PhoneType_ARRAYSIZE =
    Ext_PhoneType_PhoneType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  PhoneType_descriptor() {
    return Ext_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 Ext_PhoneType_Name(enum_t_value);
  }
  static inline bool PhoneType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      PhoneType* value) {
    return Ext_PhoneType_Parse(name, value);
  }

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

  enum : int {
    kDatabyteFieldNumber = 3,
    kAgeFieldNumber = 2,
    kEnumtypeFieldNumber = 4,
  };
  // required bytes databyte = 3;
  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:

  // optional fixed32 age = 2;
  bool has_age() const;
  private:
  bool _internal_has_age() const;
  public:
  void clear_age();
  uint32_t age() const;
  void set_age(uint32_t value);
  private:
  uint32_t _internal_age() const;
  void _internal_set_age(uint32_t value);
  public:

  // optional .Ext.PhoneType enumtype = 4 [default = HOME];
  bool has_enumtype() const;
  private:
  bool _internal_has_enumtype() const;
  public:
  void clear_enumtype();
  ::Ext_PhoneType enumtype() const;
  void set_enumtype(::Ext_PhoneType value);
  private:
  ::Ext_PhoneType _internal_enumtype() const;
  void _internal_set_enumtype(::Ext_PhoneType value);
  public:

  // @@protoc_insertion_point(class_scope:Ext)
 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 databyte_;
    uint32_t age_;
    int enumtype_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_addressbook1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline Content& operator=(const Content& from) {
    CopyFrom(from);
    return *this;
  }
  inline Content& operator=(Content&& 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 Content& default_instance() {
    return *internal_default_instance();
  }
  static inline const Content* internal_default_instance() {
    return reinterpret_cast<const Content*>(
               &_Content_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(Content& a, Content& b) {
    a.Swap(&b);
  }
  inline void Swap(Content* 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(Content* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Content* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Content>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Content& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Content& from) {
    Content::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(Content* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Content";
  }
  protected:
  explicit Content(::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 {
    kUidFieldNumber = 1,
    kExtFieldNumber = 17,
    kDistanceFieldNumber = 16,
  };
  // optional string uid = 1;
  bool has_uid() const;
  private:
  bool _internal_has_uid() const;
  public:
  void clear_uid();
  const std::string& uid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_uid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_uid();
  PROTOBUF_NODISCARD std::string* release_uid();
  void set_allocated_uid(std::string* uid);
  private:
  const std::string& _internal_uid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_uid(const std::string& value);
  std::string* _internal_mutable_uid();
  public:

  // optional .Ext ext = 17;
  bool has_ext() const;
  private:
  bool _internal_has_ext() const;
  public:
  void clear_ext();
  const ::Ext& ext() const;
  PROTOBUF_NODISCARD ::Ext* release_ext();
  ::Ext* mutable_ext();
  void set_allocated_ext(::Ext* ext);
  private:
  const ::Ext& _internal_ext() const;
  ::Ext* _internal_mutable_ext();
  public:
  void unsafe_arena_set_allocated_ext(
      ::Ext* ext);
  ::Ext* unsafe_arena_release_ext();

  // required float distance = 16;
  bool has_distance() const;
  private:
  bool _internal_has_distance() const;
  public:
  void clear_distance();
  float distance() const;
  void set_distance(float value);
  private:
  float _internal_distance() const;
  void _internal_set_distance(float value);
  public:

  // @@protoc_insertion_point(class_scope:Content)
 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 uid_;
    ::Ext* ext_;
    float distance_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_addressbook1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline JsonContextBody& operator=(const JsonContextBody& from) {
    CopyFrom(from);
    return *this;
  }
  inline JsonContextBody& operator=(JsonContextBody&& 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 JsonContextBody& default_instance() {
    return *internal_default_instance();
  }
  static inline const JsonContextBody* internal_default_instance() {
    return reinterpret_cast<const JsonContextBody*>(
               &_JsonContextBody_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(JsonContextBody& a, JsonContextBody& b) {
    a.Swap(&b);
  }
  inline void Swap(JsonContextBody* 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(JsonContextBody* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  JsonContextBody* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<JsonContextBody>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const JsonContextBody& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const JsonContextBody& from) {
    JsonContextBody::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(JsonContextBody* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "JsonContextBody";
  }
  protected:
  explicit JsonContextBody(::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 {
    kContentFieldNumber = 4,
    kDataFieldNumber = 5,
    kInfoFieldNumber = 6,
    kTypeFieldNumber = 1,
    kSpurFieldNumber = 3,
    kJudgeFieldNumber = 2,
    kTextFieldNumber = 7,
  };
  // repeated .Content content = 4;
  int content_size() const;
  private:
  int _internal_content_size() const;
  public:
  void clear_content();
  ::Content* mutable_content(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Content >*
      mutable_content();
  private:
  const ::Content& _internal_content(int index) const;
  ::Content* _internal_add_content();
  public:
  const ::Content& content(int index) const;
  ::Content* add_content();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Content >&
      content() const;

  // repeated int32 data = 5;
  int data_size() const;
  private:
  int _internal_data_size() const;
  public:
  void clear_data();
  private:
  int32_t _internal_data(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_data() const;
  void _internal_add_data(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_data();
  public:
  int32_t data(int index) const;
  void set_data(int index, int32_t value);
  void add_data(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_data();

  // repeated string info = 6;
  int info_size() const;
  private:
  int _internal_info_size() const;
  public:
  void clear_info();
  const std::string& info(int index) const;
  std::string* mutable_info(int index);
  void set_info(int index, const std::string& value);
  void set_info(int index, std::string&& value);
  void set_info(int index, const char* value);
  void set_info(int index, const char* value, size_t size);
  std::string* add_info();
  void add_info(const std::string& value);
  void add_info(std::string&& value);
  void add_info(const char* value);
  void add_info(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& info() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_info();
  private:
  const std::string& _internal_info(int index) const;
  std::string* _internal_add_info();
  public:

  // optional int64 type = 1;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  int64_t type() const;
  void set_type(int64_t value);
  private:
  int64_t _internal_type() const;
  void _internal_set_type(int64_t value);
  public:

  // required double spur = 3;
  bool has_spur() const;
  private:
  bool _internal_has_spur() const;
  public:
  void clear_spur();
  double spur() const;
  void set_spur(double value);
  private:
  double _internal_spur() const;
  void _internal_set_spur(double value);
  public:

  // required bool judge = 2;
  bool has_judge() const;
  private:
  bool _internal_has_judge() const;
  public:
  void clear_judge();
  bool judge() const;
  void set_judge(bool value);
  private:
  bool _internal_judge() const;
  void _internal_set_judge(bool value);
  public:

  // optional float text = 7;
  bool has_text() const;
  private:
  bool _internal_has_text() const;
  public:
  void clear_text();
  float text() const;
  void set_text(float value);
  private:
  float _internal_text() const;
  void _internal_set_text(float value);
  public:

  // @@protoc_insertion_point(class_scope:JsonContextBody)
 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::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Content > content_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > data_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> info_;
    int64_t type_;
    double spur_;
    bool judge_;
    float text_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_addressbook1_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline PersonInfo& operator=(const PersonInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline PersonInfo& operator=(PersonInfo&& 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 PersonInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const PersonInfo* internal_default_instance() {
    return reinterpret_cast<const PersonInfo*>(
               &_PersonInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(PersonInfo& a, PersonInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(PersonInfo* 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(PersonInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  PersonInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PersonInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PersonInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PersonInfo& from) {
    PersonInfo::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(PersonInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "PersonInfo";
  }
  protected:
  explicit PersonInfo(::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 {
    kNameFieldNumber = 1,
    kJsonBodyFieldNumber = 18,
    kIdFieldNumber = 2,
  };
  // optional 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 .JsonContextBody json_body = 18;
  bool has_json_body() const;
  private:
  bool _internal_has_json_body() const;
  public:
  void clear_json_body();
  const ::JsonContextBody& json_body() const;
  PROTOBUF_NODISCARD ::JsonContextBody* release_json_body();
  ::JsonContextBody* mutable_json_body();
  void set_allocated_json_body(::JsonContextBody* json_body);
  private:
  const ::JsonContextBody& _internal_json_body() const;
  ::JsonContextBody* _internal_mutable_json_body();
  public:
  void unsafe_arena_set_allocated_json_body(
      ::JsonContextBody* json_body);
  ::JsonContextBody* unsafe_arena_release_json_body();

  // optional 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:

  // @@protoc_insertion_point(class_scope:PersonInfo)
 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 name_;
    ::JsonContextBody* json_body_;
    int32_t id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_addressbook1_2eproto;
};
// -------------------------------------------------------------------

class AddressBook final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition: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 =
    4;

  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";
  }
  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 .PersonInfo person = 1;
  int person_size() const;
  private:
  int _internal_person_size() const;
  public:
  void clear_person();
  ::PersonInfo* mutable_person(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PersonInfo >*
      mutable_person();
  private:
  const ::PersonInfo& _internal_person(int index) const;
  ::PersonInfo* _internal_add_person();
  public:
  const ::PersonInfo& person(int index) const;
  ::PersonInfo* add_person();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PersonInfo >&
      person() const;

  // @@protoc_insertion_point(class_scope: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< ::PersonInfo > person_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_addressbook1_2eproto;
};
// ===================================================================


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

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

// optional fixed32 age = 2;
inline bool Ext::_internal_has_age() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Ext::has_age() const {
  return _internal_has_age();
}
inline void Ext::clear_age() {
  _impl_.age_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t Ext::_internal_age() const {
  return _impl_.age_;
}
inline uint32_t Ext::age() const {
  // @@protoc_insertion_point(field_get:Ext.age)
  return _internal_age();
}
inline void Ext::_internal_set_age(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.age_ = value;
}
inline void Ext::set_age(uint32_t value) {
  _internal_set_age(value);
  // @@protoc_insertion_point(field_set:Ext.age)
}

// required bytes databyte = 3;
inline bool Ext::_internal_has_databyte() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Ext::has_databyte() const {
  return _internal_has_databyte();
}
inline void Ext::clear_databyte() {
  _impl_.databyte_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Ext::databyte() const {
  // @@protoc_insertion_point(field_get:Ext.databyte)
  return _internal_databyte();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Ext::set_databyte(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.databyte_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Ext.databyte)
}
inline std::string* Ext::mutable_databyte() {
  std::string* _s = _internal_mutable_databyte();
  // @@protoc_insertion_point(field_mutable:Ext.databyte)
  return _s;
}
inline const std::string& Ext::_internal_databyte() const {
  return _impl_.databyte_.Get();
}
inline void Ext::_internal_set_databyte(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.databyte_.Set(value, GetArenaForAllocation());
}
inline std::string* Ext::_internal_mutable_databyte() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.databyte_.Mutable(GetArenaForAllocation());
}
inline std::string* Ext::release_databyte() {
  // @@protoc_insertion_point(field_release:Ext.databyte)
  if (!_internal_has_databyte()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 Ext::set_allocated_databyte(std::string* databyte) {
  if (databyte != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:Ext.databyte)
}

// optional .Ext.PhoneType enumtype = 4 [default = HOME];
inline bool Ext::_internal_has_enumtype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Ext::has_enumtype() const {
  return _internal_has_enumtype();
}
inline void Ext::clear_enumtype() {
  _impl_.enumtype_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::Ext_PhoneType Ext::_internal_enumtype() const {
  return static_cast< ::Ext_PhoneType >(_impl_.enumtype_);
}
inline ::Ext_PhoneType Ext::enumtype() const {
  // @@protoc_insertion_point(field_get:Ext.enumtype)
  return _internal_enumtype();
}
inline void Ext::_internal_set_enumtype(::Ext_PhoneType value) {
  assert(::Ext_PhoneType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.enumtype_ = value;
}
inline void Ext::set_enumtype(::Ext_PhoneType value) {
  _internal_set_enumtype(value);
  // @@protoc_insertion_point(field_set:Ext.enumtype)
}

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

// Content

// optional string uid = 1;
inline bool Content::_internal_has_uid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Content::has_uid() const {
  return _internal_has_uid();
}
inline void Content::clear_uid() {
  _impl_.uid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Content::uid() const {
  // @@protoc_insertion_point(field_get:Content.uid)
  return _internal_uid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Content::set_uid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.uid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Content.uid)
}
inline std::string* Content::mutable_uid() {
  std::string* _s = _internal_mutable_uid();
  // @@protoc_insertion_point(field_mutable:Content.uid)
  return _s;
}
inline const std::string& Content::_internal_uid() const {
  return _impl_.uid_.Get();
}
inline void Content::_internal_set_uid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.uid_.Set(value, GetArenaForAllocation());
}
inline std::string* Content::_internal_mutable_uid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.uid_.Mutable(GetArenaForAllocation());
}
inline std::string* Content::release_uid() {
  // @@protoc_insertion_point(field_release:Content.uid)
  if (!_internal_has_uid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.uid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.uid_.IsDefault()) {
    _impl_.uid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Content::set_allocated_uid(std::string* uid) {
  if (uid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.uid_.SetAllocated(uid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.uid_.IsDefault()) {
    _impl_.uid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Content.uid)
}

// required float distance = 16;
inline bool Content::_internal_has_distance() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Content::has_distance() const {
  return _internal_has_distance();
}
inline void Content::clear_distance() {
  _impl_.distance_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float Content::_internal_distance() const {
  return _impl_.distance_;
}
inline float Content::distance() const {
  // @@protoc_insertion_point(field_get:Content.distance)
  return _internal_distance();
}
inline void Content::_internal_set_distance(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.distance_ = value;
}
inline void Content::set_distance(float value) {
  _internal_set_distance(value);
  // @@protoc_insertion_point(field_set:Content.distance)
}

// optional .Ext ext = 17;
inline bool Content::_internal_has_ext() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.ext_ != nullptr);
  return value;
}
inline bool Content::has_ext() const {
  return _internal_has_ext();
}
inline void Content::clear_ext() {
  if (_impl_.ext_ != nullptr) _impl_.ext_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::Ext& Content::_internal_ext() const {
  const ::Ext* p = _impl_.ext_;
  return p != nullptr ? *p : reinterpret_cast<const ::Ext&>(
      ::_Ext_default_instance_);
}
inline const ::Ext& Content::ext() const {
  // @@protoc_insertion_point(field_get:Content.ext)
  return _internal_ext();
}
inline void Content::unsafe_arena_set_allocated_ext(
    ::Ext* ext) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ext_);
  }
  _impl_.ext_ = ext;
  if (ext) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Content.ext)
}
inline ::Ext* Content::release_ext() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::Ext* temp = _impl_.ext_;
  _impl_.ext_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::Ext* Content::unsafe_arena_release_ext() {
  // @@protoc_insertion_point(field_release:Content.ext)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::Ext* temp = _impl_.ext_;
  _impl_.ext_ = nullptr;
  return temp;
}
inline ::Ext* Content::_internal_mutable_ext() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.ext_ == nullptr) {
    auto* p = CreateMaybeMessage<::Ext>(GetArenaForAllocation());
    _impl_.ext_ = p;
  }
  return _impl_.ext_;
}
inline ::Ext* Content::mutable_ext() {
  ::Ext* _msg = _internal_mutable_ext();
  // @@protoc_insertion_point(field_mutable:Content.ext)
  return _msg;
}
inline void Content::set_allocated_ext(::Ext* ext) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.ext_;
  }
  if (ext) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(ext);
    if (message_arena != submessage_arena) {
      ext = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ext, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.ext_ = ext;
  // @@protoc_insertion_point(field_set_allocated:Content.ext)
}

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

// JsonContextBody

// optional int64 type = 1;
inline bool JsonContextBody::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool JsonContextBody::has_type() const {
  return _internal_has_type();
}
inline void JsonContextBody::clear_type() {
  _impl_.type_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int64_t JsonContextBody::_internal_type() const {
  return _impl_.type_;
}
inline int64_t JsonContextBody::type() const {
  // @@protoc_insertion_point(field_get:JsonContextBody.type)
  return _internal_type();
}
inline void JsonContextBody::_internal_set_type(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.type_ = value;
}
inline void JsonContextBody::set_type(int64_t value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:JsonContextBody.type)
}

// repeated int32 data = 5;
inline int JsonContextBody::_internal_data_size() const {
  return _impl_.data_.size();
}
inline int JsonContextBody::data_size() const {
  return _internal_data_size();
}
inline void JsonContextBody::clear_data() {
  _impl_.data_.Clear();
}
inline int32_t JsonContextBody::_internal_data(int index) const {
  return _impl_.data_.Get(index);
}
inline int32_t JsonContextBody::data(int index) const {
  // @@protoc_insertion_point(field_get:JsonContextBody.data)
  return _internal_data(index);
}
inline void JsonContextBody::set_data(int index, int32_t value) {
  _impl_.data_.Set(index, value);
  // @@protoc_insertion_point(field_set:JsonContextBody.data)
}
inline void JsonContextBody::_internal_add_data(int32_t value) {
  _impl_.data_.Add(value);
}
inline void JsonContextBody::add_data(int32_t value) {
  _internal_add_data(value);
  // @@protoc_insertion_point(field_add:JsonContextBody.data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
JsonContextBody::_internal_data() const {
  return _impl_.data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
JsonContextBody::data() const {
  // @@protoc_insertion_point(field_list:JsonContextBody.data)
  return _internal_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
JsonContextBody::_internal_mutable_data() {
  return &_impl_.data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
JsonContextBody::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:JsonContextBody.data)
  return _internal_mutable_data();
}

// repeated string info = 6;
inline int JsonContextBody::_internal_info_size() const {
  return _impl_.info_.size();
}
inline int JsonContextBody::info_size() const {
  return _internal_info_size();
}
inline void JsonContextBody::clear_info() {
  _impl_.info_.Clear();
}
inline std::string* JsonContextBody::add_info() {
  std::string* _s = _internal_add_info();
  // @@protoc_insertion_point(field_add_mutable:JsonContextBody.info)
  return _s;
}
inline const std::string& JsonContextBody::_internal_info(int index) const {
  return _impl_.info_.Get(index);
}
inline const std::string& JsonContextBody::info(int index) const {
  // @@protoc_insertion_point(field_get:JsonContextBody.info)
  return _internal_info(index);
}
inline std::string* JsonContextBody::mutable_info(int index) {
  // @@protoc_insertion_point(field_mutable:JsonContextBody.info)
  return _impl_.info_.Mutable(index);
}
inline void JsonContextBody::set_info(int index, const std::string& value) {
  _impl_.info_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:JsonContextBody.info)
}
inline void JsonContextBody::set_info(int index, std::string&& value) {
  _impl_.info_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:JsonContextBody.info)
}
inline void JsonContextBody::set_info(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.info_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:JsonContextBody.info)
}
inline void JsonContextBody::set_info(int index, const char* value, size_t size) {
  _impl_.info_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:JsonContextBody.info)
}
inline std::string* JsonContextBody::_internal_add_info() {
  return _impl_.info_.Add();
}
inline void JsonContextBody::add_info(const std::string& value) {
  _impl_.info_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:JsonContextBody.info)
}
inline void JsonContextBody::add_info(std::string&& value) {
  _impl_.info_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:JsonContextBody.info)
}
inline void JsonContextBody::add_info(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.info_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:JsonContextBody.info)
}
inline void JsonContextBody::add_info(const char* value, size_t size) {
  _impl_.info_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:JsonContextBody.info)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
JsonContextBody::info() const {
  // @@protoc_insertion_point(field_list:JsonContextBody.info)
  return _impl_.info_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
JsonContextBody::mutable_info() {
  // @@protoc_insertion_point(field_mutable_list:JsonContextBody.info)
  return &_impl_.info_;
}

// required bool judge = 2;
inline bool JsonContextBody::_internal_has_judge() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool JsonContextBody::has_judge() const {
  return _internal_has_judge();
}
inline void JsonContextBody::clear_judge() {
  _impl_.judge_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool JsonContextBody::_internal_judge() const {
  return _impl_.judge_;
}
inline bool JsonContextBody::judge() const {
  // @@protoc_insertion_point(field_get:JsonContextBody.judge)
  return _internal_judge();
}
inline void JsonContextBody::_internal_set_judge(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.judge_ = value;
}
inline void JsonContextBody::set_judge(bool value) {
  _internal_set_judge(value);
  // @@protoc_insertion_point(field_set:JsonContextBody.judge)
}

// required double spur = 3;
inline bool JsonContextBody::_internal_has_spur() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool JsonContextBody::has_spur() const {
  return _internal_has_spur();
}
inline void JsonContextBody::clear_spur() {
  _impl_.spur_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline double JsonContextBody::_internal_spur() const {
  return _impl_.spur_;
}
inline double JsonContextBody::spur() const {
  // @@protoc_insertion_point(field_get:JsonContextBody.spur)
  return _internal_spur();
}
inline void JsonContextBody::_internal_set_spur(double value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.spur_ = value;
}
inline void JsonContextBody::set_spur(double value) {
  _internal_set_spur(value);
  // @@protoc_insertion_point(field_set:JsonContextBody.spur)
}

// repeated .Content content = 4;
inline int JsonContextBody::_internal_content_size() const {
  return _impl_.content_.size();
}
inline int JsonContextBody::content_size() const {
  return _internal_content_size();
}
inline void JsonContextBody::clear_content() {
  _impl_.content_.Clear();
}
inline ::Content* JsonContextBody::mutable_content(int index) {
  // @@protoc_insertion_point(field_mutable:JsonContextBody.content)
  return _impl_.content_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Content >*
JsonContextBody::mutable_content() {
  // @@protoc_insertion_point(field_mutable_list:JsonContextBody.content)
  return &_impl_.content_;
}
inline const ::Content& JsonContextBody::_internal_content(int index) const {
  return _impl_.content_.Get(index);
}
inline const ::Content& JsonContextBody::content(int index) const {
  // @@protoc_insertion_point(field_get:JsonContextBody.content)
  return _internal_content(index);
}
inline ::Content* JsonContextBody::_internal_add_content() {
  return _impl_.content_.Add();
}
inline ::Content* JsonContextBody::add_content() {
  ::Content* _add = _internal_add_content();
  // @@protoc_insertion_point(field_add:JsonContextBody.content)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Content >&
JsonContextBody::content() const {
  // @@protoc_insertion_point(field_list:JsonContextBody.content)
  return _impl_.content_;
}

// optional float text = 7;
inline bool JsonContextBody::_internal_has_text() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool JsonContextBody::has_text() const {
  return _internal_has_text();
}
inline void JsonContextBody::clear_text() {
  _impl_.text_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float JsonContextBody::_internal_text() const {
  return _impl_.text_;
}
inline float JsonContextBody::text() const {
  // @@protoc_insertion_point(field_get:JsonContextBody.text)
  return _internal_text();
}
inline void JsonContextBody::_internal_set_text(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.text_ = value;
}
inline void JsonContextBody::set_text(float value) {
  _internal_set_text(value);
  // @@protoc_insertion_point(field_set:JsonContextBody.text)
}

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

// PersonInfo

// optional string name = 1;
inline bool PersonInfo::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PersonInfo::has_name() const {
  return _internal_has_name();
}
inline void PersonInfo::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PersonInfo::name() const {
  // @@protoc_insertion_point(field_get:PersonInfo.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PersonInfo::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:PersonInfo.name)
}
inline std::string* PersonInfo::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:PersonInfo.name)
  return _s;
}
inline const std::string& PersonInfo::_internal_name() const {
  return _impl_.name_.Get();
}
inline void PersonInfo::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* PersonInfo::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* PersonInfo::release_name() {
  // @@protoc_insertion_point(field_release:PersonInfo.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 PersonInfo::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:PersonInfo.name)
}

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

// optional .JsonContextBody json_body = 18;
inline bool PersonInfo::_internal_has_json_body() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.json_body_ != nullptr);
  return value;
}
inline bool PersonInfo::has_json_body() const {
  return _internal_has_json_body();
}
inline void PersonInfo::clear_json_body() {
  if (_impl_.json_body_ != nullptr) _impl_.json_body_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::JsonContextBody& PersonInfo::_internal_json_body() const {
  const ::JsonContextBody* p = _impl_.json_body_;
  return p != nullptr ? *p : reinterpret_cast<const ::JsonContextBody&>(
      ::_JsonContextBody_default_instance_);
}
inline const ::JsonContextBody& PersonInfo::json_body() const {
  // @@protoc_insertion_point(field_get:PersonInfo.json_body)
  return _internal_json_body();
}
inline void PersonInfo::unsafe_arena_set_allocated_json_body(
    ::JsonContextBody* json_body) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.json_body_);
  }
  _impl_.json_body_ = json_body;
  if (json_body) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PersonInfo.json_body)
}
inline ::JsonContextBody* PersonInfo::release_json_body() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::JsonContextBody* temp = _impl_.json_body_;
  _impl_.json_body_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::JsonContextBody* PersonInfo::unsafe_arena_release_json_body() {
  // @@protoc_insertion_point(field_release:PersonInfo.json_body)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::JsonContextBody* temp = _impl_.json_body_;
  _impl_.json_body_ = nullptr;
  return temp;
}
inline ::JsonContextBody* PersonInfo::_internal_mutable_json_body() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.json_body_ == nullptr) {
    auto* p = CreateMaybeMessage<::JsonContextBody>(GetArenaForAllocation());
    _impl_.json_body_ = p;
  }
  return _impl_.json_body_;
}
inline ::JsonContextBody* PersonInfo::mutable_json_body() {
  ::JsonContextBody* _msg = _internal_mutable_json_body();
  // @@protoc_insertion_point(field_mutable:PersonInfo.json_body)
  return _msg;
}
inline void PersonInfo::set_allocated_json_body(::JsonContextBody* json_body) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.json_body_;
  }
  if (json_body) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(json_body);
    if (message_arena != submessage_arena) {
      json_body = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, json_body, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.json_body_ = json_body;
  // @@protoc_insertion_point(field_set_allocated:PersonInfo.json_body)
}

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

// AddressBook

// repeated .PersonInfo 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 ::PersonInfo* AddressBook::mutable_person(int index) {
  // @@protoc_insertion_point(field_mutable:AddressBook.person)
  return _impl_.person_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PersonInfo >*
AddressBook::mutable_person() {
  // @@protoc_insertion_point(field_mutable_list:AddressBook.person)
  return &_impl_.person_;
}
inline const ::PersonInfo& AddressBook::_internal_person(int index) const {
  return _impl_.person_.Get(index);
}
inline const ::PersonInfo& AddressBook::person(int index) const {
  // @@protoc_insertion_point(field_get:AddressBook.person)
  return _internal_person(index);
}
inline ::PersonInfo* AddressBook::_internal_add_person() {
  return _impl_.person_.Add();
}
inline ::PersonInfo* AddressBook::add_person() {
  ::PersonInfo* _add = _internal_add_person();
  // @@protoc_insertion_point(field_add:AddressBook.person)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PersonInfo >&
AddressBook::person() const {
  // @@protoc_insertion_point(field_list:AddressBook.person)
  return _impl_.person_;
}

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

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

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

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


// @@protoc_insertion_point(namespace_scope)


PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::Ext_PhoneType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Ext_PhoneType>() {
  return ::Ext_PhoneType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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

Coverage Report

Created: 2025-12-17 06:32