podman

1
// Go support for Protocol Buffers - Google's data interchange format
2
//
3
// Copyright 2012 The Go Authors.  All rights reserved.
4
// https://github.com/golang/protobuf
5
//
6
// Redistribution and use in source and binary forms, with or without
7
// modification, are permitted provided that the following conditions are
8
// met:
9
//
10
//     * Redistributions of source code must retain the above copyright
11
// notice, this list of conditions and the following disclaimer.
12
//     * Redistributions in binary form must reproduce the above
13
// copyright notice, this list of conditions and the following disclaimer
14
// in the documentation and/or other materials provided with the
15
// distribution.
16
//     * Neither the name of Google Inc. nor the names of its
17
// contributors may be used to endorse or promote products derived from
18
// this software without specific prior written permission.
19
//
20
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31

32
// +build purego appengine js
33

34
// This file contains an implementation of proto field accesses using package reflect.
35
// It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can
36
// be used on App Engine.
37

38
package proto
39

40
import (
41
	"reflect"
42
	"sync"
43
)
44

45
const unsafeAllowed = false
46

47
// A field identifies a field in a struct, accessible from a pointer.
48
// In this implementation, a field is identified by the sequence of field indices
49
// passed to reflect's FieldByIndex.
50
type field []int
51

52
// toField returns a field equivalent to the given reflect field.
53
func toField(f *reflect.StructField) field {
54
	return f.Index
55
}
56

57
// invalidField is an invalid field identifier.
58
var invalidField = field(nil)
59

60
// zeroField is a noop when calling pointer.offset.
61
var zeroField = field([]int{})
62

63
// IsValid reports whether the field identifier is valid.
64
func (f field) IsValid() bool { return f != nil }
65

66
// The pointer type is for the table-driven decoder.
67
// The implementation here uses a reflect.Value of pointer type to
68
// create a generic pointer. In pointer_unsafe.go we use unsafe
69
// instead of reflect to implement the same (but faster) interface.
70
type pointer struct {
71
	v reflect.Value
72
}
73

74
// toPointer converts an interface of pointer type to a pointer
75
// that points to the same target.
76
func toPointer(i *Message) pointer {
77
	return pointer{v: reflect.ValueOf(*i)}
78
}
79

80
// toAddrPointer converts an interface to a pointer that points to
81
// the interface data.
82
func toAddrPointer(i *interface{}, isptr bool) pointer {
83
	v := reflect.ValueOf(*i)
84
	u := reflect.New(v.Type())
85
	u.Elem().Set(v)
86
	return pointer{v: u}
87
}
88

89
// valToPointer converts v to a pointer.  v must be of pointer type.
90
func valToPointer(v reflect.Value) pointer {
91
	return pointer{v: v}
92
}
93

94
// offset converts from a pointer to a structure to a pointer to
95
// one of its fields.
96
func (p pointer) offset(f field) pointer {
97
	return pointer{v: p.v.Elem().FieldByIndex(f).Addr()}
98
}
99

100
func (p pointer) isNil() bool {
101
	return p.v.IsNil()
102
}
103

104
// grow updates the slice s in place to make it one element longer.
105
// s must be addressable.
106
// Returns the (addressable) new element.
107
func grow(s reflect.Value) reflect.Value {
108
	n, m := s.Len(), s.Cap()
109
	if n < m {
110
		s.SetLen(n + 1)
111
	} else {
112
		s.Set(reflect.Append(s, reflect.Zero(s.Type().Elem())))
113
	}
114
	return s.Index(n)
115
}
116

117
func (p pointer) toInt64() *int64 {
118
	return p.v.Interface().(*int64)
119
}
120
func (p pointer) toInt64Ptr() **int64 {
121
	return p.v.Interface().(**int64)
122
}
123
func (p pointer) toInt64Slice() *[]int64 {
124
	return p.v.Interface().(*[]int64)
125
}
126

127
var int32ptr = reflect.TypeOf((*int32)(nil))
128

129
func (p pointer) toInt32() *int32 {
130
	return p.v.Convert(int32ptr).Interface().(*int32)
131
}
132

133
// The toInt32Ptr/Slice methods don't work because of enums.
134
// Instead, we must use set/get methods for the int32ptr/slice case.
135
/*
136
	func (p pointer) toInt32Ptr() **int32 {
137
		return p.v.Interface().(**int32)
138
}
139
	func (p pointer) toInt32Slice() *[]int32 {
140
		return p.v.Interface().(*[]int32)
141
}
142
*/
143
func (p pointer) getInt32Ptr() *int32 {
144
	if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
145
		// raw int32 type
146
		return p.v.Elem().Interface().(*int32)
147
	}
148
	// an enum
149
	return p.v.Elem().Convert(int32PtrType).Interface().(*int32)
150
}
151
func (p pointer) setInt32Ptr(v int32) {
152
	// Allocate value in a *int32. Possibly convert that to a *enum.
153
	// Then assign it to a **int32 or **enum.
154
	// Note: we can convert *int32 to *enum, but we can't convert
155
	// **int32 to **enum!
156
	p.v.Elem().Set(reflect.ValueOf(&v).Convert(p.v.Type().Elem()))
157
}
158

159
// getInt32Slice copies []int32 from p as a new slice.
160
// This behavior differs from the implementation in pointer_unsafe.go.
161
func (p pointer) getInt32Slice() []int32 {
162
	if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
163
		// raw int32 type
164
		return p.v.Elem().Interface().([]int32)
165
	}
166
	// an enum
167
	// Allocate a []int32, then assign []enum's values into it.
168
	// Note: we can't convert []enum to []int32.
169
	slice := p.v.Elem()
170
	s := make([]int32, slice.Len())
171
	for i := 0; i < slice.Len(); i++ {
172
		s[i] = int32(slice.Index(i).Int())
173
	}
174
	return s
175
}
176

177
// setInt32Slice copies []int32 into p as a new slice.
178
// This behavior differs from the implementation in pointer_unsafe.go.
179
func (p pointer) setInt32Slice(v []int32) {
180
	if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {
181
		// raw int32 type
182
		p.v.Elem().Set(reflect.ValueOf(v))
183
		return
184
	}
185
	// an enum
186
	// Allocate a []enum, then assign []int32's values into it.
187
	// Note: we can't convert []enum to []int32.
188
	slice := reflect.MakeSlice(p.v.Type().Elem(), len(v), cap(v))
189
	for i, x := range v {
190
		slice.Index(i).SetInt(int64(x))
191
	}
192
	p.v.Elem().Set(slice)
193
}
194
func (p pointer) appendInt32Slice(v int32) {
195
	grow(p.v.Elem()).SetInt(int64(v))
196
}
197

198
func (p pointer) toUint64() *uint64 {
199
	return p.v.Interface().(*uint64)
200
}
201
func (p pointer) toUint64Ptr() **uint64 {
202
	return p.v.Interface().(**uint64)
203
}
204
func (p pointer) toUint64Slice() *[]uint64 {
205
	return p.v.Interface().(*[]uint64)
206
}
207
func (p pointer) toUint32() *uint32 {
208
	return p.v.Interface().(*uint32)
209
}
210
func (p pointer) toUint32Ptr() **uint32 {
211
	return p.v.Interface().(**uint32)
212
}
213
func (p pointer) toUint32Slice() *[]uint32 {
214
	return p.v.Interface().(*[]uint32)
215
}
216
func (p pointer) toBool() *bool {
217
	return p.v.Interface().(*bool)
218
}
219
func (p pointer) toBoolPtr() **bool {
220
	return p.v.Interface().(**bool)
221
}
222
func (p pointer) toBoolSlice() *[]bool {
223
	return p.v.Interface().(*[]bool)
224
}
225
func (p pointer) toFloat64() *float64 {
226
	return p.v.Interface().(*float64)
227
}
228
func (p pointer) toFloat64Ptr() **float64 {
229
	return p.v.Interface().(**float64)
230
}
231
func (p pointer) toFloat64Slice() *[]float64 {
232
	return p.v.Interface().(*[]float64)
233
}
234
func (p pointer) toFloat32() *float32 {
235
	return p.v.Interface().(*float32)
236
}
237
func (p pointer) toFloat32Ptr() **float32 {
238
	return p.v.Interface().(**float32)
239
}
240
func (p pointer) toFloat32Slice() *[]float32 {
241
	return p.v.Interface().(*[]float32)
242
}
243
func (p pointer) toString() *string {
244
	return p.v.Interface().(*string)
245
}
246
func (p pointer) toStringPtr() **string {
247
	return p.v.Interface().(**string)
248
}
249
func (p pointer) toStringSlice() *[]string {
250
	return p.v.Interface().(*[]string)
251
}
252
func (p pointer) toBytes() *[]byte {
253
	return p.v.Interface().(*[]byte)
254
}
255
func (p pointer) toBytesSlice() *[][]byte {
256
	return p.v.Interface().(*[][]byte)
257
}
258
func (p pointer) toExtensions() *XXX_InternalExtensions {
259
	return p.v.Interface().(*XXX_InternalExtensions)
260
}
261
func (p pointer) toOldExtensions() *map[int32]Extension {
262
	return p.v.Interface().(*map[int32]Extension)
263
}
264
func (p pointer) getPointer() pointer {
265
	return pointer{v: p.v.Elem()}
266
}
267
func (p pointer) setPointer(q pointer) {
268
	p.v.Elem().Set(q.v)
269
}
270
func (p pointer) appendPointer(q pointer) {
271
	grow(p.v.Elem()).Set(q.v)
272
}
273

274
// getPointerSlice copies []*T from p as a new []pointer.
275
// This behavior differs from the implementation in pointer_unsafe.go.
276
func (p pointer) getPointerSlice() []pointer {
277
	if p.v.IsNil() {
278
		return nil
279
	}
280
	n := p.v.Elem().Len()
281
	s := make([]pointer, n)
282
	for i := 0; i < n; i++ {
283
		s[i] = pointer{v: p.v.Elem().Index(i)}
284
	}
285
	return s
286
}
287

288
// setPointerSlice copies []pointer into p as a new []*T.
289
// This behavior differs from the implementation in pointer_unsafe.go.
290
func (p pointer) setPointerSlice(v []pointer) {
291
	if v == nil {
292
		p.v.Elem().Set(reflect.New(p.v.Elem().Type()).Elem())
293
		return
294
	}
295
	s := reflect.MakeSlice(p.v.Elem().Type(), 0, len(v))
296
	for _, p := range v {
297
		s = reflect.Append(s, p.v)
298
	}
299
	p.v.Elem().Set(s)
300
}
301

302
// getInterfacePointer returns a pointer that points to the
303
// interface data of the interface pointed by p.
304
func (p pointer) getInterfacePointer() pointer {
305
	if p.v.Elem().IsNil() {
306
		return pointer{v: p.v.Elem()}
307
	}
308
	return pointer{v: p.v.Elem().Elem().Elem().Field(0).Addr()} // *interface -> interface -> *struct -> struct
309
}
310

311
func (p pointer) asPointerTo(t reflect.Type) reflect.Value {
312
	// TODO: check that p.v.Type().Elem() == t?
313
	return p.v
314
}
315

316
func atomicLoadUnmarshalInfo(p **unmarshalInfo) *unmarshalInfo {
317
	atomicLock.Lock()
318
	defer atomicLock.Unlock()
319
	return *p
320
}
321
func atomicStoreUnmarshalInfo(p **unmarshalInfo, v *unmarshalInfo) {
322
	atomicLock.Lock()
323
	defer atomicLock.Unlock()
324
	*p = v
325
}
326
func atomicLoadMarshalInfo(p **marshalInfo) *marshalInfo {
327
	atomicLock.Lock()
328
	defer atomicLock.Unlock()
329
	return *p
330
}
331
func atomicStoreMarshalInfo(p **marshalInfo, v *marshalInfo) {
332
	atomicLock.Lock()
333
	defer atomicLock.Unlock()
334
	*p = v
335
}
336
func atomicLoadMergeInfo(p **mergeInfo) *mergeInfo {
337
	atomicLock.Lock()
338
	defer atomicLock.Unlock()
339
	return *p
340
}
341
func atomicStoreMergeInfo(p **mergeInfo, v *mergeInfo) {
342
	atomicLock.Lock()
343
	defer atomicLock.Unlock()
344
	*p = v
345
}
346
func atomicLoadDiscardInfo(p **discardInfo) *discardInfo {
347
	atomicLock.Lock()
348
	defer atomicLock.Unlock()
349
	return *p
350
}
351
func atomicStoreDiscardInfo(p **discardInfo, v *discardInfo) {
352
	atomicLock.Lock()
353
	defer atomicLock.Unlock()
354
	*p = v
355
}
356

357
var atomicLock sync.Mutex
358