| // Protocol Buffers for Go with Gadgets |
| // |
| // Copyright (c) 2018, The GoGo Authors. All rights reserved. |
| // http://github.com/gogo/protobuf |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following disclaimer |
| // in the documentation and/or other materials provided with the |
| // distribution. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| package proto |
| |
| import ( |
| "io" |
| "reflect" |
| ) |
| |
| func makeStdDoubleValueMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| t := ptr.asPointerTo(u.typ).Interface().(*float64) |
| v := &float64Value{*t} |
| siz := Size(v) |
| return tagsize + SizeVarint(uint64(siz)) + siz |
| }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| t := ptr.asPointerTo(u.typ).Interface().(*float64) |
| v := &float64Value{*t} |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(len(buf))) |
| b = append(b, buf...) |
| return b, nil |
| } |
| } |
| |
| func makeStdDoubleValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| if ptr.isNil() { |
| return 0 |
| } |
| t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float64) |
| v := &float64Value{*t} |
| siz := Size(v) |
| return tagsize + SizeVarint(uint64(siz)) + siz |
| }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| if ptr.isNil() { |
| return b, nil |
| } |
| t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float64) |
| v := &float64Value{*t} |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(len(buf))) |
| b = append(b, buf...) |
| return b, nil |
| } |
| } |
| |
| func makeStdDoubleValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| s := ptr.getSlice(u.typ) |
| n := 0 |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(float64) |
| v := &float64Value{t} |
| siz := Size(v) |
| n += siz + SizeVarint(uint64(siz)) + tagsize |
| } |
| return n |
| }, |
| func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| s := ptr.getSlice(u.typ) |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(float64) |
| v := &float64Value{t} |
| siz := Size(v) |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(siz)) |
| b = append(b, buf...) |
| } |
| |
| return b, nil |
| } |
| } |
| |
| func makeStdDoubleValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| s := ptr.getSlice(reflect.PtrTo(u.typ)) |
| n := 0 |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(*float64) |
| v := &float64Value{*t} |
| siz := Size(v) |
| n += siz + SizeVarint(uint64(siz)) + tagsize |
| } |
| return n |
| }, |
| func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| s := ptr.getSlice(reflect.PtrTo(u.typ)) |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(*float64) |
| v := &float64Value{*t} |
| siz := Size(v) |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(siz)) |
| b = append(b, buf...) |
| } |
| |
| return b, nil |
| } |
| } |
| |
| func makeStdDoubleValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &float64Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| s := f.asPointerTo(sub.typ).Elem() |
| s.Set(reflect.ValueOf(m.Value)) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdDoubleValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &float64Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem() |
| s.Set(reflect.ValueOf(&m.Value)) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdDoubleValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &float64Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| slice := f.getSlice(reflect.PtrTo(sub.typ)) |
| newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value)) |
| slice.Set(newSlice) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdDoubleValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &float64Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| slice := f.getSlice(sub.typ) |
| newSlice := reflect.Append(slice, reflect.ValueOf(m.Value)) |
| slice.Set(newSlice) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdFloatValueMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| t := ptr.asPointerTo(u.typ).Interface().(*float32) |
| v := &float32Value{*t} |
| siz := Size(v) |
| return tagsize + SizeVarint(uint64(siz)) + siz |
| }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| t := ptr.asPointerTo(u.typ).Interface().(*float32) |
| v := &float32Value{*t} |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(len(buf))) |
| b = append(b, buf...) |
| return b, nil |
| } |
| } |
| |
| func makeStdFloatValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| if ptr.isNil() { |
| return 0 |
| } |
| t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float32) |
| v := &float32Value{*t} |
| siz := Size(v) |
| return tagsize + SizeVarint(uint64(siz)) + siz |
| }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| if ptr.isNil() { |
| return b, nil |
| } |
| t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float32) |
| v := &float32Value{*t} |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(len(buf))) |
| b = append(b, buf...) |
| return b, nil |
| } |
| } |
| |
| func makeStdFloatValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| s := ptr.getSlice(u.typ) |
| n := 0 |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(float32) |
| v := &float32Value{t} |
| siz := Size(v) |
| n += siz + SizeVarint(uint64(siz)) + tagsize |
| } |
| return n |
| }, |
| func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| s := ptr.getSlice(u.typ) |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(float32) |
| v := &float32Value{t} |
| siz := Size(v) |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(siz)) |
| b = append(b, buf...) |
| } |
| |
| return b, nil |
| } |
| } |
| |
| func makeStdFloatValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| s := ptr.getSlice(reflect.PtrTo(u.typ)) |
| n := 0 |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(*float32) |
| v := &float32Value{*t} |
| siz := Size(v) |
| n += siz + SizeVarint(uint64(siz)) + tagsize |
| } |
| return n |
| }, |
| func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| s := ptr.getSlice(reflect.PtrTo(u.typ)) |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(*float32) |
| v := &float32Value{*t} |
| siz := Size(v) |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(siz)) |
| b = append(b, buf...) |
| } |
| |
| return b, nil |
| } |
| } |
| |
| func makeStdFloatValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &float32Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| s := f.asPointerTo(sub.typ).Elem() |
| s.Set(reflect.ValueOf(m.Value)) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdFloatValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &float32Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem() |
| s.Set(reflect.ValueOf(&m.Value)) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdFloatValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &float32Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| slice := f.getSlice(reflect.PtrTo(sub.typ)) |
| newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value)) |
| slice.Set(newSlice) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdFloatValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &float32Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| slice := f.getSlice(sub.typ) |
| newSlice := reflect.Append(slice, reflect.ValueOf(m.Value)) |
| slice.Set(newSlice) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdInt64ValueMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| t := ptr.asPointerTo(u.typ).Interface().(*int64) |
| v := &int64Value{*t} |
| siz := Size(v) |
| return tagsize + SizeVarint(uint64(siz)) + siz |
| }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| t := ptr.asPointerTo(u.typ).Interface().(*int64) |
| v := &int64Value{*t} |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(len(buf))) |
| b = append(b, buf...) |
| return b, nil |
| } |
| } |
| |
| func makeStdInt64ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| if ptr.isNil() { |
| return 0 |
| } |
| t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int64) |
| v := &int64Value{*t} |
| siz := Size(v) |
| return tagsize + SizeVarint(uint64(siz)) + siz |
| }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| if ptr.isNil() { |
| return b, nil |
| } |
| t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int64) |
| v := &int64Value{*t} |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(len(buf))) |
| b = append(b, buf...) |
| return b, nil |
| } |
| } |
| |
| func makeStdInt64ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| s := ptr.getSlice(u.typ) |
| n := 0 |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(int64) |
| v := &int64Value{t} |
| siz := Size(v) |
| n += siz + SizeVarint(uint64(siz)) + tagsize |
| } |
| return n |
| }, |
| func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| s := ptr.getSlice(u.typ) |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(int64) |
| v := &int64Value{t} |
| siz := Size(v) |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(siz)) |
| b = append(b, buf...) |
| } |
| |
| return b, nil |
| } |
| } |
| |
| func makeStdInt64ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| s := ptr.getSlice(reflect.PtrTo(u.typ)) |
| n := 0 |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(*int64) |
| v := &int64Value{*t} |
| siz := Size(v) |
| n += siz + SizeVarint(uint64(siz)) + tagsize |
| } |
| return n |
| }, |
| func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| s := ptr.getSlice(reflect.PtrTo(u.typ)) |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(*int64) |
| v := &int64Value{*t} |
| siz := Size(v) |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(siz)) |
| b = append(b, buf...) |
| } |
| |
| return b, nil |
| } |
| } |
| |
| func makeStdInt64ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &int64Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| s := f.asPointerTo(sub.typ).Elem() |
| s.Set(reflect.ValueOf(m.Value)) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdInt64ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &int64Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem() |
| s.Set(reflect.ValueOf(&m.Value)) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdInt64ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &int64Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| slice := f.getSlice(reflect.PtrTo(sub.typ)) |
| newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value)) |
| slice.Set(newSlice) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdInt64ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &int64Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| slice := f.getSlice(sub.typ) |
| newSlice := reflect.Append(slice, reflect.ValueOf(m.Value)) |
| slice.Set(newSlice) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdUInt64ValueMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| t := ptr.asPointerTo(u.typ).Interface().(*uint64) |
| v := &uint64Value{*t} |
| siz := Size(v) |
| return tagsize + SizeVarint(uint64(siz)) + siz |
| }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| t := ptr.asPointerTo(u.typ).Interface().(*uint64) |
| v := &uint64Value{*t} |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(len(buf))) |
| b = append(b, buf...) |
| return b, nil |
| } |
| } |
| |
| func makeStdUInt64ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| if ptr.isNil() { |
| return 0 |
| } |
| t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint64) |
| v := &uint64Value{*t} |
| siz := Size(v) |
| return tagsize + SizeVarint(uint64(siz)) + siz |
| }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| if ptr.isNil() { |
| return b, nil |
| } |
| t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint64) |
| v := &uint64Value{*t} |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(len(buf))) |
| b = append(b, buf...) |
| return b, nil |
| } |
| } |
| |
| func makeStdUInt64ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| s := ptr.getSlice(u.typ) |
| n := 0 |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(uint64) |
| v := &uint64Value{t} |
| siz := Size(v) |
| n += siz + SizeVarint(uint64(siz)) + tagsize |
| } |
| return n |
| }, |
| func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| s := ptr.getSlice(u.typ) |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(uint64) |
| v := &uint64Value{t} |
| siz := Size(v) |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(siz)) |
| b = append(b, buf...) |
| } |
| |
| return b, nil |
| } |
| } |
| |
| func makeStdUInt64ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| s := ptr.getSlice(reflect.PtrTo(u.typ)) |
| n := 0 |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(*uint64) |
| v := &uint64Value{*t} |
| siz := Size(v) |
| n += siz + SizeVarint(uint64(siz)) + tagsize |
| } |
| return n |
| }, |
| func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| s := ptr.getSlice(reflect.PtrTo(u.typ)) |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(*uint64) |
| v := &uint64Value{*t} |
| siz := Size(v) |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(siz)) |
| b = append(b, buf...) |
| } |
| |
| return b, nil |
| } |
| } |
| |
| func makeStdUInt64ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &uint64Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| s := f.asPointerTo(sub.typ).Elem() |
| s.Set(reflect.ValueOf(m.Value)) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdUInt64ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &uint64Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem() |
| s.Set(reflect.ValueOf(&m.Value)) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdUInt64ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &uint64Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| slice := f.getSlice(reflect.PtrTo(sub.typ)) |
| newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value)) |
| slice.Set(newSlice) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdUInt64ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &uint64Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| slice := f.getSlice(sub.typ) |
| newSlice := reflect.Append(slice, reflect.ValueOf(m.Value)) |
| slice.Set(newSlice) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdInt32ValueMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| t := ptr.asPointerTo(u.typ).Interface().(*int32) |
| v := &int32Value{*t} |
| siz := Size(v) |
| return tagsize + SizeVarint(uint64(siz)) + siz |
| }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| t := ptr.asPointerTo(u.typ).Interface().(*int32) |
| v := &int32Value{*t} |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(len(buf))) |
| b = append(b, buf...) |
| return b, nil |
| } |
| } |
| |
| func makeStdInt32ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| if ptr.isNil() { |
| return 0 |
| } |
| t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int32) |
| v := &int32Value{*t} |
| siz := Size(v) |
| return tagsize + SizeVarint(uint64(siz)) + siz |
| }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| if ptr.isNil() { |
| return b, nil |
| } |
| t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int32) |
| v := &int32Value{*t} |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(len(buf))) |
| b = append(b, buf...) |
| return b, nil |
| } |
| } |
| |
| func makeStdInt32ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| s := ptr.getSlice(u.typ) |
| n := 0 |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(int32) |
| v := &int32Value{t} |
| siz := Size(v) |
| n += siz + SizeVarint(uint64(siz)) + tagsize |
| } |
| return n |
| }, |
| func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| s := ptr.getSlice(u.typ) |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(int32) |
| v := &int32Value{t} |
| siz := Size(v) |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(siz)) |
| b = append(b, buf...) |
| } |
| |
| return b, nil |
| } |
| } |
| |
| func makeStdInt32ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| s := ptr.getSlice(reflect.PtrTo(u.typ)) |
| n := 0 |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(*int32) |
| v := &int32Value{*t} |
| siz := Size(v) |
| n += siz + SizeVarint(uint64(siz)) + tagsize |
| } |
| return n |
| }, |
| func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| s := ptr.getSlice(reflect.PtrTo(u.typ)) |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(*int32) |
| v := &int32Value{*t} |
| siz := Size(v) |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(siz)) |
| b = append(b, buf...) |
| } |
| |
| return b, nil |
| } |
| } |
| |
| func makeStdInt32ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &int32Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| s := f.asPointerTo(sub.typ).Elem() |
| s.Set(reflect.ValueOf(m.Value)) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdInt32ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &int32Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem() |
| s.Set(reflect.ValueOf(&m.Value)) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdInt32ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &int32Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| slice := f.getSlice(reflect.PtrTo(sub.typ)) |
| newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value)) |
| slice.Set(newSlice) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdInt32ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &int32Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| slice := f.getSlice(sub.typ) |
| newSlice := reflect.Append(slice, reflect.ValueOf(m.Value)) |
| slice.Set(newSlice) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdUInt32ValueMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| t := ptr.asPointerTo(u.typ).Interface().(*uint32) |
| v := &uint32Value{*t} |
| siz := Size(v) |
| return tagsize + SizeVarint(uint64(siz)) + siz |
| }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| t := ptr.asPointerTo(u.typ).Interface().(*uint32) |
| v := &uint32Value{*t} |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(len(buf))) |
| b = append(b, buf...) |
| return b, nil |
| } |
| } |
| |
| func makeStdUInt32ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| if ptr.isNil() { |
| return 0 |
| } |
| t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint32) |
| v := &uint32Value{*t} |
| siz := Size(v) |
| return tagsize + SizeVarint(uint64(siz)) + siz |
| }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| if ptr.isNil() { |
| return b, nil |
| } |
| t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint32) |
| v := &uint32Value{*t} |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(len(buf))) |
| b = append(b, buf...) |
| return b, nil |
| } |
| } |
| |
| func makeStdUInt32ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| s := ptr.getSlice(u.typ) |
| n := 0 |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(uint32) |
| v := &uint32Value{t} |
| siz := Size(v) |
| n += siz + SizeVarint(uint64(siz)) + tagsize |
| } |
| return n |
| }, |
| func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| s := ptr.getSlice(u.typ) |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(uint32) |
| v := &uint32Value{t} |
| siz := Size(v) |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(siz)) |
| b = append(b, buf...) |
| } |
| |
| return b, nil |
| } |
| } |
| |
| func makeStdUInt32ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| s := ptr.getSlice(reflect.PtrTo(u.typ)) |
| n := 0 |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(*uint32) |
| v := &uint32Value{*t} |
| siz := Size(v) |
| n += siz + SizeVarint(uint64(siz)) + tagsize |
| } |
| return n |
| }, |
| func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| s := ptr.getSlice(reflect.PtrTo(u.typ)) |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(*uint32) |
| v := &uint32Value{*t} |
| siz := Size(v) |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(siz)) |
| b = append(b, buf...) |
| } |
| |
| return b, nil |
| } |
| } |
| |
| func makeStdUInt32ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &uint32Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| s := f.asPointerTo(sub.typ).Elem() |
| s.Set(reflect.ValueOf(m.Value)) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdUInt32ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &uint32Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem() |
| s.Set(reflect.ValueOf(&m.Value)) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdUInt32ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &uint32Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| slice := f.getSlice(reflect.PtrTo(sub.typ)) |
| newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value)) |
| slice.Set(newSlice) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdUInt32ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &uint32Value{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| slice := f.getSlice(sub.typ) |
| newSlice := reflect.Append(slice, reflect.ValueOf(m.Value)) |
| slice.Set(newSlice) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdBoolValueMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| t := ptr.asPointerTo(u.typ).Interface().(*bool) |
| v := &boolValue{*t} |
| siz := Size(v) |
| return tagsize + SizeVarint(uint64(siz)) + siz |
| }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| t := ptr.asPointerTo(u.typ).Interface().(*bool) |
| v := &boolValue{*t} |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(len(buf))) |
| b = append(b, buf...) |
| return b, nil |
| } |
| } |
| |
| func makeStdBoolValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| if ptr.isNil() { |
| return 0 |
| } |
| t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*bool) |
| v := &boolValue{*t} |
| siz := Size(v) |
| return tagsize + SizeVarint(uint64(siz)) + siz |
| }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| if ptr.isNil() { |
| return b, nil |
| } |
| t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*bool) |
| v := &boolValue{*t} |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(len(buf))) |
| b = append(b, buf...) |
| return b, nil |
| } |
| } |
| |
| func makeStdBoolValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| s := ptr.getSlice(u.typ) |
| n := 0 |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(bool) |
| v := &boolValue{t} |
| siz := Size(v) |
| n += siz + SizeVarint(uint64(siz)) + tagsize |
| } |
| return n |
| }, |
| func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| s := ptr.getSlice(u.typ) |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(bool) |
| v := &boolValue{t} |
| siz := Size(v) |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(siz)) |
| b = append(b, buf...) |
| } |
| |
| return b, nil |
| } |
| } |
| |
| func makeStdBoolValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| s := ptr.getSlice(reflect.PtrTo(u.typ)) |
| n := 0 |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(*bool) |
| v := &boolValue{*t} |
| siz := Size(v) |
| n += siz + SizeVarint(uint64(siz)) + tagsize |
| } |
| return n |
| }, |
| func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| s := ptr.getSlice(reflect.PtrTo(u.typ)) |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(*bool) |
| v := &boolValue{*t} |
| siz := Size(v) |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(siz)) |
| b = append(b, buf...) |
| } |
| |
| return b, nil |
| } |
| } |
| |
| func makeStdBoolValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &boolValue{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| s := f.asPointerTo(sub.typ).Elem() |
| s.Set(reflect.ValueOf(m.Value)) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdBoolValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &boolValue{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem() |
| s.Set(reflect.ValueOf(&m.Value)) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdBoolValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &boolValue{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| slice := f.getSlice(reflect.PtrTo(sub.typ)) |
| newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value)) |
| slice.Set(newSlice) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdBoolValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &boolValue{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| slice := f.getSlice(sub.typ) |
| newSlice := reflect.Append(slice, reflect.ValueOf(m.Value)) |
| slice.Set(newSlice) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdStringValueMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| t := ptr.asPointerTo(u.typ).Interface().(*string) |
| v := &stringValue{*t} |
| siz := Size(v) |
| return tagsize + SizeVarint(uint64(siz)) + siz |
| }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| t := ptr.asPointerTo(u.typ).Interface().(*string) |
| v := &stringValue{*t} |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(len(buf))) |
| b = append(b, buf...) |
| return b, nil |
| } |
| } |
| |
| func makeStdStringValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| if ptr.isNil() { |
| return 0 |
| } |
| t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*string) |
| v := &stringValue{*t} |
| siz := Size(v) |
| return tagsize + SizeVarint(uint64(siz)) + siz |
| }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| if ptr.isNil() { |
| return b, nil |
| } |
| t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*string) |
| v := &stringValue{*t} |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(len(buf))) |
| b = append(b, buf...) |
| return b, nil |
| } |
| } |
| |
| func makeStdStringValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| s := ptr.getSlice(u.typ) |
| n := 0 |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(string) |
| v := &stringValue{t} |
| siz := Size(v) |
| n += siz + SizeVarint(uint64(siz)) + tagsize |
| } |
| return n |
| }, |
| func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| s := ptr.getSlice(u.typ) |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(string) |
| v := &stringValue{t} |
| siz := Size(v) |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(siz)) |
| b = append(b, buf...) |
| } |
| |
| return b, nil |
| } |
| } |
| |
| func makeStdStringValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| s := ptr.getSlice(reflect.PtrTo(u.typ)) |
| n := 0 |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(*string) |
| v := &stringValue{*t} |
| siz := Size(v) |
| n += siz + SizeVarint(uint64(siz)) + tagsize |
| } |
| return n |
| }, |
| func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| s := ptr.getSlice(reflect.PtrTo(u.typ)) |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(*string) |
| v := &stringValue{*t} |
| siz := Size(v) |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(siz)) |
| b = append(b, buf...) |
| } |
| |
| return b, nil |
| } |
| } |
| |
| func makeStdStringValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &stringValue{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| s := f.asPointerTo(sub.typ).Elem() |
| s.Set(reflect.ValueOf(m.Value)) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdStringValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &stringValue{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem() |
| s.Set(reflect.ValueOf(&m.Value)) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdStringValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &stringValue{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| slice := f.getSlice(reflect.PtrTo(sub.typ)) |
| newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value)) |
| slice.Set(newSlice) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdStringValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &stringValue{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| slice := f.getSlice(sub.typ) |
| newSlice := reflect.Append(slice, reflect.ValueOf(m.Value)) |
| slice.Set(newSlice) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdBytesValueMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| t := ptr.asPointerTo(u.typ).Interface().(*[]byte) |
| v := &bytesValue{*t} |
| siz := Size(v) |
| return tagsize + SizeVarint(uint64(siz)) + siz |
| }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| t := ptr.asPointerTo(u.typ).Interface().(*[]byte) |
| v := &bytesValue{*t} |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(len(buf))) |
| b = append(b, buf...) |
| return b, nil |
| } |
| } |
| |
| func makeStdBytesValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| if ptr.isNil() { |
| return 0 |
| } |
| t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*[]byte) |
| v := &bytesValue{*t} |
| siz := Size(v) |
| return tagsize + SizeVarint(uint64(siz)) + siz |
| }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| if ptr.isNil() { |
| return b, nil |
| } |
| t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*[]byte) |
| v := &bytesValue{*t} |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(len(buf))) |
| b = append(b, buf...) |
| return b, nil |
| } |
| } |
| |
| func makeStdBytesValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| s := ptr.getSlice(u.typ) |
| n := 0 |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().([]byte) |
| v := &bytesValue{t} |
| siz := Size(v) |
| n += siz + SizeVarint(uint64(siz)) + tagsize |
| } |
| return n |
| }, |
| func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| s := ptr.getSlice(u.typ) |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().([]byte) |
| v := &bytesValue{t} |
| siz := Size(v) |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(siz)) |
| b = append(b, buf...) |
| } |
| |
| return b, nil |
| } |
| } |
| |
| func makeStdBytesValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) { |
| return func(ptr pointer, tagsize int) int { |
| s := ptr.getSlice(reflect.PtrTo(u.typ)) |
| n := 0 |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(*[]byte) |
| v := &bytesValue{*t} |
| siz := Size(v) |
| n += siz + SizeVarint(uint64(siz)) + tagsize |
| } |
| return n |
| }, |
| func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { |
| s := ptr.getSlice(reflect.PtrTo(u.typ)) |
| for i := 0; i < s.Len(); i++ { |
| elem := s.Index(i) |
| t := elem.Interface().(*[]byte) |
| v := &bytesValue{*t} |
| siz := Size(v) |
| buf, err := Marshal(v) |
| if err != nil { |
| return nil, err |
| } |
| b = appendVarint(b, wiretag) |
| b = appendVarint(b, uint64(siz)) |
| b = append(b, buf...) |
| } |
| |
| return b, nil |
| } |
| } |
| |
| func makeStdBytesValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &bytesValue{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| s := f.asPointerTo(sub.typ).Elem() |
| s.Set(reflect.ValueOf(m.Value)) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdBytesValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &bytesValue{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem() |
| s.Set(reflect.ValueOf(&m.Value)) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdBytesValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &bytesValue{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| slice := f.getSlice(reflect.PtrTo(sub.typ)) |
| newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value)) |
| slice.Set(newSlice) |
| return b[x:], nil |
| } |
| } |
| |
| func makeStdBytesValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler { |
| return func(b []byte, f pointer, w int) ([]byte, error) { |
| if w != WireBytes { |
| return nil, errInternalBadWireType |
| } |
| x, n := decodeVarint(b) |
| if n == 0 { |
| return nil, io.ErrUnexpectedEOF |
| } |
| b = b[n:] |
| if x > uint64(len(b)) { |
| return nil, io.ErrUnexpectedEOF |
| } |
| m := &bytesValue{} |
| if err := Unmarshal(b[:x], m); err != nil { |
| return nil, err |
| } |
| slice := f.getSlice(sub.typ) |
| newSlice := reflect.Append(slice, reflect.ValueOf(m.Value)) |
| slice.Set(newSlice) |
| return b[x:], nil |
| } |
| } |