| // 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{}) |
| } |