mirror of
https://github.com/protocolbuffers/protobuf-go.git
synced 2025-01-29 09:32:38 +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>
161 lines
5.3 KiB
Go
161 lines
5.3 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 value provides functionality for wrapping Go values to implement
|
|
// protoreflect values.
|
|
package value
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
|
|
pref "google.golang.org/protobuf/reflect/protoreflect"
|
|
)
|
|
|
|
// Unwrapper unwraps the value to the underlying value.
|
|
// This is implemented by List and Map.
|
|
type Unwrapper interface {
|
|
ProtoUnwrap() interface{}
|
|
}
|
|
|
|
var (
|
|
boolType = reflect.TypeOf(bool(false))
|
|
int32Type = reflect.TypeOf(int32(0))
|
|
int64Type = reflect.TypeOf(int64(0))
|
|
uint32Type = reflect.TypeOf(uint32(0))
|
|
uint64Type = reflect.TypeOf(uint64(0))
|
|
float32Type = reflect.TypeOf(float32(0))
|
|
float64Type = reflect.TypeOf(float64(0))
|
|
stringType = reflect.TypeOf(string(""))
|
|
bytesType = reflect.TypeOf([]byte(nil))
|
|
|
|
enumIfaceV2 = reflect.TypeOf((*pref.Enum)(nil)).Elem()
|
|
messageIfaceV2 = reflect.TypeOf((*pref.ProtoMessage)(nil)).Elem()
|
|
|
|
byteType = reflect.TypeOf(byte(0))
|
|
)
|
|
|
|
// NewConverter matches a Go type with a protobuf kind and returns a Converter
|
|
// that converts between the two. Enums must be a named int32 kind that
|
|
// implements protoreflect.Enum, and messages must be pointer to a named
|
|
// struct type that implements protoreflect.ProtoMessage.
|
|
//
|
|
// This matcher deliberately supports a wider range of Go types than what
|
|
// protoc-gen-go historically generated to be able to automatically wrap some
|
|
// v1 messages generated by other forks of protoc-gen-go.
|
|
func NewConverter(t reflect.Type, k pref.Kind) Converter {
|
|
switch k {
|
|
case pref.BoolKind:
|
|
if t.Kind() == reflect.Bool {
|
|
return newScalarConverter(t, boolType)
|
|
}
|
|
case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
|
|
if t.Kind() == reflect.Int32 {
|
|
return newScalarConverter(t, int32Type)
|
|
}
|
|
case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
|
|
if t.Kind() == reflect.Int64 {
|
|
return newScalarConverter(t, int64Type)
|
|
}
|
|
case pref.Uint32Kind, pref.Fixed32Kind:
|
|
if t.Kind() == reflect.Uint32 {
|
|
return newScalarConverter(t, uint32Type)
|
|
}
|
|
case pref.Uint64Kind, pref.Fixed64Kind:
|
|
if t.Kind() == reflect.Uint64 {
|
|
return newScalarConverter(t, uint64Type)
|
|
}
|
|
case pref.FloatKind:
|
|
if t.Kind() == reflect.Float32 {
|
|
return newScalarConverter(t, float32Type)
|
|
}
|
|
case pref.DoubleKind:
|
|
if t.Kind() == reflect.Float64 {
|
|
return newScalarConverter(t, float64Type)
|
|
}
|
|
case pref.StringKind:
|
|
if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {
|
|
return newScalarConverter(t, stringType)
|
|
}
|
|
case pref.BytesKind:
|
|
if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {
|
|
return newScalarConverter(t, bytesType)
|
|
}
|
|
case pref.EnumKind:
|
|
// Handle enums, which must be a named int32 type.
|
|
if t.Implements(enumIfaceV2) && t.Kind() == reflect.Int32 {
|
|
return 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 reflect.ValueOf(n).Convert(t).Interface().(pref.Enum)
|
|
},
|
|
}
|
|
}
|
|
case pref.MessageKind, pref.GroupKind:
|
|
// Handle v2 messages, which must satisfy the proto.Message interface.
|
|
if t.Implements(messageIfaceV2) && t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Struct {
|
|
return 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(v.Interface().(pref.ProtoMessage).ProtoReflect())
|
|
},
|
|
GoValueOf: func(v pref.Value) reflect.Value {
|
|
rv := reflect.ValueOf(v.Message().Interface())
|
|
if rv.Type() != t {
|
|
panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), t))
|
|
}
|
|
return rv
|
|
},
|
|
NewMessage: func() pref.Message {
|
|
return reflect.New(t.Elem()).Interface().(pref.ProtoMessage).ProtoReflect()
|
|
},
|
|
}
|
|
}
|
|
}
|
|
panic(fmt.Sprintf("invalid Go type %v for protobuf kind %v", t, k))
|
|
}
|
|
|
|
func newScalarConverter(goType, pbType reflect.Type) Converter {
|
|
return Converter{
|
|
PBValueOf: func(v reflect.Value) pref.Value {
|
|
if v.Type() != goType {
|
|
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), goType))
|
|
}
|
|
if goType.Kind() == reflect.String && pbType.Kind() == reflect.Slice && v.Len() == 0 {
|
|
return pref.ValueOf([]byte(nil)) // ensure empty string is []byte(nil)
|
|
}
|
|
return pref.ValueOf(v.Convert(pbType).Interface())
|
|
},
|
|
GoValueOf: func(v pref.Value) reflect.Value {
|
|
rv := reflect.ValueOf(v.Interface())
|
|
if rv.Type() != pbType {
|
|
panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), pbType))
|
|
}
|
|
if pbType.Kind() == reflect.String && goType.Kind() == reflect.Slice && rv.Len() == 0 {
|
|
return reflect.Zero(goType) // ensure empty string is []byte(nil)
|
|
}
|
|
return rv.Convert(goType)
|
|
},
|
|
}
|
|
}
|
|
|
|
// Converter provides functions for converting to/from Go reflect.Value types
|
|
// and protobuf protoreflect.Value types.
|
|
type Converter struct {
|
|
PBValueOf func(reflect.Value) pref.Value
|
|
GoValueOf func(pref.Value) reflect.Value
|
|
NewEnum func(pref.EnumNumber) pref.Enum
|
|
NewMessage func() pref.Message
|
|
}
|