podman

1
// Copyright 2018 The Go Authors. All rights reserved.
2
// Use of this source code is governed by a BSD-style
3
// license that can be found in the LICENSE file.
4

5
package impl
6

7
import (
8
	"fmt"
9
	"reflect"
10

11
	"google.golang.org/protobuf/reflect/protoreflect"
12
)
13

14
// unwrapper unwraps the value to the underlying value.
15
// This is implemented by List and Map.
16
type unwrapper interface {
17
	protoUnwrap() interface{}
18
}
19

20
// A Converter coverts to/from Go reflect.Value types and protobuf protoreflect.Value types.
21
type Converter interface {
22
	// PBValueOf converts a reflect.Value to a protoreflect.Value.
23
	PBValueOf(reflect.Value) protoreflect.Value
24

25
	// GoValueOf converts a protoreflect.Value to a reflect.Value.
26
	GoValueOf(protoreflect.Value) reflect.Value
27

28
	// IsValidPB returns whether a protoreflect.Value is compatible with this type.
29
	IsValidPB(protoreflect.Value) bool
30

31
	// IsValidGo returns whether a reflect.Value is compatible with this type.
32
	IsValidGo(reflect.Value) bool
33

34
	// New returns a new field value.
35
	// For scalars, it returns the default value of the field.
36
	// For composite types, it returns a new mutable value.
37
	New() protoreflect.Value
38

39
	// Zero returns a new field value.
40
	// For scalars, it returns the default value of the field.
41
	// For composite types, it returns an immutable, empty value.
42
	Zero() protoreflect.Value
43
}
44

45
// NewConverter matches a Go type with a protobuf field and returns a Converter
46
// that converts between the two. Enums must be a named int32 kind that
47
// implements protoreflect.Enum, and messages must be pointer to a named
48
// struct type that implements protoreflect.ProtoMessage.
49
//
50
// This matcher deliberately supports a wider range of Go types than what
51
// protoc-gen-go historically generated to be able to automatically wrap some
52
// v1 messages generated by other forks of protoc-gen-go.
53
func NewConverter(t reflect.Type, fd protoreflect.FieldDescriptor) Converter {
54
	switch {
55
	case fd.IsList():
56
		return newListConverter(t, fd)
57
	case fd.IsMap():
58
		return newMapConverter(t, fd)
59
	default:
60
		return newSingularConverter(t, fd)
61
	}
62
}
63

64
var (
65
	boolType    = reflect.TypeOf(bool(false))
66
	int32Type   = reflect.TypeOf(int32(0))
67
	int64Type   = reflect.TypeOf(int64(0))
68
	uint32Type  = reflect.TypeOf(uint32(0))
69
	uint64Type  = reflect.TypeOf(uint64(0))
70
	float32Type = reflect.TypeOf(float32(0))
71
	float64Type = reflect.TypeOf(float64(0))
72
	stringType  = reflect.TypeOf(string(""))
73
	bytesType   = reflect.TypeOf([]byte(nil))
74
	byteType    = reflect.TypeOf(byte(0))
75
)
76

77
var (
78
	boolZero    = protoreflect.ValueOfBool(false)
79
	int32Zero   = protoreflect.ValueOfInt32(0)
80
	int64Zero   = protoreflect.ValueOfInt64(0)
81
	uint32Zero  = protoreflect.ValueOfUint32(0)
82
	uint64Zero  = protoreflect.ValueOfUint64(0)
83
	float32Zero = protoreflect.ValueOfFloat32(0)
84
	float64Zero = protoreflect.ValueOfFloat64(0)
85
	stringZero  = protoreflect.ValueOfString("")
86
	bytesZero   = protoreflect.ValueOfBytes(nil)
87
)
88

89
func newSingularConverter(t reflect.Type, fd protoreflect.FieldDescriptor) Converter {
90
	defVal := func(fd protoreflect.FieldDescriptor, zero protoreflect.Value) protoreflect.Value {
91
		if fd.Cardinality() == protoreflect.Repeated {
92
			// Default isn't defined for repeated fields.
93
			return zero
94
		}
95
		return fd.Default()
96
	}
97
	switch fd.Kind() {
98
	case protoreflect.BoolKind:
99
		if t.Kind() == reflect.Bool {
100
			return &boolConverter{t, defVal(fd, boolZero)}
101
		}
102
	case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
103
		if t.Kind() == reflect.Int32 {
104
			return &int32Converter{t, defVal(fd, int32Zero)}
105
		}
106
	case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
107
		if t.Kind() == reflect.Int64 {
108
			return &int64Converter{t, defVal(fd, int64Zero)}
109
		}
110
	case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
111
		if t.Kind() == reflect.Uint32 {
112
			return &uint32Converter{t, defVal(fd, uint32Zero)}
113
		}
114
	case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
115
		if t.Kind() == reflect.Uint64 {
116
			return &uint64Converter{t, defVal(fd, uint64Zero)}
117
		}
118
	case protoreflect.FloatKind:
119
		if t.Kind() == reflect.Float32 {
120
			return &float32Converter{t, defVal(fd, float32Zero)}
121
		}
122
	case protoreflect.DoubleKind:
123
		if t.Kind() == reflect.Float64 {
124
			return &float64Converter{t, defVal(fd, float64Zero)}
125
		}
126
	case protoreflect.StringKind:
127
		if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {
128
			return &stringConverter{t, defVal(fd, stringZero)}
129
		}
130
	case protoreflect.BytesKind:
131
		if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {
132
			return &bytesConverter{t, defVal(fd, bytesZero)}
133
		}
134
	case protoreflect.EnumKind:
135
		// Handle enums, which must be a named int32 type.
136
		if t.Kind() == reflect.Int32 {
137
			return newEnumConverter(t, fd)
138
		}
139
	case protoreflect.MessageKind, protoreflect.GroupKind:
140
		return newMessageConverter(t)
141
	}
142
	panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
143
}
144

145
type boolConverter struct {
146
	goType reflect.Type
147
	def    protoreflect.Value
148
}
149

150
func (c *boolConverter) PBValueOf(v reflect.Value) protoreflect.Value {
151
	if v.Type() != c.goType {
152
		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
153
	}
154
	return protoreflect.ValueOfBool(v.Bool())
155
}
156
func (c *boolConverter) GoValueOf(v protoreflect.Value) reflect.Value {
157
	return reflect.ValueOf(v.Bool()).Convert(c.goType)
158
}
159
func (c *boolConverter) IsValidPB(v protoreflect.Value) bool {
160
	_, ok := v.Interface().(bool)
161
	return ok
162
}
163
func (c *boolConverter) IsValidGo(v reflect.Value) bool {
164
	return v.IsValid() && v.Type() == c.goType
165
}
166
func (c *boolConverter) New() protoreflect.Value  { return c.def }
167
func (c *boolConverter) Zero() protoreflect.Value { return c.def }
168

169
type int32Converter struct {
170
	goType reflect.Type
171
	def    protoreflect.Value
172
}
173

174
func (c *int32Converter) PBValueOf(v reflect.Value) protoreflect.Value {
175
	if v.Type() != c.goType {
176
		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
177
	}
178
	return protoreflect.ValueOfInt32(int32(v.Int()))
179
}
180
func (c *int32Converter) GoValueOf(v protoreflect.Value) reflect.Value {
181
	return reflect.ValueOf(int32(v.Int())).Convert(c.goType)
182
}
183
func (c *int32Converter) IsValidPB(v protoreflect.Value) bool {
184
	_, ok := v.Interface().(int32)
185
	return ok
186
}
187
func (c *int32Converter) IsValidGo(v reflect.Value) bool {
188
	return v.IsValid() && v.Type() == c.goType
189
}
190
func (c *int32Converter) New() protoreflect.Value  { return c.def }
191
func (c *int32Converter) Zero() protoreflect.Value { return c.def }
192

193
type int64Converter struct {
194
	goType reflect.Type
195
	def    protoreflect.Value
196
}
197

198
func (c *int64Converter) PBValueOf(v reflect.Value) protoreflect.Value {
199
	if v.Type() != c.goType {
200
		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
201
	}
202
	return protoreflect.ValueOfInt64(int64(v.Int()))
203
}
204
func (c *int64Converter) GoValueOf(v protoreflect.Value) reflect.Value {
205
	return reflect.ValueOf(int64(v.Int())).Convert(c.goType)
206
}
207
func (c *int64Converter) IsValidPB(v protoreflect.Value) bool {
208
	_, ok := v.Interface().(int64)
209
	return ok
210
}
211
func (c *int64Converter) IsValidGo(v reflect.Value) bool {
212
	return v.IsValid() && v.Type() == c.goType
213
}
214
func (c *int64Converter) New() protoreflect.Value  { return c.def }
215
func (c *int64Converter) Zero() protoreflect.Value { return c.def }
216

217
type uint32Converter struct {
218
	goType reflect.Type
219
	def    protoreflect.Value
220
}
221

222
func (c *uint32Converter) PBValueOf(v reflect.Value) protoreflect.Value {
223
	if v.Type() != c.goType {
224
		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
225
	}
226
	return protoreflect.ValueOfUint32(uint32(v.Uint()))
227
}
228
func (c *uint32Converter) GoValueOf(v protoreflect.Value) reflect.Value {
229
	return reflect.ValueOf(uint32(v.Uint())).Convert(c.goType)
230
}
231
func (c *uint32Converter) IsValidPB(v protoreflect.Value) bool {
232
	_, ok := v.Interface().(uint32)
233
	return ok
234
}
235
func (c *uint32Converter) IsValidGo(v reflect.Value) bool {
236
	return v.IsValid() && v.Type() == c.goType
237
}
238
func (c *uint32Converter) New() protoreflect.Value  { return c.def }
239
func (c *uint32Converter) Zero() protoreflect.Value { return c.def }
240

241
type uint64Converter struct {
242
	goType reflect.Type
243
	def    protoreflect.Value
244
}
245

246
func (c *uint64Converter) PBValueOf(v reflect.Value) protoreflect.Value {
247
	if v.Type() != c.goType {
248
		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
249
	}
250
	return protoreflect.ValueOfUint64(uint64(v.Uint()))
251
}
252
func (c *uint64Converter) GoValueOf(v protoreflect.Value) reflect.Value {
253
	return reflect.ValueOf(uint64(v.Uint())).Convert(c.goType)
254
}
255
func (c *uint64Converter) IsValidPB(v protoreflect.Value) bool {
256
	_, ok := v.Interface().(uint64)
257
	return ok
258
}
259
func (c *uint64Converter) IsValidGo(v reflect.Value) bool {
260
	return v.IsValid() && v.Type() == c.goType
261
}
262
func (c *uint64Converter) New() protoreflect.Value  { return c.def }
263
func (c *uint64Converter) Zero() protoreflect.Value { return c.def }
264

265
type float32Converter struct {
266
	goType reflect.Type
267
	def    protoreflect.Value
268
}
269

270
func (c *float32Converter) PBValueOf(v reflect.Value) protoreflect.Value {
271
	if v.Type() != c.goType {
272
		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
273
	}
274
	return protoreflect.ValueOfFloat32(float32(v.Float()))
275
}
276
func (c *float32Converter) GoValueOf(v protoreflect.Value) reflect.Value {
277
	return reflect.ValueOf(float32(v.Float())).Convert(c.goType)
278
}
279
func (c *float32Converter) IsValidPB(v protoreflect.Value) bool {
280
	_, ok := v.Interface().(float32)
281
	return ok
282
}
283
func (c *float32Converter) IsValidGo(v reflect.Value) bool {
284
	return v.IsValid() && v.Type() == c.goType
285
}
286
func (c *float32Converter) New() protoreflect.Value  { return c.def }
287
func (c *float32Converter) Zero() protoreflect.Value { return c.def }
288

289
type float64Converter struct {
290
	goType reflect.Type
291
	def    protoreflect.Value
292
}
293

294
func (c *float64Converter) PBValueOf(v reflect.Value) protoreflect.Value {
295
	if v.Type() != c.goType {
296
		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
297
	}
298
	return protoreflect.ValueOfFloat64(float64(v.Float()))
299
}
300
func (c *float64Converter) GoValueOf(v protoreflect.Value) reflect.Value {
301
	return reflect.ValueOf(float64(v.Float())).Convert(c.goType)
302
}
303
func (c *float64Converter) IsValidPB(v protoreflect.Value) bool {
304
	_, ok := v.Interface().(float64)
305
	return ok
306
}
307
func (c *float64Converter) IsValidGo(v reflect.Value) bool {
308
	return v.IsValid() && v.Type() == c.goType
309
}
310
func (c *float64Converter) New() protoreflect.Value  { return c.def }
311
func (c *float64Converter) Zero() protoreflect.Value { return c.def }
312

313
type stringConverter struct {
314
	goType reflect.Type
315
	def    protoreflect.Value
316
}
317

318
func (c *stringConverter) PBValueOf(v reflect.Value) protoreflect.Value {
319
	if v.Type() != c.goType {
320
		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
321
	}
322
	return protoreflect.ValueOfString(v.Convert(stringType).String())
323
}
324
func (c *stringConverter) GoValueOf(v protoreflect.Value) reflect.Value {
325
	// pref.Value.String never panics, so we go through an interface
326
	// conversion here to check the type.
327
	s := v.Interface().(string)
328
	if c.goType.Kind() == reflect.Slice && s == "" {
329
		return reflect.Zero(c.goType) // ensure empty string is []byte(nil)
330
	}
331
	return reflect.ValueOf(s).Convert(c.goType)
332
}
333
func (c *stringConverter) IsValidPB(v protoreflect.Value) bool {
334
	_, ok := v.Interface().(string)
335
	return ok
336
}
337
func (c *stringConverter) IsValidGo(v reflect.Value) bool {
338
	return v.IsValid() && v.Type() == c.goType
339
}
340
func (c *stringConverter) New() protoreflect.Value  { return c.def }
341
func (c *stringConverter) Zero() protoreflect.Value { return c.def }
342

343
type bytesConverter struct {
344
	goType reflect.Type
345
	def    protoreflect.Value
346
}
347

348
func (c *bytesConverter) PBValueOf(v reflect.Value) protoreflect.Value {
349
	if v.Type() != c.goType {
350
		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
351
	}
352
	if c.goType.Kind() == reflect.String && v.Len() == 0 {
353
		return protoreflect.ValueOfBytes(nil) // ensure empty string is []byte(nil)
354
	}
355
	return protoreflect.ValueOfBytes(v.Convert(bytesType).Bytes())
356
}
357
func (c *bytesConverter) GoValueOf(v protoreflect.Value) reflect.Value {
358
	return reflect.ValueOf(v.Bytes()).Convert(c.goType)
359
}
360
func (c *bytesConverter) IsValidPB(v protoreflect.Value) bool {
361
	_, ok := v.Interface().([]byte)
362
	return ok
363
}
364
func (c *bytesConverter) IsValidGo(v reflect.Value) bool {
365
	return v.IsValid() && v.Type() == c.goType
366
}
367
func (c *bytesConverter) New() protoreflect.Value  { return c.def }
368
func (c *bytesConverter) Zero() protoreflect.Value { return c.def }
369

370
type enumConverter struct {
371
	goType reflect.Type
372
	def    protoreflect.Value
373
}
374

375
func newEnumConverter(goType reflect.Type, fd protoreflect.FieldDescriptor) Converter {
376
	var def protoreflect.Value
377
	if fd.Cardinality() == protoreflect.Repeated {
378
		def = protoreflect.ValueOfEnum(fd.Enum().Values().Get(0).Number())
379
	} else {
380
		def = fd.Default()
381
	}
382
	return &enumConverter{goType, def}
383
}
384

385
func (c *enumConverter) PBValueOf(v reflect.Value) protoreflect.Value {
386
	if v.Type() != c.goType {
387
		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
388
	}
389
	return protoreflect.ValueOfEnum(protoreflect.EnumNumber(v.Int()))
390
}
391

392
func (c *enumConverter) GoValueOf(v protoreflect.Value) reflect.Value {
393
	return reflect.ValueOf(v.Enum()).Convert(c.goType)
394
}
395

396
func (c *enumConverter) IsValidPB(v protoreflect.Value) bool {
397
	_, ok := v.Interface().(protoreflect.EnumNumber)
398
	return ok
399
}
400

401
func (c *enumConverter) IsValidGo(v reflect.Value) bool {
402
	return v.IsValid() && v.Type() == c.goType
403
}
404

405
func (c *enumConverter) New() protoreflect.Value {
406
	return c.def
407
}
408

409
func (c *enumConverter) Zero() protoreflect.Value {
410
	return c.def
411
}
412

413
type messageConverter struct {
414
	goType reflect.Type
415
}
416

417
func newMessageConverter(goType reflect.Type) Converter {
418
	return &messageConverter{goType}
419
}
420

421
func (c *messageConverter) PBValueOf(v reflect.Value) protoreflect.Value {
422
	if v.Type() != c.goType {
423
		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
424
	}
425
	if c.isNonPointer() {
426
		if v.CanAddr() {
427
			v = v.Addr() // T => *T
428
		} else {
429
			v = reflect.Zero(reflect.PtrTo(v.Type()))
430
		}
431
	}
432
	if m, ok := v.Interface().(protoreflect.ProtoMessage); ok {
433
		return protoreflect.ValueOfMessage(m.ProtoReflect())
434
	}
435
	return protoreflect.ValueOfMessage(legacyWrapMessage(v))
436
}
437

438
func (c *messageConverter) GoValueOf(v protoreflect.Value) reflect.Value {
439
	m := v.Message()
440
	var rv reflect.Value
441
	if u, ok := m.(unwrapper); ok {
442
		rv = reflect.ValueOf(u.protoUnwrap())
443
	} else {
444
		rv = reflect.ValueOf(m.Interface())
445
	}
446
	if c.isNonPointer() {
447
		if rv.Type() != reflect.PtrTo(c.goType) {
448
			panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), reflect.PtrTo(c.goType)))
449
		}
450
		if !rv.IsNil() {
451
			rv = rv.Elem() // *T => T
452
		} else {
453
			rv = reflect.Zero(rv.Type().Elem())
454
		}
455
	}
456
	if rv.Type() != c.goType {
457
		panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), c.goType))
458
	}
459
	return rv
460
}
461

462
func (c *messageConverter) IsValidPB(v protoreflect.Value) bool {
463
	m := v.Message()
464
	var rv reflect.Value
465
	if u, ok := m.(unwrapper); ok {
466
		rv = reflect.ValueOf(u.protoUnwrap())
467
	} else {
468
		rv = reflect.ValueOf(m.Interface())
469
	}
470
	if c.isNonPointer() {
471
		return rv.Type() == reflect.PtrTo(c.goType)
472
	}
473
	return rv.Type() == c.goType
474
}
475

476
func (c *messageConverter) IsValidGo(v reflect.Value) bool {
477
	return v.IsValid() && v.Type() == c.goType
478
}
479

480
func (c *messageConverter) New() protoreflect.Value {
481
	if c.isNonPointer() {
482
		return c.PBValueOf(reflect.New(c.goType).Elem())
483
	}
484
	return c.PBValueOf(reflect.New(c.goType.Elem()))
485
}
486

487
func (c *messageConverter) Zero() protoreflect.Value {
488
	return c.PBValueOf(reflect.Zero(c.goType))
489
}
490

491
// isNonPointer reports whether the type is a non-pointer type.
492
// This never occurs for generated message types.
493
func (c *messageConverter) isNonPointer() bool {
494
	return c.goType.Kind() != reflect.Ptr
495
}
496