Package filetype provides functionality for wrapping descriptors with Go type information.



    This section is empty.


    This section is empty.


    This section is empty.


    type Builder

    type Builder struct {
    	// File is the underlying file descriptor builder.
    	File fdesc.Builder
    	// GoTypes is a unique set of the Go types for all declarations and
    	// dependencies. Each type is represented as a zero value of the Go type.
    	// Declarations are Go types generated for enums and messages directly
    	// declared (not publicly imported) in the proto source file.
    	// Messages for map entries are accounted for, but represented by nil.
    	// Enum declarations in "flattened ordering" come first, followed by
    	// message declarations in "flattened ordering".
    	// Dependencies are Go types for enums or messages referenced by
    	// message fields (excluding weak fields), for parent extended messages of
    	// extension fields, for enums or messages referenced by extension fields,
    	// and for input and output messages referenced by service methods.
    	// Dependencies must come after declarations, but the ordering of
    	// dependencies themselves is unspecified.
    	GoTypes []interface{}
    	// DependencyIndexes is an ordered list of indexes into GoTypes for the
    	// dependencies of messages, extensions, or services.
    	// There are 5 sub-lists in "flattened ordering" concatenated back-to-back:
    	//	0. Message field dependencies: list of the enum or message type
    	//	referred to by every message field.
    	//	1. Extension field targets: list of the extended parent message of
    	//	every extension.
    	//	2. Extension field dependencies: list of the enum or message type
    	//	referred to by every extension field.
    	//	3. Service method inputs: list of the input message type
    	//	referred to by every service method.
    	//	4. Service method outputs: list of the output message type
    	//	referred to by every service method.
    	// The offset into DependencyIndexes for the start of each sub-list
    	// is appended to the end in reverse order.
    	DependencyIndexes []int32
    	// EnumInfos is a list of enum infos in "flattened ordering".
    	EnumInfos []pimpl.EnumInfo
    	// MessageInfos is a list of message infos in "flattened ordering".
    	// If provided, the GoType and PBType for each element is populated.
    	// Requirement: len(MessageInfos) == len(Build.Messages)
    	MessageInfos []pimpl.MessageInfo
    	// ExtensionInfos is a list of extension infos in "flattened ordering".
    	// Each element is initialized and registered with the protoregistry package.
    	// Requirement: len(LegacyExtensions) == len(Build.Extensions)
    	ExtensionInfos []pimpl.ExtensionInfo
    	// TypeRegistry is the registry to register each type descriptor.
    	// If nil, it uses protoregistry.GlobalTypes.
    	TypeRegistry interface {
    		RegisterMessage(pref.MessageType) error
    		RegisterEnum(pref.EnumType) error
    		RegisterExtension(pref.ExtensionType) error

    Builder constructs type descriptors from a raw file descriptor and associated Go types for each enum and message declaration.

    Flattened Ordering

    The protobuf type system represents declarations as a tree. Certain nodes in the tree require us to either associate it with a concrete Go type or to resolve a dependency, which is information that must be provided separately since it cannot be derived from the file descriptor alone.

    However, representing a tree as Go literals is difficult to simply do in a space and time efficient way. Thus, we store them as a flattened list of objects where the serialization order from the tree-based form is important.

    The "flattened ordering" is defined as a tree traversal of all enum, message, extension, and service declarations using the following algorithm:

    def VisitFileDecls(fd):
    	for e in fd.Enums:      yield e
    	for m in fd.Messages:   yield m
    	for x in fd.Extensions: yield x
    	for s in fd.Services:   yield s
    	for m in fd.Messages:   yield from VisitMessageDecls(m)
    def VisitMessageDecls(md):
    	for e in md.Enums:      yield e
    	for m in md.Messages:   yield m
    	for x in md.Extensions: yield x
    	for m in md.Messages:   yield from VisitMessageDecls(m)

    The traversal starts at the root file descriptor and yields each direct declaration within each node before traversing into sub-declarations that children themselves may have.

    func (Builder) Build

    func (tb Builder) Build() (out Out)

    type Out

    type Out struct {
    	File pref.FileDescriptor

      Out is the output of the builder.

      Source Files