// Protocol Buffers - Google's data interchange format

// Copyright 2008 Google Inc.  All rights reserved.

//

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file or at

// https://developers.google.com/open-source/licenses/bsd

// Author: kenton@google.com (Kenton Varda)

//  Based on original Protocol Buffers design by

//  Sanjay Ghemawat, Jeff Dean, and others.

//

// This file contains classes which describe a type of protocol message.

// You can use a message's descriptor to learn at runtime what fields

// it contains and what the types of those fields are.  The Message

// interface also allows you to dynamically access and modify individual

// fields by passing the FieldDescriptor of the field you are interested

// in.

//

// Most users will not care about descriptors, because they will write

// code specific to certain protocol types and will simply use the classes

// generated by the protocol compiler directly.  Advanced users who want

// to operate on arbitrary types (not known at compile time) may want to

// read descriptors in order to learn about the contents of a message.

// A very small number of users will want to construct their own

// Descriptors, either because they are implementing Message manually or

// because they are writing something like the protocol compiler.

//

// For an example of how you might use descriptors, see the code example

// at the top of message.h.

#ifndef GOOGLE_PROTOBUF_DESCRIPTOR_H__

#define GOOGLE_PROTOBUF_DESCRIPTOR_H__

#include <atomic>

#include <cstdint>

#include <iterator>

#include <memory>

#include <string>

#include <utility>

#include <vector>

#include "google/protobuf/stubs/common.h"

#include "absl/base/attributes.h"

#include "absl/base/call_once.h"

#include "absl/container/btree_map.h"

#include "absl/container/flat_hash_map.h"

#include "absl/functional/any_invocable.h"

#include "absl/functional/function_ref.h"

#include "absl/log/absl_check.h"

#include "absl/log/absl_log.h"

#include "absl/strings/str_format.h"

#include "absl/strings/string_view.h"

#include "absl/synchronization/mutex.h"

#include "absl/types/optional.h"

#include "google/protobuf/descriptor_lite.h"

#include "google/protobuf/extension_set.h"

#include "google/protobuf/port.h"

// Must be included last.

#include "google/protobuf/port_def.inc"

#ifdef SWIG

#define PROTOBUF_EXPORT

#define PROTOBUF_IGNORE_DEPRECATION_START

#define PROTOBUF_IGNORE_DEPRECATION_STOP

#endif

namespace google {

namespace protobuf {

// Defined in this file.

class Descriptor;

class FieldDescriptor;

class OneofDescriptor;

class EnumDescriptor;

class EnumValueDescriptor;

class ServiceDescriptor;

class MethodDescriptor;

class FileDescriptor;

class DescriptorDatabase;

class DescriptorPool;

// Defined in descriptor.proto

#ifndef SWIG

enum Edition : int;

#else   // !SWIG

typedef int Edition;

#endif  // !SWIG

class DescriptorProto;

class DescriptorProto_ExtensionRange;

class FieldDescriptorProto;

class OneofDescriptorProto;

class EnumDescriptorProto;

class EnumValueDescriptorProto;

class ServiceDescriptorProto;

class MethodDescriptorProto;

class FileDescriptorProto;

class MessageOptions;

class FieldOptions;

class OneofOptions;

class EnumOptions;

class EnumValueOptions;

class ExtensionRangeOptions;

class ServiceOptions;

class MethodOptions;

class FileOptions;

class UninterpretedOption;

class FeatureSet;

class FeatureSetDefaults;

class SourceCodeInfo;

// Defined in message_lite.h

class MessageLite;

// Defined in message.h

class Message;

class Reflection;

// Defined in descriptor.cc

class DescriptorBuilder;

class FileDescriptorTables;

class Symbol;

// Defined in unknown_field_set.h.

class UnknownField;

// Defined in command_line_interface.cc

namespace compiler {

class CodeGenerator;

class CommandLineInterface;

namespace cpp {

// Defined in helpers.h

class Formatter;

}  // namespace cpp

}  // namespace compiler

namespace descriptor_unittest {

class DescriptorTest;

class ValidationErrorTest;

}  // namespace descriptor_unittest

// Defined in printer.h

namespace io {

class Printer;

}  // namespace io

// NB, all indices are zero-based.

struct SourceLocation {

  int start_line;

  int end_line;

  int start_column;

  int end_column;

  // Doc comments found at the source location.

  // See the comments in SourceCodeInfo.Location (descriptor.proto) for details.

  std::string leading_comments;

  std::string trailing_comments;

  std::vector<std::string> leading_detached_comments;

};

// Options when generating machine-parsable output from a descriptor with

// DebugString().

struct DebugStringOptions {

  // include original user comments as recorded in SourceLocation entries. N.B.

  // that this must be |false| by default: several other pieces of code (for

  // example, the C++ code generation for fields in the proto compiler) rely on

  // DebugString() output being unobstructed by user comments.

  bool include_comments;

  // If true, elide the braced body in the debug string.

  bool elide_group_body;

  bool elide_oneof_body;

  DebugStringOptions()

      : include_comments(false),

        elide_group_body(false),

        elide_oneof_body(false) {

  }

};

// A class to handle the simplest cases of a lazily linked descriptor

// for a message type that isn't built at the time of cross linking,

// which is needed when a pool has lazily_build_dependencies_ set.

// Must be instantiated as mutable in a descriptor.

namespace internal {

// The classes in this file represent a significant memory footprint for the

// library. We make sure we are not accidentally making them larger by

// hardcoding the struct size for a specific platform. Use as:

//

//   PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(type, expected_size_in_x84-64);

//

#if !defined(PROTOBUF_INTERNAL_CHECK_CLASS_SIZE)

#define PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(t, expected)

#endif

// `typedef` instead of `using` for SWIG

#if defined(PROTOBUF_FUTURE_STRING_VIEW_RETURN_TYPE)

typedef absl::string_view DescriptorStringView;

#else

typedef const std::string& DescriptorStringView;

#endif

class FlatAllocator;

class PROTOBUF_EXPORT LazyDescriptor {

 public:

  // Init function to be called at init time of a descriptor containing

  // a LazyDescriptor.

  void Init() {

    descriptor_ = nullptr;

    once_ = nullptr;

  }

  // Sets the value of the descriptor if it is known during the descriptor

  // building process. Not thread safe, should only be called during the

  // descriptor build process. Should not be called after SetLazy has been

  // called.

  void Set(const Descriptor* descriptor);

  // Sets the information needed to lazily cross link the descriptor at a later

  // time, SetLazy is not thread safe, should be called only once at descriptor

  // build time if the symbol wasn't found and building of the file containing

  // that type is delayed because lazily_build_dependencies_ is set on the pool.

  // Should not be called after Set() has been called.

  void SetLazy(absl::string_view name, const FileDescriptor* file);

  // Returns the current value of the descriptor, thread-safe. If SetLazy(...)

  // has been called, will do a one-time cross link of the type specified,

  // building the descriptor file that contains the type if necessary.

  inline const Descriptor* Get(const ServiceDescriptor* service) {

    Once(service);

    return descriptor_;

  }

 private:

  void Once(const ServiceDescriptor* service);

  const Descriptor* descriptor_;

  // The once_ flag is followed by a NUL terminated string for the type name.

  absl::once_flag* once_;

};

class PROTOBUF_EXPORT SymbolBase {

 private:

  friend class google::protobuf::Symbol;

  uint8_t symbol_type_;

};

// Some types have more than one SymbolBase because they have multiple

// identities in the table. We can't have duplicate direct bases, so we use this

// intermediate base to do so.

// See BuildEnumValue for details.

template <int N>

class PROTOBUF_EXPORT SymbolBaseN : public SymbolBase {};

// This class is for internal use only and provides access to the resolved

// runtime FeatureSets of any descriptor.  These features are not designed

// to be stable, and depending directly on them (vs the public descriptor APIs)

// is not safe.

class PROTOBUF_EXPORT InternalFeatureHelper {

 public:

  template <typename DescriptorT>

  static const FeatureSet& GetFeatures(const DescriptorT& desc) {

    return desc.features();

  }

 private:

  friend class ::google::protobuf::compiler::CodeGenerator;

  friend class ::google::protobuf::compiler::CommandLineInterface;

  // Provides a restricted view exclusively to code generators to query their

  // own unresolved features.  Unresolved features are virtually meaningless to

  // everyone else. Code generators will need them to validate their own

  // features, and runtimes may need them internally to be able to properly

  // represent the original proto files from generated code.

  template <typename DescriptorT, typename TypeTraitsT, uint8_t field_type,

            bool is_packed>

  static typename TypeTraitsT::ConstType GetUnresolvedFeatures(

      const DescriptorT& descriptor,

      const google::protobuf::internal::ExtensionIdentifier<

          FeatureSet, TypeTraitsT, field_type, is_packed>& extension) {

    return descriptor.proto_features_->GetExtension(extension);

  }

  // Provides a restricted view exclusively to code generators to query the

  // edition of files being processed.  While most people should never write

  // edition-dependent code, generators frequently will need to.

  static Edition GetEdition(const FileDescriptor& desc);

};

PROTOBUF_EXPORT absl::string_view ShortEditionName(Edition edition);

bool IsEnumFullySequential(const EnumDescriptor* enum_desc);

const std::string& DefaultValueStringAsString(const FieldDescriptor* field);

const std::string& NameOfEnumAsString(const EnumValueDescriptor* descriptor);

}  // namespace internal

// Provide an Abseil formatter for edition names.

template <typename Sink>

void AbslStringify(Sink& sink, Edition edition) {

  absl::Format(&sink, "%v", internal::ShortEditionName(edition));

}

// Describes a type of protocol message, or a particular group within a

// message.  To obtain the Descriptor for a given message object, call

// Message::GetDescriptor().  Generated message classes also have a

// static method called descriptor() which returns the type's descriptor.

// Use DescriptorPool to construct your own descriptors.

class PROTOBUF_EXPORT Descriptor : private internal::SymbolBase {

 public:

  typedef DescriptorProto Proto;

#ifndef SWIG

  Descriptor(const Descriptor&) = delete;

  Descriptor& operator=(const Descriptor&) = delete;

#endif

  // The name of the message type, not including its scope.

  internal::DescriptorStringView name() const;

  // The fully-qualified name of the message type, scope delimited by

  // periods.  For example, message type "Foo" which is declared in package

  // "bar" has full name "bar.Foo".  If a type "Baz" is nested within

  // Foo, Baz's full_name is "bar.Foo.Baz".  To get only the part that

  // comes after the last '.', use name().

  internal::DescriptorStringView full_name() const;

  // Index of this descriptor within the file or containing type's message

  // type array.

  int index() const;

  // The .proto file in which this message type was defined.  Never nullptr.

  const FileDescriptor* file() const;

  // If this Descriptor describes a nested type, this returns the type

  // in which it is nested.  Otherwise, returns nullptr.

  const Descriptor* containing_type() const;

  // Get options for this message type.  These are specified in the .proto file

  // by placing lines like "option foo = 1234;" in the message definition.

  // Allowed options are defined by MessageOptions in descriptor.proto, and any

  // available extensions of that message.

  const MessageOptions& options() const;

  // Write the contents of this Descriptor into the given DescriptorProto.

  // The target DescriptorProto must be clear before calling this; if it

  // isn't, the result may be garbage.

  void CopyTo(DescriptorProto* proto) const;

  // Fills in the message-level settings of this message (e.g. name, reserved

  // fields, message options) to `proto`.  This is essentially all of the

  // metadata owned exclusively by this descriptor, and not any nested

  // descriptors.

  void CopyHeadingTo(DescriptorProto* proto) const;

  // Write the contents of this descriptor in a human-readable form. Output

  // will be suitable for re-parsing.

  std::string DebugString() const;

  // Similar to DebugString(), but additionally takes options (e.g.,

  // include original user comments in output).

  std::string DebugStringWithOptions(const DebugStringOptions& options) const;

  // Allows formatting with absl and gtest.

  template <typename Sink>

  friend void AbslStringify(Sink& sink, const Descriptor& d) {

    absl::Format(&sink, "%s", d.DebugString());

  }

  // Returns true if this is a placeholder for an unknown type. This will

  // only be the case if this descriptor comes from a DescriptorPool

  // with AllowUnknownDependencies() set.

  bool is_placeholder() const;

  enum WellKnownType {

    WELLKNOWNTYPE_UNSPECIFIED,  // Not a well-known type.

    // Wrapper types.

    WELLKNOWNTYPE_DOUBLEVALUE,  // google.protobuf.DoubleValue

    WELLKNOWNTYPE_FLOATVALUE,   // google.protobuf.FloatValue

    WELLKNOWNTYPE_INT64VALUE,   // google.protobuf.Int64Value

    WELLKNOWNTYPE_UINT64VALUE,  // google.protobuf.UInt64Value

    WELLKNOWNTYPE_INT32VALUE,   // google.protobuf.Int32Value

    WELLKNOWNTYPE_UINT32VALUE,  // google.protobuf.UInt32Value

    WELLKNOWNTYPE_STRINGVALUE,  // google.protobuf.StringValue

    WELLKNOWNTYPE_BYTESVALUE,   // google.protobuf.BytesValue

    WELLKNOWNTYPE_BOOLVALUE,    // google.protobuf.BoolValue

    // Other well known types.

    WELLKNOWNTYPE_ANY,        // google.protobuf.Any

    WELLKNOWNTYPE_FIELDMASK,  // google.protobuf.FieldMask

    WELLKNOWNTYPE_DURATION,   // google.protobuf.Duration

    WELLKNOWNTYPE_TIMESTAMP,  // google.protobuf.Timestamp

    WELLKNOWNTYPE_VALUE,      // google.protobuf.Value

    WELLKNOWNTYPE_LISTVALUE,  // google.protobuf.ListValue

    WELLKNOWNTYPE_STRUCT,     // google.protobuf.Struct

    // New well-known types may be added in the future.

    // Please make sure any switch() statements have a 'default' case.

    __WELLKNOWNTYPE__DO_NOT_USE__ADD_DEFAULT_INSTEAD__,

  };

  WellKnownType well_known_type() const;

  // Field stuff -----------------------------------------------------

  // The number of fields in this message type.

  int field_count() const;

  // Gets a field by index, where 0 <= index < field_count().

  // These are returned in the order they were defined in the .proto file.

  const FieldDescriptor* field(int index) const;

  // Looks up a field by declared tag number.  Returns nullptr if no such field

  // exists.

  const FieldDescriptor* FindFieldByNumber(int number) const;

  // Looks up a field by name.  Returns nullptr if no such field exists.

  const FieldDescriptor* FindFieldByName(absl::string_view name) const;

  // Looks up a field by lowercased name (as returned by lowercase_name()).

  // This lookup may be ambiguous if multiple field names differ only by case,

  // in which case the field returned is chosen arbitrarily from the matches.

  const FieldDescriptor* FindFieldByLowercaseName(

      absl::string_view lowercase_name) const;

  // Looks up a field by camel-case name (as returned by camelcase_name()).

  // This lookup may be ambiguous if multiple field names differ in a way that

  // leads them to have identical camel-case names, in which case the field

  // returned is chosen arbitrarily from the matches.

  const FieldDescriptor* FindFieldByCamelcaseName(

      absl::string_view camelcase_name) const;

  // The number of oneofs in this message type.

  int oneof_decl_count() const;

  // The number of oneofs in this message type, excluding synthetic oneofs.

  // Real oneofs always come first, so iterating up to real_oneof_decl_cout()

  // will yield all real oneofs.

  int real_oneof_decl_count() const;

  // Get a oneof by index, where 0 <= index < oneof_decl_count().

  // These are returned in the order they were defined in the .proto file.

  const OneofDescriptor* oneof_decl(int index) const;

  // Get a oneof by index, excluding synthetic oneofs, where 0 <= index <

  // real_oneof_decl_count(). These are returned in the order they were defined

  // in the .proto file.

  const OneofDescriptor* real_oneof_decl(int index) const;

  // Looks up a oneof by name.  Returns nullptr if no such oneof exists.

  const OneofDescriptor* FindOneofByName(absl::string_view name) const;

  // Nested type stuff -----------------------------------------------

  // The number of nested types in this message type.

  int nested_type_count() const;

  // Gets a nested type by index, where 0 <= index < nested_type_count().

  // These are returned in the order they were defined in the .proto file.

  const Descriptor* nested_type(int index) const;

  // Looks up a nested type by name.  Returns nullptr if no such nested type

  // exists.

  const Descriptor* FindNestedTypeByName(absl::string_view name) const;

  // Enum stuff ------------------------------------------------------

  // The number of enum types in this message type.

  int enum_type_count() const;

  // Gets an enum type by index, where 0 <= index < enum_type_count().

  // These are returned in the order they were defined in the .proto file.

  const EnumDescriptor* enum_type(int index) const;

  // Looks up an enum type by name.  Returns nullptr if no such enum type

  // exists.

  const EnumDescriptor* FindEnumTypeByName(absl::string_view name) const;

  // Looks up an enum value by name, among all enum types in this message.

  // Returns nullptr if no such value exists.

  const EnumValueDescriptor* FindEnumValueByName(absl::string_view name) const;

  // Extensions ------------------------------------------------------

  // A range of field numbers which are designated for third-party

  // extensions.

  class PROTOBUF_EXPORT ExtensionRange {

   public:

    typedef DescriptorProto_ExtensionRange Proto;

    typedef ExtensionRangeOptions OptionsType;

    // See Descriptor::CopyTo().

    void CopyTo(DescriptorProto_ExtensionRange* proto) const;

    // Returns the start field number of this range (inclusive).

    int start_number() const { return start_; }

    // Returns the end field number of this range (exclusive).

    int end_number() const { return end_; }

    // Returns the index of this extension range within the message's extension

    // range array.

    int index() const;

    // Returns the ExtensionRangeOptions for this range.

    const ExtensionRangeOptions& options() const { return *options_; }

    // Returns the name of the containing type.

    internal::DescriptorStringView name() const {

      return containing_type_->name();

    }

    // Returns the full name of the containing type.

    internal::DescriptorStringView full_name() const {

      return containing_type_->full_name();

    }

    // Returns the .proto file in which this range was defined.

    // Never nullptr.

    const FileDescriptor* file() const { return containing_type_->file(); }

    // Returns the Descriptor for the message containing this range.

    // Never nullptr.

    const Descriptor* containing_type() const { return containing_type_; }

   private:

    int start_;

    int end_;

    const ExtensionRangeOptions* options_;

   private:

    const Descriptor* containing_type_;

    const FeatureSet* proto_features_;

    const FeatureSet* merged_features_;

    // Get the merged features that apply to this extension range.  These are

    // specified in the .proto file through the feature options in the message

    // definition. Allowed features are defined by Features in descriptor.proto,

    // along with any backend-specific extensions to it.

    const FeatureSet& features() const { return *merged_features_; }

    friend class internal::InternalFeatureHelper;

    // Walks up the descriptor tree to generate the source location path

    // to this descriptor from the file root.

    void GetLocationPath(std::vector<int>* output) const;

    friend class Descriptor;

    friend class DescriptorPool;

    friend class DescriptorBuilder;

  };

  // The number of extension ranges in this message type.

  int extension_range_count() const;

  // Gets an extension range by index, where 0 <= index <

  // extension_range_count(). These are returned in the order they were defined

  // in the .proto file.

  const ExtensionRange* extension_range(int index) const;

  // Returns true if the number is in one of the extension ranges.

  bool IsExtensionNumber(int number) const;

  // Returns nullptr if no extension range contains the given number.

  const ExtensionRange* FindExtensionRangeContainingNumber(int number) const;

  // The number of extensions defined nested within this message type's scope.

  // See doc:

  // https://developers.google.com/protocol-buffers/docs/proto#nested-extensions

  //

  // Note that the extensions may be extending *other* messages.

  //

  // For example:

  // message M1 {

  //   extensions 1 to max;

  // }

  //

  // message M2 {

  //   extend M1 {

  //     optional int32 foo = 1;

  //   }

  // }

  //

  // In this case,

  // DescriptorPool::generated_pool()

  //     ->FindMessageTypeByName("M2")

  //     ->extension(0)

  // will return "foo", even though "foo" is an extension of M1.

  // To find all known extensions of a given message, instead use

  // DescriptorPool::FindAllExtensions.

  int extension_count() const;

  // Get an extension by index, where 0 <= index < extension_count().

  // These are returned in the order they were defined in the .proto file.

  const FieldDescriptor* extension(int index) const;

  // Looks up a named extension (which extends some *other* message type)

  // defined within this message type's scope.

  const FieldDescriptor* FindExtensionByName(absl::string_view name) const;

  // Similar to FindFieldByLowercaseName(), but finds extensions defined within

  // this message type's scope.

  const FieldDescriptor* FindExtensionByLowercaseName(

      absl::string_view name) const;

  // Similar to FindFieldByCamelcaseName(), but finds extensions defined within

  // this message type's scope.

  const FieldDescriptor* FindExtensionByCamelcaseName(

      absl::string_view name) const;

  // Reserved fields -------------------------------------------------

  // A range of reserved field numbers.

  struct ReservedRange {

    int start;  // inclusive

    int end;    // exclusive

  };

  // The number of reserved ranges in this message type.

  int reserved_range_count() const;

  // Gets an reserved range by index, where 0 <= index <

  // reserved_range_count(). These are returned in the order they were defined

  // in the .proto file.

  const ReservedRange* reserved_range(int index) const;

  // Returns true if the number is in one of the reserved ranges.

  bool IsReservedNumber(int number) const;

  // Returns nullptr if no reserved range contains the given number.

  const ReservedRange* FindReservedRangeContainingNumber(int number) const;

  // The number of reserved field names in this message type.

  int reserved_name_count() const;

  // Gets a reserved name by index, where 0 <= index < reserved_name_count().

  internal::DescriptorStringView reserved_name(int index) const;

  // Returns true if the field name is reserved.

  bool IsReservedName(absl::string_view name) const;

  // Source Location ---------------------------------------------------

  // Updates |*out_location| to the source location of the complete

  // extent of this message declaration.  Returns false and leaves

  // |*out_location| unchanged iff location information was not available.

  bool GetSourceLocation(SourceLocation* out_location) const;

  // Maps --------------------------------------------------------------

  // Returns the FieldDescriptor for the "key" field. If this isn't a map entry

  // field, returns nullptr.

  const FieldDescriptor* map_key() const;

  // Returns the FieldDescriptor for the "value" field. If this isn't a map

  // entry field, returns nullptr.

  const FieldDescriptor* map_value() const;

 private:

  friend class Symbol;

  typedef MessageOptions OptionsType;

  // Allows tests to test CopyTo(proto, true).

  friend class descriptor_unittest::DescriptorTest;

  // Allows access to GetLocationPath for annotations.

  friend class io::Printer;

  friend class compiler::cpp::Formatter;

  // Get the merged features that apply to this message type.  These are

  // specified in the .proto file through the feature options in the message

  // definition.  Allowed features are defined by Features in descriptor.proto,

  // along with any backend-specific extensions to it.

  const FeatureSet& features() const { return *merged_features_; }

  friend class internal::InternalFeatureHelper;

  // Fill the json_name field of FieldDescriptorProto.

  void CopyJsonNameTo(DescriptorProto* proto) const;

  // Internal version of DebugString; controls the level of indenting for

  // correct depth. Takes |options| to control debug-string options, and

  // |include_opening_clause| to indicate whether the "message ... " part of the

  // clause has already been generated (this varies depending on context).

  void DebugString(int depth, std::string* contents,

                   const DebugStringOptions& options,

                   bool include_opening_clause) const;

  // Walks up the descriptor tree to generate the source location path

  // to this descriptor from the file root.

  void GetLocationPath(std::vector<int>* output) const;

  // True if this is a placeholder for an unknown type.

  bool is_placeholder_ : 1;

  // True if this is a placeholder and the type name wasn't fully-qualified.

  bool is_unqualified_placeholder_ : 1;

  // Well known type.  Stored like this to conserve space.

  uint8_t well_known_type_ : 5;

  // This points to the last field _number_ that is part of the sequence

  // starting at 1, where

  //     `desc->field(i)->number() == i + 1`

  // A value of `0` means no field matches. That is, there are no fields or the

  // first field is not field `1`.

  // Uses 16-bit to avoid extra padding. Unlikely to have more than 2^16

  // sequentially numbered fields in a message.

  uint16_t sequential_field_limit_;

  int field_count_;

  // all_names_ = [name, full_name]

  const std::string* all_names_;

  const FileDescriptor* file_;

  const Descriptor* containing_type_;

  const MessageOptions* options_;

  const FeatureSet* proto_features_;

  const FeatureSet* merged_features_;

  // These arrays are separated from their sizes to minimize padding on 64-bit.

  FieldDescriptor* fields_;

  OneofDescriptor* oneof_decls_;

  Descriptor* nested_types_;

  EnumDescriptor* enum_types_;

  ExtensionRange* extension_ranges_;

  FieldDescriptor* extensions_;

  ReservedRange* reserved_ranges_;

  const std::string** reserved_names_;

  int oneof_decl_count_;

  int real_oneof_decl_count_;

  int nested_type_count_;

  int enum_type_count_;

  int extension_range_count_;

  int extension_count_;

  int reserved_range_count_;

  int reserved_name_count_;

  // IMPORTANT:  If you add a new field, make sure to search for all instances

  // of Allocate<Descriptor>() and AllocateArray<Descriptor>() in descriptor.cc

  // and update them to initialize the field.

  // Must be constructed using DescriptorPool.

  Descriptor();

  friend class DescriptorBuilder;

  friend class DescriptorPool;

  friend class EnumDescriptor;

  friend class FieldDescriptor;

  friend class FileDescriptorTables;

  friend class OneofDescriptor;

  friend class MethodDescriptor;

  friend class FileDescriptor;

};

PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(Descriptor, 152);

// Describes a single field of a message.  To get the descriptor for a given

// field, first get the Descriptor for the message in which it is defined,

// then call Descriptor::FindFieldByName().  To get a FieldDescriptor for

// an extension, do one of the following:

// - Get the Descriptor or FileDescriptor for its containing scope, then

//   call Descriptor::FindExtensionByName() or

//   FileDescriptor::FindExtensionByName().

// - Given a DescriptorPool, call DescriptorPool::FindExtensionByNumber() or

//   DescriptorPool::FindExtensionByPrintableName().

// Use DescriptorPool to construct your own descriptors.

class PROTOBUF_EXPORT FieldDescriptor : private internal::SymbolBase,

                                        public internal::FieldDescriptorLite {

 public:

  typedef FieldDescriptorProto Proto;

#ifndef SWIG

  FieldDescriptor(const FieldDescriptor&) = delete;

  FieldDescriptor& operator=(const FieldDescriptor&) = delete;

#endif

  // Identifies a field type.  0 is reserved for errors.  The order is weird

  // for historical reasons.  Types 12 and up are new in proto2.

  // Inherited from FieldDescriptorLite:

  // enum Type {

  //   TYPE_DOUBLE = 1,    // double, exactly eight bytes on the wire.

  //   TYPE_FLOAT = 2,     // float, exactly four bytes on the wire.

  //   TYPE_INT64 = 3,     // int64, varint on the wire.  Negative numbers

  //                       // take 10 bytes.  Use TYPE_SINT64 if negative

  //                       // values are likely.

  //   TYPE_UINT64 = 4,    // uint64, varint on the wire.

  //   TYPE_INT32 = 5,     // int32, varint on the wire.  Negative numbers

  //                       // take 10 bytes.  Use TYPE_SINT32 if negative

  //                       // values are likely.

  //   TYPE_FIXED64 = 6,   // uint64, exactly eight bytes on the wire.

  //   TYPE_FIXED32 = 7,   // uint32, exactly four bytes on the wire.

  //   TYPE_BOOL = 8,      // bool, varint on the wire.

  //   TYPE_STRING = 9,    // UTF-8 text.

  //   TYPE_GROUP = 10,    // Tag-delimited message.  Deprecated.

  //   TYPE_MESSAGE = 11,  // Length-delimited message.

  //   TYPE_BYTES = 12,     // Arbitrary byte array.

  //   TYPE_UINT32 = 13,    // uint32, varint on the wire

  //   TYPE_ENUM = 14,      // Enum, varint on the wire

  //   TYPE_SFIXED32 = 15,  // int32, exactly four bytes on the wire

  //   TYPE_SFIXED64 = 16,  // int64, exactly eight bytes on the wire

  //   TYPE_SINT32 = 17,    // int32, ZigZag-encoded varint on the wire

  //   TYPE_SINT64 = 18,    // int64, ZigZag-encoded varint on the wire

  //   MAX_TYPE = 18,  // Constant useful for defining lookup tables

  //                   // indexed by Type.

  // };

  // Specifies the C++ data type used to represent the field.  There is a

  // fixed mapping from Type to CppType where each Type maps to exactly one

  // CppType.  0 is reserved for errors.

  // Inherited from FieldDescriptorLite:

  // enum CppType {

  //   CPPTYPE_INT32 = 1,     // TYPE_INT32, TYPE_SINT32, TYPE_SFIXED32

  //   CPPTYPE_INT64 = 2,     // TYPE_INT64, TYPE_SINT64, TYPE_SFIXED64

  //   CPPTYPE_UINT32 = 3,    // TYPE_UINT32, TYPE_FIXED32

  //   CPPTYPE_UINT64 = 4,    // TYPE_UINT64, TYPE_FIXED64

  //   CPPTYPE_DOUBLE = 5,    // TYPE_DOUBLE

  //   CPPTYPE_FLOAT = 6,     // TYPE_FLOAT

  //   CPPTYPE_BOOL = 7,      // TYPE_BOOL

  //   CPPTYPE_ENUM = 8,      // TYPE_ENUM

  //   CPPTYPE_STRING = 9,    // TYPE_STRING, TYPE_BYTES

  //   CPPTYPE_MESSAGE = 10,  // TYPE_MESSAGE, TYPE_GROUP

  //   MAX_CPPTYPE = 10,  // Constant useful for defining lookup tables

  //                      // indexed by CppType.

  // };

  // Identifies whether the field is optional, required, or repeated.  0 is

  // reserved for errors.

  // Inherited from FieldDescriptorLite:

  // enum Label {

  //   LABEL_OPTIONAL = 1,  // optional

  //   LABEL_REQUIRED = 2,  // required

  //   LABEL_REPEATED = 3,  // repeated

  //   MAX_LABEL = 3,  // Constant useful for defining lookup tables

  //                   // indexed by Label.

  // };

  // Valid field numbers are positive integers up to kMaxNumber.

  static const int kMaxNumber = (1 << 29) - 1;

  // First field number reserved for the protocol buffer library implementation.

  // Users may not declare fields that use reserved numbers.

  static const int kFirstReservedNumber = 19000;

  // Last field number reserved for the protocol buffer library implementation.

  // Users may not declare fields that use reserved numbers.

  static const int kLastReservedNumber = 19999;

  // Name of this field within the message.

  internal::DescriptorStringView name() const;

  // Fully-qualified name of the field.

  internal::DescriptorStringView full_name() const;

  // JSON name of this field.

  internal::DescriptorStringView json_name() const;

  const FileDescriptor* file() const;  // File in which this field was defined.

  bool is_extension() const;           // Is this an extension field?

  int number() const;                  // Declared tag number.

  // Same as name() except converted to lower-case.  This (and especially the

  // FindFieldByLowercaseName() method) can be useful when parsing formats

  // which prefer to use lowercase naming style.  (Although, technically

  // field names should be lowercased anyway according to the protobuf style

  // guide, so this only makes a difference when dealing with old .proto files

  // which do not follow the guide.)

  internal::DescriptorStringView lowercase_name() const;

  // Same as name() except converted to camel-case.  In this conversion, any

  // time an underscore appears in the name, it is removed and the next

  // letter is capitalized.  Furthermore, the first letter of the name is

  // lower-cased.  Examples:

  //   FooBar -> fooBar

  //   foo_bar -> fooBar

  //   fooBar -> fooBar

  // This (and especially the FindFieldByCamelcaseName() method) can be useful

  // when parsing formats which prefer to use camel-case naming style.

  internal::DescriptorStringView camelcase_name() const;

  Type type() const;                  // Declared type of this field.

  const char* type_name() const;      // Name of the declared type.

  CppType cpp_type() const;           // C++ type of this field.

  const char* cpp_type_name() const;  // Name of the C++ type.

  Label label() const;                // optional/required/repeated

#ifndef SWIG

  CppStringType cpp_string_type() const;  // The C++ string type of this field.

#endif

  bool is_required() const;  // shorthand for label() == LABEL_REQUIRED

  bool is_optional() const;  // shorthand for label() == LABEL_OPTIONAL

  bool is_repeated() const;  // shorthand for label() == LABEL_REPEATED

  bool is_packable() const;  // shorthand for is_repeated() &&

                             //               IsTypePackable(type())

  bool is_map() const;       // shorthand for type() == TYPE_MESSAGE &&

                             // message_type()->options().map_entry()

  // Whether or not this field is packable and packed.  In proto2, packable

  // fields must have `packed = true` specified.  In proto3, all packable fields

  // are packed by default unless `packed = false` is specified.

  bool is_packed() const;

  // Returns true if this field tracks presence, ie. does the field

  // distinguish between "unset" and "present with default value."

  // This includes required, optional, and oneof fields. It excludes maps,

  // repeated fields, and singular proto3 fields without "optional".

  //

  // For fields where has_presence() == true, the return value of

  // Reflection::HasField() is semantically meaningful.

  bool has_presence() const;

  // Returns true if this TYPE_STRING-typed field requires UTF-8 validation on

  // parse.

  bool requires_utf8_validation() const;

  // Determines if the given enum field is treated as closed based on legacy

  // non-conformant behavior.

  //

  // Conformant behavior determines closedness based on the enum and

  // can be queried using EnumDescriptor::is_closed().

  //

  // Some runtimes currently have a quirk where non-closed enums are

  // treated as closed when used as the type of fields defined in a

  // `syntax = proto2;` file. This quirk is not present in all runtimes; as of

  // writing, we know that:

  //

  // - C++, Java, and C++-based Python share this quirk.

  // - UPB and UPB-based Python do not.

  // - PHP and Ruby treat all enums as open regardless of declaration.

  //

  // Care should be taken when using this function to respect the target

  // runtime's enum handling quirks.

  bool legacy_enum_field_treated_as_closed() const;

  // Index of this field within the message's field array, or the file or

  // extension scope's extensions array.

  int index() const;

  // Does this field have an explicitly-declared default value?

  bool has_default_value() const;

  // Whether the user has specified the json_name field option in the .proto

  // file.

  bool has_json_name() const;

  // Get the field default value if cpp_type() == CPPTYPE_INT32.  If no

  // explicit default was defined, the default is 0.

  int32_t default_value_int32_t() const;

  int32_t default_value_int32() const { return default_value_int32_t(); }

  // Get the field default value if cpp_type() == CPPTYPE_INT64.  If no

  // explicit default was defined, the default is 0.

  int64_t default_value_int64_t() const;

  int64_t default_value_int64() const { return default_value_int64_t(); }

  // Get the field default value if cpp_type() == CPPTYPE_UINT32.  If no

  // explicit default was defined, the default is 0.

  uint32_t default_value_uint32_t() const;

  uint32_t default_value_uint32() const { return default_value_uint32_t(); }

  // Get the field default value if cpp_type() == CPPTYPE_UINT64.  If no

  // explicit default was defined, the default is 0.

  uint64_t default_value_uint64_t() const;

  uint64_t default_value_uint64() const { return default_value_uint64_t(); }

  // Get the field default value if cpp_type() == CPPTYPE_FLOAT.  If no

  // explicit default was defined, the default is 0.0.

  float default_value_float() const;

  // Get the field default value if cpp_type() == CPPTYPE_DOUBLE.  If no

  // explicit default was defined, the default is 0.0.

  double default_value_double() const;

  // Get the field default value if cpp_type() == CPPTYPE_BOOL.  If no

  // explicit default was defined, the default is false.

  bool default_value_bool() const;

  // Get the field default value if cpp_type() == CPPTYPE_ENUM.  If no

  // explicit default was defined, the default is the first value defined

  // in the enum type (all enum types are required to have at least one value).

  // This never returns nullptr.

  const EnumValueDescriptor* default_value_enum() const;

  // Get the field default value if cpp_type() == CPPTYPE_STRING.  If no

  // explicit default was defined, the default is the empty string.

  internal::DescriptorStringView default_value_string() const;

  // The Descriptor for the message of which this is a field.  For extensions,

  // this is the extended type.  Never nullptr.

  const Descriptor* containing_type() const;

  // If the field is a member of a oneof, this is the one, otherwise this is

  // nullptr.

  const OneofDescriptor* containing_oneof() const;

  // If the field is a member of a non-synthetic oneof, returns the descriptor

  // for the oneof, otherwise returns nullptr.

  const OneofDescriptor* real_containing_oneof() const;

  // If the field is a member of a oneof, returns the index in that oneof.

  int index_in_oneof() const;

  // An extension may be declared within the scope of another message.  If this

  // field is an extension (is_extension() is true), then extension_scope()

  // returns that message, or nullptr if the extension was declared at global

  // scope.  If this is not an extension, extension_scope() is undefined (may

  // assert-fail).

  const Descriptor* extension_scope() const;

  // If type is TYPE_MESSAGE or TYPE_GROUP, returns a descriptor for the

  // message or the group type.  Otherwise, returns null.

  const Descriptor* message_type() const;

  // If type is TYPE_ENUM, returns a descriptor for the enum.  Otherwise,

  // returns null.

  const EnumDescriptor* enum_type() const;

  // Get the FieldOptions for this field.  This includes things listed in

  // square brackets after the field definition.  E.g., the field:

  //   optional string text = 1 [ctype=CORD];

  // has the "ctype" option set.  Allowed options are defined by FieldOptions in

  // descriptor.proto, and any available extensions of that message.

  const FieldOptions& options() const;

  // See Descriptor::CopyTo().

  void CopyTo(FieldDescriptorProto* proto) const;

  // See Descriptor::DebugString().

  std::string DebugString() const;

  // See Descriptor::DebugStringWithOptions().

  std::string DebugStringWithOptions(const DebugStringOptions& options) const;

  // Allows formatting with absl and gtest.

  template <typename Sink>

  friend void AbslStringify(Sink& sink, const FieldDescriptor& d) {

    absl::Format(&sink, "%s", d.DebugString());

  }

  // Helper method to get the CppType for a particular Type.

  static CppType TypeToCppType(Type type);

  // Helper method to get the name of a Type.

  static const char* TypeName(Type type);

  // Helper method to get the name of a CppType.

  static const char* CppTypeName(CppType cpp_type);

  // Return true iff [packed = true] is valid for fields of this type.

  static inline bool IsTypePackable(Type field_type);

  // Returns full_name() except if the field is a MessageSet extension,

  // in which case it returns the full_name() of the containing message type

  // for backwards compatibility with proto1.

  //

  // A MessageSet extension is defined as an optional message extension

  // whose containing type has the message_set_wire_format option set.

  // This should be true of extensions of google.protobuf.bridge.MessageSet;

  // by convention, such extensions are named "message_set_extension".

  //

  // The opposite operation (looking up an extension's FieldDescriptor given

  // its printable name) can be accomplished with

  //     message->file()->pool()->FindExtensionByPrintableName(message, name)

  // where the extension extends "message".

  internal::DescriptorStringView PrintableNameForExtension() const;

  // Source Location ---------------------------------------------------

  // Updates |*out_location| to the source location of the complete

  // extent of this field declaration.  Returns false and leaves

  // |*out_location| unchanged iff location information was not available.

  bool GetSourceLocation(SourceLocation* out_location) const;

 private:

  friend class Symbol;

  typedef FieldOptions OptionsType;

  // Allows access to GetLocationPath for annotations.

  friend class io::Printer;

  friend class compiler::cpp::Formatter;

  friend class Reflection;

  friend class FieldDescriptorLegacy;

  friend const std::string& internal::DefaultValueStringAsString(

      const FieldDescriptor* field);

  // Returns true if this field was syntactically written with "optional" in the

  // .proto file. Excludes singular proto3 fields that do not have a label.

  bool has_optional_keyword() const;

  // Get the merged features that apply to this field.  These are specified in

  // the .proto file through the feature options in the message definition.

  // Allowed features are defined by Features in descriptor.proto, along with

  // any backend-specific extensions to it.

  const FeatureSet& features() const { return *merged_features_; }

  friend class internal::InternalFeatureHelper;

  // Fill the json_name field of FieldDescriptorProto.

  void CopyJsonNameTo(FieldDescriptorProto* proto) const;

  // See Descriptor::DebugString().

  void DebugString(int depth, std::string* contents,

                   const DebugStringOptions& options) const;

  // formats the default value appropriately and returns it as a string.

  // Must have a default value to call this. If quote_string_type is true, then

  // types of CPPTYPE_STRING will be surrounded by quotes and CEscaped.

  std::string DefaultValueAsString(bool quote_string_type) const;

  // Helper function that returns the field type name for DebugString.

  std::string FieldTypeNameDebugString() const;

  // Walks up the descriptor tree to generate the source location path

  // to this descriptor from the file root.

  void GetLocationPath(std::vector<int>* output) const;

  // Returns true if this is a map message type.

  bool is_map_message_type() const;

  bool has_default_value_ : 1;

  bool proto3_optional_ : 1;

  // Whether the user has specified the json_name field option in the .proto

  // file.

  bool has_json_name_ : 1;

  bool is_extension_ : 1;

  bool is_oneof_ : 1;

  bool is_repeated_ : 1;  // Redundant with label_, but it is queried a lot.

  // Actually a `Label` but stored as uint8_t to save space.

  uint8_t label_ : 2;

  // Actually a `Type`, but stored as uint8_t to save space.

  uint8_t type_;

  // Logically:

  //   all_names_ = [name, full_name, lower, camel, json]

  // However:

  //   duplicates will be omitted, so lower/camel/json might be in the same

  //   position.

  // We store the true offset for each name here, and the bit width must be

  // large enough to account for the worst case where all names are present.

  uint8_t lowercase_name_index_ : 2;

  uint8_t camelcase_name_index_ : 2;

  uint8_t json_name_index_ : 3;

  // Can be calculated from containing_oneof(), but we cache it for performance.

  // Located here for bitpacking.

  bool in_real_oneof_ : 1;

  // Sadly, `number_` located here to reduce padding. Unrelated to all_names_