mirror of
https://github.com/protocolbuffers/protobuf-go.git
synced 2025-01-06 10:01:25 +00:00
08e0030032
The impl package currently supports wrapping legacy v1 enums and messages so that they implement the v2 reflective APIs. This functionality is necessary for v1 and v2 to interoperate. However, the existence of this functionality presents several problems: * A significant portion of the complexity in impl is for legacy wrapping. * This complexity is linked into a Go binary even if all the other messages in the binary natively support v2 reflection. * It presents a cyclic dependency when trying to generate descriptor proto. Suppose you are generating descriptor.proto. The generated code would want to depend on the impl package because impl is the runtime implementation for protobuf messages. However, impl currently depends depends on descriptor in order to wrap legacy enum and messages since it needs the ability to dynamically create new protobuf descriptor types. In the case of descriptor.proto, it would presumably be generated with native reflection support, so the legacy wrapping logic is unneccessary. To break the dependency of impl on descriptor, we move the legacy support logic to a different package and instead add hooks in impl so that legacy support could be dynamically registered at runtime. This is dependency injection. Change-Id: I01a582908ed5629993f6699e9bf2f4bee93857a4 Reviewed-on: https://go-review.googlesource.com/c/151877 Reviewed-by: Herbie Ong <herbie@google.com>
77 lines
2.8 KiB
Go
77 lines
2.8 KiB
Go
// Copyright 2018 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package impl
|
|
|
|
import (
|
|
pref "github.com/golang/protobuf/v2/reflect/protoreflect"
|
|
ptype "github.com/golang/protobuf/v2/reflect/prototype"
|
|
)
|
|
|
|
// Export is a zero-length named type that exists only to export a set of
|
|
// functions that we do not want to appear in godoc.
|
|
type Export struct{}
|
|
|
|
// EnumOf returns the protoreflect.Enum interface over e.
|
|
// If e already implements proto.Enum, then it directly calls the
|
|
// ProtoReflect method, otherwise it wraps the v1 enum to implement
|
|
// the v2 reflective interface.
|
|
func (Export) EnumOf(e interface{}) pref.Enum {
|
|
if ev, ok := e.(pref.ProtoEnum); ok {
|
|
return ev.ProtoReflect()
|
|
}
|
|
return legacyWrapper.EnumOf(e)
|
|
}
|
|
|
|
// EnumTypeOf returns the protoreflect.EnumType for e.
|
|
// If e already implements proto.Enum, then it obtains the type by directly
|
|
// calling the ProtoReflect.Type method, otherwise it derives an enum type
|
|
// from the v1 named int32 type.
|
|
func (Export) EnumTypeOf(e interface{}) pref.EnumType {
|
|
if ev, ok := e.(pref.ProtoEnum); ok {
|
|
return ev.ProtoReflect().Type()
|
|
}
|
|
return legacyWrapper.EnumTypeOf(e)
|
|
}
|
|
|
|
// MessageOf returns the protoreflect.Message interface over m.
|
|
// If m already implements proto.Message, then it directly calls the
|
|
// ProtoReflect method, otherwise it wraps the v1 message to implement
|
|
// the v2 reflective interface.
|
|
func (Export) MessageOf(m interface{}) pref.Message {
|
|
if mv, ok := m.(pref.ProtoMessage); ok {
|
|
return mv.ProtoReflect()
|
|
}
|
|
return legacyWrapper.MessageOf(m)
|
|
}
|
|
|
|
// MessageTypeOf returns the protoreflect.MessageType for m.
|
|
// If m already implements proto.Message, then it obtains the type by directly
|
|
// calling the ProtoReflect.Type method, otherwise it derives a message type
|
|
// from the v1 message struct.
|
|
func (Export) MessageTypeOf(m interface{}) pref.MessageType {
|
|
if mv, ok := m.(pref.ProtoMessage); ok {
|
|
return mv.ProtoReflect().Type()
|
|
}
|
|
return legacyWrapper.MessageTypeOf(m)
|
|
}
|
|
|
|
// ExtensionTypeOf returns a protoreflect.ExtensionType where the type of the
|
|
// field is t. The type t must be provided if the field is an enum or message.
|
|
// If t already implements proto.Enum or proto.Message, then this returns
|
|
// an extension type by directly calling prototype.GoExtension.
|
|
// Otherwise, it derives an extension type by wrapping the enum or message
|
|
// using EnumOf or MessageOf.
|
|
func (Export) ExtensionTypeOf(d pref.ExtensionDescriptor, t interface{}) pref.ExtensionType {
|
|
switch t := t.(type) {
|
|
case nil:
|
|
return ptype.GoExtension(d, nil, nil)
|
|
case pref.ProtoEnum:
|
|
return ptype.GoExtension(d, t.ProtoReflect().Type(), nil)
|
|
case pref.ProtoMessage:
|
|
return ptype.GoExtension(d, nil, t.ProtoReflect().Type())
|
|
}
|
|
return legacyWrapper.ExtensionTypeOf(d, t)
|
|
}
|