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