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
// Code generated by generate-types. DO NOT EDIT.
6

7
package impl
8

9
import (
10
	"math"
11
	"unicode/utf8"
12

13
	"google.golang.org/protobuf/encoding/protowire"
14
	"google.golang.org/protobuf/reflect/protoreflect"
15
)
16

17
// sizeBool returns the size of wire encoding a bool pointer as a Bool.
18
func sizeBool(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
19
	v := *p.Bool()
20
	return f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
21
}
22

23
// appendBool wire encodes a bool pointer as a Bool.
24
func appendBool(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
25
	v := *p.Bool()
26
	b = protowire.AppendVarint(b, f.wiretag)
27
	b = protowire.AppendVarint(b, protowire.EncodeBool(v))
28
	return b, nil
29
}
30

31
// consumeBool wire decodes a bool pointer as a Bool.
32
func consumeBool(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
33
	if wtyp != protowire.VarintType {
34
		return out, errUnknown
35
	}
36
	var v uint64
37
	var n int
38
	if len(b) >= 1 && b[0] < 0x80 {
39
		v = uint64(b[0])
40
		n = 1
41
	} else if len(b) >= 2 && b[1] < 128 {
42
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
43
		n = 2
44
	} else {
45
		v, n = protowire.ConsumeVarint(b)
46
	}
47
	if n < 0 {
48
		return out, errDecode
49
	}
50
	*p.Bool() = protowire.DecodeBool(v)
51
	out.n = n
52
	return out, nil
53
}
54

55
var coderBool = pointerCoderFuncs{
56
	size:      sizeBool,
57
	marshal:   appendBool,
58
	unmarshal: consumeBool,
59
	merge:     mergeBool,
60
}
61

62
// sizeBoolNoZero returns the size of wire encoding a bool pointer as a Bool.
63
// The zero value is not encoded.
64
func sizeBoolNoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
65
	v := *p.Bool()
66
	if v == false {
67
		return 0
68
	}
69
	return f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
70
}
71

72
// appendBoolNoZero wire encodes a bool pointer as a Bool.
73
// The zero value is not encoded.
74
func appendBoolNoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
75
	v := *p.Bool()
76
	if v == false {
77
		return b, nil
78
	}
79
	b = protowire.AppendVarint(b, f.wiretag)
80
	b = protowire.AppendVarint(b, protowire.EncodeBool(v))
81
	return b, nil
82
}
83

84
var coderBoolNoZero = pointerCoderFuncs{
85
	size:      sizeBoolNoZero,
86
	marshal:   appendBoolNoZero,
87
	unmarshal: consumeBool,
88
	merge:     mergeBoolNoZero,
89
}
90

91
// sizeBoolPtr returns the size of wire encoding a *bool pointer as a Bool.
92
// It panics if the pointer is nil.
93
func sizeBoolPtr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
94
	v := **p.BoolPtr()
95
	return f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
96
}
97

98
// appendBoolPtr wire encodes a *bool pointer as a Bool.
99
// It panics if the pointer is nil.
100
func appendBoolPtr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
101
	v := **p.BoolPtr()
102
	b = protowire.AppendVarint(b, f.wiretag)
103
	b = protowire.AppendVarint(b, protowire.EncodeBool(v))
104
	return b, nil
105
}
106

107
// consumeBoolPtr wire decodes a *bool pointer as a Bool.
108
func consumeBoolPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
109
	if wtyp != protowire.VarintType {
110
		return out, errUnknown
111
	}
112
	var v uint64
113
	var n int
114
	if len(b) >= 1 && b[0] < 0x80 {
115
		v = uint64(b[0])
116
		n = 1
117
	} else if len(b) >= 2 && b[1] < 128 {
118
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
119
		n = 2
120
	} else {
121
		v, n = protowire.ConsumeVarint(b)
122
	}
123
	if n < 0 {
124
		return out, errDecode
125
	}
126
	vp := p.BoolPtr()
127
	if *vp == nil {
128
		*vp = new(bool)
129
	}
130
	**vp = protowire.DecodeBool(v)
131
	out.n = n
132
	return out, nil
133
}
134

135
var coderBoolPtr = pointerCoderFuncs{
136
	size:      sizeBoolPtr,
137
	marshal:   appendBoolPtr,
138
	unmarshal: consumeBoolPtr,
139
	merge:     mergeBoolPtr,
140
}
141

142
// sizeBoolSlice returns the size of wire encoding a []bool pointer as a repeated Bool.
143
func sizeBoolSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
144
	s := *p.BoolSlice()
145
	for _, v := range s {
146
		size += f.tagsize + protowire.SizeVarint(protowire.EncodeBool(v))
147
	}
148
	return size
149
}
150

151
// appendBoolSlice encodes a []bool pointer as a repeated Bool.
152
func appendBoolSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
153
	s := *p.BoolSlice()
154
	for _, v := range s {
155
		b = protowire.AppendVarint(b, f.wiretag)
156
		b = protowire.AppendVarint(b, protowire.EncodeBool(v))
157
	}
158
	return b, nil
159
}
160

161
// consumeBoolSlice wire decodes a []bool pointer as a repeated Bool.
162
func consumeBoolSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
163
	sp := p.BoolSlice()
164
	if wtyp == protowire.BytesType {
165
		b, n := protowire.ConsumeBytes(b)
166
		if n < 0 {
167
			return out, errDecode
168
		}
169
		count := 0
170
		for _, v := range b {
171
			if v < 0x80 {
172
				count++
173
			}
174
		}
175
		if count > 0 {
176
			p.growBoolSlice(count)
177
		}
178
		s := *sp
179
		for len(b) > 0 {
180
			var v uint64
181
			var n int
182
			if len(b) >= 1 && b[0] < 0x80 {
183
				v = uint64(b[0])
184
				n = 1
185
			} else if len(b) >= 2 && b[1] < 128 {
186
				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
187
				n = 2
188
			} else {
189
				v, n = protowire.ConsumeVarint(b)
190
			}
191
			if n < 0 {
192
				return out, errDecode
193
			}
194
			s = append(s, protowire.DecodeBool(v))
195
			b = b[n:]
196
		}
197
		*sp = s
198
		out.n = n
199
		return out, nil
200
	}
201
	if wtyp != protowire.VarintType {
202
		return out, errUnknown
203
	}
204
	var v uint64
205
	var n int
206
	if len(b) >= 1 && b[0] < 0x80 {
207
		v = uint64(b[0])
208
		n = 1
209
	} else if len(b) >= 2 && b[1] < 128 {
210
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
211
		n = 2
212
	} else {
213
		v, n = protowire.ConsumeVarint(b)
214
	}
215
	if n < 0 {
216
		return out, errDecode
217
	}
218
	*sp = append(*sp, protowire.DecodeBool(v))
219
	out.n = n
220
	return out, nil
221
}
222

223
var coderBoolSlice = pointerCoderFuncs{
224
	size:      sizeBoolSlice,
225
	marshal:   appendBoolSlice,
226
	unmarshal: consumeBoolSlice,
227
	merge:     mergeBoolSlice,
228
}
229

230
// sizeBoolPackedSlice returns the size of wire encoding a []bool pointer as a packed repeated Bool.
231
func sizeBoolPackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
232
	s := *p.BoolSlice()
233
	if len(s) == 0 {
234
		return 0
235
	}
236
	n := 0
237
	for _, v := range s {
238
		n += protowire.SizeVarint(protowire.EncodeBool(v))
239
	}
240
	return f.tagsize + protowire.SizeBytes(n)
241
}
242

243
// appendBoolPackedSlice encodes a []bool pointer as a packed repeated Bool.
244
func appendBoolPackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
245
	s := *p.BoolSlice()
246
	if len(s) == 0 {
247
		return b, nil
248
	}
249
	b = protowire.AppendVarint(b, f.wiretag)
250
	n := 0
251
	for _, v := range s {
252
		n += protowire.SizeVarint(protowire.EncodeBool(v))
253
	}
254
	b = protowire.AppendVarint(b, uint64(n))
255
	for _, v := range s {
256
		b = protowire.AppendVarint(b, protowire.EncodeBool(v))
257
	}
258
	return b, nil
259
}
260

261
var coderBoolPackedSlice = pointerCoderFuncs{
262
	size:      sizeBoolPackedSlice,
263
	marshal:   appendBoolPackedSlice,
264
	unmarshal: consumeBoolSlice,
265
	merge:     mergeBoolSlice,
266
}
267

268
// sizeBoolValue returns the size of wire encoding a bool value as a Bool.
269
func sizeBoolValue(v protoreflect.Value, tagsize int, opts marshalOptions) int {
270
	return tagsize + protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
271
}
272

273
// appendBoolValue encodes a bool value as a Bool.
274
func appendBoolValue(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
275
	b = protowire.AppendVarint(b, wiretag)
276
	b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
277
	return b, nil
278
}
279

280
// consumeBoolValue decodes a bool value as a Bool.
281
func consumeBoolValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
282
	if wtyp != protowire.VarintType {
283
		return protoreflect.Value{}, out, errUnknown
284
	}
285
	var v uint64
286
	var n int
287
	if len(b) >= 1 && b[0] < 0x80 {
288
		v = uint64(b[0])
289
		n = 1
290
	} else if len(b) >= 2 && b[1] < 128 {
291
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
292
		n = 2
293
	} else {
294
		v, n = protowire.ConsumeVarint(b)
295
	}
296
	if n < 0 {
297
		return protoreflect.Value{}, out, errDecode
298
	}
299
	out.n = n
300
	return protoreflect.ValueOfBool(protowire.DecodeBool(v)), out, nil
301
}
302

303
var coderBoolValue = valueCoderFuncs{
304
	size:      sizeBoolValue,
305
	marshal:   appendBoolValue,
306
	unmarshal: consumeBoolValue,
307
	merge:     mergeScalarValue,
308
}
309

310
// sizeBoolSliceValue returns the size of wire encoding a []bool value as a repeated Bool.
311
func sizeBoolSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
312
	list := listv.List()
313
	for i, llen := 0, list.Len(); i < llen; i++ {
314
		v := list.Get(i)
315
		size += tagsize + protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
316
	}
317
	return size
318
}
319

320
// appendBoolSliceValue encodes a []bool value as a repeated Bool.
321
func appendBoolSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
322
	list := listv.List()
323
	for i, llen := 0, list.Len(); i < llen; i++ {
324
		v := list.Get(i)
325
		b = protowire.AppendVarint(b, wiretag)
326
		b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
327
	}
328
	return b, nil
329
}
330

331
// consumeBoolSliceValue wire decodes a []bool value as a repeated Bool.
332
func consumeBoolSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
333
	list := listv.List()
334
	if wtyp == protowire.BytesType {
335
		b, n := protowire.ConsumeBytes(b)
336
		if n < 0 {
337
			return protoreflect.Value{}, out, errDecode
338
		}
339
		for len(b) > 0 {
340
			var v uint64
341
			var n int
342
			if len(b) >= 1 && b[0] < 0x80 {
343
				v = uint64(b[0])
344
				n = 1
345
			} else if len(b) >= 2 && b[1] < 128 {
346
				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
347
				n = 2
348
			} else {
349
				v, n = protowire.ConsumeVarint(b)
350
			}
351
			if n < 0 {
352
				return protoreflect.Value{}, out, errDecode
353
			}
354
			list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
355
			b = b[n:]
356
		}
357
		out.n = n
358
		return listv, out, nil
359
	}
360
	if wtyp != protowire.VarintType {
361
		return protoreflect.Value{}, out, errUnknown
362
	}
363
	var v uint64
364
	var n int
365
	if len(b) >= 1 && b[0] < 0x80 {
366
		v = uint64(b[0])
367
		n = 1
368
	} else if len(b) >= 2 && b[1] < 128 {
369
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
370
		n = 2
371
	} else {
372
		v, n = protowire.ConsumeVarint(b)
373
	}
374
	if n < 0 {
375
		return protoreflect.Value{}, out, errDecode
376
	}
377
	list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
378
	out.n = n
379
	return listv, out, nil
380
}
381

382
var coderBoolSliceValue = valueCoderFuncs{
383
	size:      sizeBoolSliceValue,
384
	marshal:   appendBoolSliceValue,
385
	unmarshal: consumeBoolSliceValue,
386
	merge:     mergeListValue,
387
}
388

389
// sizeBoolPackedSliceValue returns the size of wire encoding a []bool value as a packed repeated Bool.
390
func sizeBoolPackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
391
	list := listv.List()
392
	llen := list.Len()
393
	if llen == 0 {
394
		return 0
395
	}
396
	n := 0
397
	for i, llen := 0, llen; i < llen; i++ {
398
		v := list.Get(i)
399
		n += protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
400
	}
401
	return tagsize + protowire.SizeBytes(n)
402
}
403

404
// appendBoolPackedSliceValue encodes a []bool value as a packed repeated Bool.
405
func appendBoolPackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
406
	list := listv.List()
407
	llen := list.Len()
408
	if llen == 0 {
409
		return b, nil
410
	}
411
	b = protowire.AppendVarint(b, wiretag)
412
	n := 0
413
	for i := 0; i < llen; i++ {
414
		v := list.Get(i)
415
		n += protowire.SizeVarint(protowire.EncodeBool(v.Bool()))
416
	}
417
	b = protowire.AppendVarint(b, uint64(n))
418
	for i := 0; i < llen; i++ {
419
		v := list.Get(i)
420
		b = protowire.AppendVarint(b, protowire.EncodeBool(v.Bool()))
421
	}
422
	return b, nil
423
}
424

425
var coderBoolPackedSliceValue = valueCoderFuncs{
426
	size:      sizeBoolPackedSliceValue,
427
	marshal:   appendBoolPackedSliceValue,
428
	unmarshal: consumeBoolSliceValue,
429
	merge:     mergeListValue,
430
}
431

432
// sizeEnumValue returns the size of wire encoding a  value as a Enum.
433
func sizeEnumValue(v protoreflect.Value, tagsize int, opts marshalOptions) int {
434
	return tagsize + protowire.SizeVarint(uint64(v.Enum()))
435
}
436

437
// appendEnumValue encodes a  value as a Enum.
438
func appendEnumValue(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
439
	b = protowire.AppendVarint(b, wiretag)
440
	b = protowire.AppendVarint(b, uint64(v.Enum()))
441
	return b, nil
442
}
443

444
// consumeEnumValue decodes a  value as a Enum.
445
func consumeEnumValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
446
	if wtyp != protowire.VarintType {
447
		return protoreflect.Value{}, out, errUnknown
448
	}
449
	var v uint64
450
	var n int
451
	if len(b) >= 1 && b[0] < 0x80 {
452
		v = uint64(b[0])
453
		n = 1
454
	} else if len(b) >= 2 && b[1] < 128 {
455
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
456
		n = 2
457
	} else {
458
		v, n = protowire.ConsumeVarint(b)
459
	}
460
	if n < 0 {
461
		return protoreflect.Value{}, out, errDecode
462
	}
463
	out.n = n
464
	return protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)), out, nil
465
}
466

467
var coderEnumValue = valueCoderFuncs{
468
	size:      sizeEnumValue,
469
	marshal:   appendEnumValue,
470
	unmarshal: consumeEnumValue,
471
	merge:     mergeScalarValue,
472
}
473

474
// sizeEnumSliceValue returns the size of wire encoding a [] value as a repeated Enum.
475
func sizeEnumSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
476
	list := listv.List()
477
	for i, llen := 0, list.Len(); i < llen; i++ {
478
		v := list.Get(i)
479
		size += tagsize + protowire.SizeVarint(uint64(v.Enum()))
480
	}
481
	return size
482
}
483

484
// appendEnumSliceValue encodes a [] value as a repeated Enum.
485
func appendEnumSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
486
	list := listv.List()
487
	for i, llen := 0, list.Len(); i < llen; i++ {
488
		v := list.Get(i)
489
		b = protowire.AppendVarint(b, wiretag)
490
		b = protowire.AppendVarint(b, uint64(v.Enum()))
491
	}
492
	return b, nil
493
}
494

495
// consumeEnumSliceValue wire decodes a [] value as a repeated Enum.
496
func consumeEnumSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
497
	list := listv.List()
498
	if wtyp == protowire.BytesType {
499
		b, n := protowire.ConsumeBytes(b)
500
		if n < 0 {
501
			return protoreflect.Value{}, out, errDecode
502
		}
503
		for len(b) > 0 {
504
			var v uint64
505
			var n int
506
			if len(b) >= 1 && b[0] < 0x80 {
507
				v = uint64(b[0])
508
				n = 1
509
			} else if len(b) >= 2 && b[1] < 128 {
510
				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
511
				n = 2
512
			} else {
513
				v, n = protowire.ConsumeVarint(b)
514
			}
515
			if n < 0 {
516
				return protoreflect.Value{}, out, errDecode
517
			}
518
			list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
519
			b = b[n:]
520
		}
521
		out.n = n
522
		return listv, out, nil
523
	}
524
	if wtyp != protowire.VarintType {
525
		return protoreflect.Value{}, out, errUnknown
526
	}
527
	var v uint64
528
	var n int
529
	if len(b) >= 1 && b[0] < 0x80 {
530
		v = uint64(b[0])
531
		n = 1
532
	} else if len(b) >= 2 && b[1] < 128 {
533
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
534
		n = 2
535
	} else {
536
		v, n = protowire.ConsumeVarint(b)
537
	}
538
	if n < 0 {
539
		return protoreflect.Value{}, out, errDecode
540
	}
541
	list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
542
	out.n = n
543
	return listv, out, nil
544
}
545

546
var coderEnumSliceValue = valueCoderFuncs{
547
	size:      sizeEnumSliceValue,
548
	marshal:   appendEnumSliceValue,
549
	unmarshal: consumeEnumSliceValue,
550
	merge:     mergeListValue,
551
}
552

553
// sizeEnumPackedSliceValue returns the size of wire encoding a [] value as a packed repeated Enum.
554
func sizeEnumPackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
555
	list := listv.List()
556
	llen := list.Len()
557
	if llen == 0 {
558
		return 0
559
	}
560
	n := 0
561
	for i, llen := 0, llen; i < llen; i++ {
562
		v := list.Get(i)
563
		n += protowire.SizeVarint(uint64(v.Enum()))
564
	}
565
	return tagsize + protowire.SizeBytes(n)
566
}
567

568
// appendEnumPackedSliceValue encodes a [] value as a packed repeated Enum.
569
func appendEnumPackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
570
	list := listv.List()
571
	llen := list.Len()
572
	if llen == 0 {
573
		return b, nil
574
	}
575
	b = protowire.AppendVarint(b, wiretag)
576
	n := 0
577
	for i := 0; i < llen; i++ {
578
		v := list.Get(i)
579
		n += protowire.SizeVarint(uint64(v.Enum()))
580
	}
581
	b = protowire.AppendVarint(b, uint64(n))
582
	for i := 0; i < llen; i++ {
583
		v := list.Get(i)
584
		b = protowire.AppendVarint(b, uint64(v.Enum()))
585
	}
586
	return b, nil
587
}
588

589
var coderEnumPackedSliceValue = valueCoderFuncs{
590
	size:      sizeEnumPackedSliceValue,
591
	marshal:   appendEnumPackedSliceValue,
592
	unmarshal: consumeEnumSliceValue,
593
	merge:     mergeListValue,
594
}
595

596
// sizeInt32 returns the size of wire encoding a int32 pointer as a Int32.
597
func sizeInt32(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
598
	v := *p.Int32()
599
	return f.tagsize + protowire.SizeVarint(uint64(v))
600
}
601

602
// appendInt32 wire encodes a int32 pointer as a Int32.
603
func appendInt32(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
604
	v := *p.Int32()
605
	b = protowire.AppendVarint(b, f.wiretag)
606
	b = protowire.AppendVarint(b, uint64(v))
607
	return b, nil
608
}
609

610
// consumeInt32 wire decodes a int32 pointer as a Int32.
611
func consumeInt32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
612
	if wtyp != protowire.VarintType {
613
		return out, errUnknown
614
	}
615
	var v uint64
616
	var n int
617
	if len(b) >= 1 && b[0] < 0x80 {
618
		v = uint64(b[0])
619
		n = 1
620
	} else if len(b) >= 2 && b[1] < 128 {
621
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
622
		n = 2
623
	} else {
624
		v, n = protowire.ConsumeVarint(b)
625
	}
626
	if n < 0 {
627
		return out, errDecode
628
	}
629
	*p.Int32() = int32(v)
630
	out.n = n
631
	return out, nil
632
}
633

634
var coderInt32 = pointerCoderFuncs{
635
	size:      sizeInt32,
636
	marshal:   appendInt32,
637
	unmarshal: consumeInt32,
638
	merge:     mergeInt32,
639
}
640

641
// sizeInt32NoZero returns the size of wire encoding a int32 pointer as a Int32.
642
// The zero value is not encoded.
643
func sizeInt32NoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
644
	v := *p.Int32()
645
	if v == 0 {
646
		return 0
647
	}
648
	return f.tagsize + protowire.SizeVarint(uint64(v))
649
}
650

651
// appendInt32NoZero wire encodes a int32 pointer as a Int32.
652
// The zero value is not encoded.
653
func appendInt32NoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
654
	v := *p.Int32()
655
	if v == 0 {
656
		return b, nil
657
	}
658
	b = protowire.AppendVarint(b, f.wiretag)
659
	b = protowire.AppendVarint(b, uint64(v))
660
	return b, nil
661
}
662

663
var coderInt32NoZero = pointerCoderFuncs{
664
	size:      sizeInt32NoZero,
665
	marshal:   appendInt32NoZero,
666
	unmarshal: consumeInt32,
667
	merge:     mergeInt32NoZero,
668
}
669

670
// sizeInt32Ptr returns the size of wire encoding a *int32 pointer as a Int32.
671
// It panics if the pointer is nil.
672
func sizeInt32Ptr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
673
	v := **p.Int32Ptr()
674
	return f.tagsize + protowire.SizeVarint(uint64(v))
675
}
676

677
// appendInt32Ptr wire encodes a *int32 pointer as a Int32.
678
// It panics if the pointer is nil.
679
func appendInt32Ptr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
680
	v := **p.Int32Ptr()
681
	b = protowire.AppendVarint(b, f.wiretag)
682
	b = protowire.AppendVarint(b, uint64(v))
683
	return b, nil
684
}
685

686
// consumeInt32Ptr wire decodes a *int32 pointer as a Int32.
687
func consumeInt32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
688
	if wtyp != protowire.VarintType {
689
		return out, errUnknown
690
	}
691
	var v uint64
692
	var n int
693
	if len(b) >= 1 && b[0] < 0x80 {
694
		v = uint64(b[0])
695
		n = 1
696
	} else if len(b) >= 2 && b[1] < 128 {
697
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
698
		n = 2
699
	} else {
700
		v, n = protowire.ConsumeVarint(b)
701
	}
702
	if n < 0 {
703
		return out, errDecode
704
	}
705
	vp := p.Int32Ptr()
706
	if *vp == nil {
707
		*vp = new(int32)
708
	}
709
	**vp = int32(v)
710
	out.n = n
711
	return out, nil
712
}
713

714
var coderInt32Ptr = pointerCoderFuncs{
715
	size:      sizeInt32Ptr,
716
	marshal:   appendInt32Ptr,
717
	unmarshal: consumeInt32Ptr,
718
	merge:     mergeInt32Ptr,
719
}
720

721
// sizeInt32Slice returns the size of wire encoding a []int32 pointer as a repeated Int32.
722
func sizeInt32Slice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
723
	s := *p.Int32Slice()
724
	for _, v := range s {
725
		size += f.tagsize + protowire.SizeVarint(uint64(v))
726
	}
727
	return size
728
}
729

730
// appendInt32Slice encodes a []int32 pointer as a repeated Int32.
731
func appendInt32Slice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
732
	s := *p.Int32Slice()
733
	for _, v := range s {
734
		b = protowire.AppendVarint(b, f.wiretag)
735
		b = protowire.AppendVarint(b, uint64(v))
736
	}
737
	return b, nil
738
}
739

740
// consumeInt32Slice wire decodes a []int32 pointer as a repeated Int32.
741
func consumeInt32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
742
	sp := p.Int32Slice()
743
	if wtyp == protowire.BytesType {
744
		b, n := protowire.ConsumeBytes(b)
745
		if n < 0 {
746
			return out, errDecode
747
		}
748
		count := 0
749
		for _, v := range b {
750
			if v < 0x80 {
751
				count++
752
			}
753
		}
754
		if count > 0 {
755
			p.growInt32Slice(count)
756
		}
757
		s := *sp
758
		for len(b) > 0 {
759
			var v uint64
760
			var n int
761
			if len(b) >= 1 && b[0] < 0x80 {
762
				v = uint64(b[0])
763
				n = 1
764
			} else if len(b) >= 2 && b[1] < 128 {
765
				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
766
				n = 2
767
			} else {
768
				v, n = protowire.ConsumeVarint(b)
769
			}
770
			if n < 0 {
771
				return out, errDecode
772
			}
773
			s = append(s, int32(v))
774
			b = b[n:]
775
		}
776
		*sp = s
777
		out.n = n
778
		return out, nil
779
	}
780
	if wtyp != protowire.VarintType {
781
		return out, errUnknown
782
	}
783
	var v uint64
784
	var n int
785
	if len(b) >= 1 && b[0] < 0x80 {
786
		v = uint64(b[0])
787
		n = 1
788
	} else if len(b) >= 2 && b[1] < 128 {
789
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
790
		n = 2
791
	} else {
792
		v, n = protowire.ConsumeVarint(b)
793
	}
794
	if n < 0 {
795
		return out, errDecode
796
	}
797
	*sp = append(*sp, int32(v))
798
	out.n = n
799
	return out, nil
800
}
801

802
var coderInt32Slice = pointerCoderFuncs{
803
	size:      sizeInt32Slice,
804
	marshal:   appendInt32Slice,
805
	unmarshal: consumeInt32Slice,
806
	merge:     mergeInt32Slice,
807
}
808

809
// sizeInt32PackedSlice returns the size of wire encoding a []int32 pointer as a packed repeated Int32.
810
func sizeInt32PackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
811
	s := *p.Int32Slice()
812
	if len(s) == 0 {
813
		return 0
814
	}
815
	n := 0
816
	for _, v := range s {
817
		n += protowire.SizeVarint(uint64(v))
818
	}
819
	return f.tagsize + protowire.SizeBytes(n)
820
}
821

822
// appendInt32PackedSlice encodes a []int32 pointer as a packed repeated Int32.
823
func appendInt32PackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
824
	s := *p.Int32Slice()
825
	if len(s) == 0 {
826
		return b, nil
827
	}
828
	b = protowire.AppendVarint(b, f.wiretag)
829
	n := 0
830
	for _, v := range s {
831
		n += protowire.SizeVarint(uint64(v))
832
	}
833
	b = protowire.AppendVarint(b, uint64(n))
834
	for _, v := range s {
835
		b = protowire.AppendVarint(b, uint64(v))
836
	}
837
	return b, nil
838
}
839

840
var coderInt32PackedSlice = pointerCoderFuncs{
841
	size:      sizeInt32PackedSlice,
842
	marshal:   appendInt32PackedSlice,
843
	unmarshal: consumeInt32Slice,
844
	merge:     mergeInt32Slice,
845
}
846

847
// sizeInt32Value returns the size of wire encoding a int32 value as a Int32.
848
func sizeInt32Value(v protoreflect.Value, tagsize int, opts marshalOptions) int {
849
	return tagsize + protowire.SizeVarint(uint64(int32(v.Int())))
850
}
851

852
// appendInt32Value encodes a int32 value as a Int32.
853
func appendInt32Value(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
854
	b = protowire.AppendVarint(b, wiretag)
855
	b = protowire.AppendVarint(b, uint64(int32(v.Int())))
856
	return b, nil
857
}
858

859
// consumeInt32Value decodes a int32 value as a Int32.
860
func consumeInt32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
861
	if wtyp != protowire.VarintType {
862
		return protoreflect.Value{}, out, errUnknown
863
	}
864
	var v uint64
865
	var n int
866
	if len(b) >= 1 && b[0] < 0x80 {
867
		v = uint64(b[0])
868
		n = 1
869
	} else if len(b) >= 2 && b[1] < 128 {
870
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
871
		n = 2
872
	} else {
873
		v, n = protowire.ConsumeVarint(b)
874
	}
875
	if n < 0 {
876
		return protoreflect.Value{}, out, errDecode
877
	}
878
	out.n = n
879
	return protoreflect.ValueOfInt32(int32(v)), out, nil
880
}
881

882
var coderInt32Value = valueCoderFuncs{
883
	size:      sizeInt32Value,
884
	marshal:   appendInt32Value,
885
	unmarshal: consumeInt32Value,
886
	merge:     mergeScalarValue,
887
}
888

889
// sizeInt32SliceValue returns the size of wire encoding a []int32 value as a repeated Int32.
890
func sizeInt32SliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
891
	list := listv.List()
892
	for i, llen := 0, list.Len(); i < llen; i++ {
893
		v := list.Get(i)
894
		size += tagsize + protowire.SizeVarint(uint64(int32(v.Int())))
895
	}
896
	return size
897
}
898

899
// appendInt32SliceValue encodes a []int32 value as a repeated Int32.
900
func appendInt32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
901
	list := listv.List()
902
	for i, llen := 0, list.Len(); i < llen; i++ {
903
		v := list.Get(i)
904
		b = protowire.AppendVarint(b, wiretag)
905
		b = protowire.AppendVarint(b, uint64(int32(v.Int())))
906
	}
907
	return b, nil
908
}
909

910
// consumeInt32SliceValue wire decodes a []int32 value as a repeated Int32.
911
func consumeInt32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
912
	list := listv.List()
913
	if wtyp == protowire.BytesType {
914
		b, n := protowire.ConsumeBytes(b)
915
		if n < 0 {
916
			return protoreflect.Value{}, out, errDecode
917
		}
918
		for len(b) > 0 {
919
			var v uint64
920
			var n int
921
			if len(b) >= 1 && b[0] < 0x80 {
922
				v = uint64(b[0])
923
				n = 1
924
			} else if len(b) >= 2 && b[1] < 128 {
925
				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
926
				n = 2
927
			} else {
928
				v, n = protowire.ConsumeVarint(b)
929
			}
930
			if n < 0 {
931
				return protoreflect.Value{}, out, errDecode
932
			}
933
			list.Append(protoreflect.ValueOfInt32(int32(v)))
934
			b = b[n:]
935
		}
936
		out.n = n
937
		return listv, out, nil
938
	}
939
	if wtyp != protowire.VarintType {
940
		return protoreflect.Value{}, out, errUnknown
941
	}
942
	var v uint64
943
	var n int
944
	if len(b) >= 1 && b[0] < 0x80 {
945
		v = uint64(b[0])
946
		n = 1
947
	} else if len(b) >= 2 && b[1] < 128 {
948
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
949
		n = 2
950
	} else {
951
		v, n = protowire.ConsumeVarint(b)
952
	}
953
	if n < 0 {
954
		return protoreflect.Value{}, out, errDecode
955
	}
956
	list.Append(protoreflect.ValueOfInt32(int32(v)))
957
	out.n = n
958
	return listv, out, nil
959
}
960

961
var coderInt32SliceValue = valueCoderFuncs{
962
	size:      sizeInt32SliceValue,
963
	marshal:   appendInt32SliceValue,
964
	unmarshal: consumeInt32SliceValue,
965
	merge:     mergeListValue,
966
}
967

968
// sizeInt32PackedSliceValue returns the size of wire encoding a []int32 value as a packed repeated Int32.
969
func sizeInt32PackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
970
	list := listv.List()
971
	llen := list.Len()
972
	if llen == 0 {
973
		return 0
974
	}
975
	n := 0
976
	for i, llen := 0, llen; i < llen; i++ {
977
		v := list.Get(i)
978
		n += protowire.SizeVarint(uint64(int32(v.Int())))
979
	}
980
	return tagsize + protowire.SizeBytes(n)
981
}
982

983
// appendInt32PackedSliceValue encodes a []int32 value as a packed repeated Int32.
984
func appendInt32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
985
	list := listv.List()
986
	llen := list.Len()
987
	if llen == 0 {
988
		return b, nil
989
	}
990
	b = protowire.AppendVarint(b, wiretag)
991
	n := 0
992
	for i := 0; i < llen; i++ {
993
		v := list.Get(i)
994
		n += protowire.SizeVarint(uint64(int32(v.Int())))
995
	}
996
	b = protowire.AppendVarint(b, uint64(n))
997
	for i := 0; i < llen; i++ {
998
		v := list.Get(i)
999
		b = protowire.AppendVarint(b, uint64(int32(v.Int())))
1000
	}
1001
	return b, nil
1002
}
1003

1004
var coderInt32PackedSliceValue = valueCoderFuncs{
1005
	size:      sizeInt32PackedSliceValue,
1006
	marshal:   appendInt32PackedSliceValue,
1007
	unmarshal: consumeInt32SliceValue,
1008
	merge:     mergeListValue,
1009
}
1010

1011
// sizeSint32 returns the size of wire encoding a int32 pointer as a Sint32.
1012
func sizeSint32(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
1013
	v := *p.Int32()
1014
	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
1015
}
1016

1017
// appendSint32 wire encodes a int32 pointer as a Sint32.
1018
func appendSint32(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
1019
	v := *p.Int32()
1020
	b = protowire.AppendVarint(b, f.wiretag)
1021
	b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
1022
	return b, nil
1023
}
1024

1025
// consumeSint32 wire decodes a int32 pointer as a Sint32.
1026
func consumeSint32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
1027
	if wtyp != protowire.VarintType {
1028
		return out, errUnknown
1029
	}
1030
	var v uint64
1031
	var n int
1032
	if len(b) >= 1 && b[0] < 0x80 {
1033
		v = uint64(b[0])
1034
		n = 1
1035
	} else if len(b) >= 2 && b[1] < 128 {
1036
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
1037
		n = 2
1038
	} else {
1039
		v, n = protowire.ConsumeVarint(b)
1040
	}
1041
	if n < 0 {
1042
		return out, errDecode
1043
	}
1044
	*p.Int32() = int32(protowire.DecodeZigZag(v & math.MaxUint32))
1045
	out.n = n
1046
	return out, nil
1047
}
1048

1049
var coderSint32 = pointerCoderFuncs{
1050
	size:      sizeSint32,
1051
	marshal:   appendSint32,
1052
	unmarshal: consumeSint32,
1053
	merge:     mergeInt32,
1054
}
1055

1056
// sizeSint32NoZero returns the size of wire encoding a int32 pointer as a Sint32.
1057
// The zero value is not encoded.
1058
func sizeSint32NoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
1059
	v := *p.Int32()
1060
	if v == 0 {
1061
		return 0
1062
	}
1063
	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
1064
}
1065

1066
// appendSint32NoZero wire encodes a int32 pointer as a Sint32.
1067
// The zero value is not encoded.
1068
func appendSint32NoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
1069
	v := *p.Int32()
1070
	if v == 0 {
1071
		return b, nil
1072
	}
1073
	b = protowire.AppendVarint(b, f.wiretag)
1074
	b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
1075
	return b, nil
1076
}
1077

1078
var coderSint32NoZero = pointerCoderFuncs{
1079
	size:      sizeSint32NoZero,
1080
	marshal:   appendSint32NoZero,
1081
	unmarshal: consumeSint32,
1082
	merge:     mergeInt32NoZero,
1083
}
1084

1085
// sizeSint32Ptr returns the size of wire encoding a *int32 pointer as a Sint32.
1086
// It panics if the pointer is nil.
1087
func sizeSint32Ptr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
1088
	v := **p.Int32Ptr()
1089
	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
1090
}
1091

1092
// appendSint32Ptr wire encodes a *int32 pointer as a Sint32.
1093
// It panics if the pointer is nil.
1094
func appendSint32Ptr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
1095
	v := **p.Int32Ptr()
1096
	b = protowire.AppendVarint(b, f.wiretag)
1097
	b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
1098
	return b, nil
1099
}
1100

1101
// consumeSint32Ptr wire decodes a *int32 pointer as a Sint32.
1102
func consumeSint32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
1103
	if wtyp != protowire.VarintType {
1104
		return out, errUnknown
1105
	}
1106
	var v uint64
1107
	var n int
1108
	if len(b) >= 1 && b[0] < 0x80 {
1109
		v = uint64(b[0])
1110
		n = 1
1111
	} else if len(b) >= 2 && b[1] < 128 {
1112
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
1113
		n = 2
1114
	} else {
1115
		v, n = protowire.ConsumeVarint(b)
1116
	}
1117
	if n < 0 {
1118
		return out, errDecode
1119
	}
1120
	vp := p.Int32Ptr()
1121
	if *vp == nil {
1122
		*vp = new(int32)
1123
	}
1124
	**vp = int32(protowire.DecodeZigZag(v & math.MaxUint32))
1125
	out.n = n
1126
	return out, nil
1127
}
1128

1129
var coderSint32Ptr = pointerCoderFuncs{
1130
	size:      sizeSint32Ptr,
1131
	marshal:   appendSint32Ptr,
1132
	unmarshal: consumeSint32Ptr,
1133
	merge:     mergeInt32Ptr,
1134
}
1135

1136
// sizeSint32Slice returns the size of wire encoding a []int32 pointer as a repeated Sint32.
1137
func sizeSint32Slice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
1138
	s := *p.Int32Slice()
1139
	for _, v := range s {
1140
		size += f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
1141
	}
1142
	return size
1143
}
1144

1145
// appendSint32Slice encodes a []int32 pointer as a repeated Sint32.
1146
func appendSint32Slice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
1147
	s := *p.Int32Slice()
1148
	for _, v := range s {
1149
		b = protowire.AppendVarint(b, f.wiretag)
1150
		b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
1151
	}
1152
	return b, nil
1153
}
1154

1155
// consumeSint32Slice wire decodes a []int32 pointer as a repeated Sint32.
1156
func consumeSint32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
1157
	sp := p.Int32Slice()
1158
	if wtyp == protowire.BytesType {
1159
		b, n := protowire.ConsumeBytes(b)
1160
		if n < 0 {
1161
			return out, errDecode
1162
		}
1163
		count := 0
1164
		for _, v := range b {
1165
			if v < 0x80 {
1166
				count++
1167
			}
1168
		}
1169
		if count > 0 {
1170
			p.growInt32Slice(count)
1171
		}
1172
		s := *sp
1173
		for len(b) > 0 {
1174
			var v uint64
1175
			var n int
1176
			if len(b) >= 1 && b[0] < 0x80 {
1177
				v = uint64(b[0])
1178
				n = 1
1179
			} else if len(b) >= 2 && b[1] < 128 {
1180
				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
1181
				n = 2
1182
			} else {
1183
				v, n = protowire.ConsumeVarint(b)
1184
			}
1185
			if n < 0 {
1186
				return out, errDecode
1187
			}
1188
			s = append(s, int32(protowire.DecodeZigZag(v&math.MaxUint32)))
1189
			b = b[n:]
1190
		}
1191
		*sp = s
1192
		out.n = n
1193
		return out, nil
1194
	}
1195
	if wtyp != protowire.VarintType {
1196
		return out, errUnknown
1197
	}
1198
	var v uint64
1199
	var n int
1200
	if len(b) >= 1 && b[0] < 0x80 {
1201
		v = uint64(b[0])
1202
		n = 1
1203
	} else if len(b) >= 2 && b[1] < 128 {
1204
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
1205
		n = 2
1206
	} else {
1207
		v, n = protowire.ConsumeVarint(b)
1208
	}
1209
	if n < 0 {
1210
		return out, errDecode
1211
	}
1212
	*sp = append(*sp, int32(protowire.DecodeZigZag(v&math.MaxUint32)))
1213
	out.n = n
1214
	return out, nil
1215
}
1216

1217
var coderSint32Slice = pointerCoderFuncs{
1218
	size:      sizeSint32Slice,
1219
	marshal:   appendSint32Slice,
1220
	unmarshal: consumeSint32Slice,
1221
	merge:     mergeInt32Slice,
1222
}
1223

1224
// sizeSint32PackedSlice returns the size of wire encoding a []int32 pointer as a packed repeated Sint32.
1225
func sizeSint32PackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
1226
	s := *p.Int32Slice()
1227
	if len(s) == 0 {
1228
		return 0
1229
	}
1230
	n := 0
1231
	for _, v := range s {
1232
		n += protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
1233
	}
1234
	return f.tagsize + protowire.SizeBytes(n)
1235
}
1236

1237
// appendSint32PackedSlice encodes a []int32 pointer as a packed repeated Sint32.
1238
func appendSint32PackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
1239
	s := *p.Int32Slice()
1240
	if len(s) == 0 {
1241
		return b, nil
1242
	}
1243
	b = protowire.AppendVarint(b, f.wiretag)
1244
	n := 0
1245
	for _, v := range s {
1246
		n += protowire.SizeVarint(protowire.EncodeZigZag(int64(v)))
1247
	}
1248
	b = protowire.AppendVarint(b, uint64(n))
1249
	for _, v := range s {
1250
		b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(v)))
1251
	}
1252
	return b, nil
1253
}
1254

1255
var coderSint32PackedSlice = pointerCoderFuncs{
1256
	size:      sizeSint32PackedSlice,
1257
	marshal:   appendSint32PackedSlice,
1258
	unmarshal: consumeSint32Slice,
1259
	merge:     mergeInt32Slice,
1260
}
1261

1262
// sizeSint32Value returns the size of wire encoding a int32 value as a Sint32.
1263
func sizeSint32Value(v protoreflect.Value, tagsize int, opts marshalOptions) int {
1264
	return tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
1265
}
1266

1267
// appendSint32Value encodes a int32 value as a Sint32.
1268
func appendSint32Value(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
1269
	b = protowire.AppendVarint(b, wiretag)
1270
	b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
1271
	return b, nil
1272
}
1273

1274
// consumeSint32Value decodes a int32 value as a Sint32.
1275
func consumeSint32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
1276
	if wtyp != protowire.VarintType {
1277
		return protoreflect.Value{}, out, errUnknown
1278
	}
1279
	var v uint64
1280
	var n int
1281
	if len(b) >= 1 && b[0] < 0x80 {
1282
		v = uint64(b[0])
1283
		n = 1
1284
	} else if len(b) >= 2 && b[1] < 128 {
1285
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
1286
		n = 2
1287
	} else {
1288
		v, n = protowire.ConsumeVarint(b)
1289
	}
1290
	if n < 0 {
1291
		return protoreflect.Value{}, out, errDecode
1292
	}
1293
	out.n = n
1294
	return protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))), out, nil
1295
}
1296

1297
var coderSint32Value = valueCoderFuncs{
1298
	size:      sizeSint32Value,
1299
	marshal:   appendSint32Value,
1300
	unmarshal: consumeSint32Value,
1301
	merge:     mergeScalarValue,
1302
}
1303

1304
// sizeSint32SliceValue returns the size of wire encoding a []int32 value as a repeated Sint32.
1305
func sizeSint32SliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
1306
	list := listv.List()
1307
	for i, llen := 0, list.Len(); i < llen; i++ {
1308
		v := list.Get(i)
1309
		size += tagsize + protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
1310
	}
1311
	return size
1312
}
1313

1314
// appendSint32SliceValue encodes a []int32 value as a repeated Sint32.
1315
func appendSint32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
1316
	list := listv.List()
1317
	for i, llen := 0, list.Len(); i < llen; i++ {
1318
		v := list.Get(i)
1319
		b = protowire.AppendVarint(b, wiretag)
1320
		b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
1321
	}
1322
	return b, nil
1323
}
1324

1325
// consumeSint32SliceValue wire decodes a []int32 value as a repeated Sint32.
1326
func consumeSint32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
1327
	list := listv.List()
1328
	if wtyp == protowire.BytesType {
1329
		b, n := protowire.ConsumeBytes(b)
1330
		if n < 0 {
1331
			return protoreflect.Value{}, out, errDecode
1332
		}
1333
		for len(b) > 0 {
1334
			var v uint64
1335
			var n int
1336
			if len(b) >= 1 && b[0] < 0x80 {
1337
				v = uint64(b[0])
1338
				n = 1
1339
			} else if len(b) >= 2 && b[1] < 128 {
1340
				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
1341
				n = 2
1342
			} else {
1343
				v, n = protowire.ConsumeVarint(b)
1344
			}
1345
			if n < 0 {
1346
				return protoreflect.Value{}, out, errDecode
1347
			}
1348
			list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
1349
			b = b[n:]
1350
		}
1351
		out.n = n
1352
		return listv, out, nil
1353
	}
1354
	if wtyp != protowire.VarintType {
1355
		return protoreflect.Value{}, out, errUnknown
1356
	}
1357
	var v uint64
1358
	var n int
1359
	if len(b) >= 1 && b[0] < 0x80 {
1360
		v = uint64(b[0])
1361
		n = 1
1362
	} else if len(b) >= 2 && b[1] < 128 {
1363
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
1364
		n = 2
1365
	} else {
1366
		v, n = protowire.ConsumeVarint(b)
1367
	}
1368
	if n < 0 {
1369
		return protoreflect.Value{}, out, errDecode
1370
	}
1371
	list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
1372
	out.n = n
1373
	return listv, out, nil
1374
}
1375

1376
var coderSint32SliceValue = valueCoderFuncs{
1377
	size:      sizeSint32SliceValue,
1378
	marshal:   appendSint32SliceValue,
1379
	unmarshal: consumeSint32SliceValue,
1380
	merge:     mergeListValue,
1381
}
1382

1383
// sizeSint32PackedSliceValue returns the size of wire encoding a []int32 value as a packed repeated Sint32.
1384
func sizeSint32PackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
1385
	list := listv.List()
1386
	llen := list.Len()
1387
	if llen == 0 {
1388
		return 0
1389
	}
1390
	n := 0
1391
	for i, llen := 0, llen; i < llen; i++ {
1392
		v := list.Get(i)
1393
		n += protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
1394
	}
1395
	return tagsize + protowire.SizeBytes(n)
1396
}
1397

1398
// appendSint32PackedSliceValue encodes a []int32 value as a packed repeated Sint32.
1399
func appendSint32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
1400
	list := listv.List()
1401
	llen := list.Len()
1402
	if llen == 0 {
1403
		return b, nil
1404
	}
1405
	b = protowire.AppendVarint(b, wiretag)
1406
	n := 0
1407
	for i := 0; i < llen; i++ {
1408
		v := list.Get(i)
1409
		n += protowire.SizeVarint(protowire.EncodeZigZag(int64(int32(v.Int()))))
1410
	}
1411
	b = protowire.AppendVarint(b, uint64(n))
1412
	for i := 0; i < llen; i++ {
1413
		v := list.Get(i)
1414
		b = protowire.AppendVarint(b, protowire.EncodeZigZag(int64(int32(v.Int()))))
1415
	}
1416
	return b, nil
1417
}
1418

1419
var coderSint32PackedSliceValue = valueCoderFuncs{
1420
	size:      sizeSint32PackedSliceValue,
1421
	marshal:   appendSint32PackedSliceValue,
1422
	unmarshal: consumeSint32SliceValue,
1423
	merge:     mergeListValue,
1424
}
1425

1426
// sizeUint32 returns the size of wire encoding a uint32 pointer as a Uint32.
1427
func sizeUint32(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
1428
	v := *p.Uint32()
1429
	return f.tagsize + protowire.SizeVarint(uint64(v))
1430
}
1431

1432
// appendUint32 wire encodes a uint32 pointer as a Uint32.
1433
func appendUint32(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
1434
	v := *p.Uint32()
1435
	b = protowire.AppendVarint(b, f.wiretag)
1436
	b = protowire.AppendVarint(b, uint64(v))
1437
	return b, nil
1438
}
1439

1440
// consumeUint32 wire decodes a uint32 pointer as a Uint32.
1441
func consumeUint32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
1442
	if wtyp != protowire.VarintType {
1443
		return out, errUnknown
1444
	}
1445
	var v uint64
1446
	var n int
1447
	if len(b) >= 1 && b[0] < 0x80 {
1448
		v = uint64(b[0])
1449
		n = 1
1450
	} else if len(b) >= 2 && b[1] < 128 {
1451
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
1452
		n = 2
1453
	} else {
1454
		v, n = protowire.ConsumeVarint(b)
1455
	}
1456
	if n < 0 {
1457
		return out, errDecode
1458
	}
1459
	*p.Uint32() = uint32(v)
1460
	out.n = n
1461
	return out, nil
1462
}
1463

1464
var coderUint32 = pointerCoderFuncs{
1465
	size:      sizeUint32,
1466
	marshal:   appendUint32,
1467
	unmarshal: consumeUint32,
1468
	merge:     mergeUint32,
1469
}
1470

1471
// sizeUint32NoZero returns the size of wire encoding a uint32 pointer as a Uint32.
1472
// The zero value is not encoded.
1473
func sizeUint32NoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
1474
	v := *p.Uint32()
1475
	if v == 0 {
1476
		return 0
1477
	}
1478
	return f.tagsize + protowire.SizeVarint(uint64(v))
1479
}
1480

1481
// appendUint32NoZero wire encodes a uint32 pointer as a Uint32.
1482
// The zero value is not encoded.
1483
func appendUint32NoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
1484
	v := *p.Uint32()
1485
	if v == 0 {
1486
		return b, nil
1487
	}
1488
	b = protowire.AppendVarint(b, f.wiretag)
1489
	b = protowire.AppendVarint(b, uint64(v))
1490
	return b, nil
1491
}
1492

1493
var coderUint32NoZero = pointerCoderFuncs{
1494
	size:      sizeUint32NoZero,
1495
	marshal:   appendUint32NoZero,
1496
	unmarshal: consumeUint32,
1497
	merge:     mergeUint32NoZero,
1498
}
1499

1500
// sizeUint32Ptr returns the size of wire encoding a *uint32 pointer as a Uint32.
1501
// It panics if the pointer is nil.
1502
func sizeUint32Ptr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
1503
	v := **p.Uint32Ptr()
1504
	return f.tagsize + protowire.SizeVarint(uint64(v))
1505
}
1506

1507
// appendUint32Ptr wire encodes a *uint32 pointer as a Uint32.
1508
// It panics if the pointer is nil.
1509
func appendUint32Ptr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
1510
	v := **p.Uint32Ptr()
1511
	b = protowire.AppendVarint(b, f.wiretag)
1512
	b = protowire.AppendVarint(b, uint64(v))
1513
	return b, nil
1514
}
1515

1516
// consumeUint32Ptr wire decodes a *uint32 pointer as a Uint32.
1517
func consumeUint32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
1518
	if wtyp != protowire.VarintType {
1519
		return out, errUnknown
1520
	}
1521
	var v uint64
1522
	var n int
1523
	if len(b) >= 1 && b[0] < 0x80 {
1524
		v = uint64(b[0])
1525
		n = 1
1526
	} else if len(b) >= 2 && b[1] < 128 {
1527
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
1528
		n = 2
1529
	} else {
1530
		v, n = protowire.ConsumeVarint(b)
1531
	}
1532
	if n < 0 {
1533
		return out, errDecode
1534
	}
1535
	vp := p.Uint32Ptr()
1536
	if *vp == nil {
1537
		*vp = new(uint32)
1538
	}
1539
	**vp = uint32(v)
1540
	out.n = n
1541
	return out, nil
1542
}
1543

1544
var coderUint32Ptr = pointerCoderFuncs{
1545
	size:      sizeUint32Ptr,
1546
	marshal:   appendUint32Ptr,
1547
	unmarshal: consumeUint32Ptr,
1548
	merge:     mergeUint32Ptr,
1549
}
1550

1551
// sizeUint32Slice returns the size of wire encoding a []uint32 pointer as a repeated Uint32.
1552
func sizeUint32Slice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
1553
	s := *p.Uint32Slice()
1554
	for _, v := range s {
1555
		size += f.tagsize + protowire.SizeVarint(uint64(v))
1556
	}
1557
	return size
1558
}
1559

1560
// appendUint32Slice encodes a []uint32 pointer as a repeated Uint32.
1561
func appendUint32Slice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
1562
	s := *p.Uint32Slice()
1563
	for _, v := range s {
1564
		b = protowire.AppendVarint(b, f.wiretag)
1565
		b = protowire.AppendVarint(b, uint64(v))
1566
	}
1567
	return b, nil
1568
}
1569

1570
// consumeUint32Slice wire decodes a []uint32 pointer as a repeated Uint32.
1571
func consumeUint32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
1572
	sp := p.Uint32Slice()
1573
	if wtyp == protowire.BytesType {
1574
		b, n := protowire.ConsumeBytes(b)
1575
		if n < 0 {
1576
			return out, errDecode
1577
		}
1578
		count := 0
1579
		for _, v := range b {
1580
			if v < 0x80 {
1581
				count++
1582
			}
1583
		}
1584
		if count > 0 {
1585
			p.growUint32Slice(count)
1586
		}
1587
		s := *sp
1588
		for len(b) > 0 {
1589
			var v uint64
1590
			var n int
1591
			if len(b) >= 1 && b[0] < 0x80 {
1592
				v = uint64(b[0])
1593
				n = 1
1594
			} else if len(b) >= 2 && b[1] < 128 {
1595
				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
1596
				n = 2
1597
			} else {
1598
				v, n = protowire.ConsumeVarint(b)
1599
			}
1600
			if n < 0 {
1601
				return out, errDecode
1602
			}
1603
			s = append(s, uint32(v))
1604
			b = b[n:]
1605
		}
1606
		*sp = s
1607
		out.n = n
1608
		return out, nil
1609
	}
1610
	if wtyp != protowire.VarintType {
1611
		return out, errUnknown
1612
	}
1613
	var v uint64
1614
	var n int
1615
	if len(b) >= 1 && b[0] < 0x80 {
1616
		v = uint64(b[0])
1617
		n = 1
1618
	} else if len(b) >= 2 && b[1] < 128 {
1619
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
1620
		n = 2
1621
	} else {
1622
		v, n = protowire.ConsumeVarint(b)
1623
	}
1624
	if n < 0 {
1625
		return out, errDecode
1626
	}
1627
	*sp = append(*sp, uint32(v))
1628
	out.n = n
1629
	return out, nil
1630
}
1631

1632
var coderUint32Slice = pointerCoderFuncs{
1633
	size:      sizeUint32Slice,
1634
	marshal:   appendUint32Slice,
1635
	unmarshal: consumeUint32Slice,
1636
	merge:     mergeUint32Slice,
1637
}
1638

1639
// sizeUint32PackedSlice returns the size of wire encoding a []uint32 pointer as a packed repeated Uint32.
1640
func sizeUint32PackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
1641
	s := *p.Uint32Slice()
1642
	if len(s) == 0 {
1643
		return 0
1644
	}
1645
	n := 0
1646
	for _, v := range s {
1647
		n += protowire.SizeVarint(uint64(v))
1648
	}
1649
	return f.tagsize + protowire.SizeBytes(n)
1650
}
1651

1652
// appendUint32PackedSlice encodes a []uint32 pointer as a packed repeated Uint32.
1653
func appendUint32PackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
1654
	s := *p.Uint32Slice()
1655
	if len(s) == 0 {
1656
		return b, nil
1657
	}
1658
	b = protowire.AppendVarint(b, f.wiretag)
1659
	n := 0
1660
	for _, v := range s {
1661
		n += protowire.SizeVarint(uint64(v))
1662
	}
1663
	b = protowire.AppendVarint(b, uint64(n))
1664
	for _, v := range s {
1665
		b = protowire.AppendVarint(b, uint64(v))
1666
	}
1667
	return b, nil
1668
}
1669

1670
var coderUint32PackedSlice = pointerCoderFuncs{
1671
	size:      sizeUint32PackedSlice,
1672
	marshal:   appendUint32PackedSlice,
1673
	unmarshal: consumeUint32Slice,
1674
	merge:     mergeUint32Slice,
1675
}
1676

1677
// sizeUint32Value returns the size of wire encoding a uint32 value as a Uint32.
1678
func sizeUint32Value(v protoreflect.Value, tagsize int, opts marshalOptions) int {
1679
	return tagsize + protowire.SizeVarint(uint64(uint32(v.Uint())))
1680
}
1681

1682
// appendUint32Value encodes a uint32 value as a Uint32.
1683
func appendUint32Value(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
1684
	b = protowire.AppendVarint(b, wiretag)
1685
	b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
1686
	return b, nil
1687
}
1688

1689
// consumeUint32Value decodes a uint32 value as a Uint32.
1690
func consumeUint32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
1691
	if wtyp != protowire.VarintType {
1692
		return protoreflect.Value{}, out, errUnknown
1693
	}
1694
	var v uint64
1695
	var n int
1696
	if len(b) >= 1 && b[0] < 0x80 {
1697
		v = uint64(b[0])
1698
		n = 1
1699
	} else if len(b) >= 2 && b[1] < 128 {
1700
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
1701
		n = 2
1702
	} else {
1703
		v, n = protowire.ConsumeVarint(b)
1704
	}
1705
	if n < 0 {
1706
		return protoreflect.Value{}, out, errDecode
1707
	}
1708
	out.n = n
1709
	return protoreflect.ValueOfUint32(uint32(v)), out, nil
1710
}
1711

1712
var coderUint32Value = valueCoderFuncs{
1713
	size:      sizeUint32Value,
1714
	marshal:   appendUint32Value,
1715
	unmarshal: consumeUint32Value,
1716
	merge:     mergeScalarValue,
1717
}
1718

1719
// sizeUint32SliceValue returns the size of wire encoding a []uint32 value as a repeated Uint32.
1720
func sizeUint32SliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
1721
	list := listv.List()
1722
	for i, llen := 0, list.Len(); i < llen; i++ {
1723
		v := list.Get(i)
1724
		size += tagsize + protowire.SizeVarint(uint64(uint32(v.Uint())))
1725
	}
1726
	return size
1727
}
1728

1729
// appendUint32SliceValue encodes a []uint32 value as a repeated Uint32.
1730
func appendUint32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
1731
	list := listv.List()
1732
	for i, llen := 0, list.Len(); i < llen; i++ {
1733
		v := list.Get(i)
1734
		b = protowire.AppendVarint(b, wiretag)
1735
		b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
1736
	}
1737
	return b, nil
1738
}
1739

1740
// consumeUint32SliceValue wire decodes a []uint32 value as a repeated Uint32.
1741
func consumeUint32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
1742
	list := listv.List()
1743
	if wtyp == protowire.BytesType {
1744
		b, n := protowire.ConsumeBytes(b)
1745
		if n < 0 {
1746
			return protoreflect.Value{}, out, errDecode
1747
		}
1748
		for len(b) > 0 {
1749
			var v uint64
1750
			var n int
1751
			if len(b) >= 1 && b[0] < 0x80 {
1752
				v = uint64(b[0])
1753
				n = 1
1754
			} else if len(b) >= 2 && b[1] < 128 {
1755
				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
1756
				n = 2
1757
			} else {
1758
				v, n = protowire.ConsumeVarint(b)
1759
			}
1760
			if n < 0 {
1761
				return protoreflect.Value{}, out, errDecode
1762
			}
1763
			list.Append(protoreflect.ValueOfUint32(uint32(v)))
1764
			b = b[n:]
1765
		}
1766
		out.n = n
1767
		return listv, out, nil
1768
	}
1769
	if wtyp != protowire.VarintType {
1770
		return protoreflect.Value{}, out, errUnknown
1771
	}
1772
	var v uint64
1773
	var n int
1774
	if len(b) >= 1 && b[0] < 0x80 {
1775
		v = uint64(b[0])
1776
		n = 1
1777
	} else if len(b) >= 2 && b[1] < 128 {
1778
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
1779
		n = 2
1780
	} else {
1781
		v, n = protowire.ConsumeVarint(b)
1782
	}
1783
	if n < 0 {
1784
		return protoreflect.Value{}, out, errDecode
1785
	}
1786
	list.Append(protoreflect.ValueOfUint32(uint32(v)))
1787
	out.n = n
1788
	return listv, out, nil
1789
}
1790

1791
var coderUint32SliceValue = valueCoderFuncs{
1792
	size:      sizeUint32SliceValue,
1793
	marshal:   appendUint32SliceValue,
1794
	unmarshal: consumeUint32SliceValue,
1795
	merge:     mergeListValue,
1796
}
1797

1798
// sizeUint32PackedSliceValue returns the size of wire encoding a []uint32 value as a packed repeated Uint32.
1799
func sizeUint32PackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
1800
	list := listv.List()
1801
	llen := list.Len()
1802
	if llen == 0 {
1803
		return 0
1804
	}
1805
	n := 0
1806
	for i, llen := 0, llen; i < llen; i++ {
1807
		v := list.Get(i)
1808
		n += protowire.SizeVarint(uint64(uint32(v.Uint())))
1809
	}
1810
	return tagsize + protowire.SizeBytes(n)
1811
}
1812

1813
// appendUint32PackedSliceValue encodes a []uint32 value as a packed repeated Uint32.
1814
func appendUint32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
1815
	list := listv.List()
1816
	llen := list.Len()
1817
	if llen == 0 {
1818
		return b, nil
1819
	}
1820
	b = protowire.AppendVarint(b, wiretag)
1821
	n := 0
1822
	for i := 0; i < llen; i++ {
1823
		v := list.Get(i)
1824
		n += protowire.SizeVarint(uint64(uint32(v.Uint())))
1825
	}
1826
	b = protowire.AppendVarint(b, uint64(n))
1827
	for i := 0; i < llen; i++ {
1828
		v := list.Get(i)
1829
		b = protowire.AppendVarint(b, uint64(uint32(v.Uint())))
1830
	}
1831
	return b, nil
1832
}
1833

1834
var coderUint32PackedSliceValue = valueCoderFuncs{
1835
	size:      sizeUint32PackedSliceValue,
1836
	marshal:   appendUint32PackedSliceValue,
1837
	unmarshal: consumeUint32SliceValue,
1838
	merge:     mergeListValue,
1839
}
1840

1841
// sizeInt64 returns the size of wire encoding a int64 pointer as a Int64.
1842
func sizeInt64(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
1843
	v := *p.Int64()
1844
	return f.tagsize + protowire.SizeVarint(uint64(v))
1845
}
1846

1847
// appendInt64 wire encodes a int64 pointer as a Int64.
1848
func appendInt64(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
1849
	v := *p.Int64()
1850
	b = protowire.AppendVarint(b, f.wiretag)
1851
	b = protowire.AppendVarint(b, uint64(v))
1852
	return b, nil
1853
}
1854

1855
// consumeInt64 wire decodes a int64 pointer as a Int64.
1856
func consumeInt64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
1857
	if wtyp != protowire.VarintType {
1858
		return out, errUnknown
1859
	}
1860
	var v uint64
1861
	var n int
1862
	if len(b) >= 1 && b[0] < 0x80 {
1863
		v = uint64(b[0])
1864
		n = 1
1865
	} else if len(b) >= 2 && b[1] < 128 {
1866
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
1867
		n = 2
1868
	} else {
1869
		v, n = protowire.ConsumeVarint(b)
1870
	}
1871
	if n < 0 {
1872
		return out, errDecode
1873
	}
1874
	*p.Int64() = int64(v)
1875
	out.n = n
1876
	return out, nil
1877
}
1878

1879
var coderInt64 = pointerCoderFuncs{
1880
	size:      sizeInt64,
1881
	marshal:   appendInt64,
1882
	unmarshal: consumeInt64,
1883
	merge:     mergeInt64,
1884
}
1885

1886
// sizeInt64NoZero returns the size of wire encoding a int64 pointer as a Int64.
1887
// The zero value is not encoded.
1888
func sizeInt64NoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
1889
	v := *p.Int64()
1890
	if v == 0 {
1891
		return 0
1892
	}
1893
	return f.tagsize + protowire.SizeVarint(uint64(v))
1894
}
1895

1896
// appendInt64NoZero wire encodes a int64 pointer as a Int64.
1897
// The zero value is not encoded.
1898
func appendInt64NoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
1899
	v := *p.Int64()
1900
	if v == 0 {
1901
		return b, nil
1902
	}
1903
	b = protowire.AppendVarint(b, f.wiretag)
1904
	b = protowire.AppendVarint(b, uint64(v))
1905
	return b, nil
1906
}
1907

1908
var coderInt64NoZero = pointerCoderFuncs{
1909
	size:      sizeInt64NoZero,
1910
	marshal:   appendInt64NoZero,
1911
	unmarshal: consumeInt64,
1912
	merge:     mergeInt64NoZero,
1913
}
1914

1915
// sizeInt64Ptr returns the size of wire encoding a *int64 pointer as a Int64.
1916
// It panics if the pointer is nil.
1917
func sizeInt64Ptr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
1918
	v := **p.Int64Ptr()
1919
	return f.tagsize + protowire.SizeVarint(uint64(v))
1920
}
1921

1922
// appendInt64Ptr wire encodes a *int64 pointer as a Int64.
1923
// It panics if the pointer is nil.
1924
func appendInt64Ptr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
1925
	v := **p.Int64Ptr()
1926
	b = protowire.AppendVarint(b, f.wiretag)
1927
	b = protowire.AppendVarint(b, uint64(v))
1928
	return b, nil
1929
}
1930

1931
// consumeInt64Ptr wire decodes a *int64 pointer as a Int64.
1932
func consumeInt64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
1933
	if wtyp != protowire.VarintType {
1934
		return out, errUnknown
1935
	}
1936
	var v uint64
1937
	var n int
1938
	if len(b) >= 1 && b[0] < 0x80 {
1939
		v = uint64(b[0])
1940
		n = 1
1941
	} else if len(b) >= 2 && b[1] < 128 {
1942
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
1943
		n = 2
1944
	} else {
1945
		v, n = protowire.ConsumeVarint(b)
1946
	}
1947
	if n < 0 {
1948
		return out, errDecode
1949
	}
1950
	vp := p.Int64Ptr()
1951
	if *vp == nil {
1952
		*vp = new(int64)
1953
	}
1954
	**vp = int64(v)
1955
	out.n = n
1956
	return out, nil
1957
}
1958

1959
var coderInt64Ptr = pointerCoderFuncs{
1960
	size:      sizeInt64Ptr,
1961
	marshal:   appendInt64Ptr,
1962
	unmarshal: consumeInt64Ptr,
1963
	merge:     mergeInt64Ptr,
1964
}
1965

1966
// sizeInt64Slice returns the size of wire encoding a []int64 pointer as a repeated Int64.
1967
func sizeInt64Slice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
1968
	s := *p.Int64Slice()
1969
	for _, v := range s {
1970
		size += f.tagsize + protowire.SizeVarint(uint64(v))
1971
	}
1972
	return size
1973
}
1974

1975
// appendInt64Slice encodes a []int64 pointer as a repeated Int64.
1976
func appendInt64Slice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
1977
	s := *p.Int64Slice()
1978
	for _, v := range s {
1979
		b = protowire.AppendVarint(b, f.wiretag)
1980
		b = protowire.AppendVarint(b, uint64(v))
1981
	}
1982
	return b, nil
1983
}
1984

1985
// consumeInt64Slice wire decodes a []int64 pointer as a repeated Int64.
1986
func consumeInt64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
1987
	sp := p.Int64Slice()
1988
	if wtyp == protowire.BytesType {
1989
		b, n := protowire.ConsumeBytes(b)
1990
		if n < 0 {
1991
			return out, errDecode
1992
		}
1993
		count := 0
1994
		for _, v := range b {
1995
			if v < 0x80 {
1996
				count++
1997
			}
1998
		}
1999
		if count > 0 {
2000
			p.growInt64Slice(count)
2001
		}
2002
		s := *sp
2003
		for len(b) > 0 {
2004
			var v uint64
2005
			var n int
2006
			if len(b) >= 1 && b[0] < 0x80 {
2007
				v = uint64(b[0])
2008
				n = 1
2009
			} else if len(b) >= 2 && b[1] < 128 {
2010
				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
2011
				n = 2
2012
			} else {
2013
				v, n = protowire.ConsumeVarint(b)
2014
			}
2015
			if n < 0 {
2016
				return out, errDecode
2017
			}
2018
			s = append(s, int64(v))
2019
			b = b[n:]
2020
		}
2021
		*sp = s
2022
		out.n = n
2023
		return out, nil
2024
	}
2025
	if wtyp != protowire.VarintType {
2026
		return out, errUnknown
2027
	}
2028
	var v uint64
2029
	var n int
2030
	if len(b) >= 1 && b[0] < 0x80 {
2031
		v = uint64(b[0])
2032
		n = 1
2033
	} else if len(b) >= 2 && b[1] < 128 {
2034
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
2035
		n = 2
2036
	} else {
2037
		v, n = protowire.ConsumeVarint(b)
2038
	}
2039
	if n < 0 {
2040
		return out, errDecode
2041
	}
2042
	*sp = append(*sp, int64(v))
2043
	out.n = n
2044
	return out, nil
2045
}
2046

2047
var coderInt64Slice = pointerCoderFuncs{
2048
	size:      sizeInt64Slice,
2049
	marshal:   appendInt64Slice,
2050
	unmarshal: consumeInt64Slice,
2051
	merge:     mergeInt64Slice,
2052
}
2053

2054
// sizeInt64PackedSlice returns the size of wire encoding a []int64 pointer as a packed repeated Int64.
2055
func sizeInt64PackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
2056
	s := *p.Int64Slice()
2057
	if len(s) == 0 {
2058
		return 0
2059
	}
2060
	n := 0
2061
	for _, v := range s {
2062
		n += protowire.SizeVarint(uint64(v))
2063
	}
2064
	return f.tagsize + protowire.SizeBytes(n)
2065
}
2066

2067
// appendInt64PackedSlice encodes a []int64 pointer as a packed repeated Int64.
2068
func appendInt64PackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
2069
	s := *p.Int64Slice()
2070
	if len(s) == 0 {
2071
		return b, nil
2072
	}
2073
	b = protowire.AppendVarint(b, f.wiretag)
2074
	n := 0
2075
	for _, v := range s {
2076
		n += protowire.SizeVarint(uint64(v))
2077
	}
2078
	b = protowire.AppendVarint(b, uint64(n))
2079
	for _, v := range s {
2080
		b = protowire.AppendVarint(b, uint64(v))
2081
	}
2082
	return b, nil
2083
}
2084

2085
var coderInt64PackedSlice = pointerCoderFuncs{
2086
	size:      sizeInt64PackedSlice,
2087
	marshal:   appendInt64PackedSlice,
2088
	unmarshal: consumeInt64Slice,
2089
	merge:     mergeInt64Slice,
2090
}
2091

2092
// sizeInt64Value returns the size of wire encoding a int64 value as a Int64.
2093
func sizeInt64Value(v protoreflect.Value, tagsize int, opts marshalOptions) int {
2094
	return tagsize + protowire.SizeVarint(uint64(v.Int()))
2095
}
2096

2097
// appendInt64Value encodes a int64 value as a Int64.
2098
func appendInt64Value(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
2099
	b = protowire.AppendVarint(b, wiretag)
2100
	b = protowire.AppendVarint(b, uint64(v.Int()))
2101
	return b, nil
2102
}
2103

2104
// consumeInt64Value decodes a int64 value as a Int64.
2105
func consumeInt64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
2106
	if wtyp != protowire.VarintType {
2107
		return protoreflect.Value{}, out, errUnknown
2108
	}
2109
	var v uint64
2110
	var n int
2111
	if len(b) >= 1 && b[0] < 0x80 {
2112
		v = uint64(b[0])
2113
		n = 1
2114
	} else if len(b) >= 2 && b[1] < 128 {
2115
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
2116
		n = 2
2117
	} else {
2118
		v, n = protowire.ConsumeVarint(b)
2119
	}
2120
	if n < 0 {
2121
		return protoreflect.Value{}, out, errDecode
2122
	}
2123
	out.n = n
2124
	return protoreflect.ValueOfInt64(int64(v)), out, nil
2125
}
2126

2127
var coderInt64Value = valueCoderFuncs{
2128
	size:      sizeInt64Value,
2129
	marshal:   appendInt64Value,
2130
	unmarshal: consumeInt64Value,
2131
	merge:     mergeScalarValue,
2132
}
2133

2134
// sizeInt64SliceValue returns the size of wire encoding a []int64 value as a repeated Int64.
2135
func sizeInt64SliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
2136
	list := listv.List()
2137
	for i, llen := 0, list.Len(); i < llen; i++ {
2138
		v := list.Get(i)
2139
		size += tagsize + protowire.SizeVarint(uint64(v.Int()))
2140
	}
2141
	return size
2142
}
2143

2144
// appendInt64SliceValue encodes a []int64 value as a repeated Int64.
2145
func appendInt64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
2146
	list := listv.List()
2147
	for i, llen := 0, list.Len(); i < llen; i++ {
2148
		v := list.Get(i)
2149
		b = protowire.AppendVarint(b, wiretag)
2150
		b = protowire.AppendVarint(b, uint64(v.Int()))
2151
	}
2152
	return b, nil
2153
}
2154

2155
// consumeInt64SliceValue wire decodes a []int64 value as a repeated Int64.
2156
func consumeInt64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
2157
	list := listv.List()
2158
	if wtyp == protowire.BytesType {
2159
		b, n := protowire.ConsumeBytes(b)
2160
		if n < 0 {
2161
			return protoreflect.Value{}, out, errDecode
2162
		}
2163
		for len(b) > 0 {
2164
			var v uint64
2165
			var n int
2166
			if len(b) >= 1 && b[0] < 0x80 {
2167
				v = uint64(b[0])
2168
				n = 1
2169
			} else if len(b) >= 2 && b[1] < 128 {
2170
				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
2171
				n = 2
2172
			} else {
2173
				v, n = protowire.ConsumeVarint(b)
2174
			}
2175
			if n < 0 {
2176
				return protoreflect.Value{}, out, errDecode
2177
			}
2178
			list.Append(protoreflect.ValueOfInt64(int64(v)))
2179
			b = b[n:]
2180
		}
2181
		out.n = n
2182
		return listv, out, nil
2183
	}
2184
	if wtyp != protowire.VarintType {
2185
		return protoreflect.Value{}, out, errUnknown
2186
	}
2187
	var v uint64
2188
	var n int
2189
	if len(b) >= 1 && b[0] < 0x80 {
2190
		v = uint64(b[0])
2191
		n = 1
2192
	} else if len(b) >= 2 && b[1] < 128 {
2193
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
2194
		n = 2
2195
	} else {
2196
		v, n = protowire.ConsumeVarint(b)
2197
	}
2198
	if n < 0 {
2199
		return protoreflect.Value{}, out, errDecode
2200
	}
2201
	list.Append(protoreflect.ValueOfInt64(int64(v)))
2202
	out.n = n
2203
	return listv, out, nil
2204
}
2205

2206
var coderInt64SliceValue = valueCoderFuncs{
2207
	size:      sizeInt64SliceValue,
2208
	marshal:   appendInt64SliceValue,
2209
	unmarshal: consumeInt64SliceValue,
2210
	merge:     mergeListValue,
2211
}
2212

2213
// sizeInt64PackedSliceValue returns the size of wire encoding a []int64 value as a packed repeated Int64.
2214
func sizeInt64PackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
2215
	list := listv.List()
2216
	llen := list.Len()
2217
	if llen == 0 {
2218
		return 0
2219
	}
2220
	n := 0
2221
	for i, llen := 0, llen; i < llen; i++ {
2222
		v := list.Get(i)
2223
		n += protowire.SizeVarint(uint64(v.Int()))
2224
	}
2225
	return tagsize + protowire.SizeBytes(n)
2226
}
2227

2228
// appendInt64PackedSliceValue encodes a []int64 value as a packed repeated Int64.
2229
func appendInt64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
2230
	list := listv.List()
2231
	llen := list.Len()
2232
	if llen == 0 {
2233
		return b, nil
2234
	}
2235
	b = protowire.AppendVarint(b, wiretag)
2236
	n := 0
2237
	for i := 0; i < llen; i++ {
2238
		v := list.Get(i)
2239
		n += protowire.SizeVarint(uint64(v.Int()))
2240
	}
2241
	b = protowire.AppendVarint(b, uint64(n))
2242
	for i := 0; i < llen; i++ {
2243
		v := list.Get(i)
2244
		b = protowire.AppendVarint(b, uint64(v.Int()))
2245
	}
2246
	return b, nil
2247
}
2248

2249
var coderInt64PackedSliceValue = valueCoderFuncs{
2250
	size:      sizeInt64PackedSliceValue,
2251
	marshal:   appendInt64PackedSliceValue,
2252
	unmarshal: consumeInt64SliceValue,
2253
	merge:     mergeListValue,
2254
}
2255

2256
// sizeSint64 returns the size of wire encoding a int64 pointer as a Sint64.
2257
func sizeSint64(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
2258
	v := *p.Int64()
2259
	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
2260
}
2261

2262
// appendSint64 wire encodes a int64 pointer as a Sint64.
2263
func appendSint64(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
2264
	v := *p.Int64()
2265
	b = protowire.AppendVarint(b, f.wiretag)
2266
	b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
2267
	return b, nil
2268
}
2269

2270
// consumeSint64 wire decodes a int64 pointer as a Sint64.
2271
func consumeSint64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
2272
	if wtyp != protowire.VarintType {
2273
		return out, errUnknown
2274
	}
2275
	var v uint64
2276
	var n int
2277
	if len(b) >= 1 && b[0] < 0x80 {
2278
		v = uint64(b[0])
2279
		n = 1
2280
	} else if len(b) >= 2 && b[1] < 128 {
2281
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
2282
		n = 2
2283
	} else {
2284
		v, n = protowire.ConsumeVarint(b)
2285
	}
2286
	if n < 0 {
2287
		return out, errDecode
2288
	}
2289
	*p.Int64() = protowire.DecodeZigZag(v)
2290
	out.n = n
2291
	return out, nil
2292
}
2293

2294
var coderSint64 = pointerCoderFuncs{
2295
	size:      sizeSint64,
2296
	marshal:   appendSint64,
2297
	unmarshal: consumeSint64,
2298
	merge:     mergeInt64,
2299
}
2300

2301
// sizeSint64NoZero returns the size of wire encoding a int64 pointer as a Sint64.
2302
// The zero value is not encoded.
2303
func sizeSint64NoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
2304
	v := *p.Int64()
2305
	if v == 0 {
2306
		return 0
2307
	}
2308
	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
2309
}
2310

2311
// appendSint64NoZero wire encodes a int64 pointer as a Sint64.
2312
// The zero value is not encoded.
2313
func appendSint64NoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
2314
	v := *p.Int64()
2315
	if v == 0 {
2316
		return b, nil
2317
	}
2318
	b = protowire.AppendVarint(b, f.wiretag)
2319
	b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
2320
	return b, nil
2321
}
2322

2323
var coderSint64NoZero = pointerCoderFuncs{
2324
	size:      sizeSint64NoZero,
2325
	marshal:   appendSint64NoZero,
2326
	unmarshal: consumeSint64,
2327
	merge:     mergeInt64NoZero,
2328
}
2329

2330
// sizeSint64Ptr returns the size of wire encoding a *int64 pointer as a Sint64.
2331
// It panics if the pointer is nil.
2332
func sizeSint64Ptr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
2333
	v := **p.Int64Ptr()
2334
	return f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
2335
}
2336

2337
// appendSint64Ptr wire encodes a *int64 pointer as a Sint64.
2338
// It panics if the pointer is nil.
2339
func appendSint64Ptr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
2340
	v := **p.Int64Ptr()
2341
	b = protowire.AppendVarint(b, f.wiretag)
2342
	b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
2343
	return b, nil
2344
}
2345

2346
// consumeSint64Ptr wire decodes a *int64 pointer as a Sint64.
2347
func consumeSint64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
2348
	if wtyp != protowire.VarintType {
2349
		return out, errUnknown
2350
	}
2351
	var v uint64
2352
	var n int
2353
	if len(b) >= 1 && b[0] < 0x80 {
2354
		v = uint64(b[0])
2355
		n = 1
2356
	} else if len(b) >= 2 && b[1] < 128 {
2357
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
2358
		n = 2
2359
	} else {
2360
		v, n = protowire.ConsumeVarint(b)
2361
	}
2362
	if n < 0 {
2363
		return out, errDecode
2364
	}
2365
	vp := p.Int64Ptr()
2366
	if *vp == nil {
2367
		*vp = new(int64)
2368
	}
2369
	**vp = protowire.DecodeZigZag(v)
2370
	out.n = n
2371
	return out, nil
2372
}
2373

2374
var coderSint64Ptr = pointerCoderFuncs{
2375
	size:      sizeSint64Ptr,
2376
	marshal:   appendSint64Ptr,
2377
	unmarshal: consumeSint64Ptr,
2378
	merge:     mergeInt64Ptr,
2379
}
2380

2381
// sizeSint64Slice returns the size of wire encoding a []int64 pointer as a repeated Sint64.
2382
func sizeSint64Slice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
2383
	s := *p.Int64Slice()
2384
	for _, v := range s {
2385
		size += f.tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v))
2386
	}
2387
	return size
2388
}
2389

2390
// appendSint64Slice encodes a []int64 pointer as a repeated Sint64.
2391
func appendSint64Slice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
2392
	s := *p.Int64Slice()
2393
	for _, v := range s {
2394
		b = protowire.AppendVarint(b, f.wiretag)
2395
		b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
2396
	}
2397
	return b, nil
2398
}
2399

2400
// consumeSint64Slice wire decodes a []int64 pointer as a repeated Sint64.
2401
func consumeSint64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
2402
	sp := p.Int64Slice()
2403
	if wtyp == protowire.BytesType {
2404
		b, n := protowire.ConsumeBytes(b)
2405
		if n < 0 {
2406
			return out, errDecode
2407
		}
2408
		count := 0
2409
		for _, v := range b {
2410
			if v < 0x80 {
2411
				count++
2412
			}
2413
		}
2414
		if count > 0 {
2415
			p.growInt64Slice(count)
2416
		}
2417
		s := *sp
2418
		for len(b) > 0 {
2419
			var v uint64
2420
			var n int
2421
			if len(b) >= 1 && b[0] < 0x80 {
2422
				v = uint64(b[0])
2423
				n = 1
2424
			} else if len(b) >= 2 && b[1] < 128 {
2425
				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
2426
				n = 2
2427
			} else {
2428
				v, n = protowire.ConsumeVarint(b)
2429
			}
2430
			if n < 0 {
2431
				return out, errDecode
2432
			}
2433
			s = append(s, protowire.DecodeZigZag(v))
2434
			b = b[n:]
2435
		}
2436
		*sp = s
2437
		out.n = n
2438
		return out, nil
2439
	}
2440
	if wtyp != protowire.VarintType {
2441
		return out, errUnknown
2442
	}
2443
	var v uint64
2444
	var n int
2445
	if len(b) >= 1 && b[0] < 0x80 {
2446
		v = uint64(b[0])
2447
		n = 1
2448
	} else if len(b) >= 2 && b[1] < 128 {
2449
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
2450
		n = 2
2451
	} else {
2452
		v, n = protowire.ConsumeVarint(b)
2453
	}
2454
	if n < 0 {
2455
		return out, errDecode
2456
	}
2457
	*sp = append(*sp, protowire.DecodeZigZag(v))
2458
	out.n = n
2459
	return out, nil
2460
}
2461

2462
var coderSint64Slice = pointerCoderFuncs{
2463
	size:      sizeSint64Slice,
2464
	marshal:   appendSint64Slice,
2465
	unmarshal: consumeSint64Slice,
2466
	merge:     mergeInt64Slice,
2467
}
2468

2469
// sizeSint64PackedSlice returns the size of wire encoding a []int64 pointer as a packed repeated Sint64.
2470
func sizeSint64PackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
2471
	s := *p.Int64Slice()
2472
	if len(s) == 0 {
2473
		return 0
2474
	}
2475
	n := 0
2476
	for _, v := range s {
2477
		n += protowire.SizeVarint(protowire.EncodeZigZag(v))
2478
	}
2479
	return f.tagsize + protowire.SizeBytes(n)
2480
}
2481

2482
// appendSint64PackedSlice encodes a []int64 pointer as a packed repeated Sint64.
2483
func appendSint64PackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
2484
	s := *p.Int64Slice()
2485
	if len(s) == 0 {
2486
		return b, nil
2487
	}
2488
	b = protowire.AppendVarint(b, f.wiretag)
2489
	n := 0
2490
	for _, v := range s {
2491
		n += protowire.SizeVarint(protowire.EncodeZigZag(v))
2492
	}
2493
	b = protowire.AppendVarint(b, uint64(n))
2494
	for _, v := range s {
2495
		b = protowire.AppendVarint(b, protowire.EncodeZigZag(v))
2496
	}
2497
	return b, nil
2498
}
2499

2500
var coderSint64PackedSlice = pointerCoderFuncs{
2501
	size:      sizeSint64PackedSlice,
2502
	marshal:   appendSint64PackedSlice,
2503
	unmarshal: consumeSint64Slice,
2504
	merge:     mergeInt64Slice,
2505
}
2506

2507
// sizeSint64Value returns the size of wire encoding a int64 value as a Sint64.
2508
func sizeSint64Value(v protoreflect.Value, tagsize int, opts marshalOptions) int {
2509
	return tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
2510
}
2511

2512
// appendSint64Value encodes a int64 value as a Sint64.
2513
func appendSint64Value(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
2514
	b = protowire.AppendVarint(b, wiretag)
2515
	b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
2516
	return b, nil
2517
}
2518

2519
// consumeSint64Value decodes a int64 value as a Sint64.
2520
func consumeSint64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
2521
	if wtyp != protowire.VarintType {
2522
		return protoreflect.Value{}, out, errUnknown
2523
	}
2524
	var v uint64
2525
	var n int
2526
	if len(b) >= 1 && b[0] < 0x80 {
2527
		v = uint64(b[0])
2528
		n = 1
2529
	} else if len(b) >= 2 && b[1] < 128 {
2530
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
2531
		n = 2
2532
	} else {
2533
		v, n = protowire.ConsumeVarint(b)
2534
	}
2535
	if n < 0 {
2536
		return protoreflect.Value{}, out, errDecode
2537
	}
2538
	out.n = n
2539
	return protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)), out, nil
2540
}
2541

2542
var coderSint64Value = valueCoderFuncs{
2543
	size:      sizeSint64Value,
2544
	marshal:   appendSint64Value,
2545
	unmarshal: consumeSint64Value,
2546
	merge:     mergeScalarValue,
2547
}
2548

2549
// sizeSint64SliceValue returns the size of wire encoding a []int64 value as a repeated Sint64.
2550
func sizeSint64SliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
2551
	list := listv.List()
2552
	for i, llen := 0, list.Len(); i < llen; i++ {
2553
		v := list.Get(i)
2554
		size += tagsize + protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
2555
	}
2556
	return size
2557
}
2558

2559
// appendSint64SliceValue encodes a []int64 value as a repeated Sint64.
2560
func appendSint64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
2561
	list := listv.List()
2562
	for i, llen := 0, list.Len(); i < llen; i++ {
2563
		v := list.Get(i)
2564
		b = protowire.AppendVarint(b, wiretag)
2565
		b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
2566
	}
2567
	return b, nil
2568
}
2569

2570
// consumeSint64SliceValue wire decodes a []int64 value as a repeated Sint64.
2571
func consumeSint64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
2572
	list := listv.List()
2573
	if wtyp == protowire.BytesType {
2574
		b, n := protowire.ConsumeBytes(b)
2575
		if n < 0 {
2576
			return protoreflect.Value{}, out, errDecode
2577
		}
2578
		for len(b) > 0 {
2579
			var v uint64
2580
			var n int
2581
			if len(b) >= 1 && b[0] < 0x80 {
2582
				v = uint64(b[0])
2583
				n = 1
2584
			} else if len(b) >= 2 && b[1] < 128 {
2585
				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
2586
				n = 2
2587
			} else {
2588
				v, n = protowire.ConsumeVarint(b)
2589
			}
2590
			if n < 0 {
2591
				return protoreflect.Value{}, out, errDecode
2592
			}
2593
			list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
2594
			b = b[n:]
2595
		}
2596
		out.n = n
2597
		return listv, out, nil
2598
	}
2599
	if wtyp != protowire.VarintType {
2600
		return protoreflect.Value{}, out, errUnknown
2601
	}
2602
	var v uint64
2603
	var n int
2604
	if len(b) >= 1 && b[0] < 0x80 {
2605
		v = uint64(b[0])
2606
		n = 1
2607
	} else if len(b) >= 2 && b[1] < 128 {
2608
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
2609
		n = 2
2610
	} else {
2611
		v, n = protowire.ConsumeVarint(b)
2612
	}
2613
	if n < 0 {
2614
		return protoreflect.Value{}, out, errDecode
2615
	}
2616
	list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
2617
	out.n = n
2618
	return listv, out, nil
2619
}
2620

2621
var coderSint64SliceValue = valueCoderFuncs{
2622
	size:      sizeSint64SliceValue,
2623
	marshal:   appendSint64SliceValue,
2624
	unmarshal: consumeSint64SliceValue,
2625
	merge:     mergeListValue,
2626
}
2627

2628
// sizeSint64PackedSliceValue returns the size of wire encoding a []int64 value as a packed repeated Sint64.
2629
func sizeSint64PackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
2630
	list := listv.List()
2631
	llen := list.Len()
2632
	if llen == 0 {
2633
		return 0
2634
	}
2635
	n := 0
2636
	for i, llen := 0, llen; i < llen; i++ {
2637
		v := list.Get(i)
2638
		n += protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
2639
	}
2640
	return tagsize + protowire.SizeBytes(n)
2641
}
2642

2643
// appendSint64PackedSliceValue encodes a []int64 value as a packed repeated Sint64.
2644
func appendSint64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
2645
	list := listv.List()
2646
	llen := list.Len()
2647
	if llen == 0 {
2648
		return b, nil
2649
	}
2650
	b = protowire.AppendVarint(b, wiretag)
2651
	n := 0
2652
	for i := 0; i < llen; i++ {
2653
		v := list.Get(i)
2654
		n += protowire.SizeVarint(protowire.EncodeZigZag(v.Int()))
2655
	}
2656
	b = protowire.AppendVarint(b, uint64(n))
2657
	for i := 0; i < llen; i++ {
2658
		v := list.Get(i)
2659
		b = protowire.AppendVarint(b, protowire.EncodeZigZag(v.Int()))
2660
	}
2661
	return b, nil
2662
}
2663

2664
var coderSint64PackedSliceValue = valueCoderFuncs{
2665
	size:      sizeSint64PackedSliceValue,
2666
	marshal:   appendSint64PackedSliceValue,
2667
	unmarshal: consumeSint64SliceValue,
2668
	merge:     mergeListValue,
2669
}
2670

2671
// sizeUint64 returns the size of wire encoding a uint64 pointer as a Uint64.
2672
func sizeUint64(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
2673
	v := *p.Uint64()
2674
	return f.tagsize + protowire.SizeVarint(v)
2675
}
2676

2677
// appendUint64 wire encodes a uint64 pointer as a Uint64.
2678
func appendUint64(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
2679
	v := *p.Uint64()
2680
	b = protowire.AppendVarint(b, f.wiretag)
2681
	b = protowire.AppendVarint(b, v)
2682
	return b, nil
2683
}
2684

2685
// consumeUint64 wire decodes a uint64 pointer as a Uint64.
2686
func consumeUint64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
2687
	if wtyp != protowire.VarintType {
2688
		return out, errUnknown
2689
	}
2690
	var v uint64
2691
	var n int
2692
	if len(b) >= 1 && b[0] < 0x80 {
2693
		v = uint64(b[0])
2694
		n = 1
2695
	} else if len(b) >= 2 && b[1] < 128 {
2696
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
2697
		n = 2
2698
	} else {
2699
		v, n = protowire.ConsumeVarint(b)
2700
	}
2701
	if n < 0 {
2702
		return out, errDecode
2703
	}
2704
	*p.Uint64() = v
2705
	out.n = n
2706
	return out, nil
2707
}
2708

2709
var coderUint64 = pointerCoderFuncs{
2710
	size:      sizeUint64,
2711
	marshal:   appendUint64,
2712
	unmarshal: consumeUint64,
2713
	merge:     mergeUint64,
2714
}
2715

2716
// sizeUint64NoZero returns the size of wire encoding a uint64 pointer as a Uint64.
2717
// The zero value is not encoded.
2718
func sizeUint64NoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
2719
	v := *p.Uint64()
2720
	if v == 0 {
2721
		return 0
2722
	}
2723
	return f.tagsize + protowire.SizeVarint(v)
2724
}
2725

2726
// appendUint64NoZero wire encodes a uint64 pointer as a Uint64.
2727
// The zero value is not encoded.
2728
func appendUint64NoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
2729
	v := *p.Uint64()
2730
	if v == 0 {
2731
		return b, nil
2732
	}
2733
	b = protowire.AppendVarint(b, f.wiretag)
2734
	b = protowire.AppendVarint(b, v)
2735
	return b, nil
2736
}
2737

2738
var coderUint64NoZero = pointerCoderFuncs{
2739
	size:      sizeUint64NoZero,
2740
	marshal:   appendUint64NoZero,
2741
	unmarshal: consumeUint64,
2742
	merge:     mergeUint64NoZero,
2743
}
2744

2745
// sizeUint64Ptr returns the size of wire encoding a *uint64 pointer as a Uint64.
2746
// It panics if the pointer is nil.
2747
func sizeUint64Ptr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
2748
	v := **p.Uint64Ptr()
2749
	return f.tagsize + protowire.SizeVarint(v)
2750
}
2751

2752
// appendUint64Ptr wire encodes a *uint64 pointer as a Uint64.
2753
// It panics if the pointer is nil.
2754
func appendUint64Ptr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
2755
	v := **p.Uint64Ptr()
2756
	b = protowire.AppendVarint(b, f.wiretag)
2757
	b = protowire.AppendVarint(b, v)
2758
	return b, nil
2759
}
2760

2761
// consumeUint64Ptr wire decodes a *uint64 pointer as a Uint64.
2762
func consumeUint64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
2763
	if wtyp != protowire.VarintType {
2764
		return out, errUnknown
2765
	}
2766
	var v uint64
2767
	var n int
2768
	if len(b) >= 1 && b[0] < 0x80 {
2769
		v = uint64(b[0])
2770
		n = 1
2771
	} else if len(b) >= 2 && b[1] < 128 {
2772
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
2773
		n = 2
2774
	} else {
2775
		v, n = protowire.ConsumeVarint(b)
2776
	}
2777
	if n < 0 {
2778
		return out, errDecode
2779
	}
2780
	vp := p.Uint64Ptr()
2781
	if *vp == nil {
2782
		*vp = new(uint64)
2783
	}
2784
	**vp = v
2785
	out.n = n
2786
	return out, nil
2787
}
2788

2789
var coderUint64Ptr = pointerCoderFuncs{
2790
	size:      sizeUint64Ptr,
2791
	marshal:   appendUint64Ptr,
2792
	unmarshal: consumeUint64Ptr,
2793
	merge:     mergeUint64Ptr,
2794
}
2795

2796
// sizeUint64Slice returns the size of wire encoding a []uint64 pointer as a repeated Uint64.
2797
func sizeUint64Slice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
2798
	s := *p.Uint64Slice()
2799
	for _, v := range s {
2800
		size += f.tagsize + protowire.SizeVarint(v)
2801
	}
2802
	return size
2803
}
2804

2805
// appendUint64Slice encodes a []uint64 pointer as a repeated Uint64.
2806
func appendUint64Slice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
2807
	s := *p.Uint64Slice()
2808
	for _, v := range s {
2809
		b = protowire.AppendVarint(b, f.wiretag)
2810
		b = protowire.AppendVarint(b, v)
2811
	}
2812
	return b, nil
2813
}
2814

2815
// consumeUint64Slice wire decodes a []uint64 pointer as a repeated Uint64.
2816
func consumeUint64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
2817
	sp := p.Uint64Slice()
2818
	if wtyp == protowire.BytesType {
2819
		b, n := protowire.ConsumeBytes(b)
2820
		if n < 0 {
2821
			return out, errDecode
2822
		}
2823
		count := 0
2824
		for _, v := range b {
2825
			if v < 0x80 {
2826
				count++
2827
			}
2828
		}
2829
		if count > 0 {
2830
			p.growUint64Slice(count)
2831
		}
2832
		s := *sp
2833
		for len(b) > 0 {
2834
			var v uint64
2835
			var n int
2836
			if len(b) >= 1 && b[0] < 0x80 {
2837
				v = uint64(b[0])
2838
				n = 1
2839
			} else if len(b) >= 2 && b[1] < 128 {
2840
				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
2841
				n = 2
2842
			} else {
2843
				v, n = protowire.ConsumeVarint(b)
2844
			}
2845
			if n < 0 {
2846
				return out, errDecode
2847
			}
2848
			s = append(s, v)
2849
			b = b[n:]
2850
		}
2851
		*sp = s
2852
		out.n = n
2853
		return out, nil
2854
	}
2855
	if wtyp != protowire.VarintType {
2856
		return out, errUnknown
2857
	}
2858
	var v uint64
2859
	var n int
2860
	if len(b) >= 1 && b[0] < 0x80 {
2861
		v = uint64(b[0])
2862
		n = 1
2863
	} else if len(b) >= 2 && b[1] < 128 {
2864
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
2865
		n = 2
2866
	} else {
2867
		v, n = protowire.ConsumeVarint(b)
2868
	}
2869
	if n < 0 {
2870
		return out, errDecode
2871
	}
2872
	*sp = append(*sp, v)
2873
	out.n = n
2874
	return out, nil
2875
}
2876

2877
var coderUint64Slice = pointerCoderFuncs{
2878
	size:      sizeUint64Slice,
2879
	marshal:   appendUint64Slice,
2880
	unmarshal: consumeUint64Slice,
2881
	merge:     mergeUint64Slice,
2882
}
2883

2884
// sizeUint64PackedSlice returns the size of wire encoding a []uint64 pointer as a packed repeated Uint64.
2885
func sizeUint64PackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
2886
	s := *p.Uint64Slice()
2887
	if len(s) == 0 {
2888
		return 0
2889
	}
2890
	n := 0
2891
	for _, v := range s {
2892
		n += protowire.SizeVarint(v)
2893
	}
2894
	return f.tagsize + protowire.SizeBytes(n)
2895
}
2896

2897
// appendUint64PackedSlice encodes a []uint64 pointer as a packed repeated Uint64.
2898
func appendUint64PackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
2899
	s := *p.Uint64Slice()
2900
	if len(s) == 0 {
2901
		return b, nil
2902
	}
2903
	b = protowire.AppendVarint(b, f.wiretag)
2904
	n := 0
2905
	for _, v := range s {
2906
		n += protowire.SizeVarint(v)
2907
	}
2908
	b = protowire.AppendVarint(b, uint64(n))
2909
	for _, v := range s {
2910
		b = protowire.AppendVarint(b, v)
2911
	}
2912
	return b, nil
2913
}
2914

2915
var coderUint64PackedSlice = pointerCoderFuncs{
2916
	size:      sizeUint64PackedSlice,
2917
	marshal:   appendUint64PackedSlice,
2918
	unmarshal: consumeUint64Slice,
2919
	merge:     mergeUint64Slice,
2920
}
2921

2922
// sizeUint64Value returns the size of wire encoding a uint64 value as a Uint64.
2923
func sizeUint64Value(v protoreflect.Value, tagsize int, opts marshalOptions) int {
2924
	return tagsize + protowire.SizeVarint(v.Uint())
2925
}
2926

2927
// appendUint64Value encodes a uint64 value as a Uint64.
2928
func appendUint64Value(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
2929
	b = protowire.AppendVarint(b, wiretag)
2930
	b = protowire.AppendVarint(b, v.Uint())
2931
	return b, nil
2932
}
2933

2934
// consumeUint64Value decodes a uint64 value as a Uint64.
2935
func consumeUint64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
2936
	if wtyp != protowire.VarintType {
2937
		return protoreflect.Value{}, out, errUnknown
2938
	}
2939
	var v uint64
2940
	var n int
2941
	if len(b) >= 1 && b[0] < 0x80 {
2942
		v = uint64(b[0])
2943
		n = 1
2944
	} else if len(b) >= 2 && b[1] < 128 {
2945
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
2946
		n = 2
2947
	} else {
2948
		v, n = protowire.ConsumeVarint(b)
2949
	}
2950
	if n < 0 {
2951
		return protoreflect.Value{}, out, errDecode
2952
	}
2953
	out.n = n
2954
	return protoreflect.ValueOfUint64(v), out, nil
2955
}
2956

2957
var coderUint64Value = valueCoderFuncs{
2958
	size:      sizeUint64Value,
2959
	marshal:   appendUint64Value,
2960
	unmarshal: consumeUint64Value,
2961
	merge:     mergeScalarValue,
2962
}
2963

2964
// sizeUint64SliceValue returns the size of wire encoding a []uint64 value as a repeated Uint64.
2965
func sizeUint64SliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
2966
	list := listv.List()
2967
	for i, llen := 0, list.Len(); i < llen; i++ {
2968
		v := list.Get(i)
2969
		size += tagsize + protowire.SizeVarint(v.Uint())
2970
	}
2971
	return size
2972
}
2973

2974
// appendUint64SliceValue encodes a []uint64 value as a repeated Uint64.
2975
func appendUint64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
2976
	list := listv.List()
2977
	for i, llen := 0, list.Len(); i < llen; i++ {
2978
		v := list.Get(i)
2979
		b = protowire.AppendVarint(b, wiretag)
2980
		b = protowire.AppendVarint(b, v.Uint())
2981
	}
2982
	return b, nil
2983
}
2984

2985
// consumeUint64SliceValue wire decodes a []uint64 value as a repeated Uint64.
2986
func consumeUint64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
2987
	list := listv.List()
2988
	if wtyp == protowire.BytesType {
2989
		b, n := protowire.ConsumeBytes(b)
2990
		if n < 0 {
2991
			return protoreflect.Value{}, out, errDecode
2992
		}
2993
		for len(b) > 0 {
2994
			var v uint64
2995
			var n int
2996
			if len(b) >= 1 && b[0] < 0x80 {
2997
				v = uint64(b[0])
2998
				n = 1
2999
			} else if len(b) >= 2 && b[1] < 128 {
3000
				v = uint64(b[0]&0x7f) + uint64(b[1])<<7
3001
				n = 2
3002
			} else {
3003
				v, n = protowire.ConsumeVarint(b)
3004
			}
3005
			if n < 0 {
3006
				return protoreflect.Value{}, out, errDecode
3007
			}
3008
			list.Append(protoreflect.ValueOfUint64(v))
3009
			b = b[n:]
3010
		}
3011
		out.n = n
3012
		return listv, out, nil
3013
	}
3014
	if wtyp != protowire.VarintType {
3015
		return protoreflect.Value{}, out, errUnknown
3016
	}
3017
	var v uint64
3018
	var n int
3019
	if len(b) >= 1 && b[0] < 0x80 {
3020
		v = uint64(b[0])
3021
		n = 1
3022
	} else if len(b) >= 2 && b[1] < 128 {
3023
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
3024
		n = 2
3025
	} else {
3026
		v, n = protowire.ConsumeVarint(b)
3027
	}
3028
	if n < 0 {
3029
		return protoreflect.Value{}, out, errDecode
3030
	}
3031
	list.Append(protoreflect.ValueOfUint64(v))
3032
	out.n = n
3033
	return listv, out, nil
3034
}
3035

3036
var coderUint64SliceValue = valueCoderFuncs{
3037
	size:      sizeUint64SliceValue,
3038
	marshal:   appendUint64SliceValue,
3039
	unmarshal: consumeUint64SliceValue,
3040
	merge:     mergeListValue,
3041
}
3042

3043
// sizeUint64PackedSliceValue returns the size of wire encoding a []uint64 value as a packed repeated Uint64.
3044
func sizeUint64PackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
3045
	list := listv.List()
3046
	llen := list.Len()
3047
	if llen == 0 {
3048
		return 0
3049
	}
3050
	n := 0
3051
	for i, llen := 0, llen; i < llen; i++ {
3052
		v := list.Get(i)
3053
		n += protowire.SizeVarint(v.Uint())
3054
	}
3055
	return tagsize + protowire.SizeBytes(n)
3056
}
3057

3058
// appendUint64PackedSliceValue encodes a []uint64 value as a packed repeated Uint64.
3059
func appendUint64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
3060
	list := listv.List()
3061
	llen := list.Len()
3062
	if llen == 0 {
3063
		return b, nil
3064
	}
3065
	b = protowire.AppendVarint(b, wiretag)
3066
	n := 0
3067
	for i := 0; i < llen; i++ {
3068
		v := list.Get(i)
3069
		n += protowire.SizeVarint(v.Uint())
3070
	}
3071
	b = protowire.AppendVarint(b, uint64(n))
3072
	for i := 0; i < llen; i++ {
3073
		v := list.Get(i)
3074
		b = protowire.AppendVarint(b, v.Uint())
3075
	}
3076
	return b, nil
3077
}
3078

3079
var coderUint64PackedSliceValue = valueCoderFuncs{
3080
	size:      sizeUint64PackedSliceValue,
3081
	marshal:   appendUint64PackedSliceValue,
3082
	unmarshal: consumeUint64SliceValue,
3083
	merge:     mergeListValue,
3084
}
3085

3086
// sizeSfixed32 returns the size of wire encoding a int32 pointer as a Sfixed32.
3087
func sizeSfixed32(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
3088

3089
	return f.tagsize + protowire.SizeFixed32()
3090
}
3091

3092
// appendSfixed32 wire encodes a int32 pointer as a Sfixed32.
3093
func appendSfixed32(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
3094
	v := *p.Int32()
3095
	b = protowire.AppendVarint(b, f.wiretag)
3096
	b = protowire.AppendFixed32(b, uint32(v))
3097
	return b, nil
3098
}
3099

3100
// consumeSfixed32 wire decodes a int32 pointer as a Sfixed32.
3101
func consumeSfixed32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
3102
	if wtyp != protowire.Fixed32Type {
3103
		return out, errUnknown
3104
	}
3105
	v, n := protowire.ConsumeFixed32(b)
3106
	if n < 0 {
3107
		return out, errDecode
3108
	}
3109
	*p.Int32() = int32(v)
3110
	out.n = n
3111
	return out, nil
3112
}
3113

3114
var coderSfixed32 = pointerCoderFuncs{
3115
	size:      sizeSfixed32,
3116
	marshal:   appendSfixed32,
3117
	unmarshal: consumeSfixed32,
3118
	merge:     mergeInt32,
3119
}
3120

3121
// sizeSfixed32NoZero returns the size of wire encoding a int32 pointer as a Sfixed32.
3122
// The zero value is not encoded.
3123
func sizeSfixed32NoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
3124
	v := *p.Int32()
3125
	if v == 0 {
3126
		return 0
3127
	}
3128
	return f.tagsize + protowire.SizeFixed32()
3129
}
3130

3131
// appendSfixed32NoZero wire encodes a int32 pointer as a Sfixed32.
3132
// The zero value is not encoded.
3133
func appendSfixed32NoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
3134
	v := *p.Int32()
3135
	if v == 0 {
3136
		return b, nil
3137
	}
3138
	b = protowire.AppendVarint(b, f.wiretag)
3139
	b = protowire.AppendFixed32(b, uint32(v))
3140
	return b, nil
3141
}
3142

3143
var coderSfixed32NoZero = pointerCoderFuncs{
3144
	size:      sizeSfixed32NoZero,
3145
	marshal:   appendSfixed32NoZero,
3146
	unmarshal: consumeSfixed32,
3147
	merge:     mergeInt32NoZero,
3148
}
3149

3150
// sizeSfixed32Ptr returns the size of wire encoding a *int32 pointer as a Sfixed32.
3151
// It panics if the pointer is nil.
3152
func sizeSfixed32Ptr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
3153
	return f.tagsize + protowire.SizeFixed32()
3154
}
3155

3156
// appendSfixed32Ptr wire encodes a *int32 pointer as a Sfixed32.
3157
// It panics if the pointer is nil.
3158
func appendSfixed32Ptr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
3159
	v := **p.Int32Ptr()
3160
	b = protowire.AppendVarint(b, f.wiretag)
3161
	b = protowire.AppendFixed32(b, uint32(v))
3162
	return b, nil
3163
}
3164

3165
// consumeSfixed32Ptr wire decodes a *int32 pointer as a Sfixed32.
3166
func consumeSfixed32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
3167
	if wtyp != protowire.Fixed32Type {
3168
		return out, errUnknown
3169
	}
3170
	v, n := protowire.ConsumeFixed32(b)
3171
	if n < 0 {
3172
		return out, errDecode
3173
	}
3174
	vp := p.Int32Ptr()
3175
	if *vp == nil {
3176
		*vp = new(int32)
3177
	}
3178
	**vp = int32(v)
3179
	out.n = n
3180
	return out, nil
3181
}
3182

3183
var coderSfixed32Ptr = pointerCoderFuncs{
3184
	size:      sizeSfixed32Ptr,
3185
	marshal:   appendSfixed32Ptr,
3186
	unmarshal: consumeSfixed32Ptr,
3187
	merge:     mergeInt32Ptr,
3188
}
3189

3190
// sizeSfixed32Slice returns the size of wire encoding a []int32 pointer as a repeated Sfixed32.
3191
func sizeSfixed32Slice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
3192
	s := *p.Int32Slice()
3193
	size = len(s) * (f.tagsize + protowire.SizeFixed32())
3194
	return size
3195
}
3196

3197
// appendSfixed32Slice encodes a []int32 pointer as a repeated Sfixed32.
3198
func appendSfixed32Slice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
3199
	s := *p.Int32Slice()
3200
	for _, v := range s {
3201
		b = protowire.AppendVarint(b, f.wiretag)
3202
		b = protowire.AppendFixed32(b, uint32(v))
3203
	}
3204
	return b, nil
3205
}
3206

3207
// consumeSfixed32Slice wire decodes a []int32 pointer as a repeated Sfixed32.
3208
func consumeSfixed32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
3209
	sp := p.Int32Slice()
3210
	if wtyp == protowire.BytesType {
3211
		b, n := protowire.ConsumeBytes(b)
3212
		if n < 0 {
3213
			return out, errDecode
3214
		}
3215
		count := len(b) / protowire.SizeFixed32()
3216
		if count > 0 {
3217
			p.growInt32Slice(count)
3218
		}
3219
		s := *sp
3220
		for len(b) > 0 {
3221
			v, n := protowire.ConsumeFixed32(b)
3222
			if n < 0 {
3223
				return out, errDecode
3224
			}
3225
			s = append(s, int32(v))
3226
			b = b[n:]
3227
		}
3228
		*sp = s
3229
		out.n = n
3230
		return out, nil
3231
	}
3232
	if wtyp != protowire.Fixed32Type {
3233
		return out, errUnknown
3234
	}
3235
	v, n := protowire.ConsumeFixed32(b)
3236
	if n < 0 {
3237
		return out, errDecode
3238
	}
3239
	*sp = append(*sp, int32(v))
3240
	out.n = n
3241
	return out, nil
3242
}
3243

3244
var coderSfixed32Slice = pointerCoderFuncs{
3245
	size:      sizeSfixed32Slice,
3246
	marshal:   appendSfixed32Slice,
3247
	unmarshal: consumeSfixed32Slice,
3248
	merge:     mergeInt32Slice,
3249
}
3250

3251
// sizeSfixed32PackedSlice returns the size of wire encoding a []int32 pointer as a packed repeated Sfixed32.
3252
func sizeSfixed32PackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
3253
	s := *p.Int32Slice()
3254
	if len(s) == 0 {
3255
		return 0
3256
	}
3257
	n := len(s) * protowire.SizeFixed32()
3258
	return f.tagsize + protowire.SizeBytes(n)
3259
}
3260

3261
// appendSfixed32PackedSlice encodes a []int32 pointer as a packed repeated Sfixed32.
3262
func appendSfixed32PackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
3263
	s := *p.Int32Slice()
3264
	if len(s) == 0 {
3265
		return b, nil
3266
	}
3267
	b = protowire.AppendVarint(b, f.wiretag)
3268
	n := len(s) * protowire.SizeFixed32()
3269
	b = protowire.AppendVarint(b, uint64(n))
3270
	for _, v := range s {
3271
		b = protowire.AppendFixed32(b, uint32(v))
3272
	}
3273
	return b, nil
3274
}
3275

3276
var coderSfixed32PackedSlice = pointerCoderFuncs{
3277
	size:      sizeSfixed32PackedSlice,
3278
	marshal:   appendSfixed32PackedSlice,
3279
	unmarshal: consumeSfixed32Slice,
3280
	merge:     mergeInt32Slice,
3281
}
3282

3283
// sizeSfixed32Value returns the size of wire encoding a int32 value as a Sfixed32.
3284
func sizeSfixed32Value(v protoreflect.Value, tagsize int, opts marshalOptions) int {
3285
	return tagsize + protowire.SizeFixed32()
3286
}
3287

3288
// appendSfixed32Value encodes a int32 value as a Sfixed32.
3289
func appendSfixed32Value(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
3290
	b = protowire.AppendVarint(b, wiretag)
3291
	b = protowire.AppendFixed32(b, uint32(v.Int()))
3292
	return b, nil
3293
}
3294

3295
// consumeSfixed32Value decodes a int32 value as a Sfixed32.
3296
func consumeSfixed32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
3297
	if wtyp != protowire.Fixed32Type {
3298
		return protoreflect.Value{}, out, errUnknown
3299
	}
3300
	v, n := protowire.ConsumeFixed32(b)
3301
	if n < 0 {
3302
		return protoreflect.Value{}, out, errDecode
3303
	}
3304
	out.n = n
3305
	return protoreflect.ValueOfInt32(int32(v)), out, nil
3306
}
3307

3308
var coderSfixed32Value = valueCoderFuncs{
3309
	size:      sizeSfixed32Value,
3310
	marshal:   appendSfixed32Value,
3311
	unmarshal: consumeSfixed32Value,
3312
	merge:     mergeScalarValue,
3313
}
3314

3315
// sizeSfixed32SliceValue returns the size of wire encoding a []int32 value as a repeated Sfixed32.
3316
func sizeSfixed32SliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
3317
	list := listv.List()
3318
	size = list.Len() * (tagsize + protowire.SizeFixed32())
3319
	return size
3320
}
3321

3322
// appendSfixed32SliceValue encodes a []int32 value as a repeated Sfixed32.
3323
func appendSfixed32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
3324
	list := listv.List()
3325
	for i, llen := 0, list.Len(); i < llen; i++ {
3326
		v := list.Get(i)
3327
		b = protowire.AppendVarint(b, wiretag)
3328
		b = protowire.AppendFixed32(b, uint32(v.Int()))
3329
	}
3330
	return b, nil
3331
}
3332

3333
// consumeSfixed32SliceValue wire decodes a []int32 value as a repeated Sfixed32.
3334
func consumeSfixed32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
3335
	list := listv.List()
3336
	if wtyp == protowire.BytesType {
3337
		b, n := protowire.ConsumeBytes(b)
3338
		if n < 0 {
3339
			return protoreflect.Value{}, out, errDecode
3340
		}
3341
		for len(b) > 0 {
3342
			v, n := protowire.ConsumeFixed32(b)
3343
			if n < 0 {
3344
				return protoreflect.Value{}, out, errDecode
3345
			}
3346
			list.Append(protoreflect.ValueOfInt32(int32(v)))
3347
			b = b[n:]
3348
		}
3349
		out.n = n
3350
		return listv, out, nil
3351
	}
3352
	if wtyp != protowire.Fixed32Type {
3353
		return protoreflect.Value{}, out, errUnknown
3354
	}
3355
	v, n := protowire.ConsumeFixed32(b)
3356
	if n < 0 {
3357
		return protoreflect.Value{}, out, errDecode
3358
	}
3359
	list.Append(protoreflect.ValueOfInt32(int32(v)))
3360
	out.n = n
3361
	return listv, out, nil
3362
}
3363

3364
var coderSfixed32SliceValue = valueCoderFuncs{
3365
	size:      sizeSfixed32SliceValue,
3366
	marshal:   appendSfixed32SliceValue,
3367
	unmarshal: consumeSfixed32SliceValue,
3368
	merge:     mergeListValue,
3369
}
3370

3371
// sizeSfixed32PackedSliceValue returns the size of wire encoding a []int32 value as a packed repeated Sfixed32.
3372
func sizeSfixed32PackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
3373
	list := listv.List()
3374
	llen := list.Len()
3375
	if llen == 0 {
3376
		return 0
3377
	}
3378
	n := llen * protowire.SizeFixed32()
3379
	return tagsize + protowire.SizeBytes(n)
3380
}
3381

3382
// appendSfixed32PackedSliceValue encodes a []int32 value as a packed repeated Sfixed32.
3383
func appendSfixed32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
3384
	list := listv.List()
3385
	llen := list.Len()
3386
	if llen == 0 {
3387
		return b, nil
3388
	}
3389
	b = protowire.AppendVarint(b, wiretag)
3390
	n := llen * protowire.SizeFixed32()
3391
	b = protowire.AppendVarint(b, uint64(n))
3392
	for i := 0; i < llen; i++ {
3393
		v := list.Get(i)
3394
		b = protowire.AppendFixed32(b, uint32(v.Int()))
3395
	}
3396
	return b, nil
3397
}
3398

3399
var coderSfixed32PackedSliceValue = valueCoderFuncs{
3400
	size:      sizeSfixed32PackedSliceValue,
3401
	marshal:   appendSfixed32PackedSliceValue,
3402
	unmarshal: consumeSfixed32SliceValue,
3403
	merge:     mergeListValue,
3404
}
3405

3406
// sizeFixed32 returns the size of wire encoding a uint32 pointer as a Fixed32.
3407
func sizeFixed32(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
3408

3409
	return f.tagsize + protowire.SizeFixed32()
3410
}
3411

3412
// appendFixed32 wire encodes a uint32 pointer as a Fixed32.
3413
func appendFixed32(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
3414
	v := *p.Uint32()
3415
	b = protowire.AppendVarint(b, f.wiretag)
3416
	b = protowire.AppendFixed32(b, v)
3417
	return b, nil
3418
}
3419

3420
// consumeFixed32 wire decodes a uint32 pointer as a Fixed32.
3421
func consumeFixed32(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
3422
	if wtyp != protowire.Fixed32Type {
3423
		return out, errUnknown
3424
	}
3425
	v, n := protowire.ConsumeFixed32(b)
3426
	if n < 0 {
3427
		return out, errDecode
3428
	}
3429
	*p.Uint32() = v
3430
	out.n = n
3431
	return out, nil
3432
}
3433

3434
var coderFixed32 = pointerCoderFuncs{
3435
	size:      sizeFixed32,
3436
	marshal:   appendFixed32,
3437
	unmarshal: consumeFixed32,
3438
	merge:     mergeUint32,
3439
}
3440

3441
// sizeFixed32NoZero returns the size of wire encoding a uint32 pointer as a Fixed32.
3442
// The zero value is not encoded.
3443
func sizeFixed32NoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
3444
	v := *p.Uint32()
3445
	if v == 0 {
3446
		return 0
3447
	}
3448
	return f.tagsize + protowire.SizeFixed32()
3449
}
3450

3451
// appendFixed32NoZero wire encodes a uint32 pointer as a Fixed32.
3452
// The zero value is not encoded.
3453
func appendFixed32NoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
3454
	v := *p.Uint32()
3455
	if v == 0 {
3456
		return b, nil
3457
	}
3458
	b = protowire.AppendVarint(b, f.wiretag)
3459
	b = protowire.AppendFixed32(b, v)
3460
	return b, nil
3461
}
3462

3463
var coderFixed32NoZero = pointerCoderFuncs{
3464
	size:      sizeFixed32NoZero,
3465
	marshal:   appendFixed32NoZero,
3466
	unmarshal: consumeFixed32,
3467
	merge:     mergeUint32NoZero,
3468
}
3469

3470
// sizeFixed32Ptr returns the size of wire encoding a *uint32 pointer as a Fixed32.
3471
// It panics if the pointer is nil.
3472
func sizeFixed32Ptr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
3473
	return f.tagsize + protowire.SizeFixed32()
3474
}
3475

3476
// appendFixed32Ptr wire encodes a *uint32 pointer as a Fixed32.
3477
// It panics if the pointer is nil.
3478
func appendFixed32Ptr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
3479
	v := **p.Uint32Ptr()
3480
	b = protowire.AppendVarint(b, f.wiretag)
3481
	b = protowire.AppendFixed32(b, v)
3482
	return b, nil
3483
}
3484

3485
// consumeFixed32Ptr wire decodes a *uint32 pointer as a Fixed32.
3486
func consumeFixed32Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
3487
	if wtyp != protowire.Fixed32Type {
3488
		return out, errUnknown
3489
	}
3490
	v, n := protowire.ConsumeFixed32(b)
3491
	if n < 0 {
3492
		return out, errDecode
3493
	}
3494
	vp := p.Uint32Ptr()
3495
	if *vp == nil {
3496
		*vp = new(uint32)
3497
	}
3498
	**vp = v
3499
	out.n = n
3500
	return out, nil
3501
}
3502

3503
var coderFixed32Ptr = pointerCoderFuncs{
3504
	size:      sizeFixed32Ptr,
3505
	marshal:   appendFixed32Ptr,
3506
	unmarshal: consumeFixed32Ptr,
3507
	merge:     mergeUint32Ptr,
3508
}
3509

3510
// sizeFixed32Slice returns the size of wire encoding a []uint32 pointer as a repeated Fixed32.
3511
func sizeFixed32Slice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
3512
	s := *p.Uint32Slice()
3513
	size = len(s) * (f.tagsize + protowire.SizeFixed32())
3514
	return size
3515
}
3516

3517
// appendFixed32Slice encodes a []uint32 pointer as a repeated Fixed32.
3518
func appendFixed32Slice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
3519
	s := *p.Uint32Slice()
3520
	for _, v := range s {
3521
		b = protowire.AppendVarint(b, f.wiretag)
3522
		b = protowire.AppendFixed32(b, v)
3523
	}
3524
	return b, nil
3525
}
3526

3527
// consumeFixed32Slice wire decodes a []uint32 pointer as a repeated Fixed32.
3528
func consumeFixed32Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
3529
	sp := p.Uint32Slice()
3530
	if wtyp == protowire.BytesType {
3531
		b, n := protowire.ConsumeBytes(b)
3532
		if n < 0 {
3533
			return out, errDecode
3534
		}
3535
		count := len(b) / protowire.SizeFixed32()
3536
		if count > 0 {
3537
			p.growUint32Slice(count)
3538
		}
3539
		s := *sp
3540
		for len(b) > 0 {
3541
			v, n := protowire.ConsumeFixed32(b)
3542
			if n < 0 {
3543
				return out, errDecode
3544
			}
3545
			s = append(s, v)
3546
			b = b[n:]
3547
		}
3548
		*sp = s
3549
		out.n = n
3550
		return out, nil
3551
	}
3552
	if wtyp != protowire.Fixed32Type {
3553
		return out, errUnknown
3554
	}
3555
	v, n := protowire.ConsumeFixed32(b)
3556
	if n < 0 {
3557
		return out, errDecode
3558
	}
3559
	*sp = append(*sp, v)
3560
	out.n = n
3561
	return out, nil
3562
}
3563

3564
var coderFixed32Slice = pointerCoderFuncs{
3565
	size:      sizeFixed32Slice,
3566
	marshal:   appendFixed32Slice,
3567
	unmarshal: consumeFixed32Slice,
3568
	merge:     mergeUint32Slice,
3569
}
3570

3571
// sizeFixed32PackedSlice returns the size of wire encoding a []uint32 pointer as a packed repeated Fixed32.
3572
func sizeFixed32PackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
3573
	s := *p.Uint32Slice()
3574
	if len(s) == 0 {
3575
		return 0
3576
	}
3577
	n := len(s) * protowire.SizeFixed32()
3578
	return f.tagsize + protowire.SizeBytes(n)
3579
}
3580

3581
// appendFixed32PackedSlice encodes a []uint32 pointer as a packed repeated Fixed32.
3582
func appendFixed32PackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
3583
	s := *p.Uint32Slice()
3584
	if len(s) == 0 {
3585
		return b, nil
3586
	}
3587
	b = protowire.AppendVarint(b, f.wiretag)
3588
	n := len(s) * protowire.SizeFixed32()
3589
	b = protowire.AppendVarint(b, uint64(n))
3590
	for _, v := range s {
3591
		b = protowire.AppendFixed32(b, v)
3592
	}
3593
	return b, nil
3594
}
3595

3596
var coderFixed32PackedSlice = pointerCoderFuncs{
3597
	size:      sizeFixed32PackedSlice,
3598
	marshal:   appendFixed32PackedSlice,
3599
	unmarshal: consumeFixed32Slice,
3600
	merge:     mergeUint32Slice,
3601
}
3602

3603
// sizeFixed32Value returns the size of wire encoding a uint32 value as a Fixed32.
3604
func sizeFixed32Value(v protoreflect.Value, tagsize int, opts marshalOptions) int {
3605
	return tagsize + protowire.SizeFixed32()
3606
}
3607

3608
// appendFixed32Value encodes a uint32 value as a Fixed32.
3609
func appendFixed32Value(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
3610
	b = protowire.AppendVarint(b, wiretag)
3611
	b = protowire.AppendFixed32(b, uint32(v.Uint()))
3612
	return b, nil
3613
}
3614

3615
// consumeFixed32Value decodes a uint32 value as a Fixed32.
3616
func consumeFixed32Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
3617
	if wtyp != protowire.Fixed32Type {
3618
		return protoreflect.Value{}, out, errUnknown
3619
	}
3620
	v, n := protowire.ConsumeFixed32(b)
3621
	if n < 0 {
3622
		return protoreflect.Value{}, out, errDecode
3623
	}
3624
	out.n = n
3625
	return protoreflect.ValueOfUint32(uint32(v)), out, nil
3626
}
3627

3628
var coderFixed32Value = valueCoderFuncs{
3629
	size:      sizeFixed32Value,
3630
	marshal:   appendFixed32Value,
3631
	unmarshal: consumeFixed32Value,
3632
	merge:     mergeScalarValue,
3633
}
3634

3635
// sizeFixed32SliceValue returns the size of wire encoding a []uint32 value as a repeated Fixed32.
3636
func sizeFixed32SliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
3637
	list := listv.List()
3638
	size = list.Len() * (tagsize + protowire.SizeFixed32())
3639
	return size
3640
}
3641

3642
// appendFixed32SliceValue encodes a []uint32 value as a repeated Fixed32.
3643
func appendFixed32SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
3644
	list := listv.List()
3645
	for i, llen := 0, list.Len(); i < llen; i++ {
3646
		v := list.Get(i)
3647
		b = protowire.AppendVarint(b, wiretag)
3648
		b = protowire.AppendFixed32(b, uint32(v.Uint()))
3649
	}
3650
	return b, nil
3651
}
3652

3653
// consumeFixed32SliceValue wire decodes a []uint32 value as a repeated Fixed32.
3654
func consumeFixed32SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
3655
	list := listv.List()
3656
	if wtyp == protowire.BytesType {
3657
		b, n := protowire.ConsumeBytes(b)
3658
		if n < 0 {
3659
			return protoreflect.Value{}, out, errDecode
3660
		}
3661
		for len(b) > 0 {
3662
			v, n := protowire.ConsumeFixed32(b)
3663
			if n < 0 {
3664
				return protoreflect.Value{}, out, errDecode
3665
			}
3666
			list.Append(protoreflect.ValueOfUint32(uint32(v)))
3667
			b = b[n:]
3668
		}
3669
		out.n = n
3670
		return listv, out, nil
3671
	}
3672
	if wtyp != protowire.Fixed32Type {
3673
		return protoreflect.Value{}, out, errUnknown
3674
	}
3675
	v, n := protowire.ConsumeFixed32(b)
3676
	if n < 0 {
3677
		return protoreflect.Value{}, out, errDecode
3678
	}
3679
	list.Append(protoreflect.ValueOfUint32(uint32(v)))
3680
	out.n = n
3681
	return listv, out, nil
3682
}
3683

3684
var coderFixed32SliceValue = valueCoderFuncs{
3685
	size:      sizeFixed32SliceValue,
3686
	marshal:   appendFixed32SliceValue,
3687
	unmarshal: consumeFixed32SliceValue,
3688
	merge:     mergeListValue,
3689
}
3690

3691
// sizeFixed32PackedSliceValue returns the size of wire encoding a []uint32 value as a packed repeated Fixed32.
3692
func sizeFixed32PackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
3693
	list := listv.List()
3694
	llen := list.Len()
3695
	if llen == 0 {
3696
		return 0
3697
	}
3698
	n := llen * protowire.SizeFixed32()
3699
	return tagsize + protowire.SizeBytes(n)
3700
}
3701

3702
// appendFixed32PackedSliceValue encodes a []uint32 value as a packed repeated Fixed32.
3703
func appendFixed32PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
3704
	list := listv.List()
3705
	llen := list.Len()
3706
	if llen == 0 {
3707
		return b, nil
3708
	}
3709
	b = protowire.AppendVarint(b, wiretag)
3710
	n := llen * protowire.SizeFixed32()
3711
	b = protowire.AppendVarint(b, uint64(n))
3712
	for i := 0; i < llen; i++ {
3713
		v := list.Get(i)
3714
		b = protowire.AppendFixed32(b, uint32(v.Uint()))
3715
	}
3716
	return b, nil
3717
}
3718

3719
var coderFixed32PackedSliceValue = valueCoderFuncs{
3720
	size:      sizeFixed32PackedSliceValue,
3721
	marshal:   appendFixed32PackedSliceValue,
3722
	unmarshal: consumeFixed32SliceValue,
3723
	merge:     mergeListValue,
3724
}
3725

3726
// sizeFloat returns the size of wire encoding a float32 pointer as a Float.
3727
func sizeFloat(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
3728

3729
	return f.tagsize + protowire.SizeFixed32()
3730
}
3731

3732
// appendFloat wire encodes a float32 pointer as a Float.
3733
func appendFloat(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
3734
	v := *p.Float32()
3735
	b = protowire.AppendVarint(b, f.wiretag)
3736
	b = protowire.AppendFixed32(b, math.Float32bits(v))
3737
	return b, nil
3738
}
3739

3740
// consumeFloat wire decodes a float32 pointer as a Float.
3741
func consumeFloat(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
3742
	if wtyp != protowire.Fixed32Type {
3743
		return out, errUnknown
3744
	}
3745
	v, n := protowire.ConsumeFixed32(b)
3746
	if n < 0 {
3747
		return out, errDecode
3748
	}
3749
	*p.Float32() = math.Float32frombits(v)
3750
	out.n = n
3751
	return out, nil
3752
}
3753

3754
var coderFloat = pointerCoderFuncs{
3755
	size:      sizeFloat,
3756
	marshal:   appendFloat,
3757
	unmarshal: consumeFloat,
3758
	merge:     mergeFloat32,
3759
}
3760

3761
// sizeFloatNoZero returns the size of wire encoding a float32 pointer as a Float.
3762
// The zero value is not encoded.
3763
func sizeFloatNoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
3764
	v := *p.Float32()
3765
	if v == 0 && !math.Signbit(float64(v)) {
3766
		return 0
3767
	}
3768
	return f.tagsize + protowire.SizeFixed32()
3769
}
3770

3771
// appendFloatNoZero wire encodes a float32 pointer as a Float.
3772
// The zero value is not encoded.
3773
func appendFloatNoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
3774
	v := *p.Float32()
3775
	if v == 0 && !math.Signbit(float64(v)) {
3776
		return b, nil
3777
	}
3778
	b = protowire.AppendVarint(b, f.wiretag)
3779
	b = protowire.AppendFixed32(b, math.Float32bits(v))
3780
	return b, nil
3781
}
3782

3783
var coderFloatNoZero = pointerCoderFuncs{
3784
	size:      sizeFloatNoZero,
3785
	marshal:   appendFloatNoZero,
3786
	unmarshal: consumeFloat,
3787
	merge:     mergeFloat32NoZero,
3788
}
3789

3790
// sizeFloatPtr returns the size of wire encoding a *float32 pointer as a Float.
3791
// It panics if the pointer is nil.
3792
func sizeFloatPtr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
3793
	return f.tagsize + protowire.SizeFixed32()
3794
}
3795

3796
// appendFloatPtr wire encodes a *float32 pointer as a Float.
3797
// It panics if the pointer is nil.
3798
func appendFloatPtr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
3799
	v := **p.Float32Ptr()
3800
	b = protowire.AppendVarint(b, f.wiretag)
3801
	b = protowire.AppendFixed32(b, math.Float32bits(v))
3802
	return b, nil
3803
}
3804

3805
// consumeFloatPtr wire decodes a *float32 pointer as a Float.
3806
func consumeFloatPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
3807
	if wtyp != protowire.Fixed32Type {
3808
		return out, errUnknown
3809
	}
3810
	v, n := protowire.ConsumeFixed32(b)
3811
	if n < 0 {
3812
		return out, errDecode
3813
	}
3814
	vp := p.Float32Ptr()
3815
	if *vp == nil {
3816
		*vp = new(float32)
3817
	}
3818
	**vp = math.Float32frombits(v)
3819
	out.n = n
3820
	return out, nil
3821
}
3822

3823
var coderFloatPtr = pointerCoderFuncs{
3824
	size:      sizeFloatPtr,
3825
	marshal:   appendFloatPtr,
3826
	unmarshal: consumeFloatPtr,
3827
	merge:     mergeFloat32Ptr,
3828
}
3829

3830
// sizeFloatSlice returns the size of wire encoding a []float32 pointer as a repeated Float.
3831
func sizeFloatSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
3832
	s := *p.Float32Slice()
3833
	size = len(s) * (f.tagsize + protowire.SizeFixed32())
3834
	return size
3835
}
3836

3837
// appendFloatSlice encodes a []float32 pointer as a repeated Float.
3838
func appendFloatSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
3839
	s := *p.Float32Slice()
3840
	for _, v := range s {
3841
		b = protowire.AppendVarint(b, f.wiretag)
3842
		b = protowire.AppendFixed32(b, math.Float32bits(v))
3843
	}
3844
	return b, nil
3845
}
3846

3847
// consumeFloatSlice wire decodes a []float32 pointer as a repeated Float.
3848
func consumeFloatSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
3849
	sp := p.Float32Slice()
3850
	if wtyp == protowire.BytesType {
3851
		b, n := protowire.ConsumeBytes(b)
3852
		if n < 0 {
3853
			return out, errDecode
3854
		}
3855
		count := len(b) / protowire.SizeFixed32()
3856
		if count > 0 {
3857
			p.growFloat32Slice(count)
3858
		}
3859
		s := *sp
3860
		for len(b) > 0 {
3861
			v, n := protowire.ConsumeFixed32(b)
3862
			if n < 0 {
3863
				return out, errDecode
3864
			}
3865
			s = append(s, math.Float32frombits(v))
3866
			b = b[n:]
3867
		}
3868
		*sp = s
3869
		out.n = n
3870
		return out, nil
3871
	}
3872
	if wtyp != protowire.Fixed32Type {
3873
		return out, errUnknown
3874
	}
3875
	v, n := protowire.ConsumeFixed32(b)
3876
	if n < 0 {
3877
		return out, errDecode
3878
	}
3879
	*sp = append(*sp, math.Float32frombits(v))
3880
	out.n = n
3881
	return out, nil
3882
}
3883

3884
var coderFloatSlice = pointerCoderFuncs{
3885
	size:      sizeFloatSlice,
3886
	marshal:   appendFloatSlice,
3887
	unmarshal: consumeFloatSlice,
3888
	merge:     mergeFloat32Slice,
3889
}
3890

3891
// sizeFloatPackedSlice returns the size of wire encoding a []float32 pointer as a packed repeated Float.
3892
func sizeFloatPackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
3893
	s := *p.Float32Slice()
3894
	if len(s) == 0 {
3895
		return 0
3896
	}
3897
	n := len(s) * protowire.SizeFixed32()
3898
	return f.tagsize + protowire.SizeBytes(n)
3899
}
3900

3901
// appendFloatPackedSlice encodes a []float32 pointer as a packed repeated Float.
3902
func appendFloatPackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
3903
	s := *p.Float32Slice()
3904
	if len(s) == 0 {
3905
		return b, nil
3906
	}
3907
	b = protowire.AppendVarint(b, f.wiretag)
3908
	n := len(s) * protowire.SizeFixed32()
3909
	b = protowire.AppendVarint(b, uint64(n))
3910
	for _, v := range s {
3911
		b = protowire.AppendFixed32(b, math.Float32bits(v))
3912
	}
3913
	return b, nil
3914
}
3915

3916
var coderFloatPackedSlice = pointerCoderFuncs{
3917
	size:      sizeFloatPackedSlice,
3918
	marshal:   appendFloatPackedSlice,
3919
	unmarshal: consumeFloatSlice,
3920
	merge:     mergeFloat32Slice,
3921
}
3922

3923
// sizeFloatValue returns the size of wire encoding a float32 value as a Float.
3924
func sizeFloatValue(v protoreflect.Value, tagsize int, opts marshalOptions) int {
3925
	return tagsize + protowire.SizeFixed32()
3926
}
3927

3928
// appendFloatValue encodes a float32 value as a Float.
3929
func appendFloatValue(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
3930
	b = protowire.AppendVarint(b, wiretag)
3931
	b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
3932
	return b, nil
3933
}
3934

3935
// consumeFloatValue decodes a float32 value as a Float.
3936
func consumeFloatValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
3937
	if wtyp != protowire.Fixed32Type {
3938
		return protoreflect.Value{}, out, errUnknown
3939
	}
3940
	v, n := protowire.ConsumeFixed32(b)
3941
	if n < 0 {
3942
		return protoreflect.Value{}, out, errDecode
3943
	}
3944
	out.n = n
3945
	return protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))), out, nil
3946
}
3947

3948
var coderFloatValue = valueCoderFuncs{
3949
	size:      sizeFloatValue,
3950
	marshal:   appendFloatValue,
3951
	unmarshal: consumeFloatValue,
3952
	merge:     mergeScalarValue,
3953
}
3954

3955
// sizeFloatSliceValue returns the size of wire encoding a []float32 value as a repeated Float.
3956
func sizeFloatSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
3957
	list := listv.List()
3958
	size = list.Len() * (tagsize + protowire.SizeFixed32())
3959
	return size
3960
}
3961

3962
// appendFloatSliceValue encodes a []float32 value as a repeated Float.
3963
func appendFloatSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
3964
	list := listv.List()
3965
	for i, llen := 0, list.Len(); i < llen; i++ {
3966
		v := list.Get(i)
3967
		b = protowire.AppendVarint(b, wiretag)
3968
		b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
3969
	}
3970
	return b, nil
3971
}
3972

3973
// consumeFloatSliceValue wire decodes a []float32 value as a repeated Float.
3974
func consumeFloatSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
3975
	list := listv.List()
3976
	if wtyp == protowire.BytesType {
3977
		b, n := protowire.ConsumeBytes(b)
3978
		if n < 0 {
3979
			return protoreflect.Value{}, out, errDecode
3980
		}
3981
		for len(b) > 0 {
3982
			v, n := protowire.ConsumeFixed32(b)
3983
			if n < 0 {
3984
				return protoreflect.Value{}, out, errDecode
3985
			}
3986
			list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
3987
			b = b[n:]
3988
		}
3989
		out.n = n
3990
		return listv, out, nil
3991
	}
3992
	if wtyp != protowire.Fixed32Type {
3993
		return protoreflect.Value{}, out, errUnknown
3994
	}
3995
	v, n := protowire.ConsumeFixed32(b)
3996
	if n < 0 {
3997
		return protoreflect.Value{}, out, errDecode
3998
	}
3999
	list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
4000
	out.n = n
4001
	return listv, out, nil
4002
}
4003

4004
var coderFloatSliceValue = valueCoderFuncs{
4005
	size:      sizeFloatSliceValue,
4006
	marshal:   appendFloatSliceValue,
4007
	unmarshal: consumeFloatSliceValue,
4008
	merge:     mergeListValue,
4009
}
4010

4011
// sizeFloatPackedSliceValue returns the size of wire encoding a []float32 value as a packed repeated Float.
4012
func sizeFloatPackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
4013
	list := listv.List()
4014
	llen := list.Len()
4015
	if llen == 0 {
4016
		return 0
4017
	}
4018
	n := llen * protowire.SizeFixed32()
4019
	return tagsize + protowire.SizeBytes(n)
4020
}
4021

4022
// appendFloatPackedSliceValue encodes a []float32 value as a packed repeated Float.
4023
func appendFloatPackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
4024
	list := listv.List()
4025
	llen := list.Len()
4026
	if llen == 0 {
4027
		return b, nil
4028
	}
4029
	b = protowire.AppendVarint(b, wiretag)
4030
	n := llen * protowire.SizeFixed32()
4031
	b = protowire.AppendVarint(b, uint64(n))
4032
	for i := 0; i < llen; i++ {
4033
		v := list.Get(i)
4034
		b = protowire.AppendFixed32(b, math.Float32bits(float32(v.Float())))
4035
	}
4036
	return b, nil
4037
}
4038

4039
var coderFloatPackedSliceValue = valueCoderFuncs{
4040
	size:      sizeFloatPackedSliceValue,
4041
	marshal:   appendFloatPackedSliceValue,
4042
	unmarshal: consumeFloatSliceValue,
4043
	merge:     mergeListValue,
4044
}
4045

4046
// sizeSfixed64 returns the size of wire encoding a int64 pointer as a Sfixed64.
4047
func sizeSfixed64(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
4048

4049
	return f.tagsize + protowire.SizeFixed64()
4050
}
4051

4052
// appendSfixed64 wire encodes a int64 pointer as a Sfixed64.
4053
func appendSfixed64(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
4054
	v := *p.Int64()
4055
	b = protowire.AppendVarint(b, f.wiretag)
4056
	b = protowire.AppendFixed64(b, uint64(v))
4057
	return b, nil
4058
}
4059

4060
// consumeSfixed64 wire decodes a int64 pointer as a Sfixed64.
4061
func consumeSfixed64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
4062
	if wtyp != protowire.Fixed64Type {
4063
		return out, errUnknown
4064
	}
4065
	v, n := protowire.ConsumeFixed64(b)
4066
	if n < 0 {
4067
		return out, errDecode
4068
	}
4069
	*p.Int64() = int64(v)
4070
	out.n = n
4071
	return out, nil
4072
}
4073

4074
var coderSfixed64 = pointerCoderFuncs{
4075
	size:      sizeSfixed64,
4076
	marshal:   appendSfixed64,
4077
	unmarshal: consumeSfixed64,
4078
	merge:     mergeInt64,
4079
}
4080

4081
// sizeSfixed64NoZero returns the size of wire encoding a int64 pointer as a Sfixed64.
4082
// The zero value is not encoded.
4083
func sizeSfixed64NoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
4084
	v := *p.Int64()
4085
	if v == 0 {
4086
		return 0
4087
	}
4088
	return f.tagsize + protowire.SizeFixed64()
4089
}
4090

4091
// appendSfixed64NoZero wire encodes a int64 pointer as a Sfixed64.
4092
// The zero value is not encoded.
4093
func appendSfixed64NoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
4094
	v := *p.Int64()
4095
	if v == 0 {
4096
		return b, nil
4097
	}
4098
	b = protowire.AppendVarint(b, f.wiretag)
4099
	b = protowire.AppendFixed64(b, uint64(v))
4100
	return b, nil
4101
}
4102

4103
var coderSfixed64NoZero = pointerCoderFuncs{
4104
	size:      sizeSfixed64NoZero,
4105
	marshal:   appendSfixed64NoZero,
4106
	unmarshal: consumeSfixed64,
4107
	merge:     mergeInt64NoZero,
4108
}
4109

4110
// sizeSfixed64Ptr returns the size of wire encoding a *int64 pointer as a Sfixed64.
4111
// It panics if the pointer is nil.
4112
func sizeSfixed64Ptr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
4113
	return f.tagsize + protowire.SizeFixed64()
4114
}
4115

4116
// appendSfixed64Ptr wire encodes a *int64 pointer as a Sfixed64.
4117
// It panics if the pointer is nil.
4118
func appendSfixed64Ptr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
4119
	v := **p.Int64Ptr()
4120
	b = protowire.AppendVarint(b, f.wiretag)
4121
	b = protowire.AppendFixed64(b, uint64(v))
4122
	return b, nil
4123
}
4124

4125
// consumeSfixed64Ptr wire decodes a *int64 pointer as a Sfixed64.
4126
func consumeSfixed64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
4127
	if wtyp != protowire.Fixed64Type {
4128
		return out, errUnknown
4129
	}
4130
	v, n := protowire.ConsumeFixed64(b)
4131
	if n < 0 {
4132
		return out, errDecode
4133
	}
4134
	vp := p.Int64Ptr()
4135
	if *vp == nil {
4136
		*vp = new(int64)
4137
	}
4138
	**vp = int64(v)
4139
	out.n = n
4140
	return out, nil
4141
}
4142

4143
var coderSfixed64Ptr = pointerCoderFuncs{
4144
	size:      sizeSfixed64Ptr,
4145
	marshal:   appendSfixed64Ptr,
4146
	unmarshal: consumeSfixed64Ptr,
4147
	merge:     mergeInt64Ptr,
4148
}
4149

4150
// sizeSfixed64Slice returns the size of wire encoding a []int64 pointer as a repeated Sfixed64.
4151
func sizeSfixed64Slice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
4152
	s := *p.Int64Slice()
4153
	size = len(s) * (f.tagsize + protowire.SizeFixed64())
4154
	return size
4155
}
4156

4157
// appendSfixed64Slice encodes a []int64 pointer as a repeated Sfixed64.
4158
func appendSfixed64Slice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
4159
	s := *p.Int64Slice()
4160
	for _, v := range s {
4161
		b = protowire.AppendVarint(b, f.wiretag)
4162
		b = protowire.AppendFixed64(b, uint64(v))
4163
	}
4164
	return b, nil
4165
}
4166

4167
// consumeSfixed64Slice wire decodes a []int64 pointer as a repeated Sfixed64.
4168
func consumeSfixed64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
4169
	sp := p.Int64Slice()
4170
	if wtyp == protowire.BytesType {
4171
		b, n := protowire.ConsumeBytes(b)
4172
		if n < 0 {
4173
			return out, errDecode
4174
		}
4175
		count := len(b) / protowire.SizeFixed64()
4176
		if count > 0 {
4177
			p.growInt64Slice(count)
4178
		}
4179
		s := *sp
4180
		for len(b) > 0 {
4181
			v, n := protowire.ConsumeFixed64(b)
4182
			if n < 0 {
4183
				return out, errDecode
4184
			}
4185
			s = append(s, int64(v))
4186
			b = b[n:]
4187
		}
4188
		*sp = s
4189
		out.n = n
4190
		return out, nil
4191
	}
4192
	if wtyp != protowire.Fixed64Type {
4193
		return out, errUnknown
4194
	}
4195
	v, n := protowire.ConsumeFixed64(b)
4196
	if n < 0 {
4197
		return out, errDecode
4198
	}
4199
	*sp = append(*sp, int64(v))
4200
	out.n = n
4201
	return out, nil
4202
}
4203

4204
var coderSfixed64Slice = pointerCoderFuncs{
4205
	size:      sizeSfixed64Slice,
4206
	marshal:   appendSfixed64Slice,
4207
	unmarshal: consumeSfixed64Slice,
4208
	merge:     mergeInt64Slice,
4209
}
4210

4211
// sizeSfixed64PackedSlice returns the size of wire encoding a []int64 pointer as a packed repeated Sfixed64.
4212
func sizeSfixed64PackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
4213
	s := *p.Int64Slice()
4214
	if len(s) == 0 {
4215
		return 0
4216
	}
4217
	n := len(s) * protowire.SizeFixed64()
4218
	return f.tagsize + protowire.SizeBytes(n)
4219
}
4220

4221
// appendSfixed64PackedSlice encodes a []int64 pointer as a packed repeated Sfixed64.
4222
func appendSfixed64PackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
4223
	s := *p.Int64Slice()
4224
	if len(s) == 0 {
4225
		return b, nil
4226
	}
4227
	b = protowire.AppendVarint(b, f.wiretag)
4228
	n := len(s) * protowire.SizeFixed64()
4229
	b = protowire.AppendVarint(b, uint64(n))
4230
	for _, v := range s {
4231
		b = protowire.AppendFixed64(b, uint64(v))
4232
	}
4233
	return b, nil
4234
}
4235

4236
var coderSfixed64PackedSlice = pointerCoderFuncs{
4237
	size:      sizeSfixed64PackedSlice,
4238
	marshal:   appendSfixed64PackedSlice,
4239
	unmarshal: consumeSfixed64Slice,
4240
	merge:     mergeInt64Slice,
4241
}
4242

4243
// sizeSfixed64Value returns the size of wire encoding a int64 value as a Sfixed64.
4244
func sizeSfixed64Value(v protoreflect.Value, tagsize int, opts marshalOptions) int {
4245
	return tagsize + protowire.SizeFixed64()
4246
}
4247

4248
// appendSfixed64Value encodes a int64 value as a Sfixed64.
4249
func appendSfixed64Value(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
4250
	b = protowire.AppendVarint(b, wiretag)
4251
	b = protowire.AppendFixed64(b, uint64(v.Int()))
4252
	return b, nil
4253
}
4254

4255
// consumeSfixed64Value decodes a int64 value as a Sfixed64.
4256
func consumeSfixed64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
4257
	if wtyp != protowire.Fixed64Type {
4258
		return protoreflect.Value{}, out, errUnknown
4259
	}
4260
	v, n := protowire.ConsumeFixed64(b)
4261
	if n < 0 {
4262
		return protoreflect.Value{}, out, errDecode
4263
	}
4264
	out.n = n
4265
	return protoreflect.ValueOfInt64(int64(v)), out, nil
4266
}
4267

4268
var coderSfixed64Value = valueCoderFuncs{
4269
	size:      sizeSfixed64Value,
4270
	marshal:   appendSfixed64Value,
4271
	unmarshal: consumeSfixed64Value,
4272
	merge:     mergeScalarValue,
4273
}
4274

4275
// sizeSfixed64SliceValue returns the size of wire encoding a []int64 value as a repeated Sfixed64.
4276
func sizeSfixed64SliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
4277
	list := listv.List()
4278
	size = list.Len() * (tagsize + protowire.SizeFixed64())
4279
	return size
4280
}
4281

4282
// appendSfixed64SliceValue encodes a []int64 value as a repeated Sfixed64.
4283
func appendSfixed64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
4284
	list := listv.List()
4285
	for i, llen := 0, list.Len(); i < llen; i++ {
4286
		v := list.Get(i)
4287
		b = protowire.AppendVarint(b, wiretag)
4288
		b = protowire.AppendFixed64(b, uint64(v.Int()))
4289
	}
4290
	return b, nil
4291
}
4292

4293
// consumeSfixed64SliceValue wire decodes a []int64 value as a repeated Sfixed64.
4294
func consumeSfixed64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
4295
	list := listv.List()
4296
	if wtyp == protowire.BytesType {
4297
		b, n := protowire.ConsumeBytes(b)
4298
		if n < 0 {
4299
			return protoreflect.Value{}, out, errDecode
4300
		}
4301
		for len(b) > 0 {
4302
			v, n := protowire.ConsumeFixed64(b)
4303
			if n < 0 {
4304
				return protoreflect.Value{}, out, errDecode
4305
			}
4306
			list.Append(protoreflect.ValueOfInt64(int64(v)))
4307
			b = b[n:]
4308
		}
4309
		out.n = n
4310
		return listv, out, nil
4311
	}
4312
	if wtyp != protowire.Fixed64Type {
4313
		return protoreflect.Value{}, out, errUnknown
4314
	}
4315
	v, n := protowire.ConsumeFixed64(b)
4316
	if n < 0 {
4317
		return protoreflect.Value{}, out, errDecode
4318
	}
4319
	list.Append(protoreflect.ValueOfInt64(int64(v)))
4320
	out.n = n
4321
	return listv, out, nil
4322
}
4323

4324
var coderSfixed64SliceValue = valueCoderFuncs{
4325
	size:      sizeSfixed64SliceValue,
4326
	marshal:   appendSfixed64SliceValue,
4327
	unmarshal: consumeSfixed64SliceValue,
4328
	merge:     mergeListValue,
4329
}
4330

4331
// sizeSfixed64PackedSliceValue returns the size of wire encoding a []int64 value as a packed repeated Sfixed64.
4332
func sizeSfixed64PackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
4333
	list := listv.List()
4334
	llen := list.Len()
4335
	if llen == 0 {
4336
		return 0
4337
	}
4338
	n := llen * protowire.SizeFixed64()
4339
	return tagsize + protowire.SizeBytes(n)
4340
}
4341

4342
// appendSfixed64PackedSliceValue encodes a []int64 value as a packed repeated Sfixed64.
4343
func appendSfixed64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
4344
	list := listv.List()
4345
	llen := list.Len()
4346
	if llen == 0 {
4347
		return b, nil
4348
	}
4349
	b = protowire.AppendVarint(b, wiretag)
4350
	n := llen * protowire.SizeFixed64()
4351
	b = protowire.AppendVarint(b, uint64(n))
4352
	for i := 0; i < llen; i++ {
4353
		v := list.Get(i)
4354
		b = protowire.AppendFixed64(b, uint64(v.Int()))
4355
	}
4356
	return b, nil
4357
}
4358

4359
var coderSfixed64PackedSliceValue = valueCoderFuncs{
4360
	size:      sizeSfixed64PackedSliceValue,
4361
	marshal:   appendSfixed64PackedSliceValue,
4362
	unmarshal: consumeSfixed64SliceValue,
4363
	merge:     mergeListValue,
4364
}
4365

4366
// sizeFixed64 returns the size of wire encoding a uint64 pointer as a Fixed64.
4367
func sizeFixed64(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
4368

4369
	return f.tagsize + protowire.SizeFixed64()
4370
}
4371

4372
// appendFixed64 wire encodes a uint64 pointer as a Fixed64.
4373
func appendFixed64(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
4374
	v := *p.Uint64()
4375
	b = protowire.AppendVarint(b, f.wiretag)
4376
	b = protowire.AppendFixed64(b, v)
4377
	return b, nil
4378
}
4379

4380
// consumeFixed64 wire decodes a uint64 pointer as a Fixed64.
4381
func consumeFixed64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
4382
	if wtyp != protowire.Fixed64Type {
4383
		return out, errUnknown
4384
	}
4385
	v, n := protowire.ConsumeFixed64(b)
4386
	if n < 0 {
4387
		return out, errDecode
4388
	}
4389
	*p.Uint64() = v
4390
	out.n = n
4391
	return out, nil
4392
}
4393

4394
var coderFixed64 = pointerCoderFuncs{
4395
	size:      sizeFixed64,
4396
	marshal:   appendFixed64,
4397
	unmarshal: consumeFixed64,
4398
	merge:     mergeUint64,
4399
}
4400

4401
// sizeFixed64NoZero returns the size of wire encoding a uint64 pointer as a Fixed64.
4402
// The zero value is not encoded.
4403
func sizeFixed64NoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
4404
	v := *p.Uint64()
4405
	if v == 0 {
4406
		return 0
4407
	}
4408
	return f.tagsize + protowire.SizeFixed64()
4409
}
4410

4411
// appendFixed64NoZero wire encodes a uint64 pointer as a Fixed64.
4412
// The zero value is not encoded.
4413
func appendFixed64NoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
4414
	v := *p.Uint64()
4415
	if v == 0 {
4416
		return b, nil
4417
	}
4418
	b = protowire.AppendVarint(b, f.wiretag)
4419
	b = protowire.AppendFixed64(b, v)
4420
	return b, nil
4421
}
4422

4423
var coderFixed64NoZero = pointerCoderFuncs{
4424
	size:      sizeFixed64NoZero,
4425
	marshal:   appendFixed64NoZero,
4426
	unmarshal: consumeFixed64,
4427
	merge:     mergeUint64NoZero,
4428
}
4429

4430
// sizeFixed64Ptr returns the size of wire encoding a *uint64 pointer as a Fixed64.
4431
// It panics if the pointer is nil.
4432
func sizeFixed64Ptr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
4433
	return f.tagsize + protowire.SizeFixed64()
4434
}
4435

4436
// appendFixed64Ptr wire encodes a *uint64 pointer as a Fixed64.
4437
// It panics if the pointer is nil.
4438
func appendFixed64Ptr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
4439
	v := **p.Uint64Ptr()
4440
	b = protowire.AppendVarint(b, f.wiretag)
4441
	b = protowire.AppendFixed64(b, v)
4442
	return b, nil
4443
}
4444

4445
// consumeFixed64Ptr wire decodes a *uint64 pointer as a Fixed64.
4446
func consumeFixed64Ptr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
4447
	if wtyp != protowire.Fixed64Type {
4448
		return out, errUnknown
4449
	}
4450
	v, n := protowire.ConsumeFixed64(b)
4451
	if n < 0 {
4452
		return out, errDecode
4453
	}
4454
	vp := p.Uint64Ptr()
4455
	if *vp == nil {
4456
		*vp = new(uint64)
4457
	}
4458
	**vp = v
4459
	out.n = n
4460
	return out, nil
4461
}
4462

4463
var coderFixed64Ptr = pointerCoderFuncs{
4464
	size:      sizeFixed64Ptr,
4465
	marshal:   appendFixed64Ptr,
4466
	unmarshal: consumeFixed64Ptr,
4467
	merge:     mergeUint64Ptr,
4468
}
4469

4470
// sizeFixed64Slice returns the size of wire encoding a []uint64 pointer as a repeated Fixed64.
4471
func sizeFixed64Slice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
4472
	s := *p.Uint64Slice()
4473
	size = len(s) * (f.tagsize + protowire.SizeFixed64())
4474
	return size
4475
}
4476

4477
// appendFixed64Slice encodes a []uint64 pointer as a repeated Fixed64.
4478
func appendFixed64Slice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
4479
	s := *p.Uint64Slice()
4480
	for _, v := range s {
4481
		b = protowire.AppendVarint(b, f.wiretag)
4482
		b = protowire.AppendFixed64(b, v)
4483
	}
4484
	return b, nil
4485
}
4486

4487
// consumeFixed64Slice wire decodes a []uint64 pointer as a repeated Fixed64.
4488
func consumeFixed64Slice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
4489
	sp := p.Uint64Slice()
4490
	if wtyp == protowire.BytesType {
4491
		b, n := protowire.ConsumeBytes(b)
4492
		if n < 0 {
4493
			return out, errDecode
4494
		}
4495
		count := len(b) / protowire.SizeFixed64()
4496
		if count > 0 {
4497
			p.growUint64Slice(count)
4498
		}
4499
		s := *sp
4500
		for len(b) > 0 {
4501
			v, n := protowire.ConsumeFixed64(b)
4502
			if n < 0 {
4503
				return out, errDecode
4504
			}
4505
			s = append(s, v)
4506
			b = b[n:]
4507
		}
4508
		*sp = s
4509
		out.n = n
4510
		return out, nil
4511
	}
4512
	if wtyp != protowire.Fixed64Type {
4513
		return out, errUnknown
4514
	}
4515
	v, n := protowire.ConsumeFixed64(b)
4516
	if n < 0 {
4517
		return out, errDecode
4518
	}
4519
	*sp = append(*sp, v)
4520
	out.n = n
4521
	return out, nil
4522
}
4523

4524
var coderFixed64Slice = pointerCoderFuncs{
4525
	size:      sizeFixed64Slice,
4526
	marshal:   appendFixed64Slice,
4527
	unmarshal: consumeFixed64Slice,
4528
	merge:     mergeUint64Slice,
4529
}
4530

4531
// sizeFixed64PackedSlice returns the size of wire encoding a []uint64 pointer as a packed repeated Fixed64.
4532
func sizeFixed64PackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
4533
	s := *p.Uint64Slice()
4534
	if len(s) == 0 {
4535
		return 0
4536
	}
4537
	n := len(s) * protowire.SizeFixed64()
4538
	return f.tagsize + protowire.SizeBytes(n)
4539
}
4540

4541
// appendFixed64PackedSlice encodes a []uint64 pointer as a packed repeated Fixed64.
4542
func appendFixed64PackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
4543
	s := *p.Uint64Slice()
4544
	if len(s) == 0 {
4545
		return b, nil
4546
	}
4547
	b = protowire.AppendVarint(b, f.wiretag)
4548
	n := len(s) * protowire.SizeFixed64()
4549
	b = protowire.AppendVarint(b, uint64(n))
4550
	for _, v := range s {
4551
		b = protowire.AppendFixed64(b, v)
4552
	}
4553
	return b, nil
4554
}
4555

4556
var coderFixed64PackedSlice = pointerCoderFuncs{
4557
	size:      sizeFixed64PackedSlice,
4558
	marshal:   appendFixed64PackedSlice,
4559
	unmarshal: consumeFixed64Slice,
4560
	merge:     mergeUint64Slice,
4561
}
4562

4563
// sizeFixed64Value returns the size of wire encoding a uint64 value as a Fixed64.
4564
func sizeFixed64Value(v protoreflect.Value, tagsize int, opts marshalOptions) int {
4565
	return tagsize + protowire.SizeFixed64()
4566
}
4567

4568
// appendFixed64Value encodes a uint64 value as a Fixed64.
4569
func appendFixed64Value(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
4570
	b = protowire.AppendVarint(b, wiretag)
4571
	b = protowire.AppendFixed64(b, v.Uint())
4572
	return b, nil
4573
}
4574

4575
// consumeFixed64Value decodes a uint64 value as a Fixed64.
4576
func consumeFixed64Value(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
4577
	if wtyp != protowire.Fixed64Type {
4578
		return protoreflect.Value{}, out, errUnknown
4579
	}
4580
	v, n := protowire.ConsumeFixed64(b)
4581
	if n < 0 {
4582
		return protoreflect.Value{}, out, errDecode
4583
	}
4584
	out.n = n
4585
	return protoreflect.ValueOfUint64(v), out, nil
4586
}
4587

4588
var coderFixed64Value = valueCoderFuncs{
4589
	size:      sizeFixed64Value,
4590
	marshal:   appendFixed64Value,
4591
	unmarshal: consumeFixed64Value,
4592
	merge:     mergeScalarValue,
4593
}
4594

4595
// sizeFixed64SliceValue returns the size of wire encoding a []uint64 value as a repeated Fixed64.
4596
func sizeFixed64SliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
4597
	list := listv.List()
4598
	size = list.Len() * (tagsize + protowire.SizeFixed64())
4599
	return size
4600
}
4601

4602
// appendFixed64SliceValue encodes a []uint64 value as a repeated Fixed64.
4603
func appendFixed64SliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
4604
	list := listv.List()
4605
	for i, llen := 0, list.Len(); i < llen; i++ {
4606
		v := list.Get(i)
4607
		b = protowire.AppendVarint(b, wiretag)
4608
		b = protowire.AppendFixed64(b, v.Uint())
4609
	}
4610
	return b, nil
4611
}
4612

4613
// consumeFixed64SliceValue wire decodes a []uint64 value as a repeated Fixed64.
4614
func consumeFixed64SliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
4615
	list := listv.List()
4616
	if wtyp == protowire.BytesType {
4617
		b, n := protowire.ConsumeBytes(b)
4618
		if n < 0 {
4619
			return protoreflect.Value{}, out, errDecode
4620
		}
4621
		for len(b) > 0 {
4622
			v, n := protowire.ConsumeFixed64(b)
4623
			if n < 0 {
4624
				return protoreflect.Value{}, out, errDecode
4625
			}
4626
			list.Append(protoreflect.ValueOfUint64(v))
4627
			b = b[n:]
4628
		}
4629
		out.n = n
4630
		return listv, out, nil
4631
	}
4632
	if wtyp != protowire.Fixed64Type {
4633
		return protoreflect.Value{}, out, errUnknown
4634
	}
4635
	v, n := protowire.ConsumeFixed64(b)
4636
	if n < 0 {
4637
		return protoreflect.Value{}, out, errDecode
4638
	}
4639
	list.Append(protoreflect.ValueOfUint64(v))
4640
	out.n = n
4641
	return listv, out, nil
4642
}
4643

4644
var coderFixed64SliceValue = valueCoderFuncs{
4645
	size:      sizeFixed64SliceValue,
4646
	marshal:   appendFixed64SliceValue,
4647
	unmarshal: consumeFixed64SliceValue,
4648
	merge:     mergeListValue,
4649
}
4650

4651
// sizeFixed64PackedSliceValue returns the size of wire encoding a []uint64 value as a packed repeated Fixed64.
4652
func sizeFixed64PackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
4653
	list := listv.List()
4654
	llen := list.Len()
4655
	if llen == 0 {
4656
		return 0
4657
	}
4658
	n := llen * protowire.SizeFixed64()
4659
	return tagsize + protowire.SizeBytes(n)
4660
}
4661

4662
// appendFixed64PackedSliceValue encodes a []uint64 value as a packed repeated Fixed64.
4663
func appendFixed64PackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
4664
	list := listv.List()
4665
	llen := list.Len()
4666
	if llen == 0 {
4667
		return b, nil
4668
	}
4669
	b = protowire.AppendVarint(b, wiretag)
4670
	n := llen * protowire.SizeFixed64()
4671
	b = protowire.AppendVarint(b, uint64(n))
4672
	for i := 0; i < llen; i++ {
4673
		v := list.Get(i)
4674
		b = protowire.AppendFixed64(b, v.Uint())
4675
	}
4676
	return b, nil
4677
}
4678

4679
var coderFixed64PackedSliceValue = valueCoderFuncs{
4680
	size:      sizeFixed64PackedSliceValue,
4681
	marshal:   appendFixed64PackedSliceValue,
4682
	unmarshal: consumeFixed64SliceValue,
4683
	merge:     mergeListValue,
4684
}
4685

4686
// sizeDouble returns the size of wire encoding a float64 pointer as a Double.
4687
func sizeDouble(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
4688

4689
	return f.tagsize + protowire.SizeFixed64()
4690
}
4691

4692
// appendDouble wire encodes a float64 pointer as a Double.
4693
func appendDouble(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
4694
	v := *p.Float64()
4695
	b = protowire.AppendVarint(b, f.wiretag)
4696
	b = protowire.AppendFixed64(b, math.Float64bits(v))
4697
	return b, nil
4698
}
4699

4700
// consumeDouble wire decodes a float64 pointer as a Double.
4701
func consumeDouble(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
4702
	if wtyp != protowire.Fixed64Type {
4703
		return out, errUnknown
4704
	}
4705
	v, n := protowire.ConsumeFixed64(b)
4706
	if n < 0 {
4707
		return out, errDecode
4708
	}
4709
	*p.Float64() = math.Float64frombits(v)
4710
	out.n = n
4711
	return out, nil
4712
}
4713

4714
var coderDouble = pointerCoderFuncs{
4715
	size:      sizeDouble,
4716
	marshal:   appendDouble,
4717
	unmarshal: consumeDouble,
4718
	merge:     mergeFloat64,
4719
}
4720

4721
// sizeDoubleNoZero returns the size of wire encoding a float64 pointer as a Double.
4722
// The zero value is not encoded.
4723
func sizeDoubleNoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
4724
	v := *p.Float64()
4725
	if v == 0 && !math.Signbit(float64(v)) {
4726
		return 0
4727
	}
4728
	return f.tagsize + protowire.SizeFixed64()
4729
}
4730

4731
// appendDoubleNoZero wire encodes a float64 pointer as a Double.
4732
// The zero value is not encoded.
4733
func appendDoubleNoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
4734
	v := *p.Float64()
4735
	if v == 0 && !math.Signbit(float64(v)) {
4736
		return b, nil
4737
	}
4738
	b = protowire.AppendVarint(b, f.wiretag)
4739
	b = protowire.AppendFixed64(b, math.Float64bits(v))
4740
	return b, nil
4741
}
4742

4743
var coderDoubleNoZero = pointerCoderFuncs{
4744
	size:      sizeDoubleNoZero,
4745
	marshal:   appendDoubleNoZero,
4746
	unmarshal: consumeDouble,
4747
	merge:     mergeFloat64NoZero,
4748
}
4749

4750
// sizeDoublePtr returns the size of wire encoding a *float64 pointer as a Double.
4751
// It panics if the pointer is nil.
4752
func sizeDoublePtr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
4753
	return f.tagsize + protowire.SizeFixed64()
4754
}
4755

4756
// appendDoublePtr wire encodes a *float64 pointer as a Double.
4757
// It panics if the pointer is nil.
4758
func appendDoublePtr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
4759
	v := **p.Float64Ptr()
4760
	b = protowire.AppendVarint(b, f.wiretag)
4761
	b = protowire.AppendFixed64(b, math.Float64bits(v))
4762
	return b, nil
4763
}
4764

4765
// consumeDoublePtr wire decodes a *float64 pointer as a Double.
4766
func consumeDoublePtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
4767
	if wtyp != protowire.Fixed64Type {
4768
		return out, errUnknown
4769
	}
4770
	v, n := protowire.ConsumeFixed64(b)
4771
	if n < 0 {
4772
		return out, errDecode
4773
	}
4774
	vp := p.Float64Ptr()
4775
	if *vp == nil {
4776
		*vp = new(float64)
4777
	}
4778
	**vp = math.Float64frombits(v)
4779
	out.n = n
4780
	return out, nil
4781
}
4782

4783
var coderDoublePtr = pointerCoderFuncs{
4784
	size:      sizeDoublePtr,
4785
	marshal:   appendDoublePtr,
4786
	unmarshal: consumeDoublePtr,
4787
	merge:     mergeFloat64Ptr,
4788
}
4789

4790
// sizeDoubleSlice returns the size of wire encoding a []float64 pointer as a repeated Double.
4791
func sizeDoubleSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
4792
	s := *p.Float64Slice()
4793
	size = len(s) * (f.tagsize + protowire.SizeFixed64())
4794
	return size
4795
}
4796

4797
// appendDoubleSlice encodes a []float64 pointer as a repeated Double.
4798
func appendDoubleSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
4799
	s := *p.Float64Slice()
4800
	for _, v := range s {
4801
		b = protowire.AppendVarint(b, f.wiretag)
4802
		b = protowire.AppendFixed64(b, math.Float64bits(v))
4803
	}
4804
	return b, nil
4805
}
4806

4807
// consumeDoubleSlice wire decodes a []float64 pointer as a repeated Double.
4808
func consumeDoubleSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
4809
	sp := p.Float64Slice()
4810
	if wtyp == protowire.BytesType {
4811
		b, n := protowire.ConsumeBytes(b)
4812
		if n < 0 {
4813
			return out, errDecode
4814
		}
4815
		count := len(b) / protowire.SizeFixed64()
4816
		if count > 0 {
4817
			p.growFloat64Slice(count)
4818
		}
4819
		s := *sp
4820
		for len(b) > 0 {
4821
			v, n := protowire.ConsumeFixed64(b)
4822
			if n < 0 {
4823
				return out, errDecode
4824
			}
4825
			s = append(s, math.Float64frombits(v))
4826
			b = b[n:]
4827
		}
4828
		*sp = s
4829
		out.n = n
4830
		return out, nil
4831
	}
4832
	if wtyp != protowire.Fixed64Type {
4833
		return out, errUnknown
4834
	}
4835
	v, n := protowire.ConsumeFixed64(b)
4836
	if n < 0 {
4837
		return out, errDecode
4838
	}
4839
	*sp = append(*sp, math.Float64frombits(v))
4840
	out.n = n
4841
	return out, nil
4842
}
4843

4844
var coderDoubleSlice = pointerCoderFuncs{
4845
	size:      sizeDoubleSlice,
4846
	marshal:   appendDoubleSlice,
4847
	unmarshal: consumeDoubleSlice,
4848
	merge:     mergeFloat64Slice,
4849
}
4850

4851
// sizeDoublePackedSlice returns the size of wire encoding a []float64 pointer as a packed repeated Double.
4852
func sizeDoublePackedSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
4853
	s := *p.Float64Slice()
4854
	if len(s) == 0 {
4855
		return 0
4856
	}
4857
	n := len(s) * protowire.SizeFixed64()
4858
	return f.tagsize + protowire.SizeBytes(n)
4859
}
4860

4861
// appendDoublePackedSlice encodes a []float64 pointer as a packed repeated Double.
4862
func appendDoublePackedSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
4863
	s := *p.Float64Slice()
4864
	if len(s) == 0 {
4865
		return b, nil
4866
	}
4867
	b = protowire.AppendVarint(b, f.wiretag)
4868
	n := len(s) * protowire.SizeFixed64()
4869
	b = protowire.AppendVarint(b, uint64(n))
4870
	for _, v := range s {
4871
		b = protowire.AppendFixed64(b, math.Float64bits(v))
4872
	}
4873
	return b, nil
4874
}
4875

4876
var coderDoublePackedSlice = pointerCoderFuncs{
4877
	size:      sizeDoublePackedSlice,
4878
	marshal:   appendDoublePackedSlice,
4879
	unmarshal: consumeDoubleSlice,
4880
	merge:     mergeFloat64Slice,
4881
}
4882

4883
// sizeDoubleValue returns the size of wire encoding a float64 value as a Double.
4884
func sizeDoubleValue(v protoreflect.Value, tagsize int, opts marshalOptions) int {
4885
	return tagsize + protowire.SizeFixed64()
4886
}
4887

4888
// appendDoubleValue encodes a float64 value as a Double.
4889
func appendDoubleValue(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
4890
	b = protowire.AppendVarint(b, wiretag)
4891
	b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
4892
	return b, nil
4893
}
4894

4895
// consumeDoubleValue decodes a float64 value as a Double.
4896
func consumeDoubleValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
4897
	if wtyp != protowire.Fixed64Type {
4898
		return protoreflect.Value{}, out, errUnknown
4899
	}
4900
	v, n := protowire.ConsumeFixed64(b)
4901
	if n < 0 {
4902
		return protoreflect.Value{}, out, errDecode
4903
	}
4904
	out.n = n
4905
	return protoreflect.ValueOfFloat64(math.Float64frombits(v)), out, nil
4906
}
4907

4908
var coderDoubleValue = valueCoderFuncs{
4909
	size:      sizeDoubleValue,
4910
	marshal:   appendDoubleValue,
4911
	unmarshal: consumeDoubleValue,
4912
	merge:     mergeScalarValue,
4913
}
4914

4915
// sizeDoubleSliceValue returns the size of wire encoding a []float64 value as a repeated Double.
4916
func sizeDoubleSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
4917
	list := listv.List()
4918
	size = list.Len() * (tagsize + protowire.SizeFixed64())
4919
	return size
4920
}
4921

4922
// appendDoubleSliceValue encodes a []float64 value as a repeated Double.
4923
func appendDoubleSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
4924
	list := listv.List()
4925
	for i, llen := 0, list.Len(); i < llen; i++ {
4926
		v := list.Get(i)
4927
		b = protowire.AppendVarint(b, wiretag)
4928
		b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
4929
	}
4930
	return b, nil
4931
}
4932

4933
// consumeDoubleSliceValue wire decodes a []float64 value as a repeated Double.
4934
func consumeDoubleSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
4935
	list := listv.List()
4936
	if wtyp == protowire.BytesType {
4937
		b, n := protowire.ConsumeBytes(b)
4938
		if n < 0 {
4939
			return protoreflect.Value{}, out, errDecode
4940
		}
4941
		for len(b) > 0 {
4942
			v, n := protowire.ConsumeFixed64(b)
4943
			if n < 0 {
4944
				return protoreflect.Value{}, out, errDecode
4945
			}
4946
			list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
4947
			b = b[n:]
4948
		}
4949
		out.n = n
4950
		return listv, out, nil
4951
	}
4952
	if wtyp != protowire.Fixed64Type {
4953
		return protoreflect.Value{}, out, errUnknown
4954
	}
4955
	v, n := protowire.ConsumeFixed64(b)
4956
	if n < 0 {
4957
		return protoreflect.Value{}, out, errDecode
4958
	}
4959
	list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
4960
	out.n = n
4961
	return listv, out, nil
4962
}
4963

4964
var coderDoubleSliceValue = valueCoderFuncs{
4965
	size:      sizeDoubleSliceValue,
4966
	marshal:   appendDoubleSliceValue,
4967
	unmarshal: consumeDoubleSliceValue,
4968
	merge:     mergeListValue,
4969
}
4970

4971
// sizeDoublePackedSliceValue returns the size of wire encoding a []float64 value as a packed repeated Double.
4972
func sizeDoublePackedSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
4973
	list := listv.List()
4974
	llen := list.Len()
4975
	if llen == 0 {
4976
		return 0
4977
	}
4978
	n := llen * protowire.SizeFixed64()
4979
	return tagsize + protowire.SizeBytes(n)
4980
}
4981

4982
// appendDoublePackedSliceValue encodes a []float64 value as a packed repeated Double.
4983
func appendDoublePackedSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
4984
	list := listv.List()
4985
	llen := list.Len()
4986
	if llen == 0 {
4987
		return b, nil
4988
	}
4989
	b = protowire.AppendVarint(b, wiretag)
4990
	n := llen * protowire.SizeFixed64()
4991
	b = protowire.AppendVarint(b, uint64(n))
4992
	for i := 0; i < llen; i++ {
4993
		v := list.Get(i)
4994
		b = protowire.AppendFixed64(b, math.Float64bits(v.Float()))
4995
	}
4996
	return b, nil
4997
}
4998

4999
var coderDoublePackedSliceValue = valueCoderFuncs{
5000
	size:      sizeDoublePackedSliceValue,
5001
	marshal:   appendDoublePackedSliceValue,
5002
	unmarshal: consumeDoubleSliceValue,
5003
	merge:     mergeListValue,
5004
}
5005

5006
// sizeString returns the size of wire encoding a string pointer as a String.
5007
func sizeString(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
5008
	v := *p.String()
5009
	return f.tagsize + protowire.SizeBytes(len(v))
5010
}
5011

5012
// appendString wire encodes a string pointer as a String.
5013
func appendString(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
5014
	v := *p.String()
5015
	b = protowire.AppendVarint(b, f.wiretag)
5016
	b = protowire.AppendString(b, v)
5017
	return b, nil
5018
}
5019

5020
// consumeString wire decodes a string pointer as a String.
5021
func consumeString(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
5022
	if wtyp != protowire.BytesType {
5023
		return out, errUnknown
5024
	}
5025
	v, n := protowire.ConsumeBytes(b)
5026
	if n < 0 {
5027
		return out, errDecode
5028
	}
5029
	*p.String() = string(v)
5030
	out.n = n
5031
	return out, nil
5032
}
5033

5034
var coderString = pointerCoderFuncs{
5035
	size:      sizeString,
5036
	marshal:   appendString,
5037
	unmarshal: consumeString,
5038
	merge:     mergeString,
5039
}
5040

5041
// appendStringValidateUTF8 wire encodes a string pointer as a String.
5042
func appendStringValidateUTF8(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
5043
	v := *p.String()
5044
	b = protowire.AppendVarint(b, f.wiretag)
5045
	b = protowire.AppendString(b, v)
5046
	if !utf8.ValidString(v) {
5047
		return b, errInvalidUTF8{}
5048
	}
5049
	return b, nil
5050
}
5051

5052
// consumeStringValidateUTF8 wire decodes a string pointer as a String.
5053
func consumeStringValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
5054
	if wtyp != protowire.BytesType {
5055
		return out, errUnknown
5056
	}
5057
	v, n := protowire.ConsumeBytes(b)
5058
	if n < 0 {
5059
		return out, errDecode
5060
	}
5061
	if !utf8.Valid(v) {
5062
		return out, errInvalidUTF8{}
5063
	}
5064
	*p.String() = string(v)
5065
	out.n = n
5066
	return out, nil
5067
}
5068

5069
var coderStringValidateUTF8 = pointerCoderFuncs{
5070
	size:      sizeString,
5071
	marshal:   appendStringValidateUTF8,
5072
	unmarshal: consumeStringValidateUTF8,
5073
	merge:     mergeString,
5074
}
5075

5076
// sizeStringNoZero returns the size of wire encoding a string pointer as a String.
5077
// The zero value is not encoded.
5078
func sizeStringNoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
5079
	v := *p.String()
5080
	if len(v) == 0 {
5081
		return 0
5082
	}
5083
	return f.tagsize + protowire.SizeBytes(len(v))
5084
}
5085

5086
// appendStringNoZero wire encodes a string pointer as a String.
5087
// The zero value is not encoded.
5088
func appendStringNoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
5089
	v := *p.String()
5090
	if len(v) == 0 {
5091
		return b, nil
5092
	}
5093
	b = protowire.AppendVarint(b, f.wiretag)
5094
	b = protowire.AppendString(b, v)
5095
	return b, nil
5096
}
5097

5098
var coderStringNoZero = pointerCoderFuncs{
5099
	size:      sizeStringNoZero,
5100
	marshal:   appendStringNoZero,
5101
	unmarshal: consumeString,
5102
	merge:     mergeStringNoZero,
5103
}
5104

5105
// appendStringNoZeroValidateUTF8 wire encodes a string pointer as a String.
5106
// The zero value is not encoded.
5107
func appendStringNoZeroValidateUTF8(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
5108
	v := *p.String()
5109
	if len(v) == 0 {
5110
		return b, nil
5111
	}
5112
	b = protowire.AppendVarint(b, f.wiretag)
5113
	b = protowire.AppendString(b, v)
5114
	if !utf8.ValidString(v) {
5115
		return b, errInvalidUTF8{}
5116
	}
5117
	return b, nil
5118
}
5119

5120
var coderStringNoZeroValidateUTF8 = pointerCoderFuncs{
5121
	size:      sizeStringNoZero,
5122
	marshal:   appendStringNoZeroValidateUTF8,
5123
	unmarshal: consumeStringValidateUTF8,
5124
	merge:     mergeStringNoZero,
5125
}
5126

5127
// sizeStringPtr returns the size of wire encoding a *string pointer as a String.
5128
// It panics if the pointer is nil.
5129
func sizeStringPtr(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
5130
	v := **p.StringPtr()
5131
	return f.tagsize + protowire.SizeBytes(len(v))
5132
}
5133

5134
// appendStringPtr wire encodes a *string pointer as a String.
5135
// It panics if the pointer is nil.
5136
func appendStringPtr(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
5137
	v := **p.StringPtr()
5138
	b = protowire.AppendVarint(b, f.wiretag)
5139
	b = protowire.AppendString(b, v)
5140
	return b, nil
5141
}
5142

5143
// consumeStringPtr wire decodes a *string pointer as a String.
5144
func consumeStringPtr(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
5145
	if wtyp != protowire.BytesType {
5146
		return out, errUnknown
5147
	}
5148
	v, n := protowire.ConsumeBytes(b)
5149
	if n < 0 {
5150
		return out, errDecode
5151
	}
5152
	vp := p.StringPtr()
5153
	if *vp == nil {
5154
		*vp = new(string)
5155
	}
5156
	**vp = string(v)
5157
	out.n = n
5158
	return out, nil
5159
}
5160

5161
var coderStringPtr = pointerCoderFuncs{
5162
	size:      sizeStringPtr,
5163
	marshal:   appendStringPtr,
5164
	unmarshal: consumeStringPtr,
5165
	merge:     mergeStringPtr,
5166
}
5167

5168
// appendStringPtrValidateUTF8 wire encodes a *string pointer as a String.
5169
// It panics if the pointer is nil.
5170
func appendStringPtrValidateUTF8(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
5171
	v := **p.StringPtr()
5172
	b = protowire.AppendVarint(b, f.wiretag)
5173
	b = protowire.AppendString(b, v)
5174
	if !utf8.ValidString(v) {
5175
		return b, errInvalidUTF8{}
5176
	}
5177
	return b, nil
5178
}
5179

5180
// consumeStringPtrValidateUTF8 wire decodes a *string pointer as a String.
5181
func consumeStringPtrValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
5182
	if wtyp != protowire.BytesType {
5183
		return out, errUnknown
5184
	}
5185
	v, n := protowire.ConsumeBytes(b)
5186
	if n < 0 {
5187
		return out, errDecode
5188
	}
5189
	if !utf8.Valid(v) {
5190
		return out, errInvalidUTF8{}
5191
	}
5192
	vp := p.StringPtr()
5193
	if *vp == nil {
5194
		*vp = new(string)
5195
	}
5196
	**vp = string(v)
5197
	out.n = n
5198
	return out, nil
5199
}
5200

5201
var coderStringPtrValidateUTF8 = pointerCoderFuncs{
5202
	size:      sizeStringPtr,
5203
	marshal:   appendStringPtrValidateUTF8,
5204
	unmarshal: consumeStringPtrValidateUTF8,
5205
	merge:     mergeStringPtr,
5206
}
5207

5208
// sizeStringSlice returns the size of wire encoding a []string pointer as a repeated String.
5209
func sizeStringSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
5210
	s := *p.StringSlice()
5211
	for _, v := range s {
5212
		size += f.tagsize + protowire.SizeBytes(len(v))
5213
	}
5214
	return size
5215
}
5216

5217
// appendStringSlice encodes a []string pointer as a repeated String.
5218
func appendStringSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
5219
	s := *p.StringSlice()
5220
	for _, v := range s {
5221
		b = protowire.AppendVarint(b, f.wiretag)
5222
		b = protowire.AppendString(b, v)
5223
	}
5224
	return b, nil
5225
}
5226

5227
// consumeStringSlice wire decodes a []string pointer as a repeated String.
5228
func consumeStringSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
5229
	sp := p.StringSlice()
5230
	if wtyp != protowire.BytesType {
5231
		return out, errUnknown
5232
	}
5233
	v, n := protowire.ConsumeBytes(b)
5234
	if n < 0 {
5235
		return out, errDecode
5236
	}
5237
	*sp = append(*sp, string(v))
5238
	out.n = n
5239
	return out, nil
5240
}
5241

5242
var coderStringSlice = pointerCoderFuncs{
5243
	size:      sizeStringSlice,
5244
	marshal:   appendStringSlice,
5245
	unmarshal: consumeStringSlice,
5246
	merge:     mergeStringSlice,
5247
}
5248

5249
// appendStringSliceValidateUTF8 encodes a []string pointer as a repeated String.
5250
func appendStringSliceValidateUTF8(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
5251
	s := *p.StringSlice()
5252
	for _, v := range s {
5253
		b = protowire.AppendVarint(b, f.wiretag)
5254
		b = protowire.AppendString(b, v)
5255
		if !utf8.ValidString(v) {
5256
			return b, errInvalidUTF8{}
5257
		}
5258
	}
5259
	return b, nil
5260
}
5261

5262
// consumeStringSliceValidateUTF8 wire decodes a []string pointer as a repeated String.
5263
func consumeStringSliceValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
5264
	if wtyp != protowire.BytesType {
5265
		return out, errUnknown
5266
	}
5267
	v, n := protowire.ConsumeBytes(b)
5268
	if n < 0 {
5269
		return out, errDecode
5270
	}
5271
	if !utf8.Valid(v) {
5272
		return out, errInvalidUTF8{}
5273
	}
5274
	sp := p.StringSlice()
5275
	*sp = append(*sp, string(v))
5276
	out.n = n
5277
	return out, nil
5278
}
5279

5280
var coderStringSliceValidateUTF8 = pointerCoderFuncs{
5281
	size:      sizeStringSlice,
5282
	marshal:   appendStringSliceValidateUTF8,
5283
	unmarshal: consumeStringSliceValidateUTF8,
5284
	merge:     mergeStringSlice,
5285
}
5286

5287
// sizeStringValue returns the size of wire encoding a string value as a String.
5288
func sizeStringValue(v protoreflect.Value, tagsize int, opts marshalOptions) int {
5289
	return tagsize + protowire.SizeBytes(len(v.String()))
5290
}
5291

5292
// appendStringValue encodes a string value as a String.
5293
func appendStringValue(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
5294
	b = protowire.AppendVarint(b, wiretag)
5295
	b = protowire.AppendString(b, v.String())
5296
	return b, nil
5297
}
5298

5299
// consumeStringValue decodes a string value as a String.
5300
func consumeStringValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
5301
	if wtyp != protowire.BytesType {
5302
		return protoreflect.Value{}, out, errUnknown
5303
	}
5304
	v, n := protowire.ConsumeBytes(b)
5305
	if n < 0 {
5306
		return protoreflect.Value{}, out, errDecode
5307
	}
5308
	out.n = n
5309
	return protoreflect.ValueOfString(string(v)), out, nil
5310
}
5311

5312
var coderStringValue = valueCoderFuncs{
5313
	size:      sizeStringValue,
5314
	marshal:   appendStringValue,
5315
	unmarshal: consumeStringValue,
5316
	merge:     mergeScalarValue,
5317
}
5318

5319
// appendStringValueValidateUTF8 encodes a string value as a String.
5320
func appendStringValueValidateUTF8(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
5321
	b = protowire.AppendVarint(b, wiretag)
5322
	b = protowire.AppendString(b, v.String())
5323
	if !utf8.ValidString(v.String()) {
5324
		return b, errInvalidUTF8{}
5325
	}
5326
	return b, nil
5327
}
5328

5329
// consumeStringValueValidateUTF8 decodes a string value as a String.
5330
func consumeStringValueValidateUTF8(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
5331
	if wtyp != protowire.BytesType {
5332
		return protoreflect.Value{}, out, errUnknown
5333
	}
5334
	v, n := protowire.ConsumeBytes(b)
5335
	if n < 0 {
5336
		return protoreflect.Value{}, out, errDecode
5337
	}
5338
	if !utf8.Valid(v) {
5339
		return protoreflect.Value{}, out, errInvalidUTF8{}
5340
	}
5341
	out.n = n
5342
	return protoreflect.ValueOfString(string(v)), out, nil
5343
}
5344

5345
var coderStringValueValidateUTF8 = valueCoderFuncs{
5346
	size:      sizeStringValue,
5347
	marshal:   appendStringValueValidateUTF8,
5348
	unmarshal: consumeStringValueValidateUTF8,
5349
	merge:     mergeScalarValue,
5350
}
5351

5352
// sizeStringSliceValue returns the size of wire encoding a []string value as a repeated String.
5353
func sizeStringSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
5354
	list := listv.List()
5355
	for i, llen := 0, list.Len(); i < llen; i++ {
5356
		v := list.Get(i)
5357
		size += tagsize + protowire.SizeBytes(len(v.String()))
5358
	}
5359
	return size
5360
}
5361

5362
// appendStringSliceValue encodes a []string value as a repeated String.
5363
func appendStringSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
5364
	list := listv.List()
5365
	for i, llen := 0, list.Len(); i < llen; i++ {
5366
		v := list.Get(i)
5367
		b = protowire.AppendVarint(b, wiretag)
5368
		b = protowire.AppendString(b, v.String())
5369
	}
5370
	return b, nil
5371
}
5372

5373
// consumeStringSliceValue wire decodes a []string value as a repeated String.
5374
func consumeStringSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
5375
	list := listv.List()
5376
	if wtyp != protowire.BytesType {
5377
		return protoreflect.Value{}, out, errUnknown
5378
	}
5379
	v, n := protowire.ConsumeBytes(b)
5380
	if n < 0 {
5381
		return protoreflect.Value{}, out, errDecode
5382
	}
5383
	list.Append(protoreflect.ValueOfString(string(v)))
5384
	out.n = n
5385
	return listv, out, nil
5386
}
5387

5388
var coderStringSliceValue = valueCoderFuncs{
5389
	size:      sizeStringSliceValue,
5390
	marshal:   appendStringSliceValue,
5391
	unmarshal: consumeStringSliceValue,
5392
	merge:     mergeListValue,
5393
}
5394

5395
// sizeBytes returns the size of wire encoding a []byte pointer as a Bytes.
5396
func sizeBytes(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
5397
	v := *p.Bytes()
5398
	return f.tagsize + protowire.SizeBytes(len(v))
5399
}
5400

5401
// appendBytes wire encodes a []byte pointer as a Bytes.
5402
func appendBytes(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
5403
	v := *p.Bytes()
5404
	b = protowire.AppendVarint(b, f.wiretag)
5405
	b = protowire.AppendBytes(b, v)
5406
	return b, nil
5407
}
5408

5409
// consumeBytes wire decodes a []byte pointer as a Bytes.
5410
func consumeBytes(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
5411
	if wtyp != protowire.BytesType {
5412
		return out, errUnknown
5413
	}
5414
	v, n := protowire.ConsumeBytes(b)
5415
	if n < 0 {
5416
		return out, errDecode
5417
	}
5418
	*p.Bytes() = append(emptyBuf[:], v...)
5419
	out.n = n
5420
	return out, nil
5421
}
5422

5423
var coderBytes = pointerCoderFuncs{
5424
	size:      sizeBytes,
5425
	marshal:   appendBytes,
5426
	unmarshal: consumeBytes,
5427
	merge:     mergeBytes,
5428
}
5429

5430
// appendBytesValidateUTF8 wire encodes a []byte pointer as a Bytes.
5431
func appendBytesValidateUTF8(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
5432
	v := *p.Bytes()
5433
	b = protowire.AppendVarint(b, f.wiretag)
5434
	b = protowire.AppendBytes(b, v)
5435
	if !utf8.Valid(v) {
5436
		return b, errInvalidUTF8{}
5437
	}
5438
	return b, nil
5439
}
5440

5441
// consumeBytesValidateUTF8 wire decodes a []byte pointer as a Bytes.
5442
func consumeBytesValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
5443
	if wtyp != protowire.BytesType {
5444
		return out, errUnknown
5445
	}
5446
	v, n := protowire.ConsumeBytes(b)
5447
	if n < 0 {
5448
		return out, errDecode
5449
	}
5450
	if !utf8.Valid(v) {
5451
		return out, errInvalidUTF8{}
5452
	}
5453
	*p.Bytes() = append(emptyBuf[:], v...)
5454
	out.n = n
5455
	return out, nil
5456
}
5457

5458
var coderBytesValidateUTF8 = pointerCoderFuncs{
5459
	size:      sizeBytes,
5460
	marshal:   appendBytesValidateUTF8,
5461
	unmarshal: consumeBytesValidateUTF8,
5462
	merge:     mergeBytes,
5463
}
5464

5465
// sizeBytesNoZero returns the size of wire encoding a []byte pointer as a Bytes.
5466
// The zero value is not encoded.
5467
func sizeBytesNoZero(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
5468
	v := *p.Bytes()
5469
	if len(v) == 0 {
5470
		return 0
5471
	}
5472
	return f.tagsize + protowire.SizeBytes(len(v))
5473
}
5474

5475
// appendBytesNoZero wire encodes a []byte pointer as a Bytes.
5476
// The zero value is not encoded.
5477
func appendBytesNoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
5478
	v := *p.Bytes()
5479
	if len(v) == 0 {
5480
		return b, nil
5481
	}
5482
	b = protowire.AppendVarint(b, f.wiretag)
5483
	b = protowire.AppendBytes(b, v)
5484
	return b, nil
5485
}
5486

5487
// consumeBytesNoZero wire decodes a []byte pointer as a Bytes.
5488
// The zero value is not decoded.
5489
func consumeBytesNoZero(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
5490
	if wtyp != protowire.BytesType {
5491
		return out, errUnknown
5492
	}
5493
	v, n := protowire.ConsumeBytes(b)
5494
	if n < 0 {
5495
		return out, errDecode
5496
	}
5497
	*p.Bytes() = append(([]byte)(nil), v...)
5498
	out.n = n
5499
	return out, nil
5500
}
5501

5502
var coderBytesNoZero = pointerCoderFuncs{
5503
	size:      sizeBytesNoZero,
5504
	marshal:   appendBytesNoZero,
5505
	unmarshal: consumeBytesNoZero,
5506
	merge:     mergeBytesNoZero,
5507
}
5508

5509
// appendBytesNoZeroValidateUTF8 wire encodes a []byte pointer as a Bytes.
5510
// The zero value is not encoded.
5511
func appendBytesNoZeroValidateUTF8(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
5512
	v := *p.Bytes()
5513
	if len(v) == 0 {
5514
		return b, nil
5515
	}
5516
	b = protowire.AppendVarint(b, f.wiretag)
5517
	b = protowire.AppendBytes(b, v)
5518
	if !utf8.Valid(v) {
5519
		return b, errInvalidUTF8{}
5520
	}
5521
	return b, nil
5522
}
5523

5524
// consumeBytesNoZeroValidateUTF8 wire decodes a []byte pointer as a Bytes.
5525
func consumeBytesNoZeroValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
5526
	if wtyp != protowire.BytesType {
5527
		return out, errUnknown
5528
	}
5529
	v, n := protowire.ConsumeBytes(b)
5530
	if n < 0 {
5531
		return out, errDecode
5532
	}
5533
	if !utf8.Valid(v) {
5534
		return out, errInvalidUTF8{}
5535
	}
5536
	*p.Bytes() = append(([]byte)(nil), v...)
5537
	out.n = n
5538
	return out, nil
5539
}
5540

5541
var coderBytesNoZeroValidateUTF8 = pointerCoderFuncs{
5542
	size:      sizeBytesNoZero,
5543
	marshal:   appendBytesNoZeroValidateUTF8,
5544
	unmarshal: consumeBytesNoZeroValidateUTF8,
5545
	merge:     mergeBytesNoZero,
5546
}
5547

5548
// sizeBytesSlice returns the size of wire encoding a [][]byte pointer as a repeated Bytes.
5549
func sizeBytesSlice(p pointer, f *coderFieldInfo, opts marshalOptions) (size int) {
5550
	s := *p.BytesSlice()
5551
	for _, v := range s {
5552
		size += f.tagsize + protowire.SizeBytes(len(v))
5553
	}
5554
	return size
5555
}
5556

5557
// appendBytesSlice encodes a [][]byte pointer as a repeated Bytes.
5558
func appendBytesSlice(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
5559
	s := *p.BytesSlice()
5560
	for _, v := range s {
5561
		b = protowire.AppendVarint(b, f.wiretag)
5562
		b = protowire.AppendBytes(b, v)
5563
	}
5564
	return b, nil
5565
}
5566

5567
// consumeBytesSlice wire decodes a [][]byte pointer as a repeated Bytes.
5568
func consumeBytesSlice(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
5569
	sp := p.BytesSlice()
5570
	if wtyp != protowire.BytesType {
5571
		return out, errUnknown
5572
	}
5573
	v, n := protowire.ConsumeBytes(b)
5574
	if n < 0 {
5575
		return out, errDecode
5576
	}
5577
	*sp = append(*sp, append(emptyBuf[:], v...))
5578
	out.n = n
5579
	return out, nil
5580
}
5581

5582
var coderBytesSlice = pointerCoderFuncs{
5583
	size:      sizeBytesSlice,
5584
	marshal:   appendBytesSlice,
5585
	unmarshal: consumeBytesSlice,
5586
	merge:     mergeBytesSlice,
5587
}
5588

5589
// appendBytesSliceValidateUTF8 encodes a [][]byte pointer as a repeated Bytes.
5590
func appendBytesSliceValidateUTF8(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
5591
	s := *p.BytesSlice()
5592
	for _, v := range s {
5593
		b = protowire.AppendVarint(b, f.wiretag)
5594
		b = protowire.AppendBytes(b, v)
5595
		if !utf8.Valid(v) {
5596
			return b, errInvalidUTF8{}
5597
		}
5598
	}
5599
	return b, nil
5600
}
5601

5602
// consumeBytesSliceValidateUTF8 wire decodes a [][]byte pointer as a repeated Bytes.
5603
func consumeBytesSliceValidateUTF8(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
5604
	if wtyp != protowire.BytesType {
5605
		return out, errUnknown
5606
	}
5607
	v, n := protowire.ConsumeBytes(b)
5608
	if n < 0 {
5609
		return out, errDecode
5610
	}
5611
	if !utf8.Valid(v) {
5612
		return out, errInvalidUTF8{}
5613
	}
5614
	sp := p.BytesSlice()
5615
	*sp = append(*sp, append(emptyBuf[:], v...))
5616
	out.n = n
5617
	return out, nil
5618
}
5619

5620
var coderBytesSliceValidateUTF8 = pointerCoderFuncs{
5621
	size:      sizeBytesSlice,
5622
	marshal:   appendBytesSliceValidateUTF8,
5623
	unmarshal: consumeBytesSliceValidateUTF8,
5624
	merge:     mergeBytesSlice,
5625
}
5626

5627
// sizeBytesValue returns the size of wire encoding a []byte value as a Bytes.
5628
func sizeBytesValue(v protoreflect.Value, tagsize int, opts marshalOptions) int {
5629
	return tagsize + protowire.SizeBytes(len(v.Bytes()))
5630
}
5631

5632
// appendBytesValue encodes a []byte value as a Bytes.
5633
func appendBytesValue(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
5634
	b = protowire.AppendVarint(b, wiretag)
5635
	b = protowire.AppendBytes(b, v.Bytes())
5636
	return b, nil
5637
}
5638

5639
// consumeBytesValue decodes a []byte value as a Bytes.
5640
func consumeBytesValue(b []byte, _ protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
5641
	if wtyp != protowire.BytesType {
5642
		return protoreflect.Value{}, out, errUnknown
5643
	}
5644
	v, n := protowire.ConsumeBytes(b)
5645
	if n < 0 {
5646
		return protoreflect.Value{}, out, errDecode
5647
	}
5648
	out.n = n
5649
	return protoreflect.ValueOfBytes(append(emptyBuf[:], v...)), out, nil
5650
}
5651

5652
var coderBytesValue = valueCoderFuncs{
5653
	size:      sizeBytesValue,
5654
	marshal:   appendBytesValue,
5655
	unmarshal: consumeBytesValue,
5656
	merge:     mergeBytesValue,
5657
}
5658

5659
// sizeBytesSliceValue returns the size of wire encoding a [][]byte value as a repeated Bytes.
5660
func sizeBytesSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) (size int) {
5661
	list := listv.List()
5662
	for i, llen := 0, list.Len(); i < llen; i++ {
5663
		v := list.Get(i)
5664
		size += tagsize + protowire.SizeBytes(len(v.Bytes()))
5665
	}
5666
	return size
5667
}
5668

5669
// appendBytesSliceValue encodes a [][]byte value as a repeated Bytes.
5670
func appendBytesSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) {
5671
	list := listv.List()
5672
	for i, llen := 0, list.Len(); i < llen; i++ {
5673
		v := list.Get(i)
5674
		b = protowire.AppendVarint(b, wiretag)
5675
		b = protowire.AppendBytes(b, v.Bytes())
5676
	}
5677
	return b, nil
5678
}
5679

5680
// consumeBytesSliceValue wire decodes a [][]byte value as a repeated Bytes.
5681
func consumeBytesSliceValue(b []byte, listv protoreflect.Value, _ protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (_ protoreflect.Value, out unmarshalOutput, err error) {
5682
	list := listv.List()
5683
	if wtyp != protowire.BytesType {
5684
		return protoreflect.Value{}, out, errUnknown
5685
	}
5686
	v, n := protowire.ConsumeBytes(b)
5687
	if n < 0 {
5688
		return protoreflect.Value{}, out, errDecode
5689
	}
5690
	list.Append(protoreflect.ValueOfBytes(append(emptyBuf[:], v...)))
5691
	out.n = n
5692
	return listv, out, nil
5693
}
5694

5695
var coderBytesSliceValue = valueCoderFuncs{
5696
	size:      sizeBytesSliceValue,
5697
	marshal:   appendBytesSliceValue,
5698
	unmarshal: consumeBytesSliceValue,
5699
	merge:     mergeBytesListValue,
5700
}
5701

5702
// We append to an empty array rather than a nil []byte to get non-nil zero-length byte slices.
5703
var emptyBuf [0]byte
5704

5705
var wireTypes = map[protoreflect.Kind]protowire.Type{
5706
	protoreflect.BoolKind:     protowire.VarintType,
5707
	protoreflect.EnumKind:     protowire.VarintType,
5708
	protoreflect.Int32Kind:    protowire.VarintType,
5709
	protoreflect.Sint32Kind:   protowire.VarintType,
5710
	protoreflect.Uint32Kind:   protowire.VarintType,
5711
	protoreflect.Int64Kind:    protowire.VarintType,
5712
	protoreflect.Sint64Kind:   protowire.VarintType,
5713
	protoreflect.Uint64Kind:   protowire.VarintType,
5714
	protoreflect.Sfixed32Kind: protowire.Fixed32Type,
5715
	protoreflect.Fixed32Kind:  protowire.Fixed32Type,
5716
	protoreflect.FloatKind:    protowire.Fixed32Type,
5717
	protoreflect.Sfixed64Kind: protowire.Fixed64Type,
5718
	protoreflect.Fixed64Kind:  protowire.Fixed64Type,
5719
	protoreflect.DoubleKind:   protowire.Fixed64Type,
5720
	protoreflect.StringKind:   protowire.BytesType,
5721
	protoreflect.BytesKind:    protowire.BytesType,
5722
	protoreflect.MessageKind:  protowire.BytesType,
5723
	protoreflect.GroupKind:    protowire.StartGroupType,
5724
}
5725