mirror of
https://github.com/protocolbuffers/protobuf-go.git
synced 2025-04-18 05:42:53 +00:00
b2f66bedb4
Add the prototype package which provides constructors for
protoreflect.{Enum,Message,Extension}Type.
Switch all usages of the internal/prototype equivalent to the new package.
Switch all custom implementions of {Enum,Message}Type to the new package.
Change-Id: Ia9dae6fed4f2b90e55c123627044a7faf098c4b1
Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/178438
Reviewed-by: Damien Neil <dneil@google.com>
111 lines
3.2 KiB
Go
111 lines
3.2 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 legacy
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
|
|
pimpl "google.golang.org/protobuf/internal/impl"
|
|
pvalue "google.golang.org/protobuf/internal/value"
|
|
pref "google.golang.org/protobuf/reflect/protoreflect"
|
|
piface "google.golang.org/protobuf/runtime/protoiface"
|
|
)
|
|
|
|
// 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{}
|
|
|
|
func (Export) EnumOf(e interface{}) pref.Enum {
|
|
return wrapEnum(reflect.ValueOf(e))
|
|
}
|
|
|
|
func (Export) EnumTypeOf(e interface{}) pref.EnumType {
|
|
return loadEnumType(reflect.TypeOf(e))
|
|
}
|
|
|
|
func (Export) EnumDescriptorOf(e interface{}) pref.EnumDescriptor {
|
|
return LoadEnumDesc(reflect.TypeOf(e))
|
|
}
|
|
|
|
func (Export) MessageOf(m interface{}) pref.Message {
|
|
return wrapMessage(reflect.ValueOf(m)).ProtoReflect()
|
|
}
|
|
|
|
func (Export) MessageTypeOf(m interface{}) pref.MessageType {
|
|
return loadMessageInfo(reflect.TypeOf(m)).PBType
|
|
}
|
|
|
|
func (Export) MessageDescriptorOf(m interface{}) pref.MessageDescriptor {
|
|
return LoadMessageDesc(reflect.TypeOf(m))
|
|
}
|
|
|
|
func (Export) ExtensionDescFromType(t pref.ExtensionType) *piface.ExtensionDescV1 {
|
|
return extensionDescFromType(t)
|
|
}
|
|
|
|
func (Export) ExtensionTypeFromDesc(d *piface.ExtensionDescV1) pref.ExtensionType {
|
|
return extensionTypeFromDesc(d)
|
|
}
|
|
|
|
var (
|
|
enumIfaceV2 = reflect.TypeOf((*pref.Enum)(nil)).Elem()
|
|
messageIfaceV1 = reflect.TypeOf((*piface.MessageV1)(nil)).Elem()
|
|
messageIfaceV2 = reflect.TypeOf((*pref.ProtoMessage)(nil)).Elem()
|
|
)
|
|
|
|
func (Export) NewConverter(t reflect.Type, k pref.Kind) pvalue.Converter {
|
|
c, _ := newConverter(t, k)
|
|
return c
|
|
}
|
|
|
|
func newConverter(t reflect.Type, k pref.Kind) (pvalue.Converter, bool) {
|
|
switch k {
|
|
case pref.EnumKind:
|
|
if t.Kind() == reflect.Int32 && !t.Implements(enumIfaceV2) {
|
|
return pvalue.Converter{
|
|
PBValueOf: func(v reflect.Value) pref.Value {
|
|
if v.Type() != t {
|
|
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), t))
|
|
}
|
|
return pref.ValueOf(pref.EnumNumber(v.Int()))
|
|
},
|
|
GoValueOf: func(v pref.Value) reflect.Value {
|
|
return reflect.ValueOf(v.Enum()).Convert(t)
|
|
},
|
|
NewEnum: func(n pref.EnumNumber) pref.Enum {
|
|
return wrapEnum(reflect.ValueOf(n).Convert(t))
|
|
},
|
|
}, true
|
|
}
|
|
case pref.MessageKind, pref.GroupKind:
|
|
if t.Kind() == reflect.Ptr && t.Implements(messageIfaceV1) && !t.Implements(messageIfaceV2) {
|
|
return pvalue.Converter{
|
|
PBValueOf: func(v reflect.Value) pref.Value {
|
|
if v.Type() != t {
|
|
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), t))
|
|
}
|
|
return pref.ValueOf(Export{}.MessageOf(v.Interface()))
|
|
},
|
|
GoValueOf: func(v pref.Value) reflect.Value {
|
|
rv := reflect.ValueOf(v.Message().(pvalue.Unwrapper).ProtoUnwrap())
|
|
if rv.Type() != t {
|
|
panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), t))
|
|
}
|
|
return rv
|
|
},
|
|
NewMessage: func() pref.Message {
|
|
return wrapMessage(reflect.New(t.Elem())).ProtoReflect()
|
|
},
|
|
}, true
|
|
}
|
|
}
|
|
return pvalue.NewConverter(t, k), false
|
|
}
|
|
|
|
func init() {
|
|
pimpl.RegisterLegacyWrapper(Export{})
|
|
}
|