1 // Protocol Buffers for Go with Gadgets
3 // Copyright (c) 2018, The GoGo Authors. All rights reserved.
4 // http://github.com/gogo/protobuf
6 // Redistribution and use in source and binary forms, with or without
7 // modification, are permitted provided that the following conditions are
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
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.
36 func 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}
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)
49 b = appendVarint(b, wiretag)
50 b = appendVarint(b, uint64(len(buf)))
56 func makeStdDoubleValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
57 return func(ptr pointer, tagsize int) int {
61 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float64)
62 v := &float64Value{*t}
64 return tagsize + SizeVarint(uint64(siz)) + siz
65 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
69 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float64)
70 v := &float64Value{*t}
71 buf, err := Marshal(v)
75 b = appendVarint(b, wiretag)
76 b = appendVarint(b, uint64(len(buf)))
82 func makeStdDoubleValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
83 return func(ptr pointer, tagsize int) int {
84 s := ptr.getSlice(u.typ)
86 for i := 0; i < s.Len(); i++ {
88 t := elem.Interface().(float64)
91 n += siz + SizeVarint(uint64(siz)) + tagsize
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++ {
99 t := elem.Interface().(float64)
100 v := &float64Value{t}
102 buf, err := Marshal(v)
106 b = appendVarint(b, wiretag)
107 b = appendVarint(b, uint64(siz))
108 b = append(b, buf...)
115 func makeStdDoubleValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
116 return func(ptr pointer, tagsize int) int {
117 s := ptr.getSlice(reflect.PtrTo(u.typ))
119 for i := 0; i < s.Len(); i++ {
121 t := elem.Interface().(*float64)
122 v := &float64Value{*t}
124 n += siz + SizeVarint(uint64(siz)) + tagsize
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++ {
132 t := elem.Interface().(*float64)
133 v := &float64Value{*t}
135 buf, err := Marshal(v)
139 b = appendVarint(b, wiretag)
140 b = appendVarint(b, uint64(siz))
141 b = append(b, buf...)
148 func makeStdDoubleValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
149 return func(b []byte, f pointer, w int) ([]byte, error) {
151 return nil, errInternalBadWireType
153 x, n := decodeVarint(b)
155 return nil, io.ErrUnexpectedEOF
158 if x > uint64(len(b)) {
159 return nil, io.ErrUnexpectedEOF
162 if err := Unmarshal(b[:x], m); err != nil {
165 s := f.asPointerTo(sub.typ).Elem()
166 s.Set(reflect.ValueOf(m.Value))
171 func makeStdDoubleValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
172 return func(b []byte, f pointer, w int) ([]byte, error) {
174 return nil, errInternalBadWireType
176 x, n := decodeVarint(b)
178 return nil, io.ErrUnexpectedEOF
181 if x > uint64(len(b)) {
182 return nil, io.ErrUnexpectedEOF
185 if err := Unmarshal(b[:x], m); err != nil {
188 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
189 s.Set(reflect.ValueOf(&m.Value))
194 func makeStdDoubleValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
195 return func(b []byte, f pointer, w int) ([]byte, error) {
197 return nil, errInternalBadWireType
199 x, n := decodeVarint(b)
201 return nil, io.ErrUnexpectedEOF
204 if x > uint64(len(b)) {
205 return nil, io.ErrUnexpectedEOF
208 if err := Unmarshal(b[:x], m); err != nil {
211 slice := f.getSlice(reflect.PtrTo(sub.typ))
212 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
218 func makeStdDoubleValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
219 return func(b []byte, f pointer, w int) ([]byte, error) {
221 return nil, errInternalBadWireType
223 x, n := decodeVarint(b)
225 return nil, io.ErrUnexpectedEOF
228 if x > uint64(len(b)) {
229 return nil, io.ErrUnexpectedEOF
232 if err := Unmarshal(b[:x], m); err != nil {
235 slice := f.getSlice(sub.typ)
236 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
242 func 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}
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)
255 b = appendVarint(b, wiretag)
256 b = appendVarint(b, uint64(len(buf)))
257 b = append(b, buf...)
262 func makeStdFloatValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
263 return func(ptr pointer, tagsize int) int {
267 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float32)
268 v := &float32Value{*t}
270 return tagsize + SizeVarint(uint64(siz)) + siz
271 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
275 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float32)
276 v := &float32Value{*t}
277 buf, err := Marshal(v)
281 b = appendVarint(b, wiretag)
282 b = appendVarint(b, uint64(len(buf)))
283 b = append(b, buf...)
288 func makeStdFloatValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
289 return func(ptr pointer, tagsize int) int {
290 s := ptr.getSlice(u.typ)
292 for i := 0; i < s.Len(); i++ {
294 t := elem.Interface().(float32)
295 v := &float32Value{t}
297 n += siz + SizeVarint(uint64(siz)) + tagsize
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++ {
305 t := elem.Interface().(float32)
306 v := &float32Value{t}
308 buf, err := Marshal(v)
312 b = appendVarint(b, wiretag)
313 b = appendVarint(b, uint64(siz))
314 b = append(b, buf...)
321 func makeStdFloatValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
322 return func(ptr pointer, tagsize int) int {
323 s := ptr.getSlice(reflect.PtrTo(u.typ))
325 for i := 0; i < s.Len(); i++ {
327 t := elem.Interface().(*float32)
328 v := &float32Value{*t}
330 n += siz + SizeVarint(uint64(siz)) + tagsize
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++ {
338 t := elem.Interface().(*float32)
339 v := &float32Value{*t}
341 buf, err := Marshal(v)
345 b = appendVarint(b, wiretag)
346 b = appendVarint(b, uint64(siz))
347 b = append(b, buf...)
354 func makeStdFloatValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
355 return func(b []byte, f pointer, w int) ([]byte, error) {
357 return nil, errInternalBadWireType
359 x, n := decodeVarint(b)
361 return nil, io.ErrUnexpectedEOF
364 if x > uint64(len(b)) {
365 return nil, io.ErrUnexpectedEOF
368 if err := Unmarshal(b[:x], m); err != nil {
371 s := f.asPointerTo(sub.typ).Elem()
372 s.Set(reflect.ValueOf(m.Value))
377 func makeStdFloatValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
378 return func(b []byte, f pointer, w int) ([]byte, error) {
380 return nil, errInternalBadWireType
382 x, n := decodeVarint(b)
384 return nil, io.ErrUnexpectedEOF
387 if x > uint64(len(b)) {
388 return nil, io.ErrUnexpectedEOF
391 if err := Unmarshal(b[:x], m); err != nil {
394 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
395 s.Set(reflect.ValueOf(&m.Value))
400 func makeStdFloatValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
401 return func(b []byte, f pointer, w int) ([]byte, error) {
403 return nil, errInternalBadWireType
405 x, n := decodeVarint(b)
407 return nil, io.ErrUnexpectedEOF
410 if x > uint64(len(b)) {
411 return nil, io.ErrUnexpectedEOF
414 if err := Unmarshal(b[:x], m); err != nil {
417 slice := f.getSlice(reflect.PtrTo(sub.typ))
418 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
424 func makeStdFloatValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
425 return func(b []byte, f pointer, w int) ([]byte, error) {
427 return nil, errInternalBadWireType
429 x, n := decodeVarint(b)
431 return nil, io.ErrUnexpectedEOF
434 if x > uint64(len(b)) {
435 return nil, io.ErrUnexpectedEOF
438 if err := Unmarshal(b[:x], m); err != nil {
441 slice := f.getSlice(sub.typ)
442 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
448 func makeStdInt64ValueMarshaler(u *marshalInfo) (sizer, marshaler) {
449 return func(ptr pointer, tagsize int) int {
450 t := ptr.asPointerTo(u.typ).Interface().(*int64)
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)
457 buf, err := Marshal(v)
461 b = appendVarint(b, wiretag)
462 b = appendVarint(b, uint64(len(buf)))
463 b = append(b, buf...)
468 func makeStdInt64ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
469 return func(ptr pointer, tagsize int) int {
473 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int64)
476 return tagsize + SizeVarint(uint64(siz)) + siz
477 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
481 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int64)
483 buf, err := Marshal(v)
487 b = appendVarint(b, wiretag)
488 b = appendVarint(b, uint64(len(buf)))
489 b = append(b, buf...)
494 func makeStdInt64ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
495 return func(ptr pointer, tagsize int) int {
496 s := ptr.getSlice(u.typ)
498 for i := 0; i < s.Len(); i++ {
500 t := elem.Interface().(int64)
503 n += siz + SizeVarint(uint64(siz)) + tagsize
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++ {
511 t := elem.Interface().(int64)
514 buf, err := Marshal(v)
518 b = appendVarint(b, wiretag)
519 b = appendVarint(b, uint64(siz))
520 b = append(b, buf...)
527 func makeStdInt64ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
528 return func(ptr pointer, tagsize int) int {
529 s := ptr.getSlice(reflect.PtrTo(u.typ))
531 for i := 0; i < s.Len(); i++ {
533 t := elem.Interface().(*int64)
536 n += siz + SizeVarint(uint64(siz)) + tagsize
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++ {
544 t := elem.Interface().(*int64)
547 buf, err := Marshal(v)
551 b = appendVarint(b, wiretag)
552 b = appendVarint(b, uint64(siz))
553 b = append(b, buf...)
560 func makeStdInt64ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
561 return func(b []byte, f pointer, w int) ([]byte, error) {
563 return nil, errInternalBadWireType
565 x, n := decodeVarint(b)
567 return nil, io.ErrUnexpectedEOF
570 if x > uint64(len(b)) {
571 return nil, io.ErrUnexpectedEOF
574 if err := Unmarshal(b[:x], m); err != nil {
577 s := f.asPointerTo(sub.typ).Elem()
578 s.Set(reflect.ValueOf(m.Value))
583 func makeStdInt64ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
584 return func(b []byte, f pointer, w int) ([]byte, error) {
586 return nil, errInternalBadWireType
588 x, n := decodeVarint(b)
590 return nil, io.ErrUnexpectedEOF
593 if x > uint64(len(b)) {
594 return nil, io.ErrUnexpectedEOF
597 if err := Unmarshal(b[:x], m); err != nil {
600 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
601 s.Set(reflect.ValueOf(&m.Value))
606 func makeStdInt64ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
607 return func(b []byte, f pointer, w int) ([]byte, error) {
609 return nil, errInternalBadWireType
611 x, n := decodeVarint(b)
613 return nil, io.ErrUnexpectedEOF
616 if x > uint64(len(b)) {
617 return nil, io.ErrUnexpectedEOF
620 if err := Unmarshal(b[:x], m); err != nil {
623 slice := f.getSlice(reflect.PtrTo(sub.typ))
624 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
630 func makeStdInt64ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
631 return func(b []byte, f pointer, w int) ([]byte, error) {
633 return nil, errInternalBadWireType
635 x, n := decodeVarint(b)
637 return nil, io.ErrUnexpectedEOF
640 if x > uint64(len(b)) {
641 return nil, io.ErrUnexpectedEOF
644 if err := Unmarshal(b[:x], m); err != nil {
647 slice := f.getSlice(sub.typ)
648 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
654 func 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}
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)
667 b = appendVarint(b, wiretag)
668 b = appendVarint(b, uint64(len(buf)))
669 b = append(b, buf...)
674 func makeStdUInt64ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
675 return func(ptr pointer, tagsize int) int {
679 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint64)
680 v := &uint64Value{*t}
682 return tagsize + SizeVarint(uint64(siz)) + siz
683 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
687 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint64)
688 v := &uint64Value{*t}
689 buf, err := Marshal(v)
693 b = appendVarint(b, wiretag)
694 b = appendVarint(b, uint64(len(buf)))
695 b = append(b, buf...)
700 func makeStdUInt64ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
701 return func(ptr pointer, tagsize int) int {
702 s := ptr.getSlice(u.typ)
704 for i := 0; i < s.Len(); i++ {
706 t := elem.Interface().(uint64)
709 n += siz + SizeVarint(uint64(siz)) + tagsize
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++ {
717 t := elem.Interface().(uint64)
720 buf, err := Marshal(v)
724 b = appendVarint(b, wiretag)
725 b = appendVarint(b, uint64(siz))
726 b = append(b, buf...)
733 func makeStdUInt64ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
734 return func(ptr pointer, tagsize int) int {
735 s := ptr.getSlice(reflect.PtrTo(u.typ))
737 for i := 0; i < s.Len(); i++ {
739 t := elem.Interface().(*uint64)
740 v := &uint64Value{*t}
742 n += siz + SizeVarint(uint64(siz)) + tagsize
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++ {
750 t := elem.Interface().(*uint64)
751 v := &uint64Value{*t}
753 buf, err := Marshal(v)
757 b = appendVarint(b, wiretag)
758 b = appendVarint(b, uint64(siz))
759 b = append(b, buf...)
766 func makeStdUInt64ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
767 return func(b []byte, f pointer, w int) ([]byte, error) {
769 return nil, errInternalBadWireType
771 x, n := decodeVarint(b)
773 return nil, io.ErrUnexpectedEOF
776 if x > uint64(len(b)) {
777 return nil, io.ErrUnexpectedEOF
780 if err := Unmarshal(b[:x], m); err != nil {
783 s := f.asPointerTo(sub.typ).Elem()
784 s.Set(reflect.ValueOf(m.Value))
789 func makeStdUInt64ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
790 return func(b []byte, f pointer, w int) ([]byte, error) {
792 return nil, errInternalBadWireType
794 x, n := decodeVarint(b)
796 return nil, io.ErrUnexpectedEOF
799 if x > uint64(len(b)) {
800 return nil, io.ErrUnexpectedEOF
803 if err := Unmarshal(b[:x], m); err != nil {
806 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
807 s.Set(reflect.ValueOf(&m.Value))
812 func makeStdUInt64ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
813 return func(b []byte, f pointer, w int) ([]byte, error) {
815 return nil, errInternalBadWireType
817 x, n := decodeVarint(b)
819 return nil, io.ErrUnexpectedEOF
822 if x > uint64(len(b)) {
823 return nil, io.ErrUnexpectedEOF
826 if err := Unmarshal(b[:x], m); err != nil {
829 slice := f.getSlice(reflect.PtrTo(sub.typ))
830 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
836 func makeStdUInt64ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
837 return func(b []byte, f pointer, w int) ([]byte, error) {
839 return nil, errInternalBadWireType
841 x, n := decodeVarint(b)
843 return nil, io.ErrUnexpectedEOF
846 if x > uint64(len(b)) {
847 return nil, io.ErrUnexpectedEOF
850 if err := Unmarshal(b[:x], m); err != nil {
853 slice := f.getSlice(sub.typ)
854 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
860 func makeStdInt32ValueMarshaler(u *marshalInfo) (sizer, marshaler) {
861 return func(ptr pointer, tagsize int) int {
862 t := ptr.asPointerTo(u.typ).Interface().(*int32)
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)
869 buf, err := Marshal(v)
873 b = appendVarint(b, wiretag)
874 b = appendVarint(b, uint64(len(buf)))
875 b = append(b, buf...)
880 func makeStdInt32ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
881 return func(ptr pointer, tagsize int) int {
885 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int32)
888 return tagsize + SizeVarint(uint64(siz)) + siz
889 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
893 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int32)
895 buf, err := Marshal(v)
899 b = appendVarint(b, wiretag)
900 b = appendVarint(b, uint64(len(buf)))
901 b = append(b, buf...)
906 func makeStdInt32ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
907 return func(ptr pointer, tagsize int) int {
908 s := ptr.getSlice(u.typ)
910 for i := 0; i < s.Len(); i++ {
912 t := elem.Interface().(int32)
915 n += siz + SizeVarint(uint64(siz)) + tagsize
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++ {
923 t := elem.Interface().(int32)
926 buf, err := Marshal(v)
930 b = appendVarint(b, wiretag)
931 b = appendVarint(b, uint64(siz))
932 b = append(b, buf...)
939 func makeStdInt32ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
940 return func(ptr pointer, tagsize int) int {
941 s := ptr.getSlice(reflect.PtrTo(u.typ))
943 for i := 0; i < s.Len(); i++ {
945 t := elem.Interface().(*int32)
948 n += siz + SizeVarint(uint64(siz)) + tagsize
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++ {
956 t := elem.Interface().(*int32)
959 buf, err := Marshal(v)
963 b = appendVarint(b, wiretag)
964 b = appendVarint(b, uint64(siz))
965 b = append(b, buf...)
972 func makeStdInt32ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
973 return func(b []byte, f pointer, w int) ([]byte, error) {
975 return nil, errInternalBadWireType
977 x, n := decodeVarint(b)
979 return nil, io.ErrUnexpectedEOF
982 if x > uint64(len(b)) {
983 return nil, io.ErrUnexpectedEOF
986 if err := Unmarshal(b[:x], m); err != nil {
989 s := f.asPointerTo(sub.typ).Elem()
990 s.Set(reflect.ValueOf(m.Value))
995 func makeStdInt32ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
996 return func(b []byte, f pointer, w int) ([]byte, error) {
998 return nil, errInternalBadWireType
1000 x, n := decodeVarint(b)
1002 return nil, io.ErrUnexpectedEOF
1005 if x > uint64(len(b)) {
1006 return nil, io.ErrUnexpectedEOF
1009 if err := Unmarshal(b[:x], m); err != nil {
1012 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
1013 s.Set(reflect.ValueOf(&m.Value))
1018 func makeStdInt32ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1019 return func(b []byte, f pointer, w int) ([]byte, error) {
1021 return nil, errInternalBadWireType
1023 x, n := decodeVarint(b)
1025 return nil, io.ErrUnexpectedEOF
1028 if x > uint64(len(b)) {
1029 return nil, io.ErrUnexpectedEOF
1032 if err := Unmarshal(b[:x], m); err != nil {
1035 slice := f.getSlice(reflect.PtrTo(sub.typ))
1036 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
1042 func makeStdInt32ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1043 return func(b []byte, f pointer, w int) ([]byte, error) {
1045 return nil, errInternalBadWireType
1047 x, n := decodeVarint(b)
1049 return nil, io.ErrUnexpectedEOF
1052 if x > uint64(len(b)) {
1053 return nil, io.ErrUnexpectedEOF
1056 if err := Unmarshal(b[:x], m); err != nil {
1059 slice := f.getSlice(sub.typ)
1060 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
1066 func 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}
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)
1079 b = appendVarint(b, wiretag)
1080 b = appendVarint(b, uint64(len(buf)))
1081 b = append(b, buf...)
1086 func makeStdUInt32ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
1087 return func(ptr pointer, tagsize int) int {
1091 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint32)
1092 v := &uint32Value{*t}
1094 return tagsize + SizeVarint(uint64(siz)) + siz
1095 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1099 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint32)
1100 v := &uint32Value{*t}
1101 buf, err := Marshal(v)
1105 b = appendVarint(b, wiretag)
1106 b = appendVarint(b, uint64(len(buf)))
1107 b = append(b, buf...)
1112 func makeStdUInt32ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1113 return func(ptr pointer, tagsize int) int {
1114 s := ptr.getSlice(u.typ)
1116 for i := 0; i < s.Len(); i++ {
1118 t := elem.Interface().(uint32)
1119 v := &uint32Value{t}
1121 n += siz + SizeVarint(uint64(siz)) + tagsize
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++ {
1129 t := elem.Interface().(uint32)
1130 v := &uint32Value{t}
1132 buf, err := Marshal(v)
1136 b = appendVarint(b, wiretag)
1137 b = appendVarint(b, uint64(siz))
1138 b = append(b, buf...)
1145 func makeStdUInt32ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1146 return func(ptr pointer, tagsize int) int {
1147 s := ptr.getSlice(reflect.PtrTo(u.typ))
1149 for i := 0; i < s.Len(); i++ {
1151 t := elem.Interface().(*uint32)
1152 v := &uint32Value{*t}
1154 n += siz + SizeVarint(uint64(siz)) + tagsize
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++ {
1162 t := elem.Interface().(*uint32)
1163 v := &uint32Value{*t}
1165 buf, err := Marshal(v)
1169 b = appendVarint(b, wiretag)
1170 b = appendVarint(b, uint64(siz))
1171 b = append(b, buf...)
1178 func makeStdUInt32ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1179 return func(b []byte, f pointer, w int) ([]byte, error) {
1181 return nil, errInternalBadWireType
1183 x, n := decodeVarint(b)
1185 return nil, io.ErrUnexpectedEOF
1188 if x > uint64(len(b)) {
1189 return nil, io.ErrUnexpectedEOF
1192 if err := Unmarshal(b[:x], m); err != nil {
1195 s := f.asPointerTo(sub.typ).Elem()
1196 s.Set(reflect.ValueOf(m.Value))
1201 func makeStdUInt32ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1202 return func(b []byte, f pointer, w int) ([]byte, error) {
1204 return nil, errInternalBadWireType
1206 x, n := decodeVarint(b)
1208 return nil, io.ErrUnexpectedEOF
1211 if x > uint64(len(b)) {
1212 return nil, io.ErrUnexpectedEOF
1215 if err := Unmarshal(b[:x], m); err != nil {
1218 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
1219 s.Set(reflect.ValueOf(&m.Value))
1224 func makeStdUInt32ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1225 return func(b []byte, f pointer, w int) ([]byte, error) {
1227 return nil, errInternalBadWireType
1229 x, n := decodeVarint(b)
1231 return nil, io.ErrUnexpectedEOF
1234 if x > uint64(len(b)) {
1235 return nil, io.ErrUnexpectedEOF
1238 if err := Unmarshal(b[:x], m); err != nil {
1241 slice := f.getSlice(reflect.PtrTo(sub.typ))
1242 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
1248 func makeStdUInt32ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1249 return func(b []byte, f pointer, w int) ([]byte, error) {
1251 return nil, errInternalBadWireType
1253 x, n := decodeVarint(b)
1255 return nil, io.ErrUnexpectedEOF
1258 if x > uint64(len(b)) {
1259 return nil, io.ErrUnexpectedEOF
1262 if err := Unmarshal(b[:x], m); err != nil {
1265 slice := f.getSlice(sub.typ)
1266 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
1272 func makeStdBoolValueMarshaler(u *marshalInfo) (sizer, marshaler) {
1273 return func(ptr pointer, tagsize int) int {
1274 t := ptr.asPointerTo(u.typ).Interface().(*bool)
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)
1281 buf, err := Marshal(v)
1285 b = appendVarint(b, wiretag)
1286 b = appendVarint(b, uint64(len(buf)))
1287 b = append(b, buf...)
1292 func makeStdBoolValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
1293 return func(ptr pointer, tagsize int) int {
1297 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*bool)
1300 return tagsize + SizeVarint(uint64(siz)) + siz
1301 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1305 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*bool)
1307 buf, err := Marshal(v)
1311 b = appendVarint(b, wiretag)
1312 b = appendVarint(b, uint64(len(buf)))
1313 b = append(b, buf...)
1318 func makeStdBoolValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1319 return func(ptr pointer, tagsize int) int {
1320 s := ptr.getSlice(u.typ)
1322 for i := 0; i < s.Len(); i++ {
1324 t := elem.Interface().(bool)
1327 n += siz + SizeVarint(uint64(siz)) + tagsize
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++ {
1335 t := elem.Interface().(bool)
1338 buf, err := Marshal(v)
1342 b = appendVarint(b, wiretag)
1343 b = appendVarint(b, uint64(siz))
1344 b = append(b, buf...)
1351 func makeStdBoolValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1352 return func(ptr pointer, tagsize int) int {
1353 s := ptr.getSlice(reflect.PtrTo(u.typ))
1355 for i := 0; i < s.Len(); i++ {
1357 t := elem.Interface().(*bool)
1360 n += siz + SizeVarint(uint64(siz)) + tagsize
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++ {
1368 t := elem.Interface().(*bool)
1371 buf, err := Marshal(v)
1375 b = appendVarint(b, wiretag)
1376 b = appendVarint(b, uint64(siz))
1377 b = append(b, buf...)
1384 func makeStdBoolValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1385 return func(b []byte, f pointer, w int) ([]byte, error) {
1387 return nil, errInternalBadWireType
1389 x, n := decodeVarint(b)
1391 return nil, io.ErrUnexpectedEOF
1394 if x > uint64(len(b)) {
1395 return nil, io.ErrUnexpectedEOF
1398 if err := Unmarshal(b[:x], m); err != nil {
1401 s := f.asPointerTo(sub.typ).Elem()
1402 s.Set(reflect.ValueOf(m.Value))
1407 func makeStdBoolValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1408 return func(b []byte, f pointer, w int) ([]byte, error) {
1410 return nil, errInternalBadWireType
1412 x, n := decodeVarint(b)
1414 return nil, io.ErrUnexpectedEOF
1417 if x > uint64(len(b)) {
1418 return nil, io.ErrUnexpectedEOF
1421 if err := Unmarshal(b[:x], m); err != nil {
1424 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
1425 s.Set(reflect.ValueOf(&m.Value))
1430 func makeStdBoolValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1431 return func(b []byte, f pointer, w int) ([]byte, error) {
1433 return nil, errInternalBadWireType
1435 x, n := decodeVarint(b)
1437 return nil, io.ErrUnexpectedEOF
1440 if x > uint64(len(b)) {
1441 return nil, io.ErrUnexpectedEOF
1444 if err := Unmarshal(b[:x], m); err != nil {
1447 slice := f.getSlice(reflect.PtrTo(sub.typ))
1448 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
1454 func makeStdBoolValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1455 return func(b []byte, f pointer, w int) ([]byte, error) {
1457 return nil, errInternalBadWireType
1459 x, n := decodeVarint(b)
1461 return nil, io.ErrUnexpectedEOF
1464 if x > uint64(len(b)) {
1465 return nil, io.ErrUnexpectedEOF
1468 if err := Unmarshal(b[:x], m); err != nil {
1471 slice := f.getSlice(sub.typ)
1472 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
1478 func 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}
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)
1491 b = appendVarint(b, wiretag)
1492 b = appendVarint(b, uint64(len(buf)))
1493 b = append(b, buf...)
1498 func makeStdStringValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
1499 return func(ptr pointer, tagsize int) int {
1503 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*string)
1504 v := &stringValue{*t}
1506 return tagsize + SizeVarint(uint64(siz)) + siz
1507 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1511 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*string)
1512 v := &stringValue{*t}
1513 buf, err := Marshal(v)
1517 b = appendVarint(b, wiretag)
1518 b = appendVarint(b, uint64(len(buf)))
1519 b = append(b, buf...)
1524 func makeStdStringValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1525 return func(ptr pointer, tagsize int) int {
1526 s := ptr.getSlice(u.typ)
1528 for i := 0; i < s.Len(); i++ {
1530 t := elem.Interface().(string)
1531 v := &stringValue{t}
1533 n += siz + SizeVarint(uint64(siz)) + tagsize
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++ {
1541 t := elem.Interface().(string)
1542 v := &stringValue{t}
1544 buf, err := Marshal(v)
1548 b = appendVarint(b, wiretag)
1549 b = appendVarint(b, uint64(siz))
1550 b = append(b, buf...)
1557 func makeStdStringValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1558 return func(ptr pointer, tagsize int) int {
1559 s := ptr.getSlice(reflect.PtrTo(u.typ))
1561 for i := 0; i < s.Len(); i++ {
1563 t := elem.Interface().(*string)
1564 v := &stringValue{*t}
1566 n += siz + SizeVarint(uint64(siz)) + tagsize
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++ {
1574 t := elem.Interface().(*string)
1575 v := &stringValue{*t}
1577 buf, err := Marshal(v)
1581 b = appendVarint(b, wiretag)
1582 b = appendVarint(b, uint64(siz))
1583 b = append(b, buf...)
1590 func makeStdStringValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1591 return func(b []byte, f pointer, w int) ([]byte, error) {
1593 return nil, errInternalBadWireType
1595 x, n := decodeVarint(b)
1597 return nil, io.ErrUnexpectedEOF
1600 if x > uint64(len(b)) {
1601 return nil, io.ErrUnexpectedEOF
1604 if err := Unmarshal(b[:x], m); err != nil {
1607 s := f.asPointerTo(sub.typ).Elem()
1608 s.Set(reflect.ValueOf(m.Value))
1613 func makeStdStringValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1614 return func(b []byte, f pointer, w int) ([]byte, error) {
1616 return nil, errInternalBadWireType
1618 x, n := decodeVarint(b)
1620 return nil, io.ErrUnexpectedEOF
1623 if x > uint64(len(b)) {
1624 return nil, io.ErrUnexpectedEOF
1627 if err := Unmarshal(b[:x], m); err != nil {
1630 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
1631 s.Set(reflect.ValueOf(&m.Value))
1636 func makeStdStringValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1637 return func(b []byte, f pointer, w int) ([]byte, error) {
1639 return nil, errInternalBadWireType
1641 x, n := decodeVarint(b)
1643 return nil, io.ErrUnexpectedEOF
1646 if x > uint64(len(b)) {
1647 return nil, io.ErrUnexpectedEOF
1650 if err := Unmarshal(b[:x], m); err != nil {
1653 slice := f.getSlice(reflect.PtrTo(sub.typ))
1654 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
1660 func makeStdStringValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1661 return func(b []byte, f pointer, w int) ([]byte, error) {
1663 return nil, errInternalBadWireType
1665 x, n := decodeVarint(b)
1667 return nil, io.ErrUnexpectedEOF
1670 if x > uint64(len(b)) {
1671 return nil, io.ErrUnexpectedEOF
1674 if err := Unmarshal(b[:x], m); err != nil {
1677 slice := f.getSlice(sub.typ)
1678 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
1684 func 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}
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)
1697 b = appendVarint(b, wiretag)
1698 b = appendVarint(b, uint64(len(buf)))
1699 b = append(b, buf...)
1704 func makeStdBytesValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
1705 return func(ptr pointer, tagsize int) int {
1709 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*[]byte)
1710 v := &bytesValue{*t}
1712 return tagsize + SizeVarint(uint64(siz)) + siz
1713 }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
1717 t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*[]byte)
1718 v := &bytesValue{*t}
1719 buf, err := Marshal(v)
1723 b = appendVarint(b, wiretag)
1724 b = appendVarint(b, uint64(len(buf)))
1725 b = append(b, buf...)
1730 func makeStdBytesValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1731 return func(ptr pointer, tagsize int) int {
1732 s := ptr.getSlice(u.typ)
1734 for i := 0; i < s.Len(); i++ {
1736 t := elem.Interface().([]byte)
1739 n += siz + SizeVarint(uint64(siz)) + tagsize
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++ {
1747 t := elem.Interface().([]byte)
1750 buf, err := Marshal(v)
1754 b = appendVarint(b, wiretag)
1755 b = appendVarint(b, uint64(siz))
1756 b = append(b, buf...)
1763 func makeStdBytesValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
1764 return func(ptr pointer, tagsize int) int {
1765 s := ptr.getSlice(reflect.PtrTo(u.typ))
1767 for i := 0; i < s.Len(); i++ {
1769 t := elem.Interface().(*[]byte)
1770 v := &bytesValue{*t}
1772 n += siz + SizeVarint(uint64(siz)) + tagsize
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++ {
1780 t := elem.Interface().(*[]byte)
1781 v := &bytesValue{*t}
1783 buf, err := Marshal(v)
1787 b = appendVarint(b, wiretag)
1788 b = appendVarint(b, uint64(siz))
1789 b = append(b, buf...)
1796 func makeStdBytesValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1797 return func(b []byte, f pointer, w int) ([]byte, error) {
1799 return nil, errInternalBadWireType
1801 x, n := decodeVarint(b)
1803 return nil, io.ErrUnexpectedEOF
1806 if x > uint64(len(b)) {
1807 return nil, io.ErrUnexpectedEOF
1810 if err := Unmarshal(b[:x], m); err != nil {
1813 s := f.asPointerTo(sub.typ).Elem()
1814 s.Set(reflect.ValueOf(m.Value))
1819 func makeStdBytesValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1820 return func(b []byte, f pointer, w int) ([]byte, error) {
1822 return nil, errInternalBadWireType
1824 x, n := decodeVarint(b)
1826 return nil, io.ErrUnexpectedEOF
1829 if x > uint64(len(b)) {
1830 return nil, io.ErrUnexpectedEOF
1833 if err := Unmarshal(b[:x], m); err != nil {
1836 s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
1837 s.Set(reflect.ValueOf(&m.Value))
1842 func makeStdBytesValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1843 return func(b []byte, f pointer, w int) ([]byte, error) {
1845 return nil, errInternalBadWireType
1847 x, n := decodeVarint(b)
1849 return nil, io.ErrUnexpectedEOF
1852 if x > uint64(len(b)) {
1853 return nil, io.ErrUnexpectedEOF
1856 if err := Unmarshal(b[:x], m); err != nil {
1859 slice := f.getSlice(reflect.PtrTo(sub.typ))
1860 newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
1866 func makeStdBytesValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
1867 return func(b []byte, f pointer, w int) ([]byte, error) {
1869 return nil, errInternalBadWireType
1871 x, n := decodeVarint(b)
1873 return nil, io.ErrUnexpectedEOF
1876 if x > uint64(len(b)) {
1877 return nil, io.ErrUnexpectedEOF
1880 if err := Unmarshal(b[:x], m); err != nil {
1883 slice := f.getSlice(sub.typ)
1884 newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))