aboutsummaryrefslogtreecommitdiff
path: root/internal/impl/message_reflect_field.go
diff options
context:
space:
mode:
Diffstat (limited to 'internal/impl/message_reflect_field.go')
-rw-r--r--internal/impl/message_reflect_field.go543
1 files changed, 0 insertions, 543 deletions
diff --git a/internal/impl/message_reflect_field.go b/internal/impl/message_reflect_field.go
deleted file mode 100644
index 343cf872..00000000
--- a/internal/impl/message_reflect_field.go
+++ /dev/null
@@ -1,543 +0,0 @@
-// 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"
- "math"
- "reflect"
- "sync"
-
- "google.golang.org/protobuf/internal/flags"
- pref "google.golang.org/protobuf/reflect/protoreflect"
- preg "google.golang.org/protobuf/reflect/protoregistry"
-)
-
-type fieldInfo struct {
- fieldDesc pref.FieldDescriptor
-
- // These fields are used for protobuf reflection support.
- has func(pointer) bool
- clear func(pointer)
- get func(pointer) pref.Value
- set func(pointer, pref.Value)
- mutable func(pointer) pref.Value
- newMessage func() pref.Message
- newField func() pref.Value
-}
-
-func fieldInfoForMissing(fd pref.FieldDescriptor) fieldInfo {
- // This never occurs for generated message types.
- // It implies that a hand-crafted type has missing Go fields
- // for specific protobuf message fields.
- return fieldInfo{
- fieldDesc: fd,
- has: func(p pointer) bool {
- return false
- },
- clear: func(p pointer) {
- panic("missing Go struct field for " + string(fd.FullName()))
- },
- get: func(p pointer) pref.Value {
- return fd.Default()
- },
- set: func(p pointer, v pref.Value) {
- panic("missing Go struct field for " + string(fd.FullName()))
- },
- mutable: func(p pointer) pref.Value {
- panic("missing Go struct field for " + string(fd.FullName()))
- },
- newMessage: func() pref.Message {
- panic("missing Go struct field for " + string(fd.FullName()))
- },
- newField: func() pref.Value {
- if v := fd.Default(); v.IsValid() {
- return v
- }
- panic("missing Go struct field for " + string(fd.FullName()))
- },
- }
-}
-
-func fieldInfoForOneof(fd pref.FieldDescriptor, fs reflect.StructField, x exporter, ot reflect.Type) fieldInfo {
- ft := fs.Type
- if ft.Kind() != reflect.Interface {
- panic(fmt.Sprintf("field %v has invalid type: got %v, want interface kind", fd.FullName(), ft))
- }
- if ot.Kind() != reflect.Struct {
- panic(fmt.Sprintf("field %v has invalid type: got %v, want struct kind", fd.FullName(), ot))
- }
- if !reflect.PtrTo(ot).Implements(ft) {
- panic(fmt.Sprintf("field %v has invalid type: %v does not implement %v", fd.FullName(), ot, ft))
- }
- conv := NewConverter(ot.Field(0).Type, fd)
- isMessage := fd.Message() != nil
-
- // TODO: Implement unsafe fast path?
- fieldOffset := offsetOf(fs, x)
- return fieldInfo{
- // NOTE: The logic below intentionally assumes that oneof fields are
- // well-formatted. That is, the oneof interface never contains a
- // typed nil pointer to one of the wrapper structs.
-
- fieldDesc: fd,
- has: func(p pointer) bool {
- if p.IsNil() {
- return false
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
- return false
- }
- return true
- },
- clear: func(p pointer) {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if rv.IsNil() || rv.Elem().Type().Elem() != ot {
- // NOTE: We intentionally don't check for rv.Elem().IsNil()
- // so that (*OneofWrapperType)(nil) gets cleared to nil.
- return
- }
- rv.Set(reflect.Zero(rv.Type()))
- },
- get: func(p pointer) pref.Value {
- if p.IsNil() {
- return conv.Zero()
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
- return conv.Zero()
- }
- rv = rv.Elem().Elem().Field(0)
- return conv.PBValueOf(rv)
- },
- set: func(p pointer, v pref.Value) {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
- rv.Set(reflect.New(ot))
- }
- rv = rv.Elem().Elem().Field(0)
- rv.Set(conv.GoValueOf(v))
- },
- mutable: func(p pointer) pref.Value {
- if !isMessage {
- panic(fmt.Sprintf("field %v with invalid Mutable call on field with non-composite type", fd.FullName()))
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
- rv.Set(reflect.New(ot))
- }
- rv = rv.Elem().Elem().Field(0)
- if rv.Kind() == reflect.Ptr && rv.IsNil() {
- rv.Set(conv.GoValueOf(pref.ValueOfMessage(conv.New().Message())))
- }
- return conv.PBValueOf(rv)
- },
- newMessage: func() pref.Message {
- return conv.New().Message()
- },
- newField: func() pref.Value {
- return conv.New()
- },
- }
-}
-
-func fieldInfoForMap(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
- ft := fs.Type
- if ft.Kind() != reflect.Map {
- panic(fmt.Sprintf("field %v has invalid type: got %v, want map kind", fd.FullName(), ft))
- }
- conv := NewConverter(ft, fd)
-
- // TODO: Implement unsafe fast path?
- fieldOffset := offsetOf(fs, x)
- return fieldInfo{
- fieldDesc: fd,
- has: func(p pointer) bool {
- if p.IsNil() {
- return false
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- return rv.Len() > 0
- },
- clear: func(p pointer) {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- rv.Set(reflect.Zero(rv.Type()))
- },
- get: func(p pointer) pref.Value {
- if p.IsNil() {
- return conv.Zero()
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if rv.Len() == 0 {
- return conv.Zero()
- }
- return conv.PBValueOf(rv)
- },
- set: func(p pointer, v pref.Value) {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- pv := conv.GoValueOf(v)
- if pv.IsNil() {
- panic(fmt.Sprintf("map field %v cannot be set with read-only value", fd.FullName()))
- }
- rv.Set(pv)
- },
- mutable: func(p pointer) pref.Value {
- v := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if v.IsNil() {
- v.Set(reflect.MakeMap(fs.Type))
- }
- return conv.PBValueOf(v)
- },
- newField: func() pref.Value {
- return conv.New()
- },
- }
-}
-
-func fieldInfoForList(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
- ft := fs.Type
- if ft.Kind() != reflect.Slice {
- panic(fmt.Sprintf("field %v has invalid type: got %v, want slice kind", fd.FullName(), ft))
- }
- conv := NewConverter(reflect.PtrTo(ft), fd)
-
- // TODO: Implement unsafe fast path?
- fieldOffset := offsetOf(fs, x)
- return fieldInfo{
- fieldDesc: fd,
- has: func(p pointer) bool {
- if p.IsNil() {
- return false
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- return rv.Len() > 0
- },
- clear: func(p pointer) {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- rv.Set(reflect.Zero(rv.Type()))
- },
- get: func(p pointer) pref.Value {
- if p.IsNil() {
- return conv.Zero()
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type)
- if rv.Elem().Len() == 0 {
- return conv.Zero()
- }
- return conv.PBValueOf(rv)
- },
- set: func(p pointer, v pref.Value) {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- pv := conv.GoValueOf(v)
- if pv.IsNil() {
- panic(fmt.Sprintf("list field %v cannot be set with read-only value", fd.FullName()))
- }
- rv.Set(pv.Elem())
- },
- mutable: func(p pointer) pref.Value {
- v := p.Apply(fieldOffset).AsValueOf(fs.Type)
- return conv.PBValueOf(v)
- },
- newField: func() pref.Value {
- return conv.New()
- },
- }
-}
-
-var (
- nilBytes = reflect.ValueOf([]byte(nil))
- emptyBytes = reflect.ValueOf([]byte{})
-)
-
-func fieldInfoForScalar(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
- ft := fs.Type
- nullable := fd.HasPresence()
- isBytes := ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8
- if nullable {
- if ft.Kind() != reflect.Ptr && ft.Kind() != reflect.Slice {
- // This never occurs for generated message types.
- // Despite the protobuf type system specifying presence,
- // the Go field type cannot represent it.
- nullable = false
- }
- if ft.Kind() == reflect.Ptr {
- ft = ft.Elem()
- }
- }
- conv := NewConverter(ft, fd)
-
- // TODO: Implement unsafe fast path?
- fieldOffset := offsetOf(fs, x)
- return fieldInfo{
- fieldDesc: fd,
- has: func(p pointer) bool {
- if p.IsNil() {
- return false
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if nullable {
- return !rv.IsNil()
- }
- switch rv.Kind() {
- case reflect.Bool:
- return rv.Bool()
- case reflect.Int32, reflect.Int64:
- return rv.Int() != 0
- case reflect.Uint32, reflect.Uint64:
- return rv.Uint() != 0
- case reflect.Float32, reflect.Float64:
- return rv.Float() != 0 || math.Signbit(rv.Float())
- case reflect.String, reflect.Slice:
- return rv.Len() > 0
- default:
- panic(fmt.Sprintf("field %v has invalid type: %v", fd.FullName(), rv.Type())) // should never happen
- }
- },
- clear: func(p pointer) {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- rv.Set(reflect.Zero(rv.Type()))
- },
- get: func(p pointer) pref.Value {
- if p.IsNil() {
- return conv.Zero()
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if nullable {
- if rv.IsNil() {
- return conv.Zero()
- }
- if rv.Kind() == reflect.Ptr {
- rv = rv.Elem()
- }
- }
- return conv.PBValueOf(rv)
- },
- set: func(p pointer, v pref.Value) {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if nullable && rv.Kind() == reflect.Ptr {
- if rv.IsNil() {
- rv.Set(reflect.New(ft))
- }
- rv = rv.Elem()
- }
- rv.Set(conv.GoValueOf(v))
- if isBytes && rv.Len() == 0 {
- if nullable {
- rv.Set(emptyBytes) // preserve presence
- } else {
- rv.Set(nilBytes) // do not preserve presence
- }
- }
- },
- newField: func() pref.Value {
- return conv.New()
- },
- }
-}
-
-func fieldInfoForWeakMessage(fd pref.FieldDescriptor, weakOffset offset) fieldInfo {
- if !flags.ProtoLegacy {
- panic("no support for proto1 weak fields")
- }
-
- var once sync.Once
- var messageType pref.MessageType
- lazyInit := func() {
- once.Do(func() {
- messageName := fd.Message().FullName()
- messageType, _ = preg.GlobalTypes.FindMessageByName(messageName)
- if messageType == nil {
- panic(fmt.Sprintf("weak message %v for field %v is not linked in", messageName, fd.FullName()))
- }
- })
- }
-
- num := fd.Number()
- return fieldInfo{
- fieldDesc: fd,
- has: func(p pointer) bool {
- if p.IsNil() {
- return false
- }
- _, ok := p.Apply(weakOffset).WeakFields().get(num)
- return ok
- },
- clear: func(p pointer) {
- p.Apply(weakOffset).WeakFields().clear(num)
- },
- get: func(p pointer) pref.Value {
- lazyInit()
- if p.IsNil() {
- return pref.ValueOfMessage(messageType.Zero())
- }
- m, ok := p.Apply(weakOffset).WeakFields().get(num)
- if !ok {
- return pref.ValueOfMessage(messageType.Zero())
- }
- return pref.ValueOfMessage(m.ProtoReflect())
- },
- set: func(p pointer, v pref.Value) {
- lazyInit()
- m := v.Message()
- if m.Descriptor() != messageType.Descriptor() {
- if got, want := m.Descriptor().FullName(), messageType.Descriptor().FullName(); got != want {
- panic(fmt.Sprintf("field %v has mismatching message descriptor: got %v, want %v", fd.FullName(), got, want))
- }
- panic(fmt.Sprintf("field %v has mismatching message descriptor: %v", fd.FullName(), m.Descriptor().FullName()))
- }
- p.Apply(weakOffset).WeakFields().set(num, m.Interface())
- },
- mutable: func(p pointer) pref.Value {
- lazyInit()
- fs := p.Apply(weakOffset).WeakFields()
- m, ok := fs.get(num)
- if !ok {
- m = messageType.New().Interface()
- fs.set(num, m)
- }
- return pref.ValueOfMessage(m.ProtoReflect())
- },
- newMessage: func() pref.Message {
- lazyInit()
- return messageType.New()
- },
- newField: func() pref.Value {
- lazyInit()
- return pref.ValueOfMessage(messageType.New())
- },
- }
-}
-
-func fieldInfoForMessage(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
- ft := fs.Type
- conv := NewConverter(ft, fd)
-
- // TODO: Implement unsafe fast path?
- fieldOffset := offsetOf(fs, x)
- return fieldInfo{
- fieldDesc: fd,
- has: func(p pointer) bool {
- if p.IsNil() {
- return false
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if fs.Type.Kind() != reflect.Ptr {
- return !isZero(rv)
- }
- return !rv.IsNil()
- },
- clear: func(p pointer) {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- rv.Set(reflect.Zero(rv.Type()))
- },
- get: func(p pointer) pref.Value {
- if p.IsNil() {
- return conv.Zero()
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- return conv.PBValueOf(rv)
- },
- set: func(p pointer, v pref.Value) {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- rv.Set(conv.GoValueOf(v))
- if fs.Type.Kind() == reflect.Ptr && rv.IsNil() {
- panic(fmt.Sprintf("field %v has invalid nil pointer", fd.FullName()))
- }
- },
- mutable: func(p pointer) pref.Value {
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if fs.Type.Kind() == reflect.Ptr && rv.IsNil() {
- rv.Set(conv.GoValueOf(conv.New()))
- }
- return conv.PBValueOf(rv)
- },
- newMessage: func() pref.Message {
- return conv.New().Message()
- },
- newField: func() pref.Value {
- return conv.New()
- },
- }
-}
-
-type oneofInfo struct {
- oneofDesc pref.OneofDescriptor
- which func(pointer) pref.FieldNumber
-}
-
-func makeOneofInfo(od pref.OneofDescriptor, si structInfo, x exporter) *oneofInfo {
- oi := &oneofInfo{oneofDesc: od}
- if od.IsSynthetic() {
- fs := si.fieldsByNumber[od.Fields().Get(0).Number()]
- fieldOffset := offsetOf(fs, x)
- oi.which = func(p pointer) pref.FieldNumber {
- if p.IsNil() {
- return 0
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if rv.IsNil() { // valid on either *T or []byte
- return 0
- }
- return od.Fields().Get(0).Number()
- }
- } else {
- fs := si.oneofsByName[od.Name()]
- fieldOffset := offsetOf(fs, x)
- oi.which = func(p pointer) pref.FieldNumber {
- if p.IsNil() {
- return 0
- }
- rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
- if rv.IsNil() {
- return 0
- }
- rv = rv.Elem()
- if rv.IsNil() {
- return 0
- }
- return si.oneofWrappersByType[rv.Type().Elem()]
- }
- }
- return oi
-}
-
-// isZero is identical to reflect.Value.IsZero.
-// TODO: Remove this when Go1.13 is the minimally supported Go version.
-func isZero(v reflect.Value) bool {
- switch v.Kind() {
- case reflect.Bool:
- return !v.Bool()
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return v.Int() == 0
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return v.Uint() == 0
- case reflect.Float32, reflect.Float64:
- return math.Float64bits(v.Float()) == 0
- case reflect.Complex64, reflect.Complex128:
- c := v.Complex()
- return math.Float64bits(real(c)) == 0 && math.Float64bits(imag(c)) == 0
- case reflect.Array:
- for i := 0; i < v.Len(); i++ {
- if !isZero(v.Index(i)) {
- return false
- }
- }
- return true
- case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer:
- return v.IsNil()
- case reflect.String:
- return v.Len() == 0
- case reflect.Struct:
- for i := 0; i < v.NumField(); i++ {
- if !isZero(v.Field(i)) {
- return false
- }
- }
- return true
- default:
- panic(&reflect.ValueError{"reflect.Value.IsZero", v.Kind()})
- }
-}
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-12 23:56:59 +0000