internal/impl/convert.go - protobuf - Git at Google

 // 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 (
 	"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{}
 }

 // A Converter coverts to/from Go reflect.Value types and protobuf protoreflect.Value types.
 type Converter interface {
 	// PBValueOf converts a reflect.Value to a protoreflect.Value.
 	PBValueOf(reflect.Value) pref.Value

 	// GoValueOf converts a protoreflect.Value to a reflect.Value.
 	GoValueOf(pref.Value) reflect.Value

 	// New returns a new field value.
 	// For scalars, it returns the default value of the field.
 	// For composite types, it returns a new mutable value.
 	New() pref.Value

 	// Zero returns a new field value.
 	// For scalars, it returns the default value of the field.
 	// For composite types, it returns an immutable, empty value.
 	Zero() pref.Value
 }

 // NewConverter matches a Go type with a protobuf field 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, fd pref.FieldDescriptor) Converter {
 	switch {
 	case fd.IsList():
 		return newListConverter(t, fd)
 	case fd.IsMap():
 		return newMapConverter(t, fd)
 	default:
 		return newSingularConverter(t, fd)
 	}
 	panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
 }

 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))
 	byteType    = reflect.TypeOf(byte(0))
 )

 var (
 	boolZero    = pref.ValueOf(bool(false))
 	int32Zero   = pref.ValueOf(int32(0))
 	int64Zero   = pref.ValueOf(int64(0))
 	uint32Zero  = pref.ValueOf(uint32(0))
 	uint64Zero  = pref.ValueOf(uint64(0))
 	float32Zero = pref.ValueOf(float32(0))
 	float64Zero = pref.ValueOf(float64(0))
 	stringZero  = pref.ValueOf(string(""))
 	bytesZero   = pref.ValueOf([]byte(nil))
 )

 type scalarConverter struct {
 	goType, pbType reflect.Type
 	def            pref.Value
 }

 func newSingularConverter(t reflect.Type, fd pref.FieldDescriptor) Converter {
 	defVal := func(fd pref.FieldDescriptor, zero pref.Value) pref.Value {
 		if fd.Cardinality() == pref.Repeated {
 			// Default isn't defined for repeated fields.
 			return zero
 		}
 		return fd.Default()
 	}
 	switch fd.Kind() {
 	case pref.BoolKind:
 		if t.Kind() == reflect.Bool {
 			return &scalarConverter{t, boolType, defVal(fd, boolZero)}
 		}
 	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
 		if t.Kind() == reflect.Int32 {
 			return &scalarConverter{t, int32Type, defVal(fd, int32Zero)}
 		}
 	case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
 		if t.Kind() == reflect.Int64 {
 			return &scalarConverter{t, int64Type, defVal(fd, int64Zero)}
 		}
 	case pref.Uint32Kind, pref.Fixed32Kind:
 		if t.Kind() == reflect.Uint32 {
 			return &scalarConverter{t, uint32Type, defVal(fd, uint32Zero)}
 		}
 	case pref.Uint64Kind, pref.Fixed64Kind:
 		if t.Kind() == reflect.Uint64 {
 			return &scalarConverter{t, uint64Type, defVal(fd, uint64Zero)}
 		}
 	case pref.FloatKind:
 		if t.Kind() == reflect.Float32 {
 			return &scalarConverter{t, float32Type, defVal(fd, float32Zero)}
 		}
 	case pref.DoubleKind:
 		if t.Kind() == reflect.Float64 {
 			return &scalarConverter{t, float64Type, defVal(fd, float64Zero)}
 		}
 	case pref.StringKind:
 		if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {
 			return &scalarConverter{t, stringType, defVal(fd, stringZero)}
 		}
 	case pref.BytesKind:
 		if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {
 			return &scalarConverter{t, bytesType, defVal(fd, bytesZero)}
 		}
 	case pref.EnumKind:
 		// Handle enums, which must be a named int32 type.
 		if t.Kind() == reflect.Int32 {
 			return newEnumConverter(t, fd)
 		}
 	case pref.MessageKind, pref.GroupKind:
 		return newMessageConverter(t)
 	}
 	panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
 }

 func (c *scalarConverter) PBValueOf(v reflect.Value) pref.Value {
 	if v.Type() != c.goType {
 		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
 	}
 	if c.goType.Kind() == reflect.String && c.pbType.Kind() == reflect.Slice && v.Len() == 0 {
 		return pref.ValueOf([]byte(nil)) // ensure empty string is []byte(nil)
 	}
 	return pref.ValueOf(v.Convert(c.pbType).Interface())
 }

 func (c *scalarConverter) GoValueOf(v pref.Value) reflect.Value {
 	rv := reflect.ValueOf(v.Interface())
 	if rv.Type() != c.pbType {
 		panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), c.pbType))
 	}
 	if c.pbType.Kind() == reflect.String && c.goType.Kind() == reflect.Slice && rv.Len() == 0 {
 		return reflect.Zero(c.goType) // ensure empty string is []byte(nil)
 	}
 	return rv.Convert(c.goType)
 }

 func (c *scalarConverter) New() pref.Value {
 	if c.pbType == bytesType {
 		return pref.ValueOf(append(([]byte)(nil), c.def.Bytes()...))
 	}
 	return c.def
 }

 func (c *scalarConverter) Zero() pref.Value {
 	return c.New()
 }

 type enumConverter struct {
 	goType reflect.Type
 	def    pref.Value
 }

 func newEnumConverter(goType reflect.Type, fd pref.FieldDescriptor) Converter {
 	var def pref.Value
 	if fd.Cardinality() == pref.Repeated {
 		def = pref.ValueOf(fd.Enum().Values().Get(0).Number())
 	} else {
 		def = fd.Default()
 	}
 	return &enumConverter{goType, def}
 }

 func (c *enumConverter) PBValueOf(v reflect.Value) pref.Value {
 	if v.Type() != c.goType {
 		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
 	}
 	return pref.ValueOf(pref.EnumNumber(v.Int()))
 }

 func (c *enumConverter) GoValueOf(v pref.Value) reflect.Value {
 	return reflect.ValueOf(v.Enum()).Convert(c.goType)
 }

 func (c *enumConverter) New() pref.Value {
 	return c.def
 }

 func (c *enumConverter) Zero() pref.Value {
 	return c.def
 }

 type messageConverter struct {
 	goType reflect.Type
 }

 func newMessageConverter(goType reflect.Type) Converter {
 	return &messageConverter{goType}
 }

 func (c *messageConverter) PBValueOf(v reflect.Value) pref.Value {
 	if v.Type() != c.goType {
 		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
 	}
 	if m, ok := v.Interface().(pref.ProtoMessage); ok {
 		return pref.ValueOf(m.ProtoReflect())
 	}
 	return pref.ValueOf(legacyWrapMessage(v).ProtoReflect())
 }

 func (c *messageConverter) GoValueOf(v pref.Value) reflect.Value {
 	m := v.Message()
 	var rv reflect.Value
 	if u, ok := m.(Unwrapper); ok {
 		rv = reflect.ValueOf(u.ProtoUnwrap())
 	} else {
 		rv = reflect.ValueOf(m.Interface())
 	}
 	if rv.Type() != c.goType {
 		panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), c.goType))
 	}
 	return rv
 }

 func (c *messageConverter) New() pref.Value {
 	return c.PBValueOf(reflect.New(c.goType.Elem()))
 }

 func (c *messageConverter) Zero() pref.Value {
 	return c.PBValueOf(reflect.Zero(c.goType))
 }
	// 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 (
	"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{}
	}

	// A Converter coverts to/from Go reflect.Value types and protobuf protoreflect.Value types.
	type Converter interface {
	// PBValueOf converts a reflect.Value to a protoreflect.Value.
	PBValueOf(reflect.Value) pref.Value

	// GoValueOf converts a protoreflect.Value to a reflect.Value.
	GoValueOf(pref.Value) reflect.Value

	// New returns a new field value.
	// For scalars, it returns the default value of the field.
	// For composite types, it returns a new mutable value.
	New() pref.Value

	// Zero returns a new field value.
	// For scalars, it returns the default value of the field.
	// For composite types, it returns an immutable, empty value.
	Zero() pref.Value
	}

	// NewConverter matches a Go type with a protobuf field 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, fd pref.FieldDescriptor) Converter {
	switch {
	case fd.IsList():
	return newListConverter(t, fd)
	case fd.IsMap():
	return newMapConverter(t, fd)
	default:
	return newSingularConverter(t, fd)
	}
	panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
	}

	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))
	byteType = reflect.TypeOf(byte(0))
	)

	var (
	boolZero = pref.ValueOf(bool(false))
	int32Zero = pref.ValueOf(int32(0))
	int64Zero = pref.ValueOf(int64(0))
	uint32Zero = pref.ValueOf(uint32(0))
	uint64Zero = pref.ValueOf(uint64(0))
	float32Zero = pref.ValueOf(float32(0))
	float64Zero = pref.ValueOf(float64(0))
	stringZero = pref.ValueOf(string(""))
	bytesZero = pref.ValueOf([]byte(nil))
	)

	type scalarConverter struct {
	goType, pbType reflect.Type
	def pref.Value
	}

	func newSingularConverter(t reflect.Type, fd pref.FieldDescriptor) Converter {
	defVal := func(fd pref.FieldDescriptor, zero pref.Value) pref.Value {
	if fd.Cardinality() == pref.Repeated {
	// Default isn't defined for repeated fields.
	return zero
	}
	return fd.Default()
	}
	switch fd.Kind() {
	case pref.BoolKind:
	if t.Kind() == reflect.Bool {
	return &scalarConverter{t, boolType, defVal(fd, boolZero)}
	}
	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
	if t.Kind() == reflect.Int32 {
	return &scalarConverter{t, int32Type, defVal(fd, int32Zero)}
	}
	case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
	if t.Kind() == reflect.Int64 {
	return &scalarConverter{t, int64Type, defVal(fd, int64Zero)}
	}
	case pref.Uint32Kind, pref.Fixed32Kind:
	if t.Kind() == reflect.Uint32 {
	return &scalarConverter{t, uint32Type, defVal(fd, uint32Zero)}
	}
	case pref.Uint64Kind, pref.Fixed64Kind:
	if t.Kind() == reflect.Uint64 {
	return &scalarConverter{t, uint64Type, defVal(fd, uint64Zero)}
	}
	case pref.FloatKind:
	if t.Kind() == reflect.Float32 {
	return &scalarConverter{t, float32Type, defVal(fd, float32Zero)}
	}
	case pref.DoubleKind:
	if t.Kind() == reflect.Float64 {
	return &scalarConverter{t, float64Type, defVal(fd, float64Zero)}
	}
	case pref.StringKind:
	if t.Kind() == reflect.String \|\| (t.Kind() == reflect.Slice && t.Elem() == byteType) {
	return &scalarConverter{t, stringType, defVal(fd, stringZero)}
	}
	case pref.BytesKind:
	if t.Kind() == reflect.String \|\| (t.Kind() == reflect.Slice && t.Elem() == byteType) {
	return &scalarConverter{t, bytesType, defVal(fd, bytesZero)}
	}
	case pref.EnumKind:
	// Handle enums, which must be a named int32 type.
	if t.Kind() == reflect.Int32 {
	return newEnumConverter(t, fd)
	}
	case pref.MessageKind, pref.GroupKind:
	return newMessageConverter(t)
	}
	panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
	}

	func (c *scalarConverter) PBValueOf(v reflect.Value) pref.Value {
	if v.Type() != c.goType {
	panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
	}
	if c.goType.Kind() == reflect.String && c.pbType.Kind() == reflect.Slice && v.Len() == 0 {
	return pref.ValueOf([]byte(nil)) // ensure empty string is []byte(nil)
	}
	return pref.ValueOf(v.Convert(c.pbType).Interface())
	}

	func (c *scalarConverter) GoValueOf(v pref.Value) reflect.Value {
	rv := reflect.ValueOf(v.Interface())
	if rv.Type() != c.pbType {
	panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), c.pbType))
	}
	if c.pbType.Kind() == reflect.String && c.goType.Kind() == reflect.Slice && rv.Len() == 0 {
	return reflect.Zero(c.goType) // ensure empty string is []byte(nil)
	}
	return rv.Convert(c.goType)
	}

	func (c *scalarConverter) New() pref.Value {
	if c.pbType == bytesType {
	return pref.ValueOf(append(([]byte)(nil), c.def.Bytes()...))
	}
	return c.def
	}

	func (c *scalarConverter) Zero() pref.Value {
	return c.New()
	}

	type enumConverter struct {
	goType reflect.Type
	def pref.Value
	}

	func newEnumConverter(goType reflect.Type, fd pref.FieldDescriptor) Converter {
	var def pref.Value
	if fd.Cardinality() == pref.Repeated {
	def = pref.ValueOf(fd.Enum().Values().Get(0).Number())
	} else {
	def = fd.Default()
	}
	return &enumConverter{goType, def}
	}

	func (c *enumConverter) PBValueOf(v reflect.Value) pref.Value {
	if v.Type() != c.goType {
	panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
	}
	return pref.ValueOf(pref.EnumNumber(v.Int()))
	}

	func (c *enumConverter) GoValueOf(v pref.Value) reflect.Value {
	return reflect.ValueOf(v.Enum()).Convert(c.goType)
	}

	func (c *enumConverter) New() pref.Value {
	return c.def
	}

	func (c *enumConverter) Zero() pref.Value {
	return c.def
	}

	type messageConverter struct {
	goType reflect.Type
	}

	func newMessageConverter(goType reflect.Type) Converter {
	return &messageConverter{goType}
	}

	func (c *messageConverter) PBValueOf(v reflect.Value) pref.Value {
	if v.Type() != c.goType {
	panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
	}
	if m, ok := v.Interface().(pref.ProtoMessage); ok {
	return pref.ValueOf(m.ProtoReflect())
	}
	return pref.ValueOf(legacyWrapMessage(v).ProtoReflect())
	}

	func (c *messageConverter) GoValueOf(v pref.Value) reflect.Value {
	m := v.Message()
	var rv reflect.Value
	if u, ok := m.(Unwrapper); ok {
	rv = reflect.ValueOf(u.ProtoUnwrap())
	} else {
	rv = reflect.ValueOf(m.Interface())
	}
	if rv.Type() != c.goType {
	panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), c.goType))
	}
	return rv
	}

	func (c *messageConverter) New() pref.Value {
	return c.PBValueOf(reflect.New(c.goType.Elem()))
	}

	func (c *messageConverter) Zero() pref.Value {
	return c.PBValueOf(reflect.Zero(c.goType))
	}