codec_gen.go raw
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