class DescriptorPool

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.

Create a normal, empty DescriptorPool.

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.

Toggles enforcement of extension declarations.

This enforcement is disabled by default because it requires full

descriptors with source-retention options, which are generally not

available at runtime.

Dispatch recursive builds to a callback that may stick them onto a separate

thread. This is primarily to avoid stack overflows on untrusted inputs.

The dispatcher must always synchronously execute the provided callback.

Asynchronous execution is undefined behavior.

Disallow [enforce_utf8 = false] in .proto files.

Use the deprecated legacy behavior for handling JSON field name conflicts.

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.

For internal use only.

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.

Find a FileDescriptor in the pool by file name. Returns nullptr if not

found.

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.

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.

Finds an extension of the given type by number. The extendee must be

a member of this DescriptorPool or one of its underlays.

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.

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.

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 ABSL_LOG(ERROR).

Same as BuildFile() except errors are sent to the given ErrorCollector.

Sets the default feature mappings used during the build. If this function

isn't called, the C++ feature set defaults are used. If this function is

called, these defaults will be used instead.

FeatureSetDefaults includes a minimum/maximum supported edition, which will

be enforced while building proto files.

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.

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).

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.

For internal use only: Gets a non-const pointer to the generated

descriptor database.

Only used for testing.

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.

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.

Add a file to to apply more strict checks to.

- unused imports will log either warnings or errors.

- deprecated features will log warnings.