2405 lines
96 KiB
C++
2405 lines
96 KiB
C++
// Protocol Buffers - Google's data interchange format
|
|
// Copyright 2008 Google Inc. All rights reserved.
|
|
// https://developers.google.com/protocol-buffers/
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are
|
|
// met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following disclaimer
|
|
// in the documentation and/or other materials provided with the
|
|
// distribution.
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
// contributors may be used to endorse or promote products derived from
|
|
// this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
// 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 <map>
|
|
#include <memory>
|
|
#include <set>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include <google/protobuf/stubs/common.h>
|
|
#include <google/protobuf/stubs/logging.h>
|
|
#include <google/protobuf/stubs/mutex.h>
|
|
#include <google/protobuf/stubs/once.h>
|
|
#include <google/protobuf/port.h>
|
|
#include <google/protobuf/port_def.inc>
|
|
|
|
// TYPE_BOOL is defined in the MacOS's ConditionalMacros.h.
|
|
#ifdef TYPE_BOOL
|
|
#undef TYPE_BOOL
|
|
#endif // TYPE_BOOL
|
|
|
|
#ifdef SWIG
|
|
#define PROTOBUF_EXPORT
|
|
#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
|
|
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 SourceCodeInfo;
|
|
|
|
// 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 CommandLineInterface;
|
|
namespace cpp {
|
|
// Defined in helpers.h
|
|
class Formatter;
|
|
} // namespace cpp
|
|
} // namespace compiler
|
|
|
|
namespace descriptor_unittest {
|
|
class DescriptorTest;
|
|
} // 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 {
|
|
|
|
// Data required to do lazy initialization.
|
|
struct PROTOBUF_EXPORT LazyInitData {
|
|
#ifndef SWIG
|
|
internal::once_flag once;
|
|
#endif
|
|
struct Field {
|
|
const std::string* type_name;
|
|
const std::string* default_value_enum_name;
|
|
};
|
|
struct Descriptor {
|
|
const std::string* name;
|
|
const FileDescriptor* file;
|
|
};
|
|
struct File {
|
|
const std::string** dependencies_names;
|
|
};
|
|
union {
|
|
Field field;
|
|
Descriptor descriptor;
|
|
File file;
|
|
};
|
|
};
|
|
|
|
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(StringPiece 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() {
|
|
Once();
|
|
return descriptor_;
|
|
}
|
|
|
|
private:
|
|
static void OnceStatic(LazyDescriptor* lazy);
|
|
void OnceInternal();
|
|
void Once();
|
|
|
|
const Descriptor* descriptor_;
|
|
LazyInitData* 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 {};
|
|
|
|
} // namespace internal
|
|
|
|
// 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;
|
|
|
|
// The name of the message type, not including its scope.
|
|
const std::string& 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().
|
|
const std::string& 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;
|
|
|
|
// 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;
|
|
|
|
// 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(ConstStringParam 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(
|
|
ConstStringParam 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(
|
|
ConstStringParam 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;
|
|
|
|
// Looks up a oneof by name. Returns nullptr if no such oneof exists.
|
|
const OneofDescriptor* FindOneofByName(ConstStringParam 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(ConstStringParam 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(ConstStringParam 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(ConstStringParam name) const;
|
|
|
|
// Extensions ------------------------------------------------------
|
|
|
|
// A range of field numbers which are designated for third-party
|
|
// extensions.
|
|
struct ExtensionRange {
|
|
typedef DescriptorProto_ExtensionRange Proto;
|
|
|
|
typedef ExtensionRangeOptions OptionsType;
|
|
|
|
// See Descriptor::CopyTo().
|
|
void CopyTo(DescriptorProto_ExtensionRange* proto) const;
|
|
|
|
int start; // inclusive
|
|
int end; // exclusive
|
|
|
|
const ExtensionRangeOptions* options_;
|
|
};
|
|
|
|
// 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(ConstStringParam name) const;
|
|
|
|
// Similar to FindFieldByLowercaseName(), but finds extensions defined within
|
|
// this message type's scope.
|
|
const FieldDescriptor* FindExtensionByLowercaseName(
|
|
ConstStringParam name) const;
|
|
|
|
// Similar to FindFieldByCamelcaseName(), but finds extensions defined within
|
|
// this message type's scope.
|
|
const FieldDescriptor* FindExtensionByCamelcaseName(
|
|
ConstStringParam 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().
|
|
const std::string& reserved_name(int index) const;
|
|
|
|
// Returns true if the field name is reserved.
|
|
bool IsReservedName(ConstStringParam 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;
|
|
|
|
// 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 as char to conserve space.
|
|
char well_known_type_;
|
|
int field_count_;
|
|
|
|
// all_names_ = [name, full_name]
|
|
const std::string* all_names_;
|
|
const FileDescriptor* file_;
|
|
const Descriptor* containing_type_;
|
|
const MessageOptions* options_;
|
|
|
|
// 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 OneofDescriptor;
|
|
friend class MethodDescriptor;
|
|
friend class FileDescriptor;
|
|
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Descriptor);
|
|
};
|
|
|
|
|
|
// 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:
|
|
typedef FieldDescriptorProto Proto;
|
|
|
|
// Identifies a field type. 0 is reserved for errors. The order is weird
|
|
// for historical reasons. Types 12 and up are new in proto2.
|
|
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.
|
|
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.
|
|
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;
|
|
|
|
const std::string& name() const; // Name of this field within the message.
|
|
const std::string& full_name() const; // Fully-qualified name of the field.
|
|
const std::string& json_name() const; // JSON name of this field.
|
|
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.)
|
|
const std::string& 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.
|
|
const std::string& 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
|
|
|
|
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_packed() const; // shorthand for is_packable() &&
|
|
// options().packed()
|
|
bool is_map() const; // shorthand for type() == TYPE_MESSAGE &&
|
|
// message_type()->options().map_entry()
|
|
|
|
// 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;
|
|
|
|
// 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;
|
|
|
|
// 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.
|
|
const std::string& 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;
|
|
|
|
// 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".
|
|
const std::string& 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;
|
|
|
|
// 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 whill 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_;
|
|
bool proto3_optional_;
|
|
// Whether the user has specified the json_name field option in the .proto
|
|
// file.
|
|
bool has_json_name_;
|
|
bool is_extension_;
|
|
|
|
// Actually a `Type`, but stored as uint8_t to save space.
|
|
mutable uint8_t type_;
|
|
// Actually a `Label` but stored as uint8_t to save space.
|
|
uint8_t label_;
|
|
|
|
bool is_oneof_ : 1;
|
|
|
|
// 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;
|
|
const std::string* all_names_;
|
|
const FileDescriptor* file_;
|
|
|
|
internal::LazyInitData* type_once_;
|
|
static void TypeOnceInit(const FieldDescriptor* to_init);
|
|
void InternalTypeOnceInit() const;
|
|
int number_;
|
|
int index_in_oneof_;
|
|
const Descriptor* containing_type_;
|
|
union {
|
|
const OneofDescriptor* containing_oneof;
|
|
const Descriptor* extension_scope;
|
|
} scope_;
|
|
union {
|
|
mutable const Descriptor* message_type;
|
|
mutable const EnumDescriptor* enum_type;
|
|
} type_descriptor_;
|
|
const FieldOptions* options_;
|
|
// IMPORTANT: If you add a new field, make sure to search for all instances
|
|
// of Allocate<FieldDescriptor>() and AllocateArray<FieldDescriptor>() in
|
|
// descriptor.cc and update them to initialize the field.
|
|
|
|
union {
|
|
int32_t default_value_int32_t_;
|
|
int64_t default_value_int64_t_;
|
|
uint32_t default_value_uint32_t_;
|
|
uint64_t default_value_uint64_t_;
|
|
float default_value_float_;
|
|
double default_value_double_;
|
|
bool default_value_bool_;
|
|
|
|
mutable const EnumValueDescriptor* default_value_enum_;
|
|
const std::string* default_value_string_;
|
|
mutable std::atomic<const Message*> default_generated_instance_;
|
|
};
|
|
|
|
static const CppType kTypeToCppTypeMap[MAX_TYPE + 1];
|
|
|
|
static const char* const kTypeToName[MAX_TYPE + 1];
|
|
|
|
static const char* const kCppTypeToName[MAX_CPPTYPE + 1];
|
|
|
|
static const char* const kLabelToName[MAX_LABEL + 1];
|
|
|
|
// Must be constructed using DescriptorPool.
|
|
FieldDescriptor() {}
|
|
friend class DescriptorBuilder;
|
|
friend class FileDescriptor;
|
|
friend class Descriptor;
|
|
friend class OneofDescriptor;
|
|
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldDescriptor);
|
|
};
|
|
|
|
|
|
// Describes a oneof defined in a message type.
|
|
class PROTOBUF_EXPORT OneofDescriptor : private internal::SymbolBase {
|
|
public:
|
|
typedef OneofDescriptorProto Proto;
|
|
|
|
const std::string& name() const; // Name of this oneof.
|
|
const std::string& full_name() const; // Fully-qualified name of the oneof.
|
|
|
|
// Index of this oneof within the message's oneof array.
|
|
int index() const;
|
|
|
|
// Returns whether this oneof was inserted by the compiler to wrap a proto3
|
|
// optional field. If this returns true, code generators should *not* emit it.
|
|
bool is_synthetic() const;
|
|
|
|
// The .proto file in which this oneof was defined. Never nullptr.
|
|
const FileDescriptor* file() const;
|
|
// The Descriptor for the message containing this oneof.
|
|
const Descriptor* containing_type() const;
|
|
|
|
// The number of (non-extension) fields which are members of this oneof.
|
|
int field_count() const;
|
|
// Get a member of this oneof, in the order in which they were declared in the
|
|
// .proto file. Does not include extensions.
|
|
const FieldDescriptor* field(int index) const;
|
|
|
|
const OneofOptions& options() const;
|
|
|
|
// See Descriptor::CopyTo().
|
|
void CopyTo(OneofDescriptorProto* proto) const;
|
|
|
|
// See Descriptor::DebugString().
|
|
std::string DebugString() const;
|
|
|
|
// See Descriptor::DebugStringWithOptions().
|
|
std::string DebugStringWithOptions(const DebugStringOptions& options) const;
|
|
|
|
// Source Location ---------------------------------------------------
|
|
|
|
// Updates |*out_location| to the source location of the complete
|
|
// extent of this oneof 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 OneofOptions OptionsType;
|
|
|
|
// Allows access to GetLocationPath for annotations.
|
|
friend class io::Printer;
|
|
friend class compiler::cpp::Formatter;
|
|
|
|
// See Descriptor::DebugString().
|
|
void DebugString(int depth, std::string* contents,
|
|
const DebugStringOptions& options) 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;
|
|
|
|
int field_count_;
|
|
|
|
// all_names_ = [name, full_name]
|
|
const std::string* all_names_;
|
|
const Descriptor* containing_type_;
|
|
const FieldDescriptor** fields_;
|
|
const OneofOptions* options_;
|
|
|
|
// IMPORTANT: If you add a new field, make sure to search for all instances
|
|
// of Allocate<OneofDescriptor>() and AllocateArray<OneofDescriptor>()
|
|
// in descriptor.cc and update them to initialize the field.
|
|
|
|
// Must be constructed using DescriptorPool.
|
|
OneofDescriptor() {}
|
|
friend class DescriptorBuilder;
|
|
friend class Descriptor;
|
|
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(OneofDescriptor);
|
|
};
|
|
|
|
// Describes an enum type defined in a .proto file. To get the EnumDescriptor
|
|
// for a generated enum type, call TypeName_descriptor(). Use DescriptorPool
|
|
// to construct your own descriptors.
|
|
class PROTOBUF_EXPORT EnumDescriptor : private internal::SymbolBase {
|
|
public:
|
|
typedef EnumDescriptorProto Proto;
|
|
|
|
// The name of this enum type in the containing scope.
|
|
const std::string& name() const;
|
|
|
|
// The fully-qualified name of the enum type, scope delimited by periods.
|
|
const std::string& full_name() const;
|
|
|
|
// Index of this enum within the file or containing message's enum array.
|
|
int index() const;
|
|
|
|
// The .proto file in which this enum type was defined. Never nullptr.
|
|
const FileDescriptor* file() const;
|
|
|
|
// The number of values for this EnumDescriptor. Guaranteed to be greater
|
|
// than zero.
|
|
int value_count() const;
|
|
// Gets a value by index, where 0 <= index < value_count().
|
|
// These are returned in the order they were defined in the .proto file.
|
|
const EnumValueDescriptor* value(int index) const;
|
|
|
|
// Looks up a value by name. Returns nullptr if no such value exists.
|
|
const EnumValueDescriptor* FindValueByName(ConstStringParam name) const;
|
|
// Looks up a value by number. Returns nullptr if no such value exists. If
|
|
// multiple values have this number, the first one defined is returned.
|
|
const EnumValueDescriptor* FindValueByNumber(int number) const;
|
|
|
|
// If this enum type is nested in a message type, this is that message type.
|
|
// Otherwise, nullptr.
|
|
const Descriptor* containing_type() const;
|
|
|
|
// Get options for this enum type. These are specified in the .proto file by
|
|
// placing lines like "option foo = 1234;" in the enum definition. Allowed
|
|
// options are defined by EnumOptions in descriptor.proto, and any available
|
|
// extensions of that message.
|
|
const EnumOptions& options() const;
|
|
|
|
// See Descriptor::CopyTo().
|
|
void CopyTo(EnumDescriptorProto* proto) const;
|
|
|
|
// See Descriptor::DebugString().
|
|
std::string DebugString() const;
|
|
|
|
// See Descriptor::DebugStringWithOptions().
|
|
std::string DebugStringWithOptions(const DebugStringOptions& options) const;
|
|
|
|
// Returns true if this is a placeholder for an unknown enum. This will
|
|
// only be the case if this descriptor comes from a DescriptorPool
|
|
// with AllowUnknownDependencies() set.
|
|
bool is_placeholder() const;
|
|
|
|
// Reserved fields -------------------------------------------------
|
|
|
|
// A range of reserved field numbers.
|
|
struct ReservedRange {
|
|
int start; // inclusive
|
|
int end; // inclusive
|
|
};
|
|
|
|
// 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 EnumDescriptor::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 EnumDescriptor::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().
|
|
const std::string& reserved_name(int index) const;
|
|
|
|
// Returns true if the field name is reserved.
|
|
bool IsReservedName(ConstStringParam name) const;
|
|
|
|
// Source Location ---------------------------------------------------
|
|
|
|
// Updates |*out_location| to the source location of the complete
|
|
// extent of this enum 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 EnumOptions OptionsType;
|
|
|
|
// Allows access to GetLocationPath for annotations.
|
|
friend class io::Printer;
|
|
friend class compiler::cpp::Formatter;
|
|
|
|
// Looks up a value by number. If the value does not exist, dynamically
|
|
// creates a new EnumValueDescriptor for that value, assuming that it was
|
|
// unknown. If a new descriptor is created, this is done in a thread-safe way,
|
|
// and future calls will return the same value descriptor pointer.
|
|
//
|
|
// This is private but is used by Reflection (which is friended below) to
|
|
// return a valid EnumValueDescriptor from GetEnum() when this feature is
|
|
// enabled.
|
|
const EnumValueDescriptor* FindValueByNumberCreatingIfUnknown(
|
|
int number) const;
|
|
|
|
// See Descriptor::DebugString().
|
|
void DebugString(int depth, std::string* contents,
|
|
const DebugStringOptions& options) 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_;
|
|
// True if this is a placeholder and the type name wasn't fully-qualified.
|
|
bool is_unqualified_placeholder_;
|
|
|
|
int value_count_;
|
|
|
|
// all_names_ = [name, full_name]
|
|
const std::string* all_names_;
|
|
const FileDescriptor* file_;
|
|
const Descriptor* containing_type_;
|
|
const EnumOptions* options_;
|
|
EnumValueDescriptor* values_;
|
|
|
|
int reserved_range_count_;
|
|
int reserved_name_count_;
|
|
EnumDescriptor::ReservedRange* reserved_ranges_;
|
|
const std::string** reserved_names_;
|
|
|
|
// IMPORTANT: If you add a new field, make sure to search for all instances
|
|
// of Allocate<EnumDescriptor>() and AllocateArray<EnumDescriptor>() in
|
|
// descriptor.cc and update them to initialize the field.
|
|
|
|
// Must be constructed using DescriptorPool.
|
|
EnumDescriptor() {}
|
|
friend class DescriptorBuilder;
|
|
friend class Descriptor;
|
|
friend class FieldDescriptor;
|
|
friend class EnumValueDescriptor;
|
|
friend class FileDescriptor;
|
|
friend class DescriptorPool;
|
|
friend class Reflection;
|
|
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(EnumDescriptor);
|
|
};
|
|
|
|
// Describes an individual enum constant of a particular type. To get the
|
|
// EnumValueDescriptor for a given enum value, first get the EnumDescriptor
|
|
// for its type, then use EnumDescriptor::FindValueByName() or
|
|
// EnumDescriptor::FindValueByNumber(). Use DescriptorPool to construct
|
|
// your own descriptors.
|
|
class PROTOBUF_EXPORT EnumValueDescriptor : private internal::SymbolBaseN<0>,
|
|
private internal::SymbolBaseN<1> {
|
|
public:
|
|
typedef EnumValueDescriptorProto Proto;
|
|
|
|
const std::string& name() const; // Name of this enum constant.
|
|
int index() const; // Index within the enums's Descriptor.
|
|
int number() const; // Numeric value of this enum constant.
|
|
|
|
// The full_name of an enum value is a sibling symbol of the enum type.
|
|
// e.g. the full name of FieldDescriptorProto::TYPE_INT32 is actually
|
|
// "google.protobuf.FieldDescriptorProto.TYPE_INT32", NOT
|
|
// "google.protobuf.FieldDescriptorProto.Type.TYPE_INT32". This is to conform
|
|
// with C++ scoping rules for enums.
|
|
const std::string& full_name() const;
|
|
|
|
// The .proto file in which this value was defined. Never nullptr.
|
|
const FileDescriptor* file() const;
|
|
// The type of this value. Never nullptr.
|
|
const EnumDescriptor* type() const;
|
|
|
|
// Get options for this enum value. These are specified in the .proto file by
|
|
// adding text like "[foo = 1234]" after an enum value definition. Allowed
|
|
// options are defined by EnumValueOptions in descriptor.proto, and any
|
|
// available extensions of that message.
|
|
const EnumValueOptions& options() const;
|
|
|
|
// See Descriptor::CopyTo().
|
|
void CopyTo(EnumValueDescriptorProto* proto) const;
|
|
|
|
// See Descriptor::DebugString().
|
|
std::string DebugString() const;
|
|
|
|
// See Descriptor::DebugStringWithOptions().
|
|
std::string DebugStringWithOptions(const DebugStringOptions& options) const;
|
|
|
|
// Source Location ---------------------------------------------------
|
|
|
|
// Updates |*out_location| to the source location of the complete
|
|
// extent of this enum value 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 EnumValueOptions OptionsType;
|
|
|
|
// Allows access to GetLocationPath for annotations.
|
|
friend class io::Printer;
|
|
friend class compiler::cpp::Formatter;
|
|
|
|
// See Descriptor::DebugString().
|
|
void DebugString(int depth, std::string* contents,
|
|
const DebugStringOptions& options) 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;
|
|
|
|
int number_;
|
|
// all_names_ = [name, full_name]
|
|
const std::string* all_names_;
|
|
const EnumDescriptor* type_;
|
|
const EnumValueOptions* options_;
|
|
// IMPORTANT: If you add a new field, make sure to search for all instances
|
|
// of Allocate<EnumValueDescriptor>() and AllocateArray<EnumValueDescriptor>()
|
|
// in descriptor.cc and update them to initialize the field.
|
|
|
|
// Must be constructed using DescriptorPool.
|
|
EnumValueDescriptor() {}
|
|
friend class DescriptorBuilder;
|
|
friend class EnumDescriptor;
|
|
friend class DescriptorPool;
|
|
friend class FileDescriptorTables;
|
|
friend class Reflection;
|
|
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(EnumValueDescriptor);
|
|
};
|
|
|
|
// Describes an RPC service. Use DescriptorPool to construct your own
|
|
// descriptors.
|
|
class PROTOBUF_EXPORT ServiceDescriptor : private internal::SymbolBase {
|
|
public:
|
|
typedef ServiceDescriptorProto Proto;
|
|
|
|
// The name of the service, not including its containing scope.
|
|
const std::string& name() const;
|
|
// The fully-qualified name of the service, scope delimited by periods.
|
|
const std::string& full_name() const;
|
|
// Index of this service within the file's services array.
|
|
int index() const;
|
|
|
|
// The .proto file in which this service was defined. Never nullptr.
|
|
const FileDescriptor* file() const;
|
|
|
|
// Get options for this service type. These are specified in the .proto file
|
|
// by placing lines like "option foo = 1234;" in the service definition.
|
|
// Allowed options are defined by ServiceOptions in descriptor.proto, and any
|
|
// available extensions of that message.
|
|
const ServiceOptions& options() const;
|
|
|
|
// The number of methods this service defines.
|
|
int method_count() const;
|
|
// Gets a MethodDescriptor by index, where 0 <= index < method_count().
|
|
// These are returned in the order they were defined in the .proto file.
|
|
const MethodDescriptor* method(int index) const;
|
|
|
|
// Look up a MethodDescriptor by name.
|
|
const MethodDescriptor* FindMethodByName(ConstStringParam name) const;
|
|
// See Descriptor::CopyTo().
|
|
void CopyTo(ServiceDescriptorProto* proto) const;
|
|
|
|
// See Descriptor::DebugString().
|
|
std::string DebugString() const;
|
|
|
|
// See Descriptor::DebugStringWithOptions().
|
|
std::string DebugStringWithOptions(const DebugStringOptions& options) const;
|
|
|
|
// Source Location ---------------------------------------------------
|
|
|
|
// Updates |*out_location| to the source location of the complete
|
|
// extent of this service 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 ServiceOptions OptionsType;
|
|
|
|
// Allows access to GetLocationPath for annotations.
|
|
friend class io::Printer;
|
|
friend class compiler::cpp::Formatter;
|
|
|
|
// See Descriptor::DebugString().
|
|
void DebugString(std::string* contents,
|
|
const DebugStringOptions& options) 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;
|
|
|
|
// all_names_ = [name, full_name]
|
|
const std::string* all_names_;
|
|
const FileDescriptor* file_;
|
|
const ServiceOptions* options_;
|
|
MethodDescriptor* methods_;
|
|
int method_count_;
|
|
// IMPORTANT: If you add a new field, make sure to search for all instances
|
|
// of Allocate<ServiceDescriptor>() and AllocateArray<ServiceDescriptor>() in
|
|
// descriptor.cc and update them to initialize the field.
|
|
|
|
// Must be constructed using DescriptorPool.
|
|
ServiceDescriptor() {}
|
|
friend class DescriptorBuilder;
|
|
friend class FileDescriptor;
|
|
friend class MethodDescriptor;
|
|
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ServiceDescriptor);
|
|
};
|
|
|
|
|
|
// Describes an individual service method. To obtain a MethodDescriptor given
|
|
// a service, first get its ServiceDescriptor, then call
|
|
// ServiceDescriptor::FindMethodByName(). Use DescriptorPool to construct your
|
|
// own descriptors.
|
|
class PROTOBUF_EXPORT MethodDescriptor : private internal::SymbolBase {
|
|
public:
|
|
typedef MethodDescriptorProto Proto;
|
|
|
|
// Name of this method, not including containing scope.
|
|
const std::string& name() const;
|
|
// The fully-qualified name of the method, scope delimited by periods.
|
|
const std::string& full_name() const;
|
|
// Index within the service's Descriptor.
|
|
int index() const;
|
|
|
|
// The .proto file in which this method was defined. Never nullptr.
|
|
const FileDescriptor* file() const;
|
|
// Gets the service to which this method belongs. Never nullptr.
|
|
const ServiceDescriptor* service() const;
|
|
|
|
// Gets the type of protocol message which this method accepts as input.
|
|
const Descriptor* input_type() const;
|
|
// Gets the type of protocol message which this message produces as output.
|
|
const Descriptor* output_type() const;
|
|
|
|
// Gets whether the client streams multiple requests.
|
|
bool client_streaming() const;
|
|
// Gets whether the server streams multiple responses.
|
|
bool server_streaming() const;
|
|
|
|
// Get options for this method. These are specified in the .proto file by
|
|
// placing lines like "option foo = 1234;" in curly-braces after a method
|
|
// declaration. Allowed options are defined by MethodOptions in
|
|
// descriptor.proto, and any available extensions of that message.
|
|
const MethodOptions& options() const;
|
|
|
|
// See Descriptor::CopyTo().
|
|
void CopyTo(MethodDescriptorProto* proto) const;
|
|
|
|
// See Descriptor::DebugString().
|
|
std::string DebugString() const;
|
|
|
|
// See Descriptor::DebugStringWithOptions().
|
|
std::string DebugStringWithOptions(const DebugStringOptions& options) const;
|
|
|
|
// Source Location ---------------------------------------------------
|
|
|
|
// Updates |*out_location| to the source location of the complete
|
|
// extent of this method 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 MethodOptions OptionsType;
|
|
|
|
// Allows access to GetLocationPath for annotations.
|
|
friend class io::Printer;
|
|
friend class compiler::cpp::Formatter;
|
|
|
|
// See Descriptor::DebugString().
|
|
void DebugString(int depth, std::string* contents,
|
|
const DebugStringOptions& options) 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;
|
|
|
|
bool client_streaming_;
|
|
bool server_streaming_;
|
|
// all_names_ = [name, full_name]
|
|
const std::string* all_names_;
|
|
const ServiceDescriptor* service_;
|
|
mutable internal::LazyDescriptor input_type_;
|
|
mutable internal::LazyDescriptor output_type_;
|
|
const MethodOptions* options_;
|
|
// IMPORTANT: If you add a new field, make sure to search for all instances
|
|
// of Allocate<MethodDescriptor>() and AllocateArray<MethodDescriptor>() in
|
|
// descriptor.cc and update them to initialize the field.
|
|
|
|
// Must be constructed using DescriptorPool.
|
|
MethodDescriptor() {}
|
|
friend class DescriptorBuilder;
|
|
friend class ServiceDescriptor;
|
|
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MethodDescriptor);
|
|
};
|
|
|
|
|
|
// Describes a whole .proto file. To get the FileDescriptor for a compiled-in
|
|
// file, get the descriptor for something defined in that file and call
|
|
// descriptor->file(). Use DescriptorPool to construct your own descriptors.
|
|
class PROTOBUF_EXPORT FileDescriptor {
|
|
public:
|
|
typedef FileDescriptorProto Proto;
|
|
|
|
// The filename, relative to the source tree.
|
|
// e.g. "foo/bar/baz.proto"
|
|
const std::string& name() const;
|
|
|
|
// The package, e.g. "google.protobuf.compiler".
|
|
const std::string& package() const;
|
|
|
|
// The DescriptorPool in which this FileDescriptor and all its contents were
|
|
// allocated. Never nullptr.
|
|
const DescriptorPool* pool() const;
|
|
|
|
// The number of files imported by this one.
|
|
int dependency_count() const;
|
|
// Gets an imported file by index, where 0 <= index < dependency_count().
|
|
// These are returned in the order they were defined in the .proto file.
|
|
const FileDescriptor* dependency(int index) const;
|
|
|
|
// The number of files public imported by this one.
|
|
// The public dependency list is a subset of the dependency list.
|
|
int public_dependency_count() const;
|
|
// Gets a public imported file by index, where 0 <= index <
|
|
// public_dependency_count().
|
|
// These are returned in the order they were defined in the .proto file.
|
|
const FileDescriptor* public_dependency(int index) const;
|
|
|
|
// The number of files that are imported for weak fields.
|
|
// The weak dependency list is a subset of the dependency list.
|
|
int weak_dependency_count() const;
|
|
// Gets a weak imported file by index, where 0 <= index <
|
|
// weak_dependency_count().
|
|
// These are returned in the order they were defined in the .proto file.
|
|
const FileDescriptor* weak_dependency(int index) const;
|
|
|
|
// Number of top-level message types defined in this file. (This does not
|
|
// include nested types.)
|
|
int message_type_count() const;
|
|
// Gets a top-level message type, where 0 <= index < message_type_count().
|
|
// These are returned in the order they were defined in the .proto file.
|
|
const Descriptor* message_type(int index) const;
|
|
|
|
// Number of top-level enum types defined in this file. (This does not
|
|
// include nested types.)
|
|
int enum_type_count() const;
|
|
// Gets a top-level enum type, 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;
|
|
|
|
// Number of services defined in this file.
|
|
int service_count() const;
|
|
// Gets a service, where 0 <= index < service_count().
|
|
// These are returned in the order they were defined in the .proto file.
|
|
const ServiceDescriptor* service(int index) const;
|
|
|
|
// Number of extensions defined at file scope. (This does not include
|
|
// extensions nested within message types.)
|
|
int extension_count() const;
|
|
// Gets an extension's descriptor, where 0 <= index < extension_count().
|
|
// These are returned in the order they were defined in the .proto file.
|
|
const FieldDescriptor* extension(int index) const;
|
|
|
|
// Get options for this file. These are specified in the .proto file by
|
|
// placing lines like "option foo = 1234;" at the top level, outside of any
|
|
// other definitions. Allowed options are defined by FileOptions in
|
|
// descriptor.proto, and any available extensions of that message.
|
|
const FileOptions& options() const;
|
|
|
|
// Syntax of this file.
|
|
enum Syntax {
|
|
SYNTAX_UNKNOWN = 0,
|
|
SYNTAX_PROTO2 = 2,
|
|
SYNTAX_PROTO3 = 3,
|
|
};
|
|
Syntax syntax() const;
|
|
static const char* SyntaxName(Syntax syntax);
|
|
|
|
// Find a top-level message type by name (not full_name). Returns nullptr if
|
|
// not found.
|
|
const Descriptor* FindMessageTypeByName(ConstStringParam name) const;
|
|
// Find a top-level enum type by name. Returns nullptr if not found.
|
|
const EnumDescriptor* FindEnumTypeByName(ConstStringParam name) const;
|
|
// Find an enum value defined in any top-level enum by name. Returns nullptr
|
|
// if not found.
|
|
const EnumValueDescriptor* FindEnumValueByName(ConstStringParam name) const;
|
|
// Find a service definition by name. Returns nullptr if not found.
|
|
const ServiceDescriptor* FindServiceByName(ConstStringParam name) const;
|
|
// Find a top-level extension definition by name. Returns nullptr if not
|
|
// found.
|
|
const FieldDescriptor* FindExtensionByName(ConstStringParam name) const;
|
|
// Similar to FindExtensionByName(), but searches by lowercased-name. See
|
|
// Descriptor::FindFieldByLowercaseName().
|
|
const FieldDescriptor* FindExtensionByLowercaseName(
|
|
ConstStringParam name) const;
|
|
// Similar to FindExtensionByName(), but searches by camelcased-name. See
|
|
// Descriptor::FindFieldByCamelcaseName().
|
|
const FieldDescriptor* FindExtensionByCamelcaseName(
|
|
ConstStringParam name) const;
|
|
|
|
// See Descriptor::CopyTo().
|
|
// Notes:
|
|
// - This method does NOT copy source code information since it is relatively
|
|
// large and rarely needed. See CopySourceCodeInfoTo() below.
|
|
void CopyTo(FileDescriptorProto* proto) const;
|
|
// Write the source code information of this FileDescriptor into the given
|
|
// FileDescriptorProto. See CopyTo() above.
|
|
void CopySourceCodeInfoTo(FileDescriptorProto* proto) const;
|
|
// Fill the json_name field of FieldDescriptorProto for all fields. Can only
|
|
// be called after CopyTo().
|
|
void CopyJsonNameTo(FileDescriptorProto* proto) const;
|
|
|
|
// See Descriptor::DebugString().
|
|
std::string DebugString() const;
|
|
|
|
// See Descriptor::DebugStringWithOptions().
|
|
std::string DebugStringWithOptions(const DebugStringOptions& options) const;
|
|
|
|
// Returns true if this is a placeholder for an unknown file. This will
|
|
// only be the case if this descriptor comes from a DescriptorPool
|
|
// with AllowUnknownDependencies() set.
|
|
bool is_placeholder() const;
|
|
|
|
// Updates |*out_location| to the source location of the complete extent of
|
|
// this file declaration (namely, the empty path).
|
|
bool GetSourceLocation(SourceLocation* out_location) const;
|
|
|
|
// Updates |*out_location| to the source location of the complete
|
|
// extent of the declaration or declaration-part denoted by |path|.
|
|
// Returns false and leaves |*out_location| unchanged iff location
|
|
// information was not available. (See SourceCodeInfo for
|
|
// description of path encoding.)
|
|
bool GetSourceLocation(const std::vector<int>& path,
|
|
SourceLocation* out_location) const;
|
|
|
|
private:
|
|
typedef FileOptions OptionsType;
|
|
|
|
const std::string* name_;
|
|
const std::string* package_;
|
|
const DescriptorPool* pool_;
|
|
internal::LazyInitData* dependencies_once_;
|
|
static void DependenciesOnceInit(const FileDescriptor* to_init);
|
|
void InternalDependenciesOnceInit() const;
|
|
|
|
// These are arranged to minimize padding on 64-bit.
|
|
int dependency_count_;
|
|
int public_dependency_count_;
|
|
int weak_dependency_count_;
|
|
int message_type_count_;
|
|
int enum_type_count_;
|
|
int service_count_;
|
|
|
|
bool is_placeholder_;
|
|
// Indicates the FileDescriptor is completed building. Used to verify
|
|
// that type accessor functions that can possibly build a dependent file
|
|
// aren't called during the process of building the file.
|
|
bool finished_building_;
|
|
// Actually a `Syntax` but stored as uint8_t to save space.
|
|
uint8_t syntax_;
|
|
// This one is here to fill the padding.
|
|
int extension_count_;
|
|
|
|
mutable const FileDescriptor** dependencies_;
|
|
int* public_dependencies_;
|
|
int* weak_dependencies_;
|
|
Descriptor* message_types_;
|
|
EnumDescriptor* enum_types_;
|
|
ServiceDescriptor* services_;
|
|
FieldDescriptor* extensions_;
|
|
const FileOptions* options_;
|
|
|
|
const FileDescriptorTables* tables_;
|
|
const SourceCodeInfo* source_code_info_;
|
|
|
|
// IMPORTANT: If you add a new field, make sure to search for all instances
|
|
// of Allocate<FileDescriptor>() and AllocateArray<FileDescriptor>() in
|
|
// descriptor.cc and update them to initialize the field.
|
|
|
|
FileDescriptor() {}
|
|
friend class DescriptorBuilder;
|
|
friend class DescriptorPool;
|
|
friend class Descriptor;
|
|
friend class FieldDescriptor;
|
|
friend class internal::LazyDescriptor;
|
|
friend class OneofDescriptor;
|
|
friend class EnumDescriptor;
|
|
friend class EnumValueDescriptor;
|
|
friend class MethodDescriptor;
|
|
friend class ServiceDescriptor;
|
|
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FileDescriptor);
|
|
};
|
|
|
|
|
|
// ===================================================================
|
|
|
|
// Used to construct descriptors.
|
|
//
|
|
// Normally you won't want to build your own descriptors. Message classes
|
|
// constructed by the protocol compiler will provide them for you. However,
|
|
// if you are implementing Message on your own, or if you are writing a
|
|
// program which can operate on totally arbitrary types and needs to load
|
|
// them from some sort of database, you might need to.
|
|
//
|
|
// Since Descriptors are composed of a whole lot of cross-linked bits of
|
|
// data that would be a pain to put together manually, the
|
|
// DescriptorPool class is provided to make the process easier. It can
|
|
// take a FileDescriptorProto (defined in descriptor.proto), validate it,
|
|
// and convert it to a set of nicely cross-linked Descriptors.
|
|
//
|
|
// DescriptorPool also helps with memory management. Descriptors are
|
|
// composed of many objects containing static data and pointers to each
|
|
// other. In all likelihood, when it comes time to delete this data,
|
|
// you'll want to delete it all at once. In fact, it is not uncommon to
|
|
// have a whole pool of descriptors all cross-linked with each other which
|
|
// you wish to delete all at once. This class represents such a pool, and
|
|
// handles the memory management for you.
|
|
//
|
|
// You can also search for descriptors within a DescriptorPool by name, and
|
|
// extensions by number.
|
|
class PROTOBUF_EXPORT DescriptorPool {
|
|
public:
|
|
// Create a normal, empty DescriptorPool.
|
|
DescriptorPool();
|
|
|
|
// Constructs a DescriptorPool that, when it can't find something among the
|
|
// descriptors already in the pool, looks for it in the given
|
|
// DescriptorDatabase.
|
|
// Notes:
|
|
// - If a DescriptorPool is constructed this way, its BuildFile*() methods
|
|
// must not be called (they will assert-fail). The only way to populate
|
|
// the pool with descriptors is to call the Find*By*() methods.
|
|
// - The Find*By*() methods may block the calling thread if the
|
|
// DescriptorDatabase blocks. This in turn means that parsing messages
|
|
// may block if they need to look up extensions.
|
|
// - The Find*By*() methods will use mutexes for thread-safety, thus making
|
|
// them slower even when they don't have to fall back to the database.
|
|
// In fact, even the Find*By*() methods of descriptor objects owned by
|
|
// this pool will be slower, since they will have to obtain locks too.
|
|
// - An ErrorCollector may optionally be given to collect validation errors
|
|
// in files loaded from the database. If not given, errors will be printed
|
|
// to GOOGLE_LOG(ERROR). Remember that files are built on-demand, so this
|
|
// ErrorCollector may be called from any thread that calls one of the
|
|
// Find*By*() methods.
|
|
// - The DescriptorDatabase must not be mutated during the lifetime of
|
|
// the DescriptorPool. Even if the client takes care to avoid data races,
|
|
// changes to the content of the DescriptorDatabase may not be reflected
|
|
// in subsequent lookups in the DescriptorPool.
|
|
class ErrorCollector;
|
|
explicit DescriptorPool(DescriptorDatabase* fallback_database,
|
|
ErrorCollector* error_collector = nullptr);
|
|
|
|
~DescriptorPool();
|
|
|
|
// Get a pointer to the generated pool. Generated protocol message classes
|
|
// which are compiled into the binary will allocate their descriptors in
|
|
// this pool. Do not add your own descriptors to this pool.
|
|
static const DescriptorPool* generated_pool();
|
|
|
|
|
|
// Find a FileDescriptor in the pool by file name. Returns nullptr if not
|
|
// found.
|
|
const FileDescriptor* FindFileByName(ConstStringParam name) const;
|
|
|
|
// Find the FileDescriptor in the pool which defines the given symbol.
|
|
// If any of the Find*ByName() methods below would succeed, then this is
|
|
// equivalent to calling that method and calling the result's file() method.
|
|
// Otherwise this returns nullptr.
|
|
const FileDescriptor* FindFileContainingSymbol(
|
|
ConstStringParam symbol_name) const;
|
|
|
|
// Looking up descriptors ------------------------------------------
|
|
// These find descriptors by fully-qualified name. These will find both
|
|
// top-level descriptors and nested descriptors. They return nullptr if not
|
|
// found.
|
|
|
|
const Descriptor* FindMessageTypeByName(ConstStringParam name) const;
|
|
const FieldDescriptor* FindFieldByName(ConstStringParam name) const;
|
|
const FieldDescriptor* FindExtensionByName(ConstStringParam name) const;
|
|
const OneofDescriptor* FindOneofByName(ConstStringParam name) const;
|
|
const EnumDescriptor* FindEnumTypeByName(ConstStringParam name) const;
|
|
const EnumValueDescriptor* FindEnumValueByName(ConstStringParam name) const;
|
|
const ServiceDescriptor* FindServiceByName(ConstStringParam name) const;
|
|
const MethodDescriptor* FindMethodByName(ConstStringParam name) const;
|
|
|
|
// Finds an extension of the given type by number. The extendee must be
|
|
// a member of this DescriptorPool or one of its underlays.
|
|
const FieldDescriptor* FindExtensionByNumber(const Descriptor* extendee,
|
|
int number) const;
|
|
|
|
// Finds an extension of the given type by its printable name.
|
|
// See comments above PrintableNameForExtension() for the definition of
|
|
// "printable name". The extendee must be a member of this DescriptorPool
|
|
// or one of its underlays. Returns nullptr if there is no known message
|
|
// extension with the given printable name.
|
|
const FieldDescriptor* FindExtensionByPrintableName(
|
|
const Descriptor* extendee, ConstStringParam printable_name) const;
|
|
|
|
// Finds extensions of extendee. The extensions will be appended to
|
|
// out in an undefined order. Only extensions defined directly in
|
|
// this DescriptorPool or one of its underlays are guaranteed to be
|
|
// found: extensions defined in the fallback database might not be found
|
|
// depending on the database implementation.
|
|
void FindAllExtensions(const Descriptor* extendee,
|
|
std::vector<const FieldDescriptor*>* out) const;
|
|
|
|
// Building descriptors --------------------------------------------
|
|
|
|
// When converting a FileDescriptorProto to a FileDescriptor, various
|
|
// errors might be detected in the input. The caller may handle these
|
|
// programmatically by implementing an ErrorCollector.
|
|
class PROTOBUF_EXPORT ErrorCollector {
|
|
public:
|
|
inline ErrorCollector() {}
|
|
virtual ~ErrorCollector();
|
|
|
|
// These constants specify what exact part of the construct is broken.
|
|
// This is useful e.g. for mapping the error back to an exact location
|
|
// in a .proto file.
|
|
enum ErrorLocation {
|
|
NAME, // the symbol name, or the package name for files
|
|
NUMBER, // field or extension range number
|
|
TYPE, // field type
|
|
EXTENDEE, // field extendee
|
|
DEFAULT_VALUE, // field default value
|
|
INPUT_TYPE, // method input type
|
|
OUTPUT_TYPE, // method output type
|
|
OPTION_NAME, // name in assignment
|
|
OPTION_VALUE, // value in option assignment
|
|
IMPORT, // import error
|
|
OTHER // some other problem
|
|
};
|
|
|
|
// Reports an error in the FileDescriptorProto. Use this function if the
|
|
// problem occurred should interrupt building the FileDescriptorProto.
|
|
virtual void AddError(
|
|
const std::string& filename, // File name in which the error occurred.
|
|
const std::string& element_name, // Full name of the erroneous element.
|
|
const Message* descriptor, // Descriptor of the erroneous element.
|
|
ErrorLocation location, // One of the location constants, above.
|
|
const std::string& message // Human-readable error message.
|
|
) = 0;
|
|
|
|
// Reports a warning in the FileDescriptorProto. Use this function if the
|
|
// problem occurred should NOT interrupt building the FileDescriptorProto.
|
|
virtual void AddWarning(
|
|
const std::string& /*filename*/, // File name in which the error
|
|
// occurred.
|
|
const std::string& /*element_name*/, // Full name of the erroneous
|
|
// element.
|
|
const Message* /*descriptor*/, // Descriptor of the erroneous element.
|
|
ErrorLocation /*location*/, // One of the location constants, above.
|
|
const std::string& /*message*/ // Human-readable error message.
|
|
) {}
|
|
|
|
private:
|
|
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ErrorCollector);
|
|
};
|
|
|
|
// Convert the FileDescriptorProto to real descriptors and place them in
|
|
// this DescriptorPool. All dependencies of the file must already be in
|
|
// the pool. Returns the resulting FileDescriptor, or nullptr if there were
|
|
// problems with the input (e.g. the message was invalid, or dependencies
|
|
// were missing). Details about the errors are written to GOOGLE_LOG(ERROR).
|
|
const FileDescriptor* BuildFile(const FileDescriptorProto& proto);
|
|
|
|
// Same as BuildFile() except errors are sent to the given ErrorCollector.
|
|
const FileDescriptor* BuildFileCollectingErrors(
|
|
const FileDescriptorProto& proto, ErrorCollector* error_collector);
|
|
|
|
// By default, it is an error if a FileDescriptorProto contains references
|
|
// to types or other files that are not found in the DescriptorPool (or its
|
|
// backing DescriptorDatabase, if any). If you call
|
|
// AllowUnknownDependencies(), however, then unknown types and files
|
|
// will be replaced by placeholder descriptors (which can be identified by
|
|
// the is_placeholder() method). This can allow you to
|
|
// perform some useful operations with a .proto file even if you do not
|
|
// have access to other .proto files on which it depends. However, some
|
|
// heuristics must be used to fill in the gaps in information, and these
|
|
// can lead to descriptors which are inaccurate. For example, the
|
|
// DescriptorPool may be forced to guess whether an unknown type is a message
|
|
// or an enum, as well as what package it resides in. Furthermore,
|
|
// placeholder types will not be discoverable via FindMessageTypeByName()
|
|
// and similar methods, which could confuse some descriptor-based algorithms.
|
|
// Generally, the results of this option should be handled with extreme care.
|
|
void AllowUnknownDependencies() { allow_unknown_ = true; }
|
|
|
|
// By default, weak imports are allowed to be missing, in which case we will
|
|
// use a placeholder for the dependency and convert the field to be an Empty
|
|
// message field. If you call EnforceWeakDependencies(true), however, the
|
|
// DescriptorPool will report a import not found error.
|
|
void EnforceWeakDependencies(bool enforce) { enforce_weak_ = enforce; }
|
|
|
|
// Internal stuff --------------------------------------------------
|
|
// These methods MUST NOT be called from outside the proto2 library.
|
|
// These methods may contain hidden pitfalls and may be removed in a
|
|
// future library version.
|
|
|
|
// Create a DescriptorPool which is overlaid on top of some other pool.
|
|
// If you search for a descriptor in the overlay and it is not found, the
|
|
// underlay will be searched as a backup. If the underlay has its own
|
|
// underlay, that will be searched next, and so on. This also means that
|
|
// files built in the overlay will be cross-linked with the underlay's
|
|
// descriptors if necessary. The underlay remains property of the caller;
|
|
// it must remain valid for the lifetime of the newly-constructed pool.
|
|
//
|
|
// Example: Say you want to parse a .proto file at runtime in order to use
|
|
// its type with a DynamicMessage. Say this .proto file has dependencies,
|
|
// but you know that all the dependencies will be things that are already
|
|
// compiled into the binary. For ease of use, you'd like to load the types
|
|
// right out of generated_pool() rather than have to parse redundant copies
|
|
// of all these .protos and runtime. But, you don't want to add the parsed
|
|
// types directly into generated_pool(): this is not allowed, and would be
|
|
// bad design anyway. So, instead, you could use generated_pool() as an
|
|
// underlay for a new DescriptorPool in which you add only the new file.
|
|
//
|
|
// WARNING: Use of underlays can lead to many subtle gotchas. Instead,
|
|
// try to formulate what you want to do in terms of DescriptorDatabases.
|
|
explicit DescriptorPool(const DescriptorPool* underlay);
|
|
|
|
// Called by generated classes at init time to add their descriptors to
|
|
// generated_pool. Do NOT call this in your own code! filename must be a
|
|
// permanent string (e.g. a string literal).
|
|
static void InternalAddGeneratedFile(const void* encoded_file_descriptor,
|
|
int size);
|
|
|
|
// Disallow [enforce_utf8 = false] in .proto files.
|
|
void DisallowEnforceUtf8() { disallow_enforce_utf8_ = true; }
|
|
|
|
|
|
// For internal use only: Gets a non-const pointer to the generated pool.
|
|
// This is called at static-initialization time only, so thread-safety is
|
|
// not a concern. If both an underlay and a fallback database are present,
|
|
// the underlay takes precedence.
|
|
static DescriptorPool* internal_generated_pool();
|
|
|
|
// For internal use only: Gets a non-const pointer to the generated
|
|
// descriptor database.
|
|
// Only used for testing.
|
|
static DescriptorDatabase* internal_generated_database();
|
|
|
|
// For internal use only: Changes the behavior of BuildFile() such that it
|
|
// allows the file to make reference to message types declared in other files
|
|
// which it did not officially declare as dependencies.
|
|
void InternalDontEnforceDependencies();
|
|
|
|
// For internal use only: Enables lazy building of dependencies of a file.
|
|
// Delay the building of dependencies of a file descriptor until absolutely
|
|
// necessary, like when message_type() is called on a field that is defined
|
|
// in that dependency's file. This will cause functional issues if a proto
|
|
// or one of its dependencies has errors. Should only be enabled for the
|
|
// generated_pool_ (because no descriptor build errors are guaranteed by
|
|
// the compilation generation process), testing, or if a lack of descriptor
|
|
// build errors can be guaranteed for a pool.
|
|
void InternalSetLazilyBuildDependencies() {
|
|
lazily_build_dependencies_ = true;
|
|
// This needs to be set when lazily building dependencies, as it breaks
|
|
// dependency checking.
|
|
InternalDontEnforceDependencies();
|
|
}
|
|
|
|
// For internal use only.
|
|
void internal_set_underlay(const DescriptorPool* underlay) {
|
|
underlay_ = underlay;
|
|
}
|
|
|
|
// For internal (unit test) use only: Returns true if a FileDescriptor has
|
|
// been constructed for the given file, false otherwise. Useful for testing
|
|
// lazy descriptor initialization behavior.
|
|
bool InternalIsFileLoaded(ConstStringParam filename) const;
|
|
|
|
// Add a file to unused_import_track_files_. DescriptorBuilder will log
|
|
// warnings or errors for those files if there is any unused import.
|
|
void AddUnusedImportTrackFile(ConstStringParam file_name,
|
|
bool is_error = false);
|
|
void ClearUnusedImportTrackFiles();
|
|
|
|
private:
|
|
friend class Descriptor;
|
|
friend class internal::LazyDescriptor;
|
|
friend class FieldDescriptor;
|
|
friend class EnumDescriptor;
|
|
friend class ServiceDescriptor;
|
|
friend class MethodDescriptor;
|
|
friend class FileDescriptor;
|
|
friend class StreamDescriptor;
|
|
friend class DescriptorBuilder;
|
|
friend class FileDescriptorTables;
|
|
|
|
// Return true if the given name is a sub-symbol of any non-package
|
|
// descriptor that already exists in the descriptor pool. (The full
|
|
// definition of such types is already known.)
|
|
bool IsSubSymbolOfBuiltType(StringPiece name) const;
|
|
|
|
// Tries to find something in the fallback database and link in the
|
|
// corresponding proto file. Returns true if successful, in which case
|
|
// the caller should search for the thing again. These are declared
|
|
// const because they are called by (semantically) const methods.
|
|
bool TryFindFileInFallbackDatabase(StringPiece name) const;
|
|
bool TryFindSymbolInFallbackDatabase(StringPiece name) const;
|
|
bool TryFindExtensionInFallbackDatabase(const Descriptor* containing_type,
|
|
int field_number) const;
|
|
|
|
// This internal find extension method only check with its table and underlay
|
|
// descriptor_pool's table. It does not check with fallback DB and no
|
|
// additional proto file will be build in this method.
|
|
const FieldDescriptor* InternalFindExtensionByNumberNoLock(
|
|
const Descriptor* extendee, int number) const;
|
|
|
|
// Like BuildFile() but called internally when the file has been loaded from
|
|
// fallback_database_. Declared const because it is called by (semantically)
|
|
// const methods.
|
|
const FileDescriptor* BuildFileFromDatabase(
|
|
const FileDescriptorProto& proto) const;
|
|
|
|
// Helper for when lazily_build_dependencies_ is set, can look up a symbol
|
|
// after the file's descriptor is built, and can build the file where that
|
|
// symbol is defined if necessary. Will create a placeholder if the type
|
|
// doesn't exist in the fallback database, or the file doesn't build
|
|
// successfully.
|
|
Symbol CrossLinkOnDemandHelper(StringPiece name,
|
|
bool expecting_enum) const;
|
|
|
|
// Create a placeholder FileDescriptor of the specified name
|
|
FileDescriptor* NewPlaceholderFile(StringPiece name) const;
|
|
FileDescriptor* NewPlaceholderFileWithMutexHeld(StringPiece name) const;
|
|
|
|
enum PlaceholderType {
|
|
PLACEHOLDER_MESSAGE,
|
|
PLACEHOLDER_ENUM,
|
|
PLACEHOLDER_EXTENDABLE_MESSAGE
|
|
};
|
|
// Create a placeholder Descriptor of the specified name
|
|
Symbol NewPlaceholder(StringPiece name,
|
|
PlaceholderType placeholder_type) const;
|
|
Symbol NewPlaceholderWithMutexHeld(StringPiece name,
|
|
PlaceholderType placeholder_type) const;
|
|
|
|
// If fallback_database_ is nullptr, this is nullptr. Otherwise, this is a
|
|
// mutex which must be locked while accessing tables_.
|
|
internal::WrappedMutex* mutex_;
|
|
|
|
// See constructor.
|
|
DescriptorDatabase* fallback_database_;
|
|
ErrorCollector* default_error_collector_;
|
|
const DescriptorPool* underlay_;
|
|
|
|
// This class contains a lot of hash maps with complicated types that
|
|
// we'd like to keep out of the header.
|
|
class Tables;
|
|
std::unique_ptr<Tables> tables_;
|
|
|
|
bool enforce_dependencies_;
|
|
bool lazily_build_dependencies_;
|
|
bool allow_unknown_;
|
|
bool enforce_weak_;
|
|
bool disallow_enforce_utf8_;
|
|
|
|
// Set of files to track for unused imports. The bool value when true means
|
|
// unused imports are treated as errors (and as warnings when false).
|
|
std::map<std::string, bool> unused_import_track_files_;
|
|
|
|
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DescriptorPool);
|
|
};
|
|
|
|
|
|
// inline methods ====================================================
|
|
|
|
// These macros makes this repetitive code more readable.
|
|
#define PROTOBUF_DEFINE_ACCESSOR(CLASS, FIELD, TYPE) \
|
|
inline TYPE CLASS::FIELD() const { return FIELD##_; }
|
|
|
|
// Strings fields are stored as pointers but returned as const references.
|
|
#define PROTOBUF_DEFINE_STRING_ACCESSOR(CLASS, FIELD) \
|
|
inline const std::string& CLASS::FIELD() const { return *FIELD##_; }
|
|
|
|
// Name and full name are stored in a single array to save space.
|
|
#define PROTOBUF_DEFINE_NAME_ACCESSOR(CLASS) \
|
|
inline const std::string& CLASS::name() const { return all_names_[0]; } \
|
|
inline const std::string& CLASS::full_name() const { return all_names_[1]; }
|
|
|
|
// Arrays take an index parameter, obviously.
|
|
#define PROTOBUF_DEFINE_ARRAY_ACCESSOR(CLASS, FIELD, TYPE) \
|
|
inline TYPE CLASS::FIELD(int index) const { return FIELD##s_ + index; }
|
|
|
|
#define PROTOBUF_DEFINE_OPTIONS_ACCESSOR(CLASS, TYPE) \
|
|
inline const TYPE& CLASS::options() const { return *options_; }
|
|
|
|
PROTOBUF_DEFINE_NAME_ACCESSOR(Descriptor)
|
|
PROTOBUF_DEFINE_ACCESSOR(Descriptor, file, const FileDescriptor*)
|
|
PROTOBUF_DEFINE_ACCESSOR(Descriptor, containing_type, const Descriptor*)
|
|
|
|
PROTOBUF_DEFINE_ACCESSOR(Descriptor, field_count, int)
|
|
PROTOBUF_DEFINE_ACCESSOR(Descriptor, oneof_decl_count, int)
|
|
PROTOBUF_DEFINE_ACCESSOR(Descriptor, real_oneof_decl_count, int)
|
|
PROTOBUF_DEFINE_ACCESSOR(Descriptor, nested_type_count, int)
|
|
PROTOBUF_DEFINE_ACCESSOR(Descriptor, enum_type_count, int)
|
|
|
|
PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, field, const FieldDescriptor*)
|
|
PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, oneof_decl, const OneofDescriptor*)
|
|
PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, nested_type, const Descriptor*)
|
|
PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, enum_type, const EnumDescriptor*)
|
|
|
|
PROTOBUF_DEFINE_ACCESSOR(Descriptor, extension_range_count, int)
|
|
PROTOBUF_DEFINE_ACCESSOR(Descriptor, extension_count, int)
|
|
PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, extension_range,
|
|
const Descriptor::ExtensionRange*)
|
|
PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, extension, const FieldDescriptor*)
|
|
|
|
PROTOBUF_DEFINE_ACCESSOR(Descriptor, reserved_range_count, int)
|
|
PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, reserved_range,
|
|
const Descriptor::ReservedRange*)
|
|
PROTOBUF_DEFINE_ACCESSOR(Descriptor, reserved_name_count, int)
|
|
|
|
PROTOBUF_DEFINE_OPTIONS_ACCESSOR(Descriptor, MessageOptions)
|
|
PROTOBUF_DEFINE_ACCESSOR(Descriptor, is_placeholder, bool)
|
|
|
|
PROTOBUF_DEFINE_NAME_ACCESSOR(FieldDescriptor)
|
|
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, file, const FileDescriptor*)
|
|
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, number, int)
|
|
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, is_extension, bool)
|
|
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, containing_type, const Descriptor*)
|
|
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, index_in_oneof, int)
|
|
PROTOBUF_DEFINE_OPTIONS_ACCESSOR(FieldDescriptor, FieldOptions)
|
|
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, has_default_value, bool)
|
|
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, has_json_name, bool)
|
|
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_int32_t, int32_t)
|
|
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_int64_t, int64_t)
|
|
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_uint32_t, uint32_t)
|
|
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_uint64_t, uint64_t)
|
|
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_float, float)
|
|
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_double, double)
|
|
PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_bool, bool)
|
|
PROTOBUF_DEFINE_STRING_ACCESSOR(FieldDescriptor, default_value_string)
|
|
|
|
PROTOBUF_DEFINE_NAME_ACCESSOR(OneofDescriptor)
|
|
PROTOBUF_DEFINE_ACCESSOR(OneofDescriptor, containing_type, const Descriptor*)
|
|
PROTOBUF_DEFINE_ACCESSOR(OneofDescriptor, field_count, int)
|
|
PROTOBUF_DEFINE_OPTIONS_ACCESSOR(OneofDescriptor, OneofOptions)
|
|
|
|
PROTOBUF_DEFINE_NAME_ACCESSOR(EnumDescriptor)
|
|
PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, file, const FileDescriptor*)
|
|
PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, containing_type, const Descriptor*)
|
|
PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, value_count, int)
|
|
PROTOBUF_DEFINE_ARRAY_ACCESSOR(EnumDescriptor, value,
|
|
const EnumValueDescriptor*)
|
|
PROTOBUF_DEFINE_OPTIONS_ACCESSOR(EnumDescriptor, EnumOptions)
|
|
PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, is_placeholder, bool)
|
|
PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, reserved_range_count, int)
|
|
PROTOBUF_DEFINE_ARRAY_ACCESSOR(EnumDescriptor, reserved_range,
|
|
const EnumDescriptor::ReservedRange*)
|
|
PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, reserved_name_count, int)
|
|
|
|
PROTOBUF_DEFINE_NAME_ACCESSOR(EnumValueDescriptor)
|
|
PROTOBUF_DEFINE_ACCESSOR(EnumValueDescriptor, number, int)
|
|
PROTOBUF_DEFINE_ACCESSOR(EnumValueDescriptor, type, const EnumDescriptor*)
|
|
PROTOBUF_DEFINE_OPTIONS_ACCESSOR(EnumValueDescriptor, EnumValueOptions)
|
|
|
|
PROTOBUF_DEFINE_NAME_ACCESSOR(ServiceDescriptor)
|
|
PROTOBUF_DEFINE_ACCESSOR(ServiceDescriptor, file, const FileDescriptor*)
|
|
PROTOBUF_DEFINE_ACCESSOR(ServiceDescriptor, method_count, int)
|
|
PROTOBUF_DEFINE_ARRAY_ACCESSOR(ServiceDescriptor, method,
|
|
const MethodDescriptor*)
|
|
PROTOBUF_DEFINE_OPTIONS_ACCESSOR(ServiceDescriptor, ServiceOptions)
|
|
|
|
PROTOBUF_DEFINE_NAME_ACCESSOR(MethodDescriptor)
|
|
PROTOBUF_DEFINE_ACCESSOR(MethodDescriptor, service, const ServiceDescriptor*)
|
|
PROTOBUF_DEFINE_OPTIONS_ACCESSOR(MethodDescriptor, MethodOptions)
|
|
PROTOBUF_DEFINE_ACCESSOR(MethodDescriptor, client_streaming, bool)
|
|
PROTOBUF_DEFINE_ACCESSOR(MethodDescriptor, server_streaming, bool)
|
|
|
|
PROTOBUF_DEFINE_STRING_ACCESSOR(FileDescriptor, name)
|
|
PROTOBUF_DEFINE_STRING_ACCESSOR(FileDescriptor, package)
|
|
PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, pool, const DescriptorPool*)
|
|
PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, dependency_count, int)
|
|
PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, public_dependency_count, int)
|
|
PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, weak_dependency_count, int)
|
|
PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, message_type_count, int)
|
|
PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, enum_type_count, int)
|
|
PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, service_count, int)
|
|
PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, extension_count, int)
|
|
PROTOBUF_DEFINE_OPTIONS_ACCESSOR(FileDescriptor, FileOptions)
|
|
PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, is_placeholder, bool)
|
|
|
|
PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, message_type, const Descriptor*)
|
|
PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, enum_type, const EnumDescriptor*)
|
|
PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, service,
|
|
const ServiceDescriptor*)
|
|
PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, extension,
|
|
const FieldDescriptor*)
|
|
|
|
#undef PROTOBUF_DEFINE_ACCESSOR
|
|
#undef PROTOBUF_DEFINE_STRING_ACCESSOR
|
|
#undef PROTOBUF_DEFINE_ARRAY_ACCESSOR
|
|
|
|
// A few accessors differ from the macros...
|
|
|
|
inline Descriptor::WellKnownType Descriptor::well_known_type() const {
|
|
return static_cast<Descriptor::WellKnownType>(well_known_type_);
|
|
}
|
|
|
|
inline bool Descriptor::IsExtensionNumber(int number) const {
|
|
return FindExtensionRangeContainingNumber(number) != nullptr;
|
|
}
|
|
|
|
inline bool Descriptor::IsReservedNumber(int number) const {
|
|
return FindReservedRangeContainingNumber(number) != nullptr;
|
|
}
|
|
|
|
inline bool Descriptor::IsReservedName(ConstStringParam name) const {
|
|
for (int i = 0; i < reserved_name_count(); i++) {
|
|
if (name == static_cast<ConstStringParam>(reserved_name(i))) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Can't use PROTOBUF_DEFINE_ARRAY_ACCESSOR because reserved_names_ is actually
|
|
// an array of pointers rather than the usual array of objects.
|
|
inline const std::string& Descriptor::reserved_name(int index) const {
|
|
return *reserved_names_[index];
|
|
}
|
|
|
|
inline bool EnumDescriptor::IsReservedNumber(int number) const {
|
|
return FindReservedRangeContainingNumber(number) != nullptr;
|
|
}
|
|
|
|
inline bool EnumDescriptor::IsReservedName(ConstStringParam name) const {
|
|
for (int i = 0; i < reserved_name_count(); i++) {
|
|
if (name == static_cast<ConstStringParam>(reserved_name(i))) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Can't use PROTOBUF_DEFINE_ARRAY_ACCESSOR because reserved_names_ is actually
|
|
// an array of pointers rather than the usual array of objects.
|
|
inline const std::string& EnumDescriptor::reserved_name(int index) const {
|
|
return *reserved_names_[index];
|
|
}
|
|
|
|
inline const std::string& FieldDescriptor::lowercase_name() const {
|
|
return all_names_[lowercase_name_index_];
|
|
}
|
|
|
|
inline const std::string& FieldDescriptor::camelcase_name() const {
|
|
return all_names_[camelcase_name_index_];
|
|
}
|
|
|
|
inline const std::string& FieldDescriptor::json_name() const {
|
|
return all_names_[json_name_index_];
|
|
}
|
|
|
|
inline const OneofDescriptor* FieldDescriptor::containing_oneof() const {
|
|
return is_oneof_ ? scope_.containing_oneof : nullptr;
|
|
}
|
|
|
|
inline const Descriptor* FieldDescriptor::extension_scope() const {
|
|
GOOGLE_CHECK(is_extension_);
|
|
return scope_.extension_scope;
|
|
}
|
|
|
|
inline FieldDescriptor::Label FieldDescriptor::label() const {
|
|
return static_cast<Label>(label_);
|
|
}
|
|
|
|
inline FieldDescriptor::Type FieldDescriptor::type() const {
|
|
if (type_once_) {
|
|
internal::call_once(type_once_->once, &FieldDescriptor::TypeOnceInit, this);
|
|
}
|
|
return static_cast<Type>(type_);
|
|
}
|
|
|
|
inline bool FieldDescriptor::is_required() const {
|
|
return label() == LABEL_REQUIRED;
|
|
}
|
|
|
|
inline bool FieldDescriptor::is_optional() const {
|
|
return label() == LABEL_OPTIONAL;
|
|
}
|
|
|
|
inline bool FieldDescriptor::is_repeated() const {
|
|
return label() == LABEL_REPEATED;
|
|
}
|
|
|
|
inline bool FieldDescriptor::is_packable() const {
|
|
return is_repeated() && IsTypePackable(type());
|
|
}
|
|
|
|
inline bool FieldDescriptor::is_map() const {
|
|
return type() == TYPE_MESSAGE && is_map_message_type();
|
|
}
|
|
|
|
inline bool FieldDescriptor::has_optional_keyword() const {
|
|
return proto3_optional_ ||
|
|
(file()->syntax() == FileDescriptor::SYNTAX_PROTO2 && is_optional() &&
|
|
!containing_oneof());
|
|
}
|
|
|
|
inline const OneofDescriptor* FieldDescriptor::real_containing_oneof() const {
|
|
auto* oneof = containing_oneof();
|
|
return oneof && !oneof->is_synthetic() ? oneof : nullptr;
|
|
}
|
|
|
|
inline bool FieldDescriptor::has_presence() const {
|
|
if (is_repeated()) return false;
|
|
return cpp_type() == CPPTYPE_MESSAGE || containing_oneof() ||
|
|
file()->syntax() == FileDescriptor::SYNTAX_PROTO2;
|
|
}
|
|
|
|
// To save space, index() is computed by looking at the descriptor's position
|
|
// in the parent's array of children.
|
|
inline int FieldDescriptor::index() const {
|
|
if (!is_extension_) {
|
|
return static_cast<int>(this - containing_type()->fields_);
|
|
} else if (extension_scope() != nullptr) {
|
|
return static_cast<int>(this - extension_scope()->extensions_);
|
|
} else {
|
|
return static_cast<int>(this - file_->extensions_);
|
|
}
|
|
}
|
|
|
|
inline int Descriptor::index() const {
|
|
if (containing_type_ == nullptr) {
|
|
return static_cast<int>(this - file_->message_types_);
|
|
} else {
|
|
return static_cast<int>(this - containing_type_->nested_types_);
|
|
}
|
|
}
|
|
|
|
inline const FileDescriptor* OneofDescriptor::file() const {
|
|
return containing_type()->file();
|
|
}
|
|
|
|
inline int OneofDescriptor::index() const {
|
|
return static_cast<int>(this - containing_type_->oneof_decls_);
|
|
}
|
|
|
|
inline bool OneofDescriptor::is_synthetic() const {
|
|
return field_count() == 1 && field(0)->proto3_optional_;
|
|
}
|
|
|
|
inline int EnumDescriptor::index() const {
|
|
if (containing_type_ == nullptr) {
|
|
return static_cast<int>(this - file_->enum_types_);
|
|
} else {
|
|
return static_cast<int>(this - containing_type_->enum_types_);
|
|
}
|
|
}
|
|
|
|
inline const FileDescriptor* EnumValueDescriptor::file() const {
|
|
return type()->file();
|
|
}
|
|
|
|
inline int EnumValueDescriptor::index() const {
|
|
return static_cast<int>(this - type_->values_);
|
|
}
|
|
|
|
inline int ServiceDescriptor::index() const {
|
|
return static_cast<int>(this - file_->services_);
|
|
}
|
|
|
|
inline const FileDescriptor* MethodDescriptor::file() const {
|
|
return service()->file();
|
|
}
|
|
|
|
inline int MethodDescriptor::index() const {
|
|
return static_cast<int>(this - service_->methods_);
|
|
}
|
|
|
|
inline const char* FieldDescriptor::type_name() const {
|
|
return kTypeToName[type()];
|
|
}
|
|
|
|
inline FieldDescriptor::CppType FieldDescriptor::cpp_type() const {
|
|
return kTypeToCppTypeMap[type()];
|
|
}
|
|
|
|
inline const char* FieldDescriptor::cpp_type_name() const {
|
|
return kCppTypeToName[kTypeToCppTypeMap[type()]];
|
|
}
|
|
|
|
inline FieldDescriptor::CppType FieldDescriptor::TypeToCppType(Type type) {
|
|
return kTypeToCppTypeMap[type];
|
|
}
|
|
|
|
inline const char* FieldDescriptor::TypeName(Type type) {
|
|
return kTypeToName[type];
|
|
}
|
|
|
|
inline const char* FieldDescriptor::CppTypeName(CppType cpp_type) {
|
|
return kCppTypeToName[cpp_type];
|
|
}
|
|
|
|
inline bool FieldDescriptor::IsTypePackable(Type field_type) {
|
|
return (field_type != FieldDescriptor::TYPE_STRING &&
|
|
field_type != FieldDescriptor::TYPE_GROUP &&
|
|
field_type != FieldDescriptor::TYPE_MESSAGE &&
|
|
field_type != FieldDescriptor::TYPE_BYTES);
|
|
}
|
|
|
|
inline const FileDescriptor* FileDescriptor::public_dependency(
|
|
int index) const {
|
|
return dependency(public_dependencies_[index]);
|
|
}
|
|
|
|
inline const FileDescriptor* FileDescriptor::weak_dependency(int index) const {
|
|
return dependency(weak_dependencies_[index]);
|
|
}
|
|
|
|
inline FileDescriptor::Syntax FileDescriptor::syntax() const {
|
|
return static_cast<Syntax>(syntax_);
|
|
}
|
|
|
|
// Can't use PROTOBUF_DEFINE_ARRAY_ACCESSOR because fields_ is actually an array
|
|
// of pointers rather than the usual array of objects.
|
|
inline const FieldDescriptor* OneofDescriptor::field(int index) const {
|
|
return fields_[index];
|
|
}
|
|
|
|
} // namespace protobuf
|
|
} // namespace google
|
|
|
|
#include <google/protobuf/port_undef.inc>
|
|
|
|
#endif // GOOGLE_PROTOBUF_DESCRIPTOR_H__
|