Source: registry.go in package github.com/golang/protobuf/proto


package proto

import (
	"bytes"
	"compress/gzip"
	"fmt"
	"io/ioutil"
	"reflect"
	"strings"
	"sync"

	"google.golang.org/protobuf/reflect/protoreflect"
	"google.golang.org/protobuf/reflect/protoregistry"
	"google.golang.org/protobuf/runtime/protoimpl"
)

filePath is the path to the proto source file.

type filePath = string // e.g., "google/protobuf/descriptor.proto"

fileDescGZIP is the compressed contents of the encoded FileDescriptorProto.

type fileDescGZIP = []byte

var fileCache sync.Map // map[filePath]fileDescGZIP

RegisterFile is called from generated code to register the compressed FileDescriptorProto with the file path for a proto source file. Deprecated: Use protoregistry.GlobalFiles.RegisterFile instead.

Decompress the descriptor.

	zr, err := gzip.NewReader(bytes.NewReader(d))
	if err != nil {
		panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err))
	}
	b, err := ioutil.ReadAll(zr)
	if err != nil {
		panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err))
	}

Construct a protoreflect.FileDescriptor from the raw descriptor. Note that DescBuilder.Build automatically registers the constructed file descriptor with the v2 registry.

	protoimpl.DescBuilder{RawDescriptor: b}.Build()

Locally cache the raw descriptor form for the file.

	fileCache.Store(s, d)
}

FileDescriptor returns the compressed FileDescriptorProto given the file path for a proto source file. It returns nil if not found. Deprecated: Use protoregistry.GlobalFiles.FindFileByPath instead.

func FileDescriptor(s filePath) fileDescGZIP {
	if v, ok := fileCache.Load(s); ok {
		return v.(fileDescGZIP)
	}

Find the descriptor in the v2 registry.

	var b []byte
	if fd, _ := protoregistry.GlobalFiles.FindFileByPath(s); fd != nil {
		if fd, ok := fd.(interface{ ProtoLegacyRawDesc() []byte }); ok {
			b = fd.ProtoLegacyRawDesc()

TODO: Use protodesc.ToFileDescriptorProto to construct a descriptorpb.FileDescriptorProto and marshal it. However, doing so causes the proto package to have a dependency on descriptorpb, leading to cyclic dependency issues.

		}
	}

Locally cache the raw descriptor form for the file.

	if len(b) > 0 {
		v, _ := fileCache.LoadOrStore(s, protoimpl.X.CompressGZIP(b))
		return v.(fileDescGZIP)
	}
	return nil
}

enumName is the name of an enum. For historical reasons, the enum name is neither the full Go name nor the full protobuf name of the enum. The name is the dot-separated combination of just the proto package that the enum is declared within followed by the Go type name of the generated enum.

type enumName = string // e.g., "my.proto.package.GoMessage_GoEnum"

enumsByName maps enum values by name to their numeric counterpart.

type enumsByName = map[string]int32

enumsByNumber maps enum values by number to their name counterpart.

type enumsByNumber = map[int32]string

var enumCache sync.Map     // map[enumName]enumsByName
var numFilesCache sync.Map // map[protoreflect.FullName]int

RegisterEnum is called from the generated code to register the mapping of enum value names to enum numbers for the enum identified by s. Deprecated: Use protoregistry.GlobalTypes.RegisterEnum instead.

func RegisterEnum(s enumName, _ enumsByNumber, m enumsByName) {
	if _, ok := enumCache.Load(s); ok {
		panic("proto: duplicate enum registered: " + s)
	}
	enumCache.Store(s, m)

This does not forward registration to the v2 registry since this API lacks sufficient information to construct a complete v2 enum descriptor.

EnumValueMap returns the mapping from enum value names to enum numbers for the enum of the given name. It returns nil if not found. Deprecated: Use protoregistry.GlobalTypes.FindEnumByName instead.

func EnumValueMap(s enumName) enumsByName {
	if v, ok := enumCache.Load(s); ok {
		return v.(enumsByName)
	}

Check whether the cache is stale. If the number of files in the current package differs, then it means that some enums may have been recently registered upstream that we do not know about.

	var protoPkg protoreflect.FullName
	if i := strings.LastIndexByte(s, '.'); i >= 0 {
		protoPkg = protoreflect.FullName(s[:i])
	}
	v, _ := numFilesCache.Load(protoPkg)
	numFiles, _ := v.(int)
	if protoregistry.GlobalFiles.NumFilesByPackage(protoPkg) == numFiles {
		return nil // cache is up-to-date; was not found earlier
	}

Update the enum cache for all enums declared in the given proto package.

	numFiles = 0
	protoregistry.GlobalFiles.RangeFilesByPackage(protoPkg, func(fd protoreflect.FileDescriptor) bool {
		walkEnums(fd, func(ed protoreflect.EnumDescriptor) {
			name := protoimpl.X.LegacyEnumName(ed)
			if _, ok := enumCache.Load(name); !ok {
				m := make(enumsByName)
				evs := ed.Values()
				for i := evs.Len() - 1; i >= 0; i-- {
					ev := evs.Get(i)
					m[string(ev.Name())] = int32(ev.Number())
				}
				enumCache.LoadOrStore(name, m)
			}
		})
		numFiles++
		return true
	})
	numFilesCache.Store(protoPkg, numFiles)

Check cache again for enum map.

	if v, ok := enumCache.Load(s); ok {
		return v.(enumsByName)
	}
	return nil
}

walkEnums recursively walks all enums declared in d.

func walkEnums(d interface {
	Enums() protoreflect.EnumDescriptors
	Messages() protoreflect.MessageDescriptors
}, f func(protoreflect.EnumDescriptor)) {
	eds := d.Enums()
	for i := eds.Len() - 1; i >= 0; i-- {
		f(eds.Get(i))
	}
	mds := d.Messages()
	for i := mds.Len() - 1; i >= 0; i-- {
		walkEnums(mds.Get(i), f)
	}
}

messageName is the full name of protobuf message.

type messageName = string

var messageTypeCache sync.Map // map[messageName]reflect.Type

RegisterType is called from generated code to register the message Go type for a message of the given name. Deprecated: Use protoregistry.GlobalTypes.RegisterMessage instead.

func RegisterType(m Message, s messageName) {
	mt := protoimpl.X.LegacyMessageTypeOf(m, protoreflect.FullName(s))
	if err := protoregistry.GlobalTypes.RegisterMessage(mt); err != nil {
		panic(err)
	}
	messageTypeCache.Store(s, reflect.TypeOf(m))
}

RegisterMapType is called from generated code to register the Go map type for a protobuf message representing a map entry. Deprecated: Do not use.

func RegisterMapType(m interface{}, s messageName) {
	t := reflect.TypeOf(m)
	if t.Kind() != reflect.Map {
		panic(fmt.Sprintf("invalid map kind: %v", t))
	}
	if _, ok := messageTypeCache.Load(s); ok {
		panic(fmt.Errorf("proto: duplicate proto message registered: %s", s))
	}
	messageTypeCache.Store(s, t)
}

MessageType returns the message type for a named message. It returns nil if not found. Deprecated: Use protoregistry.GlobalTypes.FindMessageByName instead.

func MessageType(s messageName) reflect.Type {
	if v, ok := messageTypeCache.Load(s); ok {
		return v.(reflect.Type)
	}

Derive the message type from the v2 registry.

	var t reflect.Type
	if mt, _ := protoregistry.GlobalTypes.FindMessageByName(protoreflect.FullName(s)); mt != nil {
		t = messageGoType(mt)
	}

If we could not get a concrete type, it is possible that it is a pseudo-message for a map entry.

	if t == nil {
		d, _ := protoregistry.GlobalFiles.FindDescriptorByName(protoreflect.FullName(s))
		if md, _ := d.(protoreflect.MessageDescriptor); md != nil && md.IsMapEntry() {
			kt := goTypeForField(md.Fields().ByNumber(1))
			vt := goTypeForField(md.Fields().ByNumber(2))
			t = reflect.MapOf(kt, vt)
		}
	}

Locally cache the message type for the given name.

	if t != nil {
		v, _ := messageTypeCache.LoadOrStore(s, t)
		return v.(reflect.Type)
	}
	return nil
}

func goTypeForField(fd protoreflect.FieldDescriptor) reflect.Type {
	switch k := fd.Kind(); k {
	case protoreflect.EnumKind:
		if et, _ := protoregistry.GlobalTypes.FindEnumByName(fd.Enum().FullName()); et != nil {
			return enumGoType(et)
		}
		return reflect.TypeOf(protoreflect.EnumNumber(0))
	case protoreflect.MessageKind, protoreflect.GroupKind:
		if mt, _ := protoregistry.GlobalTypes.FindMessageByName(fd.Message().FullName()); mt != nil {
			return messageGoType(mt)
		}
		return reflect.TypeOf((*protoreflect.Message)(nil)).Elem()
	default:
		return reflect.TypeOf(fd.Default().Interface())
	}
}

func enumGoType(et protoreflect.EnumType) reflect.Type {
	return reflect.TypeOf(et.New(0))
}

func messageGoType(mt protoreflect.MessageType) reflect.Type {
	return reflect.TypeOf(MessageV1(mt.Zero().Interface()))
}

MessageName returns the full protobuf name for the given message type. Deprecated: Use protoreflect.MessageDescriptor.FullName instead.

func MessageName(m Message) messageName {
	if m == nil {
		return ""
	}
	if m, ok := m.(interface{ XXX_MessageName() messageName }); ok {
		return m.XXX_MessageName()
	}
	return messageName(protoimpl.X.MessageDescriptorOf(m).FullName())
}

RegisterExtension is called from the generated code to register the extension descriptor. Deprecated: Use protoregistry.GlobalTypes.RegisterExtension instead.

func RegisterExtension(d *ExtensionDesc) {
	if err := protoregistry.GlobalTypes.RegisterExtension(d); err != nil {
		panic(err)
	}
}

type extensionsByNumber = map[int32]*ExtensionDesc

var extensionCache sync.Map // map[messageName]extensionsByNumber

RegisteredExtensions returns a map of the registered extensions for the provided protobuf message, indexed by the extension field number. Deprecated: Use protoregistry.GlobalTypes.RangeExtensionsByMessage instead.

Check whether the cache is stale. If the number of extensions for the given message differs, then it means that some extensions were recently registered upstream that we do not know about.

	s := MessageName(m)
	v, _ := extensionCache.Load(s)
	xs, _ := v.(extensionsByNumber)
	if protoregistry.GlobalTypes.NumExtensionsByMessage(protoreflect.FullName(s)) == len(xs) {
		return xs // cache is up-to-date
	}

Cache is stale, re-compute the extensions map.

	xs = make(extensionsByNumber)
	protoregistry.GlobalTypes.RangeExtensionsByMessage(protoreflect.FullName(s), func(xt protoreflect.ExtensionType) bool {
		if xd, ok := xt.(*ExtensionDesc); ok {
			xs[int32(xt.TypeDescriptor().Number())] = xd

TODO: This implies that the protoreflect.ExtensionType is a custom type not generated by protoc-gen-go. We could try and convert the type to an ExtensionDesc.

		}
		return true
	})
	extensionCache.Store(s, xs)
	return xs