blob: b175d1b642346310019fc972f5fcd0d75cf436f5 [file] [log] [blame]
Scott Baker2d897982019-09-24 11:50:08 -07001// Protocol Buffers for Go with Gadgets
2//
3// Copyright (c) 2018, The GoGo Authors. All rights reserved.
4// http://github.com/gogo/protobuf
5//
6// Redistribution and use in source and binary forms, with or without
7// modification, are permitted provided that the following conditions are
8// met:
9//
10// * Redistributions of source code must retain the above copyright
11// notice, this list of conditions and the following disclaimer.
12// * Redistributions in binary form must reproduce the above
13// copyright notice, this list of conditions and the following disclaimer
14// in the documentation and/or other materials provided with the
15// distribution.
16//
17// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
29package proto
30
31import (
32 "io"
33 "reflect"
34)
35
36func makeStdDoubleValueMarshaler(u *marshalInfo) (sizer, marshaler) {
37 return func(ptr pointer, tagsize int) int {
38 t := ptr.asPointerTo(u.typ).Interface().(*float64)
39 v := &float64Value{*t}
40 siz := Size(v)
41 return tagsize + SizeVarint(uint64(siz)) + siz
42 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
43 t := ptr.asPointerTo(u.typ).Interface().(*float64)
44 v := &float64Value{*t}
45 buf, err := Marshal(v)
46 if err != nil {
47 return nil, err
48 }
49 b = appendVarint(b, wiretag)
50 b = appendVarint(b, uint64(len(buf)))
51 b = append(b, buf...)
52 return b, nil
53 }
54}
55
56func makeStdDoubleValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
57 return func(ptr pointer, tagsize int) int {
58 if ptr.isNil() {
59 return 0
60 }
61 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float64)
62 v := &float64Value{*t}
63 siz := Size(v)
64 return tagsize + SizeVarint(uint64(siz)) + siz
65 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
66 if ptr.isNil() {
67 return b, nil
68 }
69 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float64)
70 v := &float64Value{*t}
71 buf, err := Marshal(v)
72 if err != nil {
73 return nil, err
74 }
75 b = appendVarint(b, wiretag)
76 b = appendVarint(b, uint64(len(buf)))
77 b = append(b, buf...)
78 return b, nil
79 }
80}
81
82func makeStdDoubleValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
83 return func(ptr pointer, tagsize int) int {
84 s := ptr.getSlice(u.typ)
85 n := 0
86 for i := 0; i < s.Len(); i++ {
87 elem := s.Index(i)
88 t := elem.Interface().(float64)
89 v := &float64Value{t}
90 siz := Size(v)
91 n += siz + SizeVarint(uint64(siz)) + tagsize
92 }
93 return n
94 },
95 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
96 s := ptr.getSlice(u.typ)
97 for i := 0; i < s.Len(); i++ {
98 elem := s.Index(i)
99 t := elem.Interface().(float64)
100 v := &float64Value{t}
101 siz := Size(v)
102 buf, err := Marshal(v)
103 if err != nil {
104 return nil, err
105 }
106 b = appendVarint(b, wiretag)
107 b = appendVarint(b, uint64(siz))
108 b = append(b, buf...)
109 }
110
111 return b, nil
112 }
113}
114
115func makeStdDoubleValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
116 return func(ptr pointer, tagsize int) int {
117 s := ptr.getSlice(reflect.PtrTo(u.typ))
118 n := 0
119 for i := 0; i < s.Len(); i++ {
120 elem := s.Index(i)
121 t := elem.Interface().(*float64)
122 v := &float64Value{*t}
123 siz := Size(v)
124 n += siz + SizeVarint(uint64(siz)) + tagsize
125 }
126 return n
127 },
128 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
129 s := ptr.getSlice(reflect.PtrTo(u.typ))
130 for i := 0; i < s.Len(); i++ {
131 elem := s.Index(i)
132 t := elem.Interface().(*float64)
133 v := &float64Value{*t}
134 siz := Size(v)
135 buf, err := Marshal(v)
136 if err != nil {
137 return nil, err
138 }
139 b = appendVarint(b, wiretag)
140 b = appendVarint(b, uint64(siz))
141 b = append(b, buf...)
142 }
143
144 return b, nil
145 }
146}
147
148func makeStdDoubleValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
149 return func(b []byte, f pointer, w int) ([]byte, error) {
150 if w != WireBytes {
151 return nil, errInternalBadWireType
152 }
153 x, n := decodeVarint(b)
154 if n == 0 {
155 return nil, io.ErrUnexpectedEOF
156 }
157 b = b[n:]
158 if x > uint64(len(b)) {
159 return nil, io.ErrUnexpectedEOF
160 }
161 m := &float64Value{}
162 if err := Unmarshal(b[:x], m); err != nil {
163 return nil, err
164 }
165 s := f.asPointerTo(sub.typ).Elem()
166 s.Set(reflect.ValueOf(m.Value))
167 return b[x:], nil
168 }
169}
170
171func makeStdDoubleValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
172 return func(b []byte, f pointer, w int) ([]byte, error) {
173 if w != WireBytes {
174 return nil, errInternalBadWireType
175 }
176 x, n := decodeVarint(b)
177 if n == 0 {
178 return nil, io.ErrUnexpectedEOF
179 }
180 b = b[n:]
181 if x > uint64(len(b)) {
182 return nil, io.ErrUnexpectedEOF
183 }
184 m := &float64Value{}
185 if err := Unmarshal(b[:x], m); err != nil {
186 return nil, err
187 }
188 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
189 s.Set(reflect.ValueOf(&m.Value))
190 return b[x:], nil
191 }
192}
193
194func makeStdDoubleValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
195 return func(b []byte, f pointer, w int) ([]byte, error) {
196 if w != WireBytes {
197 return nil, errInternalBadWireType
198 }
199 x, n := decodeVarint(b)
200 if n == 0 {
201 return nil, io.ErrUnexpectedEOF
202 }
203 b = b[n:]
204 if x > uint64(len(b)) {
205 return nil, io.ErrUnexpectedEOF
206 }
207 m := &float64Value{}
208 if err := Unmarshal(b[:x], m); err != nil {
209 return nil, err
210 }
211 slice := f.getSlice(reflect.PtrTo(sub.typ))
212 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
213 slice.Set(newSlice)
214 return b[x:], nil
215 }
216}
217
218func makeStdDoubleValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
219 return func(b []byte, f pointer, w int) ([]byte, error) {
220 if w != WireBytes {
221 return nil, errInternalBadWireType
222 }
223 x, n := decodeVarint(b)
224 if n == 0 {
225 return nil, io.ErrUnexpectedEOF
226 }
227 b = b[n:]
228 if x > uint64(len(b)) {
229 return nil, io.ErrUnexpectedEOF
230 }
231 m := &float64Value{}
232 if err := Unmarshal(b[:x], m); err != nil {
233 return nil, err
234 }
235 slice := f.getSlice(sub.typ)
236 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
237 slice.Set(newSlice)
238 return b[x:], nil
239 }
240}
241
242func makeStdFloatValueMarshaler(u *marshalInfo) (sizer, marshaler) {
243 return func(ptr pointer, tagsize int) int {
244 t := ptr.asPointerTo(u.typ).Interface().(*float32)
245 v := &float32Value{*t}
246 siz := Size(v)
247 return tagsize + SizeVarint(uint64(siz)) + siz
248 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
249 t := ptr.asPointerTo(u.typ).Interface().(*float32)
250 v := &float32Value{*t}
251 buf, err := Marshal(v)
252 if err != nil {
253 return nil, err
254 }
255 b = appendVarint(b, wiretag)
256 b = appendVarint(b, uint64(len(buf)))
257 b = append(b, buf...)
258 return b, nil
259 }
260}
261
262func makeStdFloatValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
263 return func(ptr pointer, tagsize int) int {
264 if ptr.isNil() {
265 return 0
266 }
267 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float32)
268 v := &float32Value{*t}
269 siz := Size(v)
270 return tagsize + SizeVarint(uint64(siz)) + siz
271 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
272 if ptr.isNil() {
273 return b, nil
274 }
275 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float32)
276 v := &float32Value{*t}
277 buf, err := Marshal(v)
278 if err != nil {
279 return nil, err
280 }
281 b = appendVarint(b, wiretag)
282 b = appendVarint(b, uint64(len(buf)))
283 b = append(b, buf...)
284 return b, nil
285 }
286}
287
288func makeStdFloatValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
289 return func(ptr pointer, tagsize int) int {
290 s := ptr.getSlice(u.typ)
291 n := 0
292 for i := 0; i < s.Len(); i++ {
293 elem := s.Index(i)
294 t := elem.Interface().(float32)
295 v := &float32Value{t}
296 siz := Size(v)
297 n += siz + SizeVarint(uint64(siz)) + tagsize
298 }
299 return n
300 },
301 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
302 s := ptr.getSlice(u.typ)
303 for i := 0; i < s.Len(); i++ {
304 elem := s.Index(i)
305 t := elem.Interface().(float32)
306 v := &float32Value{t}
307 siz := Size(v)
308 buf, err := Marshal(v)
309 if err != nil {
310 return nil, err
311 }
312 b = appendVarint(b, wiretag)
313 b = appendVarint(b, uint64(siz))
314 b = append(b, buf...)
315 }
316
317 return b, nil
318 }
319}
320
321func makeStdFloatValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
322 return func(ptr pointer, tagsize int) int {
323 s := ptr.getSlice(reflect.PtrTo(u.typ))
324 n := 0
325 for i := 0; i < s.Len(); i++ {
326 elem := s.Index(i)
327 t := elem.Interface().(*float32)
328 v := &float32Value{*t}
329 siz := Size(v)
330 n += siz + SizeVarint(uint64(siz)) + tagsize
331 }
332 return n
333 },
334 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
335 s := ptr.getSlice(reflect.PtrTo(u.typ))
336 for i := 0; i < s.Len(); i++ {
337 elem := s.Index(i)
338 t := elem.Interface().(*float32)
339 v := &float32Value{*t}
340 siz := Size(v)
341 buf, err := Marshal(v)
342 if err != nil {
343 return nil, err
344 }
345 b = appendVarint(b, wiretag)
346 b = appendVarint(b, uint64(siz))
347 b = append(b, buf...)
348 }
349
350 return b, nil
351 }
352}
353
354func makeStdFloatValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
355 return func(b []byte, f pointer, w int) ([]byte, error) {
356 if w != WireBytes {
357 return nil, errInternalBadWireType
358 }
359 x, n := decodeVarint(b)
360 if n == 0 {
361 return nil, io.ErrUnexpectedEOF
362 }
363 b = b[n:]
364 if x > uint64(len(b)) {
365 return nil, io.ErrUnexpectedEOF
366 }
367 m := &float32Value{}
368 if err := Unmarshal(b[:x], m); err != nil {
369 return nil, err
370 }
371 s := f.asPointerTo(sub.typ).Elem()
372 s.Set(reflect.ValueOf(m.Value))
373 return b[x:], nil
374 }
375}
376
377func makeStdFloatValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
378 return func(b []byte, f pointer, w int) ([]byte, error) {
379 if w != WireBytes {
380 return nil, errInternalBadWireType
381 }
382 x, n := decodeVarint(b)
383 if n == 0 {
384 return nil, io.ErrUnexpectedEOF
385 }
386 b = b[n:]
387 if x > uint64(len(b)) {
388 return nil, io.ErrUnexpectedEOF
389 }
390 m := &float32Value{}
391 if err := Unmarshal(b[:x], m); err != nil {
392 return nil, err
393 }
394 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
395 s.Set(reflect.ValueOf(&m.Value))
396 return b[x:], nil
397 }
398}
399
400func makeStdFloatValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
401 return func(b []byte, f pointer, w int) ([]byte, error) {
402 if w != WireBytes {
403 return nil, errInternalBadWireType
404 }
405 x, n := decodeVarint(b)
406 if n == 0 {
407 return nil, io.ErrUnexpectedEOF
408 }
409 b = b[n:]
410 if x > uint64(len(b)) {
411 return nil, io.ErrUnexpectedEOF
412 }
413 m := &float32Value{}
414 if err := Unmarshal(b[:x], m); err != nil {
415 return nil, err
416 }
417 slice := f.getSlice(reflect.PtrTo(sub.typ))
418 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
419 slice.Set(newSlice)
420 return b[x:], nil
421 }
422}
423
424func makeStdFloatValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
425 return func(b []byte, f pointer, w int) ([]byte, error) {
426 if w != WireBytes {
427 return nil, errInternalBadWireType
428 }
429 x, n := decodeVarint(b)
430 if n == 0 {
431 return nil, io.ErrUnexpectedEOF
432 }
433 b = b[n:]
434 if x > uint64(len(b)) {
435 return nil, io.ErrUnexpectedEOF
436 }
437 m := &float32Value{}
438 if err := Unmarshal(b[:x], m); err != nil {
439 return nil, err
440 }
441 slice := f.getSlice(sub.typ)
442 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
443 slice.Set(newSlice)
444 return b[x:], nil
445 }
446}
447
448func makeStdInt64ValueMarshaler(u *marshalInfo) (sizer, marshaler) {
449 return func(ptr pointer, tagsize int) int {
450 t := ptr.asPointerTo(u.typ).Interface().(*int64)
451 v := &int64Value{*t}
452 siz := Size(v)
453 return tagsize + SizeVarint(uint64(siz)) + siz
454 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
455 t := ptr.asPointerTo(u.typ).Interface().(*int64)
456 v := &int64Value{*t}
457 buf, err := Marshal(v)
458 if err != nil {
459 return nil, err
460 }
461 b = appendVarint(b, wiretag)
462 b = appendVarint(b, uint64(len(buf)))
463 b = append(b, buf...)
464 return b, nil
465 }
466}
467
468func makeStdInt64ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
469 return func(ptr pointer, tagsize int) int {
470 if ptr.isNil() {
471 return 0
472 }
473 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int64)
474 v := &int64Value{*t}
475 siz := Size(v)
476 return tagsize + SizeVarint(uint64(siz)) + siz
477 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
478 if ptr.isNil() {
479 return b, nil
480 }
481 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int64)
482 v := &int64Value{*t}
483 buf, err := Marshal(v)
484 if err != nil {
485 return nil, err
486 }
487 b = appendVarint(b, wiretag)
488 b = appendVarint(b, uint64(len(buf)))
489 b = append(b, buf...)
490 return b, nil
491 }
492}
493
494func makeStdInt64ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
495 return func(ptr pointer, tagsize int) int {
496 s := ptr.getSlice(u.typ)
497 n := 0
498 for i := 0; i < s.Len(); i++ {
499 elem := s.Index(i)
500 t := elem.Interface().(int64)
501 v := &int64Value{t}
502 siz := Size(v)
503 n += siz + SizeVarint(uint64(siz)) + tagsize
504 }
505 return n
506 },
507 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
508 s := ptr.getSlice(u.typ)
509 for i := 0; i < s.Len(); i++ {
510 elem := s.Index(i)
511 t := elem.Interface().(int64)
512 v := &int64Value{t}
513 siz := Size(v)
514 buf, err := Marshal(v)
515 if err != nil {
516 return nil, err
517 }
518 b = appendVarint(b, wiretag)
519 b = appendVarint(b, uint64(siz))
520 b = append(b, buf...)
521 }
522
523 return b, nil
524 }
525}
526
527func makeStdInt64ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
528 return func(ptr pointer, tagsize int) int {
529 s := ptr.getSlice(reflect.PtrTo(u.typ))
530 n := 0
531 for i := 0; i < s.Len(); i++ {
532 elem := s.Index(i)
533 t := elem.Interface().(*int64)
534 v := &int64Value{*t}
535 siz := Size(v)
536 n += siz + SizeVarint(uint64(siz)) + tagsize
537 }
538 return n
539 },
540 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
541 s := ptr.getSlice(reflect.PtrTo(u.typ))
542 for i := 0; i < s.Len(); i++ {
543 elem := s.Index(i)
544 t := elem.Interface().(*int64)
545 v := &int64Value{*t}
546 siz := Size(v)
547 buf, err := Marshal(v)
548 if err != nil {
549 return nil, err
550 }
551 b = appendVarint(b, wiretag)
552 b = appendVarint(b, uint64(siz))
553 b = append(b, buf...)
554 }
555
556 return b, nil
557 }
558}
559
560func makeStdInt64ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
561 return func(b []byte, f pointer, w int) ([]byte, error) {
562 if w != WireBytes {
563 return nil, errInternalBadWireType
564 }
565 x, n := decodeVarint(b)
566 if n == 0 {
567 return nil, io.ErrUnexpectedEOF
568 }
569 b = b[n:]
570 if x > uint64(len(b)) {
571 return nil, io.ErrUnexpectedEOF
572 }
573 m := &int64Value{}
574 if err := Unmarshal(b[:x], m); err != nil {
575 return nil, err
576 }
577 s := f.asPointerTo(sub.typ).Elem()
578 s.Set(reflect.ValueOf(m.Value))
579 return b[x:], nil
580 }
581}
582
583func makeStdInt64ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
584 return func(b []byte, f pointer, w int) ([]byte, error) {
585 if w != WireBytes {
586 return nil, errInternalBadWireType
587 }
588 x, n := decodeVarint(b)
589 if n == 0 {
590 return nil, io.ErrUnexpectedEOF
591 }
592 b = b[n:]
593 if x > uint64(len(b)) {
594 return nil, io.ErrUnexpectedEOF
595 }
596 m := &int64Value{}
597 if err := Unmarshal(b[:x], m); err != nil {
598 return nil, err
599 }
600 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
601 s.Set(reflect.ValueOf(&m.Value))
602 return b[x:], nil
603 }
604}
605
606func makeStdInt64ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
607 return func(b []byte, f pointer, w int) ([]byte, error) {
608 if w != WireBytes {
609 return nil, errInternalBadWireType
610 }
611 x, n := decodeVarint(b)
612 if n == 0 {
613 return nil, io.ErrUnexpectedEOF
614 }
615 b = b[n:]
616 if x > uint64(len(b)) {
617 return nil, io.ErrUnexpectedEOF
618 }
619 m := &int64Value{}
620 if err := Unmarshal(b[:x], m); err != nil {
621 return nil, err
622 }
623 slice := f.getSlice(reflect.PtrTo(sub.typ))
624 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
625 slice.Set(newSlice)
626 return b[x:], nil
627 }
628}
629
630func makeStdInt64ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
631 return func(b []byte, f pointer, w int) ([]byte, error) {
632 if w != WireBytes {
633 return nil, errInternalBadWireType
634 }
635 x, n := decodeVarint(b)
636 if n == 0 {
637 return nil, io.ErrUnexpectedEOF
638 }
639 b = b[n:]
640 if x > uint64(len(b)) {
641 return nil, io.ErrUnexpectedEOF
642 }
643 m := &int64Value{}
644 if err := Unmarshal(b[:x], m); err != nil {
645 return nil, err
646 }
647 slice := f.getSlice(sub.typ)
648 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
649 slice.Set(newSlice)
650 return b[x:], nil
651 }
652}
653
654func makeStdUInt64ValueMarshaler(u *marshalInfo) (sizer, marshaler) {
655 return func(ptr pointer, tagsize int) int {
656 t := ptr.asPointerTo(u.typ).Interface().(*uint64)
657 v := &uint64Value{*t}
658 siz := Size(v)
659 return tagsize + SizeVarint(uint64(siz)) + siz
660 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
661 t := ptr.asPointerTo(u.typ).Interface().(*uint64)
662 v := &uint64Value{*t}
663 buf, err := Marshal(v)
664 if err != nil {
665 return nil, err
666 }
667 b = appendVarint(b, wiretag)
668 b = appendVarint(b, uint64(len(buf)))
669 b = append(b, buf...)
670 return b, nil
671 }
672}
673
674func makeStdUInt64ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
675 return func(ptr pointer, tagsize int) int {
676 if ptr.isNil() {
677 return 0
678 }
679 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint64)
680 v := &uint64Value{*t}
681 siz := Size(v)
682 return tagsize + SizeVarint(uint64(siz)) + siz
683 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
684 if ptr.isNil() {
685 return b, nil
686 }
687 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint64)
688 v := &uint64Value{*t}
689 buf, err := Marshal(v)
690 if err != nil {
691 return nil, err
692 }
693 b = appendVarint(b, wiretag)
694 b = appendVarint(b, uint64(len(buf)))
695 b = append(b, buf...)
696 return b, nil
697 }
698}
699
700func makeStdUInt64ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
701 return func(ptr pointer, tagsize int) int {
702 s := ptr.getSlice(u.typ)
703 n := 0
704 for i := 0; i < s.Len(); i++ {
705 elem := s.Index(i)
706 t := elem.Interface().(uint64)
707 v := &uint64Value{t}
708 siz := Size(v)
709 n += siz + SizeVarint(uint64(siz)) + tagsize
710 }
711 return n
712 },
713 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
714 s := ptr.getSlice(u.typ)
715 for i := 0; i < s.Len(); i++ {
716 elem := s.Index(i)
717 t := elem.Interface().(uint64)
718 v := &uint64Value{t}
719 siz := Size(v)
720 buf, err := Marshal(v)
721 if err != nil {
722 return nil, err
723 }
724 b = appendVarint(b, wiretag)
725 b = appendVarint(b, uint64(siz))
726 b = append(b, buf...)
727 }
728
729 return b, nil
730 }
731}
732
733func makeStdUInt64ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
734 return func(ptr pointer, tagsize int) int {
735 s := ptr.getSlice(reflect.PtrTo(u.typ))
736 n := 0
737 for i := 0; i < s.Len(); i++ {
738 elem := s.Index(i)
739 t := elem.Interface().(*uint64)
740 v := &uint64Value{*t}
741 siz := Size(v)
742 n += siz + SizeVarint(uint64(siz)) + tagsize
743 }
744 return n
745 },
746 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
747 s := ptr.getSlice(reflect.PtrTo(u.typ))
748 for i := 0; i < s.Len(); i++ {
749 elem := s.Index(i)
750 t := elem.Interface().(*uint64)
751 v := &uint64Value{*t}
752 siz := Size(v)
753 buf, err := Marshal(v)
754 if err != nil {
755 return nil, err
756 }
757 b = appendVarint(b, wiretag)
758 b = appendVarint(b, uint64(siz))
759 b = append(b, buf...)
760 }
761
762 return b, nil
763 }
764}
765
766func makeStdUInt64ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
767 return func(b []byte, f pointer, w int) ([]byte, error) {
768 if w != WireBytes {
769 return nil, errInternalBadWireType
770 }
771 x, n := decodeVarint(b)
772 if n == 0 {
773 return nil, io.ErrUnexpectedEOF
774 }
775 b = b[n:]
776 if x > uint64(len(b)) {
777 return nil, io.ErrUnexpectedEOF
778 }
779 m := &uint64Value{}
780 if err := Unmarshal(b[:x], m); err != nil {
781 return nil, err
782 }
783 s := f.asPointerTo(sub.typ).Elem()
784 s.Set(reflect.ValueOf(m.Value))
785 return b[x:], nil
786 }
787}
788
789func makeStdUInt64ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
790 return func(b []byte, f pointer, w int) ([]byte, error) {
791 if w != WireBytes {
792 return nil, errInternalBadWireType
793 }
794 x, n := decodeVarint(b)
795 if n == 0 {
796 return nil, io.ErrUnexpectedEOF
797 }
798 b = b[n:]
799 if x > uint64(len(b)) {
800 return nil, io.ErrUnexpectedEOF
801 }
802 m := &uint64Value{}
803 if err := Unmarshal(b[:x], m); err != nil {
804 return nil, err
805 }
806 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
807 s.Set(reflect.ValueOf(&m.Value))
808 return b[x:], nil
809 }
810}
811
812func makeStdUInt64ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
813 return func(b []byte, f pointer, w int) ([]byte, error) {
814 if w != WireBytes {
815 return nil, errInternalBadWireType
816 }
817 x, n := decodeVarint(b)
818 if n == 0 {
819 return nil, io.ErrUnexpectedEOF
820 }
821 b = b[n:]
822 if x > uint64(len(b)) {
823 return nil, io.ErrUnexpectedEOF
824 }
825 m := &uint64Value{}
826 if err := Unmarshal(b[:x], m); err != nil {
827 return nil, err
828 }
829 slice := f.getSlice(reflect.PtrTo(sub.typ))
830 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
831 slice.Set(newSlice)
832 return b[x:], nil
833 }
834}
835
836func makeStdUInt64ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
837 return func(b []byte, f pointer, w int) ([]byte, error) {
838 if w != WireBytes {
839 return nil, errInternalBadWireType
840 }
841 x, n := decodeVarint(b)
842 if n == 0 {
843 return nil, io.ErrUnexpectedEOF
844 }
845 b = b[n:]
846 if x > uint64(len(b)) {
847 return nil, io.ErrUnexpectedEOF
848 }
849 m := &uint64Value{}
850 if err := Unmarshal(b[:x], m); err != nil {
851 return nil, err
852 }
853 slice := f.getSlice(sub.typ)
854 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
855 slice.Set(newSlice)
856 return b[x:], nil
857 }
858}
859
860func makeStdInt32ValueMarshaler(u *marshalInfo) (sizer, marshaler) {
861 return func(ptr pointer, tagsize int) int {
862 t := ptr.asPointerTo(u.typ).Interface().(*int32)
863 v := &int32Value{*t}
864 siz := Size(v)
865 return tagsize + SizeVarint(uint64(siz)) + siz
866 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
867 t := ptr.asPointerTo(u.typ).Interface().(*int32)
868 v := &int32Value{*t}
869 buf, err := Marshal(v)
870 if err != nil {
871 return nil, err
872 }
873 b = appendVarint(b, wiretag)
874 b = appendVarint(b, uint64(len(buf)))
875 b = append(b, buf...)
876 return b, nil
877 }
878}
879
880func makeStdInt32ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
881 return func(ptr pointer, tagsize int) int {
882 if ptr.isNil() {
883 return 0
884 }
885 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int32)
886 v := &int32Value{*t}
887 siz := Size(v)
888 return tagsize + SizeVarint(uint64(siz)) + siz
889 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
890 if ptr.isNil() {
891 return b, nil
892 }
893 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int32)
894 v := &int32Value{*t}
895 buf, err := Marshal(v)
896 if err != nil {
897 return nil, err
898 }
899 b = appendVarint(b, wiretag)
900 b = appendVarint(b, uint64(len(buf)))
901 b = append(b, buf...)
902 return b, nil
903 }
904}
905
906func makeStdInt32ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
907 return func(ptr pointer, tagsize int) int {
908 s := ptr.getSlice(u.typ)
909 n := 0
910 for i := 0; i < s.Len(); i++ {
911 elem := s.Index(i)
912 t := elem.Interface().(int32)
913 v := &int32Value{t}
914 siz := Size(v)
915 n += siz + SizeVarint(uint64(siz)) + tagsize
916 }
917 return n
918 },
919 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
920 s := ptr.getSlice(u.typ)
921 for i := 0; i < s.Len(); i++ {
922 elem := s.Index(i)
923 t := elem.Interface().(int32)
924 v := &int32Value{t}
925 siz := Size(v)
926 buf, err := Marshal(v)
927 if err != nil {
928 return nil, err
929 }
930 b = appendVarint(b, wiretag)
931 b = appendVarint(b, uint64(siz))
932 b = append(b, buf...)
933 }
934
935 return b, nil
936 }
937}
938
939func makeStdInt32ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
940 return func(ptr pointer, tagsize int) int {
941 s := ptr.getSlice(reflect.PtrTo(u.typ))
942 n := 0
943 for i := 0; i < s.Len(); i++ {
944 elem := s.Index(i)
945 t := elem.Interface().(*int32)
946 v := &int32Value{*t}
947 siz := Size(v)
948 n += siz + SizeVarint(uint64(siz)) + tagsize
949 }
950 return n
951 },
952 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
953 s := ptr.getSlice(reflect.PtrTo(u.typ))
954 for i := 0; i < s.Len(); i++ {
955 elem := s.Index(i)
956 t := elem.Interface().(*int32)
957 v := &int32Value{*t}
958 siz := Size(v)
959 buf, err := Marshal(v)
960 if err != nil {
961 return nil, err
962 }
963 b = appendVarint(b, wiretag)
964 b = appendVarint(b, uint64(siz))
965 b = append(b, buf...)
966 }
967
968 return b, nil
969 }
970}
971
972func makeStdInt32ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
973 return func(b []byte, f pointer, w int) ([]byte, error) {
974 if w != WireBytes {
975 return nil, errInternalBadWireType
976 }
977 x, n := decodeVarint(b)
978 if n == 0 {
979 return nil, io.ErrUnexpectedEOF
980 }
981 b = b[n:]
982 if x > uint64(len(b)) {
983 return nil, io.ErrUnexpectedEOF
984 }
985 m := &int32Value{}
986 if err := Unmarshal(b[:x], m); err != nil {
987 return nil, err
988 }
989 s := f.asPointerTo(sub.typ).Elem()
990 s.Set(reflect.ValueOf(m.Value))
991 return b[x:], nil
992 }
993}
994
995func makeStdInt32ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
996 return func(b []byte, f pointer, w int) ([]byte, error) {
997 if w != WireBytes {
998 return nil, errInternalBadWireType
999 }
1000 x, n := decodeVarint(b)
1001 if n == 0 {
1002 return nil, io.ErrUnexpectedEOF
1003 }
1004 b = b[n:]
1005 if x > uint64(len(b)) {
1006 return nil, io.ErrUnexpectedEOF
1007 }
1008 m := &int32Value{}
1009 if err := Unmarshal(b[:x], m); err != nil {
1010 return nil, err
1011 }
1012 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
1013 s.Set(reflect.ValueOf(&m.Value))
1014 return b[x:], nil
1015 }
1016}
1017
1018func makeStdInt32ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1019 return func(b []byte, f pointer, w int) ([]byte, error) {
1020 if w != WireBytes {
1021 return nil, errInternalBadWireType
1022 }
1023 x, n := decodeVarint(b)
1024 if n == 0 {
1025 return nil, io.ErrUnexpectedEOF
1026 }
1027 b = b[n:]
1028 if x > uint64(len(b)) {
1029 return nil, io.ErrUnexpectedEOF
1030 }
1031 m := &int32Value{}
1032 if err := Unmarshal(b[:x], m); err != nil {
1033 return nil, err
1034 }
1035 slice := f.getSlice(reflect.PtrTo(sub.typ))
1036 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
1037 slice.Set(newSlice)
1038 return b[x:], nil
1039 }
1040}
1041
1042func makeStdInt32ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1043 return func(b []byte, f pointer, w int) ([]byte, error) {
1044 if w != WireBytes {
1045 return nil, errInternalBadWireType
1046 }
1047 x, n := decodeVarint(b)
1048 if n == 0 {
1049 return nil, io.ErrUnexpectedEOF
1050 }
1051 b = b[n:]
1052 if x > uint64(len(b)) {
1053 return nil, io.ErrUnexpectedEOF
1054 }
1055 m := &int32Value{}
1056 if err := Unmarshal(b[:x], m); err != nil {
1057 return nil, err
1058 }
1059 slice := f.getSlice(sub.typ)
1060 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
1061 slice.Set(newSlice)
1062 return b[x:], nil
1063 }
1064}
1065
1066func makeStdUInt32ValueMarshaler(u *marshalInfo) (sizer, marshaler) {
1067 return func(ptr pointer, tagsize int) int {
1068 t := ptr.asPointerTo(u.typ).Interface().(*uint32)
1069 v := &uint32Value{*t}
1070 siz := Size(v)
1071 return tagsize + SizeVarint(uint64(siz)) + siz
1072 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1073 t := ptr.asPointerTo(u.typ).Interface().(*uint32)
1074 v := &uint32Value{*t}
1075 buf, err := Marshal(v)
1076 if err != nil {
1077 return nil, err
1078 }
1079 b = appendVarint(b, wiretag)
1080 b = appendVarint(b, uint64(len(buf)))
1081 b = append(b, buf...)
1082 return b, nil
1083 }
1084}
1085
1086func makeStdUInt32ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
1087 return func(ptr pointer, tagsize int) int {
1088 if ptr.isNil() {
1089 return 0
1090 }
1091 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint32)
1092 v := &uint32Value{*t}
1093 siz := Size(v)
1094 return tagsize + SizeVarint(uint64(siz)) + siz
1095 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1096 if ptr.isNil() {
1097 return b, nil
1098 }
1099 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint32)
1100 v := &uint32Value{*t}
1101 buf, err := Marshal(v)
1102 if err != nil {
1103 return nil, err
1104 }
1105 b = appendVarint(b, wiretag)
1106 b = appendVarint(b, uint64(len(buf)))
1107 b = append(b, buf...)
1108 return b, nil
1109 }
1110}
1111
1112func makeStdUInt32ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1113 return func(ptr pointer, tagsize int) int {
1114 s := ptr.getSlice(u.typ)
1115 n := 0
1116 for i := 0; i < s.Len(); i++ {
1117 elem := s.Index(i)
1118 t := elem.Interface().(uint32)
1119 v := &uint32Value{t}
1120 siz := Size(v)
1121 n += siz + SizeVarint(uint64(siz)) + tagsize
1122 }
1123 return n
1124 },
1125 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1126 s := ptr.getSlice(u.typ)
1127 for i := 0; i < s.Len(); i++ {
1128 elem := s.Index(i)
1129 t := elem.Interface().(uint32)
1130 v := &uint32Value{t}
1131 siz := Size(v)
1132 buf, err := Marshal(v)
1133 if err != nil {
1134 return nil, err
1135 }
1136 b = appendVarint(b, wiretag)
1137 b = appendVarint(b, uint64(siz))
1138 b = append(b, buf...)
1139 }
1140
1141 return b, nil
1142 }
1143}
1144
1145func makeStdUInt32ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1146 return func(ptr pointer, tagsize int) int {
1147 s := ptr.getSlice(reflect.PtrTo(u.typ))
1148 n := 0
1149 for i := 0; i < s.Len(); i++ {
1150 elem := s.Index(i)
1151 t := elem.Interface().(*uint32)
1152 v := &uint32Value{*t}
1153 siz := Size(v)
1154 n += siz + SizeVarint(uint64(siz)) + tagsize
1155 }
1156 return n
1157 },
1158 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1159 s := ptr.getSlice(reflect.PtrTo(u.typ))
1160 for i := 0; i < s.Len(); i++ {
1161 elem := s.Index(i)
1162 t := elem.Interface().(*uint32)
1163 v := &uint32Value{*t}
1164 siz := Size(v)
1165 buf, err := Marshal(v)
1166 if err != nil {
1167 return nil, err
1168 }
1169 b = appendVarint(b, wiretag)
1170 b = appendVarint(b, uint64(siz))
1171 b = append(b, buf...)
1172 }
1173
1174 return b, nil
1175 }
1176}
1177
1178func makeStdUInt32ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1179 return func(b []byte, f pointer, w int) ([]byte, error) {
1180 if w != WireBytes {
1181 return nil, errInternalBadWireType
1182 }
1183 x, n := decodeVarint(b)
1184 if n == 0 {
1185 return nil, io.ErrUnexpectedEOF
1186 }
1187 b = b[n:]
1188 if x > uint64(len(b)) {
1189 return nil, io.ErrUnexpectedEOF
1190 }
1191 m := &uint32Value{}
1192 if err := Unmarshal(b[:x], m); err != nil {
1193 return nil, err
1194 }
1195 s := f.asPointerTo(sub.typ).Elem()
1196 s.Set(reflect.ValueOf(m.Value))
1197 return b[x:], nil
1198 }
1199}
1200
1201func makeStdUInt32ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1202 return func(b []byte, f pointer, w int) ([]byte, error) {
1203 if w != WireBytes {
1204 return nil, errInternalBadWireType
1205 }
1206 x, n := decodeVarint(b)
1207 if n == 0 {
1208 return nil, io.ErrUnexpectedEOF
1209 }
1210 b = b[n:]
1211 if x > uint64(len(b)) {
1212 return nil, io.ErrUnexpectedEOF
1213 }
1214 m := &uint32Value{}
1215 if err := Unmarshal(b[:x], m); err != nil {
1216 return nil, err
1217 }
1218 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
1219 s.Set(reflect.ValueOf(&m.Value))
1220 return b[x:], nil
1221 }
1222}
1223
1224func makeStdUInt32ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1225 return func(b []byte, f pointer, w int) ([]byte, error) {
1226 if w != WireBytes {
1227 return nil, errInternalBadWireType
1228 }
1229 x, n := decodeVarint(b)
1230 if n == 0 {
1231 return nil, io.ErrUnexpectedEOF
1232 }
1233 b = b[n:]
1234 if x > uint64(len(b)) {
1235 return nil, io.ErrUnexpectedEOF
1236 }
1237 m := &uint32Value{}
1238 if err := Unmarshal(b[:x], m); err != nil {
1239 return nil, err
1240 }
1241 slice := f.getSlice(reflect.PtrTo(sub.typ))
1242 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
1243 slice.Set(newSlice)
1244 return b[x:], nil
1245 }
1246}
1247
1248func makeStdUInt32ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1249 return func(b []byte, f pointer, w int) ([]byte, error) {
1250 if w != WireBytes {
1251 return nil, errInternalBadWireType
1252 }
1253 x, n := decodeVarint(b)
1254 if n == 0 {
1255 return nil, io.ErrUnexpectedEOF
1256 }
1257 b = b[n:]
1258 if x > uint64(len(b)) {
1259 return nil, io.ErrUnexpectedEOF
1260 }
1261 m := &uint32Value{}
1262 if err := Unmarshal(b[:x], m); err != nil {
1263 return nil, err
1264 }
1265 slice := f.getSlice(sub.typ)
1266 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
1267 slice.Set(newSlice)
1268 return b[x:], nil
1269 }
1270}
1271
1272func makeStdBoolValueMarshaler(u *marshalInfo) (sizer, marshaler) {
1273 return func(ptr pointer, tagsize int) int {
1274 t := ptr.asPointerTo(u.typ).Interface().(*bool)
1275 v := &boolValue{*t}
1276 siz := Size(v)
1277 return tagsize + SizeVarint(uint64(siz)) + siz
1278 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1279 t := ptr.asPointerTo(u.typ).Interface().(*bool)
1280 v := &boolValue{*t}
1281 buf, err := Marshal(v)
1282 if err != nil {
1283 return nil, err
1284 }
1285 b = appendVarint(b, wiretag)
1286 b = appendVarint(b, uint64(len(buf)))
1287 b = append(b, buf...)
1288 return b, nil
1289 }
1290}
1291
1292func makeStdBoolValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
1293 return func(ptr pointer, tagsize int) int {
1294 if ptr.isNil() {
1295 return 0
1296 }
1297 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*bool)
1298 v := &boolValue{*t}
1299 siz := Size(v)
1300 return tagsize + SizeVarint(uint64(siz)) + siz
1301 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1302 if ptr.isNil() {
1303 return b, nil
1304 }
1305 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*bool)
1306 v := &boolValue{*t}
1307 buf, err := Marshal(v)
1308 if err != nil {
1309 return nil, err
1310 }
1311 b = appendVarint(b, wiretag)
1312 b = appendVarint(b, uint64(len(buf)))
1313 b = append(b, buf...)
1314 return b, nil
1315 }
1316}
1317
1318func makeStdBoolValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1319 return func(ptr pointer, tagsize int) int {
1320 s := ptr.getSlice(u.typ)
1321 n := 0
1322 for i := 0; i < s.Len(); i++ {
1323 elem := s.Index(i)
1324 t := elem.Interface().(bool)
1325 v := &boolValue{t}
1326 siz := Size(v)
1327 n += siz + SizeVarint(uint64(siz)) + tagsize
1328 }
1329 return n
1330 },
1331 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1332 s := ptr.getSlice(u.typ)
1333 for i := 0; i < s.Len(); i++ {
1334 elem := s.Index(i)
1335 t := elem.Interface().(bool)
1336 v := &boolValue{t}
1337 siz := Size(v)
1338 buf, err := Marshal(v)
1339 if err != nil {
1340 return nil, err
1341 }
1342 b = appendVarint(b, wiretag)
1343 b = appendVarint(b, uint64(siz))
1344 b = append(b, buf...)
1345 }
1346
1347 return b, nil
1348 }
1349}
1350
1351func makeStdBoolValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1352 return func(ptr pointer, tagsize int) int {
1353 s := ptr.getSlice(reflect.PtrTo(u.typ))
1354 n := 0
1355 for i := 0; i < s.Len(); i++ {
1356 elem := s.Index(i)
1357 t := elem.Interface().(*bool)
1358 v := &boolValue{*t}
1359 siz := Size(v)
1360 n += siz + SizeVarint(uint64(siz)) + tagsize
1361 }
1362 return n
1363 },
1364 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1365 s := ptr.getSlice(reflect.PtrTo(u.typ))
1366 for i := 0; i < s.Len(); i++ {
1367 elem := s.Index(i)
1368 t := elem.Interface().(*bool)
1369 v := &boolValue{*t}
1370 siz := Size(v)
1371 buf, err := Marshal(v)
1372 if err != nil {
1373 return nil, err
1374 }
1375 b = appendVarint(b, wiretag)
1376 b = appendVarint(b, uint64(siz))
1377 b = append(b, buf...)
1378 }
1379
1380 return b, nil
1381 }
1382}
1383
1384func makeStdBoolValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1385 return func(b []byte, f pointer, w int) ([]byte, error) {
1386 if w != WireBytes {
1387 return nil, errInternalBadWireType
1388 }
1389 x, n := decodeVarint(b)
1390 if n == 0 {
1391 return nil, io.ErrUnexpectedEOF
1392 }
1393 b = b[n:]
1394 if x > uint64(len(b)) {
1395 return nil, io.ErrUnexpectedEOF
1396 }
1397 m := &boolValue{}
1398 if err := Unmarshal(b[:x], m); err != nil {
1399 return nil, err
1400 }
1401 s := f.asPointerTo(sub.typ).Elem()
1402 s.Set(reflect.ValueOf(m.Value))
1403 return b[x:], nil
1404 }
1405}
1406
1407func makeStdBoolValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1408 return func(b []byte, f pointer, w int) ([]byte, error) {
1409 if w != WireBytes {
1410 return nil, errInternalBadWireType
1411 }
1412 x, n := decodeVarint(b)
1413 if n == 0 {
1414 return nil, io.ErrUnexpectedEOF
1415 }
1416 b = b[n:]
1417 if x > uint64(len(b)) {
1418 return nil, io.ErrUnexpectedEOF
1419 }
1420 m := &boolValue{}
1421 if err := Unmarshal(b[:x], m); err != nil {
1422 return nil, err
1423 }
1424 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
1425 s.Set(reflect.ValueOf(&m.Value))
1426 return b[x:], nil
1427 }
1428}
1429
1430func makeStdBoolValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1431 return func(b []byte, f pointer, w int) ([]byte, error) {
1432 if w != WireBytes {
1433 return nil, errInternalBadWireType
1434 }
1435 x, n := decodeVarint(b)
1436 if n == 0 {
1437 return nil, io.ErrUnexpectedEOF
1438 }
1439 b = b[n:]
1440 if x > uint64(len(b)) {
1441 return nil, io.ErrUnexpectedEOF
1442 }
1443 m := &boolValue{}
1444 if err := Unmarshal(b[:x], m); err != nil {
1445 return nil, err
1446 }
1447 slice := f.getSlice(reflect.PtrTo(sub.typ))
1448 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
1449 slice.Set(newSlice)
1450 return b[x:], nil
1451 }
1452}
1453
1454func makeStdBoolValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1455 return func(b []byte, f pointer, w int) ([]byte, error) {
1456 if w != WireBytes {
1457 return nil, errInternalBadWireType
1458 }
1459 x, n := decodeVarint(b)
1460 if n == 0 {
1461 return nil, io.ErrUnexpectedEOF
1462 }
1463 b = b[n:]
1464 if x > uint64(len(b)) {
1465 return nil, io.ErrUnexpectedEOF
1466 }
1467 m := &boolValue{}
1468 if err := Unmarshal(b[:x], m); err != nil {
1469 return nil, err
1470 }
1471 slice := f.getSlice(sub.typ)
1472 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
1473 slice.Set(newSlice)
1474 return b[x:], nil
1475 }
1476}
1477
1478func makeStdStringValueMarshaler(u *marshalInfo) (sizer, marshaler) {
1479 return func(ptr pointer, tagsize int) int {
1480 t := ptr.asPointerTo(u.typ).Interface().(*string)
1481 v := &stringValue{*t}
1482 siz := Size(v)
1483 return tagsize + SizeVarint(uint64(siz)) + siz
1484 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1485 t := ptr.asPointerTo(u.typ).Interface().(*string)
1486 v := &stringValue{*t}
1487 buf, err := Marshal(v)
1488 if err != nil {
1489 return nil, err
1490 }
1491 b = appendVarint(b, wiretag)
1492 b = appendVarint(b, uint64(len(buf)))
1493 b = append(b, buf...)
1494 return b, nil
1495 }
1496}
1497
1498func makeStdStringValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
1499 return func(ptr pointer, tagsize int) int {
1500 if ptr.isNil() {
1501 return 0
1502 }
1503 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*string)
1504 v := &stringValue{*t}
1505 siz := Size(v)
1506 return tagsize + SizeVarint(uint64(siz)) + siz
1507 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1508 if ptr.isNil() {
1509 return b, nil
1510 }
1511 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*string)
1512 v := &stringValue{*t}
1513 buf, err := Marshal(v)
1514 if err != nil {
1515 return nil, err
1516 }
1517 b = appendVarint(b, wiretag)
1518 b = appendVarint(b, uint64(len(buf)))
1519 b = append(b, buf...)
1520 return b, nil
1521 }
1522}
1523
1524func makeStdStringValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1525 return func(ptr pointer, tagsize int) int {
1526 s := ptr.getSlice(u.typ)
1527 n := 0
1528 for i := 0; i < s.Len(); i++ {
1529 elem := s.Index(i)
1530 t := elem.Interface().(string)
1531 v := &stringValue{t}
1532 siz := Size(v)
1533 n += siz + SizeVarint(uint64(siz)) + tagsize
1534 }
1535 return n
1536 },
1537 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1538 s := ptr.getSlice(u.typ)
1539 for i := 0; i < s.Len(); i++ {
1540 elem := s.Index(i)
1541 t := elem.Interface().(string)
1542 v := &stringValue{t}
1543 siz := Size(v)
1544 buf, err := Marshal(v)
1545 if err != nil {
1546 return nil, err
1547 }
1548 b = appendVarint(b, wiretag)
1549 b = appendVarint(b, uint64(siz))
1550 b = append(b, buf...)
1551 }
1552
1553 return b, nil
1554 }
1555}
1556
1557func makeStdStringValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1558 return func(ptr pointer, tagsize int) int {
1559 s := ptr.getSlice(reflect.PtrTo(u.typ))
1560 n := 0
1561 for i := 0; i < s.Len(); i++ {
1562 elem := s.Index(i)
1563 t := elem.Interface().(*string)
1564 v := &stringValue{*t}
1565 siz := Size(v)
1566 n += siz + SizeVarint(uint64(siz)) + tagsize
1567 }
1568 return n
1569 },
1570 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1571 s := ptr.getSlice(reflect.PtrTo(u.typ))
1572 for i := 0; i < s.Len(); i++ {
1573 elem := s.Index(i)
1574 t := elem.Interface().(*string)
1575 v := &stringValue{*t}
1576 siz := Size(v)
1577 buf, err := Marshal(v)
1578 if err != nil {
1579 return nil, err
1580 }
1581 b = appendVarint(b, wiretag)
1582 b = appendVarint(b, uint64(siz))
1583 b = append(b, buf...)
1584 }
1585
1586 return b, nil
1587 }
1588}
1589
1590func makeStdStringValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1591 return func(b []byte, f pointer, w int) ([]byte, error) {
1592 if w != WireBytes {
1593 return nil, errInternalBadWireType
1594 }
1595 x, n := decodeVarint(b)
1596 if n == 0 {
1597 return nil, io.ErrUnexpectedEOF
1598 }
1599 b = b[n:]
1600 if x > uint64(len(b)) {
1601 return nil, io.ErrUnexpectedEOF
1602 }
1603 m := &stringValue{}
1604 if err := Unmarshal(b[:x], m); err != nil {
1605 return nil, err
1606 }
1607 s := f.asPointerTo(sub.typ).Elem()
1608 s.Set(reflect.ValueOf(m.Value))
1609 return b[x:], nil
1610 }
1611}
1612
1613func makeStdStringValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1614 return func(b []byte, f pointer, w int) ([]byte, error) {
1615 if w != WireBytes {
1616 return nil, errInternalBadWireType
1617 }
1618 x, n := decodeVarint(b)
1619 if n == 0 {
1620 return nil, io.ErrUnexpectedEOF
1621 }
1622 b = b[n:]
1623 if x > uint64(len(b)) {
1624 return nil, io.ErrUnexpectedEOF
1625 }
1626 m := &stringValue{}
1627 if err := Unmarshal(b[:x], m); err != nil {
1628 return nil, err
1629 }
1630 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
1631 s.Set(reflect.ValueOf(&m.Value))
1632 return b[x:], nil
1633 }
1634}
1635
1636func makeStdStringValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1637 return func(b []byte, f pointer, w int) ([]byte, error) {
1638 if w != WireBytes {
1639 return nil, errInternalBadWireType
1640 }
1641 x, n := decodeVarint(b)
1642 if n == 0 {
1643 return nil, io.ErrUnexpectedEOF
1644 }
1645 b = b[n:]
1646 if x > uint64(len(b)) {
1647 return nil, io.ErrUnexpectedEOF
1648 }
1649 m := &stringValue{}
1650 if err := Unmarshal(b[:x], m); err != nil {
1651 return nil, err
1652 }
1653 slice := f.getSlice(reflect.PtrTo(sub.typ))
1654 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
1655 slice.Set(newSlice)
1656 return b[x:], nil
1657 }
1658}
1659
1660func makeStdStringValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1661 return func(b []byte, f pointer, w int) ([]byte, error) {
1662 if w != WireBytes {
1663 return nil, errInternalBadWireType
1664 }
1665 x, n := decodeVarint(b)
1666 if n == 0 {
1667 return nil, io.ErrUnexpectedEOF
1668 }
1669 b = b[n:]
1670 if x > uint64(len(b)) {
1671 return nil, io.ErrUnexpectedEOF
1672 }
1673 m := &stringValue{}
1674 if err := Unmarshal(b[:x], m); err != nil {
1675 return nil, err
1676 }
1677 slice := f.getSlice(sub.typ)
1678 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
1679 slice.Set(newSlice)
1680 return b[x:], nil
1681 }
1682}
1683
1684func makeStdBytesValueMarshaler(u *marshalInfo) (sizer, marshaler) {
1685 return func(ptr pointer, tagsize int) int {
1686 t := ptr.asPointerTo(u.typ).Interface().(*[]byte)
1687 v := &bytesValue{*t}
1688 siz := Size(v)
1689 return tagsize + SizeVarint(uint64(siz)) + siz
1690 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1691 t := ptr.asPointerTo(u.typ).Interface().(*[]byte)
1692 v := &bytesValue{*t}
1693 buf, err := Marshal(v)
1694 if err != nil {
1695 return nil, err
1696 }
1697 b = appendVarint(b, wiretag)
1698 b = appendVarint(b, uint64(len(buf)))
1699 b = append(b, buf...)
1700 return b, nil
1701 }
1702}
1703
1704func makeStdBytesValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
1705 return func(ptr pointer, tagsize int) int {
1706 if ptr.isNil() {
1707 return 0
1708 }
1709 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*[]byte)
1710 v := &bytesValue{*t}
1711 siz := Size(v)
1712 return tagsize + SizeVarint(uint64(siz)) + siz
1713 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1714 if ptr.isNil() {
1715 return b, nil
1716 }
1717 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*[]byte)
1718 v := &bytesValue{*t}
1719 buf, err := Marshal(v)
1720 if err != nil {
1721 return nil, err
1722 }
1723 b = appendVarint(b, wiretag)
1724 b = appendVarint(b, uint64(len(buf)))
1725 b = append(b, buf...)
1726 return b, nil
1727 }
1728}
1729
1730func makeStdBytesValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1731 return func(ptr pointer, tagsize int) int {
1732 s := ptr.getSlice(u.typ)
1733 n := 0
1734 for i := 0; i < s.Len(); i++ {
1735 elem := s.Index(i)
1736 t := elem.Interface().([]byte)
1737 v := &bytesValue{t}
1738 siz := Size(v)
1739 n += siz + SizeVarint(uint64(siz)) + tagsize
1740 }
1741 return n
1742 },
1743 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1744 s := ptr.getSlice(u.typ)
1745 for i := 0; i < s.Len(); i++ {
1746 elem := s.Index(i)
1747 t := elem.Interface().([]byte)
1748 v := &bytesValue{t}
1749 siz := Size(v)
1750 buf, err := Marshal(v)
1751 if err != nil {
1752 return nil, err
1753 }
1754 b = appendVarint(b, wiretag)
1755 b = appendVarint(b, uint64(siz))
1756 b = append(b, buf...)
1757 }
1758
1759 return b, nil
1760 }
1761}
1762
1763func makeStdBytesValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1764 return func(ptr pointer, tagsize int) int {
1765 s := ptr.getSlice(reflect.PtrTo(u.typ))
1766 n := 0
1767 for i := 0; i < s.Len(); i++ {
1768 elem := s.Index(i)
1769 t := elem.Interface().(*[]byte)
1770 v := &bytesValue{*t}
1771 siz := Size(v)
1772 n += siz + SizeVarint(uint64(siz)) + tagsize
1773 }
1774 return n
1775 },
1776 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1777 s := ptr.getSlice(reflect.PtrTo(u.typ))
1778 for i := 0; i < s.Len(); i++ {
1779 elem := s.Index(i)
1780 t := elem.Interface().(*[]byte)
1781 v := &bytesValue{*t}
1782 siz := Size(v)
1783 buf, err := Marshal(v)
1784 if err != nil {
1785 return nil, err
1786 }
1787 b = appendVarint(b, wiretag)
1788 b = appendVarint(b, uint64(siz))
1789 b = append(b, buf...)
1790 }
1791
1792 return b, nil
1793 }
1794}
1795
1796func makeStdBytesValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1797 return func(b []byte, f pointer, w int) ([]byte, error) {
1798 if w != WireBytes {
1799 return nil, errInternalBadWireType
1800 }
1801 x, n := decodeVarint(b)
1802 if n == 0 {
1803 return nil, io.ErrUnexpectedEOF
1804 }
1805 b = b[n:]
1806 if x > uint64(len(b)) {
1807 return nil, io.ErrUnexpectedEOF
1808 }
1809 m := &bytesValue{}
1810 if err := Unmarshal(b[:x], m); err != nil {
1811 return nil, err
1812 }
1813 s := f.asPointerTo(sub.typ).Elem()
1814 s.Set(reflect.ValueOf(m.Value))
1815 return b[x:], nil
1816 }
1817}
1818
1819func makeStdBytesValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1820 return func(b []byte, f pointer, w int) ([]byte, error) {
1821 if w != WireBytes {
1822 return nil, errInternalBadWireType
1823 }
1824 x, n := decodeVarint(b)
1825 if n == 0 {
1826 return nil, io.ErrUnexpectedEOF
1827 }
1828 b = b[n:]
1829 if x > uint64(len(b)) {
1830 return nil, io.ErrUnexpectedEOF
1831 }
1832 m := &bytesValue{}
1833 if err := Unmarshal(b[:x], m); err != nil {
1834 return nil, err
1835 }
1836 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
1837 s.Set(reflect.ValueOf(&m.Value))
1838 return b[x:], nil
1839 }
1840}
1841
1842func makeStdBytesValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1843 return func(b []byte, f pointer, w int) ([]byte, error) {
1844 if w != WireBytes {
1845 return nil, errInternalBadWireType
1846 }
1847 x, n := decodeVarint(b)
1848 if n == 0 {
1849 return nil, io.ErrUnexpectedEOF
1850 }
1851 b = b[n:]
1852 if x > uint64(len(b)) {
1853 return nil, io.ErrUnexpectedEOF
1854 }
1855 m := &bytesValue{}
1856 if err := Unmarshal(b[:x], m); err != nil {
1857 return nil, err
1858 }
1859 slice := f.getSlice(reflect.PtrTo(sub.typ))
1860 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
1861 slice.Set(newSlice)
1862 return b[x:], nil
1863 }
1864}
1865
1866func makeStdBytesValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1867 return func(b []byte, f pointer, w int) ([]byte, error) {
1868 if w != WireBytes {
1869 return nil, errInternalBadWireType
1870 }
1871 x, n := decodeVarint(b)
1872 if n == 0 {
1873 return nil, io.ErrUnexpectedEOF
1874 }
1875 b = b[n:]
1876 if x > uint64(len(b)) {
1877 return nil, io.ErrUnexpectedEOF
1878 }
1879 m := &bytesValue{}
1880 if err := Unmarshal(b[:x], m); err != nil {
1881 return nil, err
1882 }
1883 slice := f.getSlice(sub.typ)
1884 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
1885 slice.Set(newSlice)
1886 return b[x:], nil
1887 }
1888}