Equivalent to
ExtensionRegistry but supports only "lite" types.
If all of your types are lite types, then you only need to use
ExtensionRegistryLite. Similarly, if all your types are regular
types, then you only need
ExtensionRegistry. Typically it does not
make sense to mix the two, since if you have any regular types in your
program, you then require the full runtime and lose all the benefits of
the lite runtime, so you might as well make all your types be regular types.
However, in some cases (e.g. when depending on multiple third-party libraries
where one uses lite types and one uses regular), you may find yourself
wanting to mix the two. In this case things get more complicated.
There are three factors to consider: Whether the type being extended is
lite, whether the embedded type (in the case of a message-typed extension)
is lite, and whether the extension itself is lite. Since all three are
declared in different files, they could all be different. Here are all
the combinations and which type of registry to use:
Extended type Inner type Extension Use registry
=======================================================================
lite lite lite ExtensionRegistryLite
lite regular lite ExtensionRegistry
regular regular regular ExtensionRegistry
all other combinations not supported
Note that just as regular types are not allowed to contain lite-type fields,
they are also not allowed to contain lite-type extensions. This is because
regular types must be fully accessible via reflection, which in turn means
that all the inner messages must also support reflection. On the other hand,
since regular types implement the entire lite interface, there is no problem
with embedding regular types inside lite types.