| // Copyright 2018 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style. |
| // license that can be found in the LICENSE file. |
| |
| // Code generated by generate-types. DO NOT EDIT. |
| |
| package impl |
| |
| import ( |
| "math" |
| "unicode/utf8" |
| |
| "google.golang.org/protobuf/internal/encoding/wire" |
| "google.golang.org/protobuf/reflect/protoreflect" |
| ) |
| |
| // sizeBool returns the size of wire encoding a bool pointer as a Bool. |
| func sizeBool(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Bool() |
| return tagsize + wire.SizeVarint(wire.EncodeBool(v)) |
| } |
| |
| // appendBool wire encodes a bool pointer as a Bool. |
| func appendBool(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Bool() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, wire.EncodeBool(v)) |
| return b, nil |
| } |
| |
| // consumeBool wire decodes a bool pointer as a Bool. |
| func consumeBool(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.VarintType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *p.Bool() = wire.DecodeBool(v) |
| return n, nil |
| } |
| |
| var coderBool = pointerCoderFuncs{ |
| size: sizeBool, |
| marshal: appendBool, |
| unmarshal: consumeBool, |
| } |
| |
| // sizeBoolNoZero returns the size of wire encoding a bool pointer as a Bool. |
| // The zero value is not encoded. |
| func sizeBoolNoZero(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Bool() |
| if v == false { |
| return 0 |
| } |
| return tagsize + wire.SizeVarint(wire.EncodeBool(v)) |
| } |
| |
| // appendBoolNoZero wire encodes a bool pointer as a Bool. |
| // The zero value is not encoded. |
| func appendBoolNoZero(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Bool() |
| if v == false { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, wire.EncodeBool(v)) |
| return b, nil |
| } |
| |
| var coderBoolNoZero = pointerCoderFuncs{ |
| size: sizeBoolNoZero, |
| marshal: appendBoolNoZero, |
| unmarshal: consumeBool, |
| } |
| |
| // sizeBoolPtr returns the size of wire encoding a *bool pointer as a Bool. |
| // It panics if the pointer is nil. |
| func sizeBoolPtr(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := **p.BoolPtr() |
| return tagsize + wire.SizeVarint(wire.EncodeBool(v)) |
| } |
| |
| // appendBoolPtr wire encodes a *bool pointer as a Bool. |
| // It panics if the pointer is nil. |
| func appendBoolPtr(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := **p.BoolPtr() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, wire.EncodeBool(v)) |
| return b, nil |
| } |
| |
| // consumeBoolPtr wire decodes a *bool pointer as a Bool. |
| func consumeBoolPtr(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.VarintType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| vp := p.BoolPtr() |
| if *vp == nil { |
| *vp = new(bool) |
| } |
| **vp = wire.DecodeBool(v) |
| return n, nil |
| } |
| |
| var coderBoolPtr = pointerCoderFuncs{ |
| size: sizeBoolPtr, |
| marshal: appendBoolPtr, |
| unmarshal: consumeBoolPtr, |
| } |
| |
| // sizeBoolSlice returns the size of wire encoding a []bool pointer as a repeated Bool. |
| func sizeBoolSlice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.BoolSlice() |
| for _, v := range s { |
| size += tagsize + wire.SizeVarint(wire.EncodeBool(v)) |
| } |
| return size |
| } |
| |
| // appendBoolSlice encodes a []bool pointer as a repeated Bool. |
| func appendBoolSlice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.BoolSlice() |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, wire.EncodeBool(v)) |
| } |
| return b, nil |
| } |
| |
| // consumeBoolSlice wire decodes a []bool pointer as a repeated Bool. |
| func consumeBoolSlice(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| sp := p.BoolSlice() |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| s = append(s, wire.DecodeBool(v)) |
| b = b[n:] |
| } |
| *sp = s |
| return n, nil |
| } |
| if wtyp != wire.VarintType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, wire.DecodeBool(v)) |
| return n, nil |
| } |
| |
| var coderBoolSlice = pointerCoderFuncs{ |
| size: sizeBoolSlice, |
| marshal: appendBoolSlice, |
| unmarshal: consumeBoolSlice, |
| } |
| |
| // sizeBoolPackedSlice returns the size of wire encoding a []bool pointer as a packed repeated Bool. |
| func sizeBoolPackedSlice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.BoolSlice() |
| if len(s) == 0 { |
| return 0 |
| } |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(wire.EncodeBool(v)) |
| } |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendBoolPackedSlice encodes a []bool pointer as a packed repeated Bool. |
| func appendBoolPackedSlice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.BoolSlice() |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(wire.EncodeBool(v)) |
| } |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendVarint(b, wire.EncodeBool(v)) |
| } |
| return b, nil |
| } |
| |
| var coderBoolPackedSlice = pointerCoderFuncs{ |
| size: sizeBoolPackedSlice, |
| marshal: appendBoolPackedSlice, |
| unmarshal: consumeBoolSlice, |
| } |
| |
| // sizeBoolIface returns the size of wire encoding a bool value as a Bool. |
| func sizeBoolIface(ival interface{}, tagsize int, _ marshalOptions) int { |
| v := ival.(bool) |
| return tagsize + wire.SizeVarint(wire.EncodeBool(v)) |
| } |
| |
| // appendBoolIface encodes a bool value as a Bool. |
| func appendBoolIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := ival.(bool) |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, wire.EncodeBool(v)) |
| return b, nil |
| } |
| |
| // consumeBoolIface decodes a bool value as a Bool. |
| func consumeBoolIface(b []byte, _ interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (interface{}, int, error) { |
| if wtyp != wire.VarintType { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| return wire.DecodeBool(v), n, nil |
| } |
| |
| var coderBoolIface = ifaceCoderFuncs{ |
| size: sizeBoolIface, |
| marshal: appendBoolIface, |
| unmarshal: consumeBoolIface, |
| } |
| |
| // sizeBoolSliceIface returns the size of wire encoding a []bool value as a repeated Bool. |
| func sizeBoolSliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]bool) |
| for _, v := range s { |
| size += tagsize + wire.SizeVarint(wire.EncodeBool(v)) |
| } |
| return size |
| } |
| |
| // appendBoolSliceIface encodes a []bool value as a repeated Bool. |
| func appendBoolSliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]bool) |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, wire.EncodeBool(v)) |
| } |
| return b, nil |
| } |
| |
| // consumeBoolSliceIface wire decodes a []bool value as a repeated Bool. |
| func consumeBoolSliceIface(b []byte, ival interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ interface{}, n int, err error) { |
| sp := ival.(*[]bool) |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| s = append(s, wire.DecodeBool(v)) |
| b = b[n:] |
| } |
| *sp = s |
| return ival, n, nil |
| } |
| if wtyp != wire.VarintType { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, wire.DecodeBool(v)) |
| return ival, n, nil |
| } |
| |
| var coderBoolSliceIface = ifaceCoderFuncs{ |
| size: sizeBoolSliceIface, |
| marshal: appendBoolSliceIface, |
| unmarshal: consumeBoolSliceIface, |
| } |
| |
| // sizeBoolPackedSliceIface returns the size of wire encoding a []bool value as a packed repeated Bool. |
| func sizeBoolPackedSliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]bool) |
| if len(s) == 0 { |
| return 0 |
| } |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(wire.EncodeBool(v)) |
| } |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendBoolPackedSliceIface encodes a []bool value as a packed repeated Bool. |
| func appendBoolPackedSliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]bool) |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(wire.EncodeBool(v)) |
| } |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendVarint(b, wire.EncodeBool(v)) |
| } |
| return b, nil |
| } |
| |
| var coderBoolPackedSliceIface = ifaceCoderFuncs{ |
| size: sizeBoolPackedSliceIface, |
| marshal: appendBoolPackedSliceIface, |
| unmarshal: consumeBoolSliceIface, |
| } |
| |
| // sizeInt32 returns the size of wire encoding a int32 pointer as a Int32. |
| func sizeInt32(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Int32() |
| return tagsize + wire.SizeVarint(uint64(v)) |
| } |
| |
| // appendInt32 wire encodes a int32 pointer as a Int32. |
| func appendInt32(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Int32() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, uint64(v)) |
| return b, nil |
| } |
| |
| // consumeInt32 wire decodes a int32 pointer as a Int32. |
| func consumeInt32(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.VarintType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *p.Int32() = int32(v) |
| return n, nil |
| } |
| |
| var coderInt32 = pointerCoderFuncs{ |
| size: sizeInt32, |
| marshal: appendInt32, |
| unmarshal: consumeInt32, |
| } |
| |
| // sizeInt32NoZero returns the size of wire encoding a int32 pointer as a Int32. |
| // The zero value is not encoded. |
| func sizeInt32NoZero(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Int32() |
| if v == 0 { |
| return 0 |
| } |
| return tagsize + wire.SizeVarint(uint64(v)) |
| } |
| |
| // appendInt32NoZero wire encodes a int32 pointer as a Int32. |
| // The zero value is not encoded. |
| func appendInt32NoZero(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Int32() |
| if v == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, uint64(v)) |
| return b, nil |
| } |
| |
| var coderInt32NoZero = pointerCoderFuncs{ |
| size: sizeInt32NoZero, |
| marshal: appendInt32NoZero, |
| unmarshal: consumeInt32, |
| } |
| |
| // sizeInt32Ptr returns the size of wire encoding a *int32 pointer as a Int32. |
| // It panics if the pointer is nil. |
| func sizeInt32Ptr(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := **p.Int32Ptr() |
| return tagsize + wire.SizeVarint(uint64(v)) |
| } |
| |
| // appendInt32Ptr wire encodes a *int32 pointer as a Int32. |
| // It panics if the pointer is nil. |
| func appendInt32Ptr(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := **p.Int32Ptr() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, uint64(v)) |
| return b, nil |
| } |
| |
| // consumeInt32Ptr wire decodes a *int32 pointer as a Int32. |
| func consumeInt32Ptr(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.VarintType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| vp := p.Int32Ptr() |
| if *vp == nil { |
| *vp = new(int32) |
| } |
| **vp = int32(v) |
| return n, nil |
| } |
| |
| var coderInt32Ptr = pointerCoderFuncs{ |
| size: sizeInt32Ptr, |
| marshal: appendInt32Ptr, |
| unmarshal: consumeInt32Ptr, |
| } |
| |
| // sizeInt32Slice returns the size of wire encoding a []int32 pointer as a repeated Int32. |
| func sizeInt32Slice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Int32Slice() |
| for _, v := range s { |
| size += tagsize + wire.SizeVarint(uint64(v)) |
| } |
| return size |
| } |
| |
| // appendInt32Slice encodes a []int32 pointer as a repeated Int32. |
| func appendInt32Slice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Int32Slice() |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, uint64(v)) |
| } |
| return b, nil |
| } |
| |
| // consumeInt32Slice wire decodes a []int32 pointer as a repeated Int32. |
| func consumeInt32Slice(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| sp := p.Int32Slice() |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| s = append(s, int32(v)) |
| b = b[n:] |
| } |
| *sp = s |
| return n, nil |
| } |
| if wtyp != wire.VarintType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, int32(v)) |
| return n, nil |
| } |
| |
| var coderInt32Slice = pointerCoderFuncs{ |
| size: sizeInt32Slice, |
| marshal: appendInt32Slice, |
| unmarshal: consumeInt32Slice, |
| } |
| |
| // sizeInt32PackedSlice returns the size of wire encoding a []int32 pointer as a packed repeated Int32. |
| func sizeInt32PackedSlice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Int32Slice() |
| if len(s) == 0 { |
| return 0 |
| } |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(uint64(v)) |
| } |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendInt32PackedSlice encodes a []int32 pointer as a packed repeated Int32. |
| func appendInt32PackedSlice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Int32Slice() |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(uint64(v)) |
| } |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendVarint(b, uint64(v)) |
| } |
| return b, nil |
| } |
| |
| var coderInt32PackedSlice = pointerCoderFuncs{ |
| size: sizeInt32PackedSlice, |
| marshal: appendInt32PackedSlice, |
| unmarshal: consumeInt32Slice, |
| } |
| |
| // sizeInt32Iface returns the size of wire encoding a int32 value as a Int32. |
| func sizeInt32Iface(ival interface{}, tagsize int, _ marshalOptions) int { |
| v := ival.(int32) |
| return tagsize + wire.SizeVarint(uint64(v)) |
| } |
| |
| // appendInt32Iface encodes a int32 value as a Int32. |
| func appendInt32Iface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := ival.(int32) |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, uint64(v)) |
| return b, nil |
| } |
| |
| // consumeInt32Iface decodes a int32 value as a Int32. |
| func consumeInt32Iface(b []byte, _ interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (interface{}, int, error) { |
| if wtyp != wire.VarintType { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| return int32(v), n, nil |
| } |
| |
| var coderInt32Iface = ifaceCoderFuncs{ |
| size: sizeInt32Iface, |
| marshal: appendInt32Iface, |
| unmarshal: consumeInt32Iface, |
| } |
| |
| // sizeInt32SliceIface returns the size of wire encoding a []int32 value as a repeated Int32. |
| func sizeInt32SliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]int32) |
| for _, v := range s { |
| size += tagsize + wire.SizeVarint(uint64(v)) |
| } |
| return size |
| } |
| |
| // appendInt32SliceIface encodes a []int32 value as a repeated Int32. |
| func appendInt32SliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]int32) |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, uint64(v)) |
| } |
| return b, nil |
| } |
| |
| // consumeInt32SliceIface wire decodes a []int32 value as a repeated Int32. |
| func consumeInt32SliceIface(b []byte, ival interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ interface{}, n int, err error) { |
| sp := ival.(*[]int32) |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| s = append(s, int32(v)) |
| b = b[n:] |
| } |
| *sp = s |
| return ival, n, nil |
| } |
| if wtyp != wire.VarintType { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, int32(v)) |
| return ival, n, nil |
| } |
| |
| var coderInt32SliceIface = ifaceCoderFuncs{ |
| size: sizeInt32SliceIface, |
| marshal: appendInt32SliceIface, |
| unmarshal: consumeInt32SliceIface, |
| } |
| |
| // sizeInt32PackedSliceIface returns the size of wire encoding a []int32 value as a packed repeated Int32. |
| func sizeInt32PackedSliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]int32) |
| if len(s) == 0 { |
| return 0 |
| } |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(uint64(v)) |
| } |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendInt32PackedSliceIface encodes a []int32 value as a packed repeated Int32. |
| func appendInt32PackedSliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]int32) |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(uint64(v)) |
| } |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendVarint(b, uint64(v)) |
| } |
| return b, nil |
| } |
| |
| var coderInt32PackedSliceIface = ifaceCoderFuncs{ |
| size: sizeInt32PackedSliceIface, |
| marshal: appendInt32PackedSliceIface, |
| unmarshal: consumeInt32SliceIface, |
| } |
| |
| // sizeSint32 returns the size of wire encoding a int32 pointer as a Sint32. |
| func sizeSint32(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Int32() |
| return tagsize + wire.SizeVarint(wire.EncodeZigZag(int64(v))) |
| } |
| |
| // appendSint32 wire encodes a int32 pointer as a Sint32. |
| func appendSint32(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Int32() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, wire.EncodeZigZag(int64(v))) |
| return b, nil |
| } |
| |
| // consumeSint32 wire decodes a int32 pointer as a Sint32. |
| func consumeSint32(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.VarintType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *p.Int32() = int32(wire.DecodeZigZag(v & math.MaxUint32)) |
| return n, nil |
| } |
| |
| var coderSint32 = pointerCoderFuncs{ |
| size: sizeSint32, |
| marshal: appendSint32, |
| unmarshal: consumeSint32, |
| } |
| |
| // sizeSint32NoZero returns the size of wire encoding a int32 pointer as a Sint32. |
| // The zero value is not encoded. |
| func sizeSint32NoZero(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Int32() |
| if v == 0 { |
| return 0 |
| } |
| return tagsize + wire.SizeVarint(wire.EncodeZigZag(int64(v))) |
| } |
| |
| // appendSint32NoZero wire encodes a int32 pointer as a Sint32. |
| // The zero value is not encoded. |
| func appendSint32NoZero(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Int32() |
| if v == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, wire.EncodeZigZag(int64(v))) |
| return b, nil |
| } |
| |
| var coderSint32NoZero = pointerCoderFuncs{ |
| size: sizeSint32NoZero, |
| marshal: appendSint32NoZero, |
| unmarshal: consumeSint32, |
| } |
| |
| // sizeSint32Ptr returns the size of wire encoding a *int32 pointer as a Sint32. |
| // It panics if the pointer is nil. |
| func sizeSint32Ptr(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := **p.Int32Ptr() |
| return tagsize + wire.SizeVarint(wire.EncodeZigZag(int64(v))) |
| } |
| |
| // appendSint32Ptr wire encodes a *int32 pointer as a Sint32. |
| // It panics if the pointer is nil. |
| func appendSint32Ptr(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := **p.Int32Ptr() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, wire.EncodeZigZag(int64(v))) |
| return b, nil |
| } |
| |
| // consumeSint32Ptr wire decodes a *int32 pointer as a Sint32. |
| func consumeSint32Ptr(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.VarintType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| vp := p.Int32Ptr() |
| if *vp == nil { |
| *vp = new(int32) |
| } |
| **vp = int32(wire.DecodeZigZag(v & math.MaxUint32)) |
| return n, nil |
| } |
| |
| var coderSint32Ptr = pointerCoderFuncs{ |
| size: sizeSint32Ptr, |
| marshal: appendSint32Ptr, |
| unmarshal: consumeSint32Ptr, |
| } |
| |
| // sizeSint32Slice returns the size of wire encoding a []int32 pointer as a repeated Sint32. |
| func sizeSint32Slice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Int32Slice() |
| for _, v := range s { |
| size += tagsize + wire.SizeVarint(wire.EncodeZigZag(int64(v))) |
| } |
| return size |
| } |
| |
| // appendSint32Slice encodes a []int32 pointer as a repeated Sint32. |
| func appendSint32Slice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Int32Slice() |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, wire.EncodeZigZag(int64(v))) |
| } |
| return b, nil |
| } |
| |
| // consumeSint32Slice wire decodes a []int32 pointer as a repeated Sint32. |
| func consumeSint32Slice(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| sp := p.Int32Slice() |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| s = append(s, int32(wire.DecodeZigZag(v&math.MaxUint32))) |
| b = b[n:] |
| } |
| *sp = s |
| return n, nil |
| } |
| if wtyp != wire.VarintType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, int32(wire.DecodeZigZag(v&math.MaxUint32))) |
| return n, nil |
| } |
| |
| var coderSint32Slice = pointerCoderFuncs{ |
| size: sizeSint32Slice, |
| marshal: appendSint32Slice, |
| unmarshal: consumeSint32Slice, |
| } |
| |
| // sizeSint32PackedSlice returns the size of wire encoding a []int32 pointer as a packed repeated Sint32. |
| func sizeSint32PackedSlice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Int32Slice() |
| if len(s) == 0 { |
| return 0 |
| } |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(wire.EncodeZigZag(int64(v))) |
| } |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendSint32PackedSlice encodes a []int32 pointer as a packed repeated Sint32. |
| func appendSint32PackedSlice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Int32Slice() |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(wire.EncodeZigZag(int64(v))) |
| } |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendVarint(b, wire.EncodeZigZag(int64(v))) |
| } |
| return b, nil |
| } |
| |
| var coderSint32PackedSlice = pointerCoderFuncs{ |
| size: sizeSint32PackedSlice, |
| marshal: appendSint32PackedSlice, |
| unmarshal: consumeSint32Slice, |
| } |
| |
| // sizeSint32Iface returns the size of wire encoding a int32 value as a Sint32. |
| func sizeSint32Iface(ival interface{}, tagsize int, _ marshalOptions) int { |
| v := ival.(int32) |
| return tagsize + wire.SizeVarint(wire.EncodeZigZag(int64(v))) |
| } |
| |
| // appendSint32Iface encodes a int32 value as a Sint32. |
| func appendSint32Iface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := ival.(int32) |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, wire.EncodeZigZag(int64(v))) |
| return b, nil |
| } |
| |
| // consumeSint32Iface decodes a int32 value as a Sint32. |
| func consumeSint32Iface(b []byte, _ interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (interface{}, int, error) { |
| if wtyp != wire.VarintType { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| return int32(wire.DecodeZigZag(v & math.MaxUint32)), n, nil |
| } |
| |
| var coderSint32Iface = ifaceCoderFuncs{ |
| size: sizeSint32Iface, |
| marshal: appendSint32Iface, |
| unmarshal: consumeSint32Iface, |
| } |
| |
| // sizeSint32SliceIface returns the size of wire encoding a []int32 value as a repeated Sint32. |
| func sizeSint32SliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]int32) |
| for _, v := range s { |
| size += tagsize + wire.SizeVarint(wire.EncodeZigZag(int64(v))) |
| } |
| return size |
| } |
| |
| // appendSint32SliceIface encodes a []int32 value as a repeated Sint32. |
| func appendSint32SliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]int32) |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, wire.EncodeZigZag(int64(v))) |
| } |
| return b, nil |
| } |
| |
| // consumeSint32SliceIface wire decodes a []int32 value as a repeated Sint32. |
| func consumeSint32SliceIface(b []byte, ival interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ interface{}, n int, err error) { |
| sp := ival.(*[]int32) |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| s = append(s, int32(wire.DecodeZigZag(v&math.MaxUint32))) |
| b = b[n:] |
| } |
| *sp = s |
| return ival, n, nil |
| } |
| if wtyp != wire.VarintType { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, int32(wire.DecodeZigZag(v&math.MaxUint32))) |
| return ival, n, nil |
| } |
| |
| var coderSint32SliceIface = ifaceCoderFuncs{ |
| size: sizeSint32SliceIface, |
| marshal: appendSint32SliceIface, |
| unmarshal: consumeSint32SliceIface, |
| } |
| |
| // sizeSint32PackedSliceIface returns the size of wire encoding a []int32 value as a packed repeated Sint32. |
| func sizeSint32PackedSliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]int32) |
| if len(s) == 0 { |
| return 0 |
| } |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(wire.EncodeZigZag(int64(v))) |
| } |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendSint32PackedSliceIface encodes a []int32 value as a packed repeated Sint32. |
| func appendSint32PackedSliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]int32) |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(wire.EncodeZigZag(int64(v))) |
| } |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendVarint(b, wire.EncodeZigZag(int64(v))) |
| } |
| return b, nil |
| } |
| |
| var coderSint32PackedSliceIface = ifaceCoderFuncs{ |
| size: sizeSint32PackedSliceIface, |
| marshal: appendSint32PackedSliceIface, |
| unmarshal: consumeSint32SliceIface, |
| } |
| |
| // sizeUint32 returns the size of wire encoding a uint32 pointer as a Uint32. |
| func sizeUint32(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Uint32() |
| return tagsize + wire.SizeVarint(uint64(v)) |
| } |
| |
| // appendUint32 wire encodes a uint32 pointer as a Uint32. |
| func appendUint32(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Uint32() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, uint64(v)) |
| return b, nil |
| } |
| |
| // consumeUint32 wire decodes a uint32 pointer as a Uint32. |
| func consumeUint32(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.VarintType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *p.Uint32() = uint32(v) |
| return n, nil |
| } |
| |
| var coderUint32 = pointerCoderFuncs{ |
| size: sizeUint32, |
| marshal: appendUint32, |
| unmarshal: consumeUint32, |
| } |
| |
| // sizeUint32NoZero returns the size of wire encoding a uint32 pointer as a Uint32. |
| // The zero value is not encoded. |
| func sizeUint32NoZero(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Uint32() |
| if v == 0 { |
| return 0 |
| } |
| return tagsize + wire.SizeVarint(uint64(v)) |
| } |
| |
| // appendUint32NoZero wire encodes a uint32 pointer as a Uint32. |
| // The zero value is not encoded. |
| func appendUint32NoZero(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Uint32() |
| if v == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, uint64(v)) |
| return b, nil |
| } |
| |
| var coderUint32NoZero = pointerCoderFuncs{ |
| size: sizeUint32NoZero, |
| marshal: appendUint32NoZero, |
| unmarshal: consumeUint32, |
| } |
| |
| // sizeUint32Ptr returns the size of wire encoding a *uint32 pointer as a Uint32. |
| // It panics if the pointer is nil. |
| func sizeUint32Ptr(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := **p.Uint32Ptr() |
| return tagsize + wire.SizeVarint(uint64(v)) |
| } |
| |
| // appendUint32Ptr wire encodes a *uint32 pointer as a Uint32. |
| // It panics if the pointer is nil. |
| func appendUint32Ptr(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := **p.Uint32Ptr() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, uint64(v)) |
| return b, nil |
| } |
| |
| // consumeUint32Ptr wire decodes a *uint32 pointer as a Uint32. |
| func consumeUint32Ptr(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.VarintType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| vp := p.Uint32Ptr() |
| if *vp == nil { |
| *vp = new(uint32) |
| } |
| **vp = uint32(v) |
| return n, nil |
| } |
| |
| var coderUint32Ptr = pointerCoderFuncs{ |
| size: sizeUint32Ptr, |
| marshal: appendUint32Ptr, |
| unmarshal: consumeUint32Ptr, |
| } |
| |
| // sizeUint32Slice returns the size of wire encoding a []uint32 pointer as a repeated Uint32. |
| func sizeUint32Slice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Uint32Slice() |
| for _, v := range s { |
| size += tagsize + wire.SizeVarint(uint64(v)) |
| } |
| return size |
| } |
| |
| // appendUint32Slice encodes a []uint32 pointer as a repeated Uint32. |
| func appendUint32Slice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Uint32Slice() |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, uint64(v)) |
| } |
| return b, nil |
| } |
| |
| // consumeUint32Slice wire decodes a []uint32 pointer as a repeated Uint32. |
| func consumeUint32Slice(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| sp := p.Uint32Slice() |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| s = append(s, uint32(v)) |
| b = b[n:] |
| } |
| *sp = s |
| return n, nil |
| } |
| if wtyp != wire.VarintType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, uint32(v)) |
| return n, nil |
| } |
| |
| var coderUint32Slice = pointerCoderFuncs{ |
| size: sizeUint32Slice, |
| marshal: appendUint32Slice, |
| unmarshal: consumeUint32Slice, |
| } |
| |
| // sizeUint32PackedSlice returns the size of wire encoding a []uint32 pointer as a packed repeated Uint32. |
| func sizeUint32PackedSlice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Uint32Slice() |
| if len(s) == 0 { |
| return 0 |
| } |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(uint64(v)) |
| } |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendUint32PackedSlice encodes a []uint32 pointer as a packed repeated Uint32. |
| func appendUint32PackedSlice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Uint32Slice() |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(uint64(v)) |
| } |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendVarint(b, uint64(v)) |
| } |
| return b, nil |
| } |
| |
| var coderUint32PackedSlice = pointerCoderFuncs{ |
| size: sizeUint32PackedSlice, |
| marshal: appendUint32PackedSlice, |
| unmarshal: consumeUint32Slice, |
| } |
| |
| // sizeUint32Iface returns the size of wire encoding a uint32 value as a Uint32. |
| func sizeUint32Iface(ival interface{}, tagsize int, _ marshalOptions) int { |
| v := ival.(uint32) |
| return tagsize + wire.SizeVarint(uint64(v)) |
| } |
| |
| // appendUint32Iface encodes a uint32 value as a Uint32. |
| func appendUint32Iface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := ival.(uint32) |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, uint64(v)) |
| return b, nil |
| } |
| |
| // consumeUint32Iface decodes a uint32 value as a Uint32. |
| func consumeUint32Iface(b []byte, _ interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (interface{}, int, error) { |
| if wtyp != wire.VarintType { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| return uint32(v), n, nil |
| } |
| |
| var coderUint32Iface = ifaceCoderFuncs{ |
| size: sizeUint32Iface, |
| marshal: appendUint32Iface, |
| unmarshal: consumeUint32Iface, |
| } |
| |
| // sizeUint32SliceIface returns the size of wire encoding a []uint32 value as a repeated Uint32. |
| func sizeUint32SliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]uint32) |
| for _, v := range s { |
| size += tagsize + wire.SizeVarint(uint64(v)) |
| } |
| return size |
| } |
| |
| // appendUint32SliceIface encodes a []uint32 value as a repeated Uint32. |
| func appendUint32SliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]uint32) |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, uint64(v)) |
| } |
| return b, nil |
| } |
| |
| // consumeUint32SliceIface wire decodes a []uint32 value as a repeated Uint32. |
| func consumeUint32SliceIface(b []byte, ival interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ interface{}, n int, err error) { |
| sp := ival.(*[]uint32) |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| s = append(s, uint32(v)) |
| b = b[n:] |
| } |
| *sp = s |
| return ival, n, nil |
| } |
| if wtyp != wire.VarintType { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, uint32(v)) |
| return ival, n, nil |
| } |
| |
| var coderUint32SliceIface = ifaceCoderFuncs{ |
| size: sizeUint32SliceIface, |
| marshal: appendUint32SliceIface, |
| unmarshal: consumeUint32SliceIface, |
| } |
| |
| // sizeUint32PackedSliceIface returns the size of wire encoding a []uint32 value as a packed repeated Uint32. |
| func sizeUint32PackedSliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]uint32) |
| if len(s) == 0 { |
| return 0 |
| } |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(uint64(v)) |
| } |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendUint32PackedSliceIface encodes a []uint32 value as a packed repeated Uint32. |
| func appendUint32PackedSliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]uint32) |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(uint64(v)) |
| } |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendVarint(b, uint64(v)) |
| } |
| return b, nil |
| } |
| |
| var coderUint32PackedSliceIface = ifaceCoderFuncs{ |
| size: sizeUint32PackedSliceIface, |
| marshal: appendUint32PackedSliceIface, |
| unmarshal: consumeUint32SliceIface, |
| } |
| |
| // sizeInt64 returns the size of wire encoding a int64 pointer as a Int64. |
| func sizeInt64(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Int64() |
| return tagsize + wire.SizeVarint(uint64(v)) |
| } |
| |
| // appendInt64 wire encodes a int64 pointer as a Int64. |
| func appendInt64(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Int64() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, uint64(v)) |
| return b, nil |
| } |
| |
| // consumeInt64 wire decodes a int64 pointer as a Int64. |
| func consumeInt64(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.VarintType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *p.Int64() = int64(v) |
| return n, nil |
| } |
| |
| var coderInt64 = pointerCoderFuncs{ |
| size: sizeInt64, |
| marshal: appendInt64, |
| unmarshal: consumeInt64, |
| } |
| |
| // sizeInt64NoZero returns the size of wire encoding a int64 pointer as a Int64. |
| // The zero value is not encoded. |
| func sizeInt64NoZero(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Int64() |
| if v == 0 { |
| return 0 |
| } |
| return tagsize + wire.SizeVarint(uint64(v)) |
| } |
| |
| // appendInt64NoZero wire encodes a int64 pointer as a Int64. |
| // The zero value is not encoded. |
| func appendInt64NoZero(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Int64() |
| if v == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, uint64(v)) |
| return b, nil |
| } |
| |
| var coderInt64NoZero = pointerCoderFuncs{ |
| size: sizeInt64NoZero, |
| marshal: appendInt64NoZero, |
| unmarshal: consumeInt64, |
| } |
| |
| // sizeInt64Ptr returns the size of wire encoding a *int64 pointer as a Int64. |
| // It panics if the pointer is nil. |
| func sizeInt64Ptr(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := **p.Int64Ptr() |
| return tagsize + wire.SizeVarint(uint64(v)) |
| } |
| |
| // appendInt64Ptr wire encodes a *int64 pointer as a Int64. |
| // It panics if the pointer is nil. |
| func appendInt64Ptr(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := **p.Int64Ptr() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, uint64(v)) |
| return b, nil |
| } |
| |
| // consumeInt64Ptr wire decodes a *int64 pointer as a Int64. |
| func consumeInt64Ptr(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.VarintType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| vp := p.Int64Ptr() |
| if *vp == nil { |
| *vp = new(int64) |
| } |
| **vp = int64(v) |
| return n, nil |
| } |
| |
| var coderInt64Ptr = pointerCoderFuncs{ |
| size: sizeInt64Ptr, |
| marshal: appendInt64Ptr, |
| unmarshal: consumeInt64Ptr, |
| } |
| |
| // sizeInt64Slice returns the size of wire encoding a []int64 pointer as a repeated Int64. |
| func sizeInt64Slice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Int64Slice() |
| for _, v := range s { |
| size += tagsize + wire.SizeVarint(uint64(v)) |
| } |
| return size |
| } |
| |
| // appendInt64Slice encodes a []int64 pointer as a repeated Int64. |
| func appendInt64Slice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Int64Slice() |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, uint64(v)) |
| } |
| return b, nil |
| } |
| |
| // consumeInt64Slice wire decodes a []int64 pointer as a repeated Int64. |
| func consumeInt64Slice(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| sp := p.Int64Slice() |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| s = append(s, int64(v)) |
| b = b[n:] |
| } |
| *sp = s |
| return n, nil |
| } |
| if wtyp != wire.VarintType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, int64(v)) |
| return n, nil |
| } |
| |
| var coderInt64Slice = pointerCoderFuncs{ |
| size: sizeInt64Slice, |
| marshal: appendInt64Slice, |
| unmarshal: consumeInt64Slice, |
| } |
| |
| // sizeInt64PackedSlice returns the size of wire encoding a []int64 pointer as a packed repeated Int64. |
| func sizeInt64PackedSlice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Int64Slice() |
| if len(s) == 0 { |
| return 0 |
| } |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(uint64(v)) |
| } |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendInt64PackedSlice encodes a []int64 pointer as a packed repeated Int64. |
| func appendInt64PackedSlice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Int64Slice() |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(uint64(v)) |
| } |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendVarint(b, uint64(v)) |
| } |
| return b, nil |
| } |
| |
| var coderInt64PackedSlice = pointerCoderFuncs{ |
| size: sizeInt64PackedSlice, |
| marshal: appendInt64PackedSlice, |
| unmarshal: consumeInt64Slice, |
| } |
| |
| // sizeInt64Iface returns the size of wire encoding a int64 value as a Int64. |
| func sizeInt64Iface(ival interface{}, tagsize int, _ marshalOptions) int { |
| v := ival.(int64) |
| return tagsize + wire.SizeVarint(uint64(v)) |
| } |
| |
| // appendInt64Iface encodes a int64 value as a Int64. |
| func appendInt64Iface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := ival.(int64) |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, uint64(v)) |
| return b, nil |
| } |
| |
| // consumeInt64Iface decodes a int64 value as a Int64. |
| func consumeInt64Iface(b []byte, _ interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (interface{}, int, error) { |
| if wtyp != wire.VarintType { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| return int64(v), n, nil |
| } |
| |
| var coderInt64Iface = ifaceCoderFuncs{ |
| size: sizeInt64Iface, |
| marshal: appendInt64Iface, |
| unmarshal: consumeInt64Iface, |
| } |
| |
| // sizeInt64SliceIface returns the size of wire encoding a []int64 value as a repeated Int64. |
| func sizeInt64SliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]int64) |
| for _, v := range s { |
| size += tagsize + wire.SizeVarint(uint64(v)) |
| } |
| return size |
| } |
| |
| // appendInt64SliceIface encodes a []int64 value as a repeated Int64. |
| func appendInt64SliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]int64) |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, uint64(v)) |
| } |
| return b, nil |
| } |
| |
| // consumeInt64SliceIface wire decodes a []int64 value as a repeated Int64. |
| func consumeInt64SliceIface(b []byte, ival interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ interface{}, n int, err error) { |
| sp := ival.(*[]int64) |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| s = append(s, int64(v)) |
| b = b[n:] |
| } |
| *sp = s |
| return ival, n, nil |
| } |
| if wtyp != wire.VarintType { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, int64(v)) |
| return ival, n, nil |
| } |
| |
| var coderInt64SliceIface = ifaceCoderFuncs{ |
| size: sizeInt64SliceIface, |
| marshal: appendInt64SliceIface, |
| unmarshal: consumeInt64SliceIface, |
| } |
| |
| // sizeInt64PackedSliceIface returns the size of wire encoding a []int64 value as a packed repeated Int64. |
| func sizeInt64PackedSliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]int64) |
| if len(s) == 0 { |
| return 0 |
| } |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(uint64(v)) |
| } |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendInt64PackedSliceIface encodes a []int64 value as a packed repeated Int64. |
| func appendInt64PackedSliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]int64) |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(uint64(v)) |
| } |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendVarint(b, uint64(v)) |
| } |
| return b, nil |
| } |
| |
| var coderInt64PackedSliceIface = ifaceCoderFuncs{ |
| size: sizeInt64PackedSliceIface, |
| marshal: appendInt64PackedSliceIface, |
| unmarshal: consumeInt64SliceIface, |
| } |
| |
| // sizeSint64 returns the size of wire encoding a int64 pointer as a Sint64. |
| func sizeSint64(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Int64() |
| return tagsize + wire.SizeVarint(wire.EncodeZigZag(v)) |
| } |
| |
| // appendSint64 wire encodes a int64 pointer as a Sint64. |
| func appendSint64(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Int64() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, wire.EncodeZigZag(v)) |
| return b, nil |
| } |
| |
| // consumeSint64 wire decodes a int64 pointer as a Sint64. |
| func consumeSint64(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.VarintType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *p.Int64() = wire.DecodeZigZag(v) |
| return n, nil |
| } |
| |
| var coderSint64 = pointerCoderFuncs{ |
| size: sizeSint64, |
| marshal: appendSint64, |
| unmarshal: consumeSint64, |
| } |
| |
| // sizeSint64NoZero returns the size of wire encoding a int64 pointer as a Sint64. |
| // The zero value is not encoded. |
| func sizeSint64NoZero(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Int64() |
| if v == 0 { |
| return 0 |
| } |
| return tagsize + wire.SizeVarint(wire.EncodeZigZag(v)) |
| } |
| |
| // appendSint64NoZero wire encodes a int64 pointer as a Sint64. |
| // The zero value is not encoded. |
| func appendSint64NoZero(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Int64() |
| if v == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, wire.EncodeZigZag(v)) |
| return b, nil |
| } |
| |
| var coderSint64NoZero = pointerCoderFuncs{ |
| size: sizeSint64NoZero, |
| marshal: appendSint64NoZero, |
| unmarshal: consumeSint64, |
| } |
| |
| // sizeSint64Ptr returns the size of wire encoding a *int64 pointer as a Sint64. |
| // It panics if the pointer is nil. |
| func sizeSint64Ptr(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := **p.Int64Ptr() |
| return tagsize + wire.SizeVarint(wire.EncodeZigZag(v)) |
| } |
| |
| // appendSint64Ptr wire encodes a *int64 pointer as a Sint64. |
| // It panics if the pointer is nil. |
| func appendSint64Ptr(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := **p.Int64Ptr() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, wire.EncodeZigZag(v)) |
| return b, nil |
| } |
| |
| // consumeSint64Ptr wire decodes a *int64 pointer as a Sint64. |
| func consumeSint64Ptr(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.VarintType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| vp := p.Int64Ptr() |
| if *vp == nil { |
| *vp = new(int64) |
| } |
| **vp = wire.DecodeZigZag(v) |
| return n, nil |
| } |
| |
| var coderSint64Ptr = pointerCoderFuncs{ |
| size: sizeSint64Ptr, |
| marshal: appendSint64Ptr, |
| unmarshal: consumeSint64Ptr, |
| } |
| |
| // sizeSint64Slice returns the size of wire encoding a []int64 pointer as a repeated Sint64. |
| func sizeSint64Slice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Int64Slice() |
| for _, v := range s { |
| size += tagsize + wire.SizeVarint(wire.EncodeZigZag(v)) |
| } |
| return size |
| } |
| |
| // appendSint64Slice encodes a []int64 pointer as a repeated Sint64. |
| func appendSint64Slice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Int64Slice() |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, wire.EncodeZigZag(v)) |
| } |
| return b, nil |
| } |
| |
| // consumeSint64Slice wire decodes a []int64 pointer as a repeated Sint64. |
| func consumeSint64Slice(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| sp := p.Int64Slice() |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| s = append(s, wire.DecodeZigZag(v)) |
| b = b[n:] |
| } |
| *sp = s |
| return n, nil |
| } |
| if wtyp != wire.VarintType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, wire.DecodeZigZag(v)) |
| return n, nil |
| } |
| |
| var coderSint64Slice = pointerCoderFuncs{ |
| size: sizeSint64Slice, |
| marshal: appendSint64Slice, |
| unmarshal: consumeSint64Slice, |
| } |
| |
| // sizeSint64PackedSlice returns the size of wire encoding a []int64 pointer as a packed repeated Sint64. |
| func sizeSint64PackedSlice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Int64Slice() |
| if len(s) == 0 { |
| return 0 |
| } |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(wire.EncodeZigZag(v)) |
| } |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendSint64PackedSlice encodes a []int64 pointer as a packed repeated Sint64. |
| func appendSint64PackedSlice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Int64Slice() |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(wire.EncodeZigZag(v)) |
| } |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendVarint(b, wire.EncodeZigZag(v)) |
| } |
| return b, nil |
| } |
| |
| var coderSint64PackedSlice = pointerCoderFuncs{ |
| size: sizeSint64PackedSlice, |
| marshal: appendSint64PackedSlice, |
| unmarshal: consumeSint64Slice, |
| } |
| |
| // sizeSint64Iface returns the size of wire encoding a int64 value as a Sint64. |
| func sizeSint64Iface(ival interface{}, tagsize int, _ marshalOptions) int { |
| v := ival.(int64) |
| return tagsize + wire.SizeVarint(wire.EncodeZigZag(v)) |
| } |
| |
| // appendSint64Iface encodes a int64 value as a Sint64. |
| func appendSint64Iface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := ival.(int64) |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, wire.EncodeZigZag(v)) |
| return b, nil |
| } |
| |
| // consumeSint64Iface decodes a int64 value as a Sint64. |
| func consumeSint64Iface(b []byte, _ interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (interface{}, int, error) { |
| if wtyp != wire.VarintType { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| return wire.DecodeZigZag(v), n, nil |
| } |
| |
| var coderSint64Iface = ifaceCoderFuncs{ |
| size: sizeSint64Iface, |
| marshal: appendSint64Iface, |
| unmarshal: consumeSint64Iface, |
| } |
| |
| // sizeSint64SliceIface returns the size of wire encoding a []int64 value as a repeated Sint64. |
| func sizeSint64SliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]int64) |
| for _, v := range s { |
| size += tagsize + wire.SizeVarint(wire.EncodeZigZag(v)) |
| } |
| return size |
| } |
| |
| // appendSint64SliceIface encodes a []int64 value as a repeated Sint64. |
| func appendSint64SliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]int64) |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, wire.EncodeZigZag(v)) |
| } |
| return b, nil |
| } |
| |
| // consumeSint64SliceIface wire decodes a []int64 value as a repeated Sint64. |
| func consumeSint64SliceIface(b []byte, ival interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ interface{}, n int, err error) { |
| sp := ival.(*[]int64) |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| s = append(s, wire.DecodeZigZag(v)) |
| b = b[n:] |
| } |
| *sp = s |
| return ival, n, nil |
| } |
| if wtyp != wire.VarintType { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, wire.DecodeZigZag(v)) |
| return ival, n, nil |
| } |
| |
| var coderSint64SliceIface = ifaceCoderFuncs{ |
| size: sizeSint64SliceIface, |
| marshal: appendSint64SliceIface, |
| unmarshal: consumeSint64SliceIface, |
| } |
| |
| // sizeSint64PackedSliceIface returns the size of wire encoding a []int64 value as a packed repeated Sint64. |
| func sizeSint64PackedSliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]int64) |
| if len(s) == 0 { |
| return 0 |
| } |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(wire.EncodeZigZag(v)) |
| } |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendSint64PackedSliceIface encodes a []int64 value as a packed repeated Sint64. |
| func appendSint64PackedSliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]int64) |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(wire.EncodeZigZag(v)) |
| } |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendVarint(b, wire.EncodeZigZag(v)) |
| } |
| return b, nil |
| } |
| |
| var coderSint64PackedSliceIface = ifaceCoderFuncs{ |
| size: sizeSint64PackedSliceIface, |
| marshal: appendSint64PackedSliceIface, |
| unmarshal: consumeSint64SliceIface, |
| } |
| |
| // sizeUint64 returns the size of wire encoding a uint64 pointer as a Uint64. |
| func sizeUint64(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Uint64() |
| return tagsize + wire.SizeVarint(v) |
| } |
| |
| // appendUint64 wire encodes a uint64 pointer as a Uint64. |
| func appendUint64(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Uint64() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, v) |
| return b, nil |
| } |
| |
| // consumeUint64 wire decodes a uint64 pointer as a Uint64. |
| func consumeUint64(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.VarintType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *p.Uint64() = v |
| return n, nil |
| } |
| |
| var coderUint64 = pointerCoderFuncs{ |
| size: sizeUint64, |
| marshal: appendUint64, |
| unmarshal: consumeUint64, |
| } |
| |
| // sizeUint64NoZero returns the size of wire encoding a uint64 pointer as a Uint64. |
| // The zero value is not encoded. |
| func sizeUint64NoZero(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Uint64() |
| if v == 0 { |
| return 0 |
| } |
| return tagsize + wire.SizeVarint(v) |
| } |
| |
| // appendUint64NoZero wire encodes a uint64 pointer as a Uint64. |
| // The zero value is not encoded. |
| func appendUint64NoZero(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Uint64() |
| if v == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, v) |
| return b, nil |
| } |
| |
| var coderUint64NoZero = pointerCoderFuncs{ |
| size: sizeUint64NoZero, |
| marshal: appendUint64NoZero, |
| unmarshal: consumeUint64, |
| } |
| |
| // sizeUint64Ptr returns the size of wire encoding a *uint64 pointer as a Uint64. |
| // It panics if the pointer is nil. |
| func sizeUint64Ptr(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := **p.Uint64Ptr() |
| return tagsize + wire.SizeVarint(v) |
| } |
| |
| // appendUint64Ptr wire encodes a *uint64 pointer as a Uint64. |
| // It panics if the pointer is nil. |
| func appendUint64Ptr(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := **p.Uint64Ptr() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, v) |
| return b, nil |
| } |
| |
| // consumeUint64Ptr wire decodes a *uint64 pointer as a Uint64. |
| func consumeUint64Ptr(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.VarintType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| vp := p.Uint64Ptr() |
| if *vp == nil { |
| *vp = new(uint64) |
| } |
| **vp = v |
| return n, nil |
| } |
| |
| var coderUint64Ptr = pointerCoderFuncs{ |
| size: sizeUint64Ptr, |
| marshal: appendUint64Ptr, |
| unmarshal: consumeUint64Ptr, |
| } |
| |
| // sizeUint64Slice returns the size of wire encoding a []uint64 pointer as a repeated Uint64. |
| func sizeUint64Slice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Uint64Slice() |
| for _, v := range s { |
| size += tagsize + wire.SizeVarint(v) |
| } |
| return size |
| } |
| |
| // appendUint64Slice encodes a []uint64 pointer as a repeated Uint64. |
| func appendUint64Slice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Uint64Slice() |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, v) |
| } |
| return b, nil |
| } |
| |
| // consumeUint64Slice wire decodes a []uint64 pointer as a repeated Uint64. |
| func consumeUint64Slice(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| sp := p.Uint64Slice() |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| s = append(s, v) |
| b = b[n:] |
| } |
| *sp = s |
| return n, nil |
| } |
| if wtyp != wire.VarintType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, v) |
| return n, nil |
| } |
| |
| var coderUint64Slice = pointerCoderFuncs{ |
| size: sizeUint64Slice, |
| marshal: appendUint64Slice, |
| unmarshal: consumeUint64Slice, |
| } |
| |
| // sizeUint64PackedSlice returns the size of wire encoding a []uint64 pointer as a packed repeated Uint64. |
| func sizeUint64PackedSlice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Uint64Slice() |
| if len(s) == 0 { |
| return 0 |
| } |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(v) |
| } |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendUint64PackedSlice encodes a []uint64 pointer as a packed repeated Uint64. |
| func appendUint64PackedSlice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Uint64Slice() |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(v) |
| } |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendVarint(b, v) |
| } |
| return b, nil |
| } |
| |
| var coderUint64PackedSlice = pointerCoderFuncs{ |
| size: sizeUint64PackedSlice, |
| marshal: appendUint64PackedSlice, |
| unmarshal: consumeUint64Slice, |
| } |
| |
| // sizeUint64Iface returns the size of wire encoding a uint64 value as a Uint64. |
| func sizeUint64Iface(ival interface{}, tagsize int, _ marshalOptions) int { |
| v := ival.(uint64) |
| return tagsize + wire.SizeVarint(v) |
| } |
| |
| // appendUint64Iface encodes a uint64 value as a Uint64. |
| func appendUint64Iface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := ival.(uint64) |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, v) |
| return b, nil |
| } |
| |
| // consumeUint64Iface decodes a uint64 value as a Uint64. |
| func consumeUint64Iface(b []byte, _ interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (interface{}, int, error) { |
| if wtyp != wire.VarintType { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| return v, n, nil |
| } |
| |
| var coderUint64Iface = ifaceCoderFuncs{ |
| size: sizeUint64Iface, |
| marshal: appendUint64Iface, |
| unmarshal: consumeUint64Iface, |
| } |
| |
| // sizeUint64SliceIface returns the size of wire encoding a []uint64 value as a repeated Uint64. |
| func sizeUint64SliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]uint64) |
| for _, v := range s { |
| size += tagsize + wire.SizeVarint(v) |
| } |
| return size |
| } |
| |
| // appendUint64SliceIface encodes a []uint64 value as a repeated Uint64. |
| func appendUint64SliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]uint64) |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendVarint(b, v) |
| } |
| return b, nil |
| } |
| |
| // consumeUint64SliceIface wire decodes a []uint64 value as a repeated Uint64. |
| func consumeUint64SliceIface(b []byte, ival interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ interface{}, n int, err error) { |
| sp := ival.(*[]uint64) |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| s = append(s, v) |
| b = b[n:] |
| } |
| *sp = s |
| return ival, n, nil |
| } |
| if wtyp != wire.VarintType { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeVarint(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, v) |
| return ival, n, nil |
| } |
| |
| var coderUint64SliceIface = ifaceCoderFuncs{ |
| size: sizeUint64SliceIface, |
| marshal: appendUint64SliceIface, |
| unmarshal: consumeUint64SliceIface, |
| } |
| |
| // sizeUint64PackedSliceIface returns the size of wire encoding a []uint64 value as a packed repeated Uint64. |
| func sizeUint64PackedSliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]uint64) |
| if len(s) == 0 { |
| return 0 |
| } |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(v) |
| } |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendUint64PackedSliceIface encodes a []uint64 value as a packed repeated Uint64. |
| func appendUint64PackedSliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]uint64) |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := 0 |
| for _, v := range s { |
| n += wire.SizeVarint(v) |
| } |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendVarint(b, v) |
| } |
| return b, nil |
| } |
| |
| var coderUint64PackedSliceIface = ifaceCoderFuncs{ |
| size: sizeUint64PackedSliceIface, |
| marshal: appendUint64PackedSliceIface, |
| unmarshal: consumeUint64SliceIface, |
| } |
| |
| // sizeSfixed32 returns the size of wire encoding a int32 pointer as a Sfixed32. |
| func sizeSfixed32(p pointer, tagsize int, _ marshalOptions) (size int) { |
| |
| return tagsize + wire.SizeFixed32() |
| } |
| |
| // appendSfixed32 wire encodes a int32 pointer as a Sfixed32. |
| func appendSfixed32(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Int32() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed32(b, uint32(v)) |
| return b, nil |
| } |
| |
| // consumeSfixed32 wire decodes a int32 pointer as a Sfixed32. |
| func consumeSfixed32(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.Fixed32Type { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed32(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *p.Int32() = int32(v) |
| return n, nil |
| } |
| |
| var coderSfixed32 = pointerCoderFuncs{ |
| size: sizeSfixed32, |
| marshal: appendSfixed32, |
| unmarshal: consumeSfixed32, |
| } |
| |
| // sizeSfixed32NoZero returns the size of wire encoding a int32 pointer as a Sfixed32. |
| // The zero value is not encoded. |
| func sizeSfixed32NoZero(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Int32() |
| if v == 0 { |
| return 0 |
| } |
| return tagsize + wire.SizeFixed32() |
| } |
| |
| // appendSfixed32NoZero wire encodes a int32 pointer as a Sfixed32. |
| // The zero value is not encoded. |
| func appendSfixed32NoZero(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Int32() |
| if v == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed32(b, uint32(v)) |
| return b, nil |
| } |
| |
| var coderSfixed32NoZero = pointerCoderFuncs{ |
| size: sizeSfixed32NoZero, |
| marshal: appendSfixed32NoZero, |
| unmarshal: consumeSfixed32, |
| } |
| |
| // sizeSfixed32Ptr returns the size of wire encoding a *int32 pointer as a Sfixed32. |
| // It panics if the pointer is nil. |
| func sizeSfixed32Ptr(p pointer, tagsize int, _ marshalOptions) (size int) { |
| return tagsize + wire.SizeFixed32() |
| } |
| |
| // appendSfixed32Ptr wire encodes a *int32 pointer as a Sfixed32. |
| // It panics if the pointer is nil. |
| func appendSfixed32Ptr(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := **p.Int32Ptr() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed32(b, uint32(v)) |
| return b, nil |
| } |
| |
| // consumeSfixed32Ptr wire decodes a *int32 pointer as a Sfixed32. |
| func consumeSfixed32Ptr(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.Fixed32Type { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed32(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| vp := p.Int32Ptr() |
| if *vp == nil { |
| *vp = new(int32) |
| } |
| **vp = int32(v) |
| return n, nil |
| } |
| |
| var coderSfixed32Ptr = pointerCoderFuncs{ |
| size: sizeSfixed32Ptr, |
| marshal: appendSfixed32Ptr, |
| unmarshal: consumeSfixed32Ptr, |
| } |
| |
| // sizeSfixed32Slice returns the size of wire encoding a []int32 pointer as a repeated Sfixed32. |
| func sizeSfixed32Slice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Int32Slice() |
| size = len(s) * (tagsize + wire.SizeFixed32()) |
| return size |
| } |
| |
| // appendSfixed32Slice encodes a []int32 pointer as a repeated Sfixed32. |
| func appendSfixed32Slice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Int32Slice() |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed32(b, uint32(v)) |
| } |
| return b, nil |
| } |
| |
| // consumeSfixed32Slice wire decodes a []int32 pointer as a repeated Sfixed32. |
| func consumeSfixed32Slice(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| sp := p.Int32Slice() |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeFixed32(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| s = append(s, int32(v)) |
| b = b[n:] |
| } |
| *sp = s |
| return n, nil |
| } |
| if wtyp != wire.Fixed32Type { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed32(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, int32(v)) |
| return n, nil |
| } |
| |
| var coderSfixed32Slice = pointerCoderFuncs{ |
| size: sizeSfixed32Slice, |
| marshal: appendSfixed32Slice, |
| unmarshal: consumeSfixed32Slice, |
| } |
| |
| // sizeSfixed32PackedSlice returns the size of wire encoding a []int32 pointer as a packed repeated Sfixed32. |
| func sizeSfixed32PackedSlice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Int32Slice() |
| if len(s) == 0 { |
| return 0 |
| } |
| n := len(s) * wire.SizeFixed32() |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendSfixed32PackedSlice encodes a []int32 pointer as a packed repeated Sfixed32. |
| func appendSfixed32PackedSlice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Int32Slice() |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := len(s) * wire.SizeFixed32() |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendFixed32(b, uint32(v)) |
| } |
| return b, nil |
| } |
| |
| var coderSfixed32PackedSlice = pointerCoderFuncs{ |
| size: sizeSfixed32PackedSlice, |
| marshal: appendSfixed32PackedSlice, |
| unmarshal: consumeSfixed32Slice, |
| } |
| |
| // sizeSfixed32Iface returns the size of wire encoding a int32 value as a Sfixed32. |
| func sizeSfixed32Iface(ival interface{}, tagsize int, _ marshalOptions) int { |
| return tagsize + wire.SizeFixed32() |
| } |
| |
| // appendSfixed32Iface encodes a int32 value as a Sfixed32. |
| func appendSfixed32Iface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := ival.(int32) |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed32(b, uint32(v)) |
| return b, nil |
| } |
| |
| // consumeSfixed32Iface decodes a int32 value as a Sfixed32. |
| func consumeSfixed32Iface(b []byte, _ interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (interface{}, int, error) { |
| if wtyp != wire.Fixed32Type { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed32(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| return int32(v), n, nil |
| } |
| |
| var coderSfixed32Iface = ifaceCoderFuncs{ |
| size: sizeSfixed32Iface, |
| marshal: appendSfixed32Iface, |
| unmarshal: consumeSfixed32Iface, |
| } |
| |
| // sizeSfixed32SliceIface returns the size of wire encoding a []int32 value as a repeated Sfixed32. |
| func sizeSfixed32SliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]int32) |
| size = len(s) * (tagsize + wire.SizeFixed32()) |
| return size |
| } |
| |
| // appendSfixed32SliceIface encodes a []int32 value as a repeated Sfixed32. |
| func appendSfixed32SliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]int32) |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed32(b, uint32(v)) |
| } |
| return b, nil |
| } |
| |
| // consumeSfixed32SliceIface wire decodes a []int32 value as a repeated Sfixed32. |
| func consumeSfixed32SliceIface(b []byte, ival interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ interface{}, n int, err error) { |
| sp := ival.(*[]int32) |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeFixed32(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| s = append(s, int32(v)) |
| b = b[n:] |
| } |
| *sp = s |
| return ival, n, nil |
| } |
| if wtyp != wire.Fixed32Type { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed32(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, int32(v)) |
| return ival, n, nil |
| } |
| |
| var coderSfixed32SliceIface = ifaceCoderFuncs{ |
| size: sizeSfixed32SliceIface, |
| marshal: appendSfixed32SliceIface, |
| unmarshal: consumeSfixed32SliceIface, |
| } |
| |
| // sizeSfixed32PackedSliceIface returns the size of wire encoding a []int32 value as a packed repeated Sfixed32. |
| func sizeSfixed32PackedSliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]int32) |
| if len(s) == 0 { |
| return 0 |
| } |
| n := len(s) * wire.SizeFixed32() |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendSfixed32PackedSliceIface encodes a []int32 value as a packed repeated Sfixed32. |
| func appendSfixed32PackedSliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]int32) |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := len(s) * wire.SizeFixed32() |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendFixed32(b, uint32(v)) |
| } |
| return b, nil |
| } |
| |
| var coderSfixed32PackedSliceIface = ifaceCoderFuncs{ |
| size: sizeSfixed32PackedSliceIface, |
| marshal: appendSfixed32PackedSliceIface, |
| unmarshal: consumeSfixed32SliceIface, |
| } |
| |
| // sizeFixed32 returns the size of wire encoding a uint32 pointer as a Fixed32. |
| func sizeFixed32(p pointer, tagsize int, _ marshalOptions) (size int) { |
| |
| return tagsize + wire.SizeFixed32() |
| } |
| |
| // appendFixed32 wire encodes a uint32 pointer as a Fixed32. |
| func appendFixed32(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Uint32() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed32(b, v) |
| return b, nil |
| } |
| |
| // consumeFixed32 wire decodes a uint32 pointer as a Fixed32. |
| func consumeFixed32(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.Fixed32Type { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed32(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *p.Uint32() = v |
| return n, nil |
| } |
| |
| var coderFixed32 = pointerCoderFuncs{ |
| size: sizeFixed32, |
| marshal: appendFixed32, |
| unmarshal: consumeFixed32, |
| } |
| |
| // sizeFixed32NoZero returns the size of wire encoding a uint32 pointer as a Fixed32. |
| // The zero value is not encoded. |
| func sizeFixed32NoZero(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Uint32() |
| if v == 0 { |
| return 0 |
| } |
| return tagsize + wire.SizeFixed32() |
| } |
| |
| // appendFixed32NoZero wire encodes a uint32 pointer as a Fixed32. |
| // The zero value is not encoded. |
| func appendFixed32NoZero(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Uint32() |
| if v == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed32(b, v) |
| return b, nil |
| } |
| |
| var coderFixed32NoZero = pointerCoderFuncs{ |
| size: sizeFixed32NoZero, |
| marshal: appendFixed32NoZero, |
| unmarshal: consumeFixed32, |
| } |
| |
| // sizeFixed32Ptr returns the size of wire encoding a *uint32 pointer as a Fixed32. |
| // It panics if the pointer is nil. |
| func sizeFixed32Ptr(p pointer, tagsize int, _ marshalOptions) (size int) { |
| return tagsize + wire.SizeFixed32() |
| } |
| |
| // appendFixed32Ptr wire encodes a *uint32 pointer as a Fixed32. |
| // It panics if the pointer is nil. |
| func appendFixed32Ptr(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := **p.Uint32Ptr() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed32(b, v) |
| return b, nil |
| } |
| |
| // consumeFixed32Ptr wire decodes a *uint32 pointer as a Fixed32. |
| func consumeFixed32Ptr(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.Fixed32Type { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed32(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| vp := p.Uint32Ptr() |
| if *vp == nil { |
| *vp = new(uint32) |
| } |
| **vp = v |
| return n, nil |
| } |
| |
| var coderFixed32Ptr = pointerCoderFuncs{ |
| size: sizeFixed32Ptr, |
| marshal: appendFixed32Ptr, |
| unmarshal: consumeFixed32Ptr, |
| } |
| |
| // sizeFixed32Slice returns the size of wire encoding a []uint32 pointer as a repeated Fixed32. |
| func sizeFixed32Slice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Uint32Slice() |
| size = len(s) * (tagsize + wire.SizeFixed32()) |
| return size |
| } |
| |
| // appendFixed32Slice encodes a []uint32 pointer as a repeated Fixed32. |
| func appendFixed32Slice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Uint32Slice() |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed32(b, v) |
| } |
| return b, nil |
| } |
| |
| // consumeFixed32Slice wire decodes a []uint32 pointer as a repeated Fixed32. |
| func consumeFixed32Slice(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| sp := p.Uint32Slice() |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeFixed32(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| s = append(s, v) |
| b = b[n:] |
| } |
| *sp = s |
| return n, nil |
| } |
| if wtyp != wire.Fixed32Type { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed32(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, v) |
| return n, nil |
| } |
| |
| var coderFixed32Slice = pointerCoderFuncs{ |
| size: sizeFixed32Slice, |
| marshal: appendFixed32Slice, |
| unmarshal: consumeFixed32Slice, |
| } |
| |
| // sizeFixed32PackedSlice returns the size of wire encoding a []uint32 pointer as a packed repeated Fixed32. |
| func sizeFixed32PackedSlice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Uint32Slice() |
| if len(s) == 0 { |
| return 0 |
| } |
| n := len(s) * wire.SizeFixed32() |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendFixed32PackedSlice encodes a []uint32 pointer as a packed repeated Fixed32. |
| func appendFixed32PackedSlice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Uint32Slice() |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := len(s) * wire.SizeFixed32() |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendFixed32(b, v) |
| } |
| return b, nil |
| } |
| |
| var coderFixed32PackedSlice = pointerCoderFuncs{ |
| size: sizeFixed32PackedSlice, |
| marshal: appendFixed32PackedSlice, |
| unmarshal: consumeFixed32Slice, |
| } |
| |
| // sizeFixed32Iface returns the size of wire encoding a uint32 value as a Fixed32. |
| func sizeFixed32Iface(ival interface{}, tagsize int, _ marshalOptions) int { |
| return tagsize + wire.SizeFixed32() |
| } |
| |
| // appendFixed32Iface encodes a uint32 value as a Fixed32. |
| func appendFixed32Iface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := ival.(uint32) |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed32(b, v) |
| return b, nil |
| } |
| |
| // consumeFixed32Iface decodes a uint32 value as a Fixed32. |
| func consumeFixed32Iface(b []byte, _ interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (interface{}, int, error) { |
| if wtyp != wire.Fixed32Type { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed32(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| return v, n, nil |
| } |
| |
| var coderFixed32Iface = ifaceCoderFuncs{ |
| size: sizeFixed32Iface, |
| marshal: appendFixed32Iface, |
| unmarshal: consumeFixed32Iface, |
| } |
| |
| // sizeFixed32SliceIface returns the size of wire encoding a []uint32 value as a repeated Fixed32. |
| func sizeFixed32SliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]uint32) |
| size = len(s) * (tagsize + wire.SizeFixed32()) |
| return size |
| } |
| |
| // appendFixed32SliceIface encodes a []uint32 value as a repeated Fixed32. |
| func appendFixed32SliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]uint32) |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed32(b, v) |
| } |
| return b, nil |
| } |
| |
| // consumeFixed32SliceIface wire decodes a []uint32 value as a repeated Fixed32. |
| func consumeFixed32SliceIface(b []byte, ival interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ interface{}, n int, err error) { |
| sp := ival.(*[]uint32) |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeFixed32(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| s = append(s, v) |
| b = b[n:] |
| } |
| *sp = s |
| return ival, n, nil |
| } |
| if wtyp != wire.Fixed32Type { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed32(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, v) |
| return ival, n, nil |
| } |
| |
| var coderFixed32SliceIface = ifaceCoderFuncs{ |
| size: sizeFixed32SliceIface, |
| marshal: appendFixed32SliceIface, |
| unmarshal: consumeFixed32SliceIface, |
| } |
| |
| // sizeFixed32PackedSliceIface returns the size of wire encoding a []uint32 value as a packed repeated Fixed32. |
| func sizeFixed32PackedSliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]uint32) |
| if len(s) == 0 { |
| return 0 |
| } |
| n := len(s) * wire.SizeFixed32() |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendFixed32PackedSliceIface encodes a []uint32 value as a packed repeated Fixed32. |
| func appendFixed32PackedSliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]uint32) |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := len(s) * wire.SizeFixed32() |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendFixed32(b, v) |
| } |
| return b, nil |
| } |
| |
| var coderFixed32PackedSliceIface = ifaceCoderFuncs{ |
| size: sizeFixed32PackedSliceIface, |
| marshal: appendFixed32PackedSliceIface, |
| unmarshal: consumeFixed32SliceIface, |
| } |
| |
| // sizeFloat returns the size of wire encoding a float32 pointer as a Float. |
| func sizeFloat(p pointer, tagsize int, _ marshalOptions) (size int) { |
| |
| return tagsize + wire.SizeFixed32() |
| } |
| |
| // appendFloat wire encodes a float32 pointer as a Float. |
| func appendFloat(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Float32() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed32(b, math.Float32bits(v)) |
| return b, nil |
| } |
| |
| // consumeFloat wire decodes a float32 pointer as a Float. |
| func consumeFloat(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.Fixed32Type { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed32(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *p.Float32() = math.Float32frombits(v) |
| return n, nil |
| } |
| |
| var coderFloat = pointerCoderFuncs{ |
| size: sizeFloat, |
| marshal: appendFloat, |
| unmarshal: consumeFloat, |
| } |
| |
| // sizeFloatNoZero returns the size of wire encoding a float32 pointer as a Float. |
| // The zero value is not encoded. |
| func sizeFloatNoZero(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Float32() |
| if v == 0 && !math.Signbit(float64(v)) { |
| return 0 |
| } |
| return tagsize + wire.SizeFixed32() |
| } |
| |
| // appendFloatNoZero wire encodes a float32 pointer as a Float. |
| // The zero value is not encoded. |
| func appendFloatNoZero(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Float32() |
| if v == 0 && !math.Signbit(float64(v)) { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed32(b, math.Float32bits(v)) |
| return b, nil |
| } |
| |
| var coderFloatNoZero = pointerCoderFuncs{ |
| size: sizeFloatNoZero, |
| marshal: appendFloatNoZero, |
| unmarshal: consumeFloat, |
| } |
| |
| // sizeFloatPtr returns the size of wire encoding a *float32 pointer as a Float. |
| // It panics if the pointer is nil. |
| func sizeFloatPtr(p pointer, tagsize int, _ marshalOptions) (size int) { |
| return tagsize + wire.SizeFixed32() |
| } |
| |
| // appendFloatPtr wire encodes a *float32 pointer as a Float. |
| // It panics if the pointer is nil. |
| func appendFloatPtr(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := **p.Float32Ptr() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed32(b, math.Float32bits(v)) |
| return b, nil |
| } |
| |
| // consumeFloatPtr wire decodes a *float32 pointer as a Float. |
| func consumeFloatPtr(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.Fixed32Type { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed32(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| vp := p.Float32Ptr() |
| if *vp == nil { |
| *vp = new(float32) |
| } |
| **vp = math.Float32frombits(v) |
| return n, nil |
| } |
| |
| var coderFloatPtr = pointerCoderFuncs{ |
| size: sizeFloatPtr, |
| marshal: appendFloatPtr, |
| unmarshal: consumeFloatPtr, |
| } |
| |
| // sizeFloatSlice returns the size of wire encoding a []float32 pointer as a repeated Float. |
| func sizeFloatSlice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Float32Slice() |
| size = len(s) * (tagsize + wire.SizeFixed32()) |
| return size |
| } |
| |
| // appendFloatSlice encodes a []float32 pointer as a repeated Float. |
| func appendFloatSlice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Float32Slice() |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed32(b, math.Float32bits(v)) |
| } |
| return b, nil |
| } |
| |
| // consumeFloatSlice wire decodes a []float32 pointer as a repeated Float. |
| func consumeFloatSlice(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| sp := p.Float32Slice() |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeFixed32(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| s = append(s, math.Float32frombits(v)) |
| b = b[n:] |
| } |
| *sp = s |
| return n, nil |
| } |
| if wtyp != wire.Fixed32Type { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed32(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, math.Float32frombits(v)) |
| return n, nil |
| } |
| |
| var coderFloatSlice = pointerCoderFuncs{ |
| size: sizeFloatSlice, |
| marshal: appendFloatSlice, |
| unmarshal: consumeFloatSlice, |
| } |
| |
| // sizeFloatPackedSlice returns the size of wire encoding a []float32 pointer as a packed repeated Float. |
| func sizeFloatPackedSlice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Float32Slice() |
| if len(s) == 0 { |
| return 0 |
| } |
| n := len(s) * wire.SizeFixed32() |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendFloatPackedSlice encodes a []float32 pointer as a packed repeated Float. |
| func appendFloatPackedSlice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Float32Slice() |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := len(s) * wire.SizeFixed32() |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendFixed32(b, math.Float32bits(v)) |
| } |
| return b, nil |
| } |
| |
| var coderFloatPackedSlice = pointerCoderFuncs{ |
| size: sizeFloatPackedSlice, |
| marshal: appendFloatPackedSlice, |
| unmarshal: consumeFloatSlice, |
| } |
| |
| // sizeFloatIface returns the size of wire encoding a float32 value as a Float. |
| func sizeFloatIface(ival interface{}, tagsize int, _ marshalOptions) int { |
| return tagsize + wire.SizeFixed32() |
| } |
| |
| // appendFloatIface encodes a float32 value as a Float. |
| func appendFloatIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := ival.(float32) |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed32(b, math.Float32bits(v)) |
| return b, nil |
| } |
| |
| // consumeFloatIface decodes a float32 value as a Float. |
| func consumeFloatIface(b []byte, _ interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (interface{}, int, error) { |
| if wtyp != wire.Fixed32Type { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed32(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| return math.Float32frombits(v), n, nil |
| } |
| |
| var coderFloatIface = ifaceCoderFuncs{ |
| size: sizeFloatIface, |
| marshal: appendFloatIface, |
| unmarshal: consumeFloatIface, |
| } |
| |
| // sizeFloatSliceIface returns the size of wire encoding a []float32 value as a repeated Float. |
| func sizeFloatSliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]float32) |
| size = len(s) * (tagsize + wire.SizeFixed32()) |
| return size |
| } |
| |
| // appendFloatSliceIface encodes a []float32 value as a repeated Float. |
| func appendFloatSliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]float32) |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed32(b, math.Float32bits(v)) |
| } |
| return b, nil |
| } |
| |
| // consumeFloatSliceIface wire decodes a []float32 value as a repeated Float. |
| func consumeFloatSliceIface(b []byte, ival interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ interface{}, n int, err error) { |
| sp := ival.(*[]float32) |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeFixed32(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| s = append(s, math.Float32frombits(v)) |
| b = b[n:] |
| } |
| *sp = s |
| return ival, n, nil |
| } |
| if wtyp != wire.Fixed32Type { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed32(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, math.Float32frombits(v)) |
| return ival, n, nil |
| } |
| |
| var coderFloatSliceIface = ifaceCoderFuncs{ |
| size: sizeFloatSliceIface, |
| marshal: appendFloatSliceIface, |
| unmarshal: consumeFloatSliceIface, |
| } |
| |
| // sizeFloatPackedSliceIface returns the size of wire encoding a []float32 value as a packed repeated Float. |
| func sizeFloatPackedSliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]float32) |
| if len(s) == 0 { |
| return 0 |
| } |
| n := len(s) * wire.SizeFixed32() |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendFloatPackedSliceIface encodes a []float32 value as a packed repeated Float. |
| func appendFloatPackedSliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]float32) |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := len(s) * wire.SizeFixed32() |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendFixed32(b, math.Float32bits(v)) |
| } |
| return b, nil |
| } |
| |
| var coderFloatPackedSliceIface = ifaceCoderFuncs{ |
| size: sizeFloatPackedSliceIface, |
| marshal: appendFloatPackedSliceIface, |
| unmarshal: consumeFloatSliceIface, |
| } |
| |
| // sizeSfixed64 returns the size of wire encoding a int64 pointer as a Sfixed64. |
| func sizeSfixed64(p pointer, tagsize int, _ marshalOptions) (size int) { |
| |
| return tagsize + wire.SizeFixed64() |
| } |
| |
| // appendSfixed64 wire encodes a int64 pointer as a Sfixed64. |
| func appendSfixed64(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Int64() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed64(b, uint64(v)) |
| return b, nil |
| } |
| |
| // consumeSfixed64 wire decodes a int64 pointer as a Sfixed64. |
| func consumeSfixed64(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.Fixed64Type { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed64(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *p.Int64() = int64(v) |
| return n, nil |
| } |
| |
| var coderSfixed64 = pointerCoderFuncs{ |
| size: sizeSfixed64, |
| marshal: appendSfixed64, |
| unmarshal: consumeSfixed64, |
| } |
| |
| // sizeSfixed64NoZero returns the size of wire encoding a int64 pointer as a Sfixed64. |
| // The zero value is not encoded. |
| func sizeSfixed64NoZero(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Int64() |
| if v == 0 { |
| return 0 |
| } |
| return tagsize + wire.SizeFixed64() |
| } |
| |
| // appendSfixed64NoZero wire encodes a int64 pointer as a Sfixed64. |
| // The zero value is not encoded. |
| func appendSfixed64NoZero(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Int64() |
| if v == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed64(b, uint64(v)) |
| return b, nil |
| } |
| |
| var coderSfixed64NoZero = pointerCoderFuncs{ |
| size: sizeSfixed64NoZero, |
| marshal: appendSfixed64NoZero, |
| unmarshal: consumeSfixed64, |
| } |
| |
| // sizeSfixed64Ptr returns the size of wire encoding a *int64 pointer as a Sfixed64. |
| // It panics if the pointer is nil. |
| func sizeSfixed64Ptr(p pointer, tagsize int, _ marshalOptions) (size int) { |
| return tagsize + wire.SizeFixed64() |
| } |
| |
| // appendSfixed64Ptr wire encodes a *int64 pointer as a Sfixed64. |
| // It panics if the pointer is nil. |
| func appendSfixed64Ptr(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := **p.Int64Ptr() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed64(b, uint64(v)) |
| return b, nil |
| } |
| |
| // consumeSfixed64Ptr wire decodes a *int64 pointer as a Sfixed64. |
| func consumeSfixed64Ptr(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.Fixed64Type { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed64(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| vp := p.Int64Ptr() |
| if *vp == nil { |
| *vp = new(int64) |
| } |
| **vp = int64(v) |
| return n, nil |
| } |
| |
| var coderSfixed64Ptr = pointerCoderFuncs{ |
| size: sizeSfixed64Ptr, |
| marshal: appendSfixed64Ptr, |
| unmarshal: consumeSfixed64Ptr, |
| } |
| |
| // sizeSfixed64Slice returns the size of wire encoding a []int64 pointer as a repeated Sfixed64. |
| func sizeSfixed64Slice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Int64Slice() |
| size = len(s) * (tagsize + wire.SizeFixed64()) |
| return size |
| } |
| |
| // appendSfixed64Slice encodes a []int64 pointer as a repeated Sfixed64. |
| func appendSfixed64Slice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Int64Slice() |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed64(b, uint64(v)) |
| } |
| return b, nil |
| } |
| |
| // consumeSfixed64Slice wire decodes a []int64 pointer as a repeated Sfixed64. |
| func consumeSfixed64Slice(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| sp := p.Int64Slice() |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeFixed64(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| s = append(s, int64(v)) |
| b = b[n:] |
| } |
| *sp = s |
| return n, nil |
| } |
| if wtyp != wire.Fixed64Type { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed64(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, int64(v)) |
| return n, nil |
| } |
| |
| var coderSfixed64Slice = pointerCoderFuncs{ |
| size: sizeSfixed64Slice, |
| marshal: appendSfixed64Slice, |
| unmarshal: consumeSfixed64Slice, |
| } |
| |
| // sizeSfixed64PackedSlice returns the size of wire encoding a []int64 pointer as a packed repeated Sfixed64. |
| func sizeSfixed64PackedSlice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Int64Slice() |
| if len(s) == 0 { |
| return 0 |
| } |
| n := len(s) * wire.SizeFixed64() |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendSfixed64PackedSlice encodes a []int64 pointer as a packed repeated Sfixed64. |
| func appendSfixed64PackedSlice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Int64Slice() |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := len(s) * wire.SizeFixed64() |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendFixed64(b, uint64(v)) |
| } |
| return b, nil |
| } |
| |
| var coderSfixed64PackedSlice = pointerCoderFuncs{ |
| size: sizeSfixed64PackedSlice, |
| marshal: appendSfixed64PackedSlice, |
| unmarshal: consumeSfixed64Slice, |
| } |
| |
| // sizeSfixed64Iface returns the size of wire encoding a int64 value as a Sfixed64. |
| func sizeSfixed64Iface(ival interface{}, tagsize int, _ marshalOptions) int { |
| return tagsize + wire.SizeFixed64() |
| } |
| |
| // appendSfixed64Iface encodes a int64 value as a Sfixed64. |
| func appendSfixed64Iface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := ival.(int64) |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed64(b, uint64(v)) |
| return b, nil |
| } |
| |
| // consumeSfixed64Iface decodes a int64 value as a Sfixed64. |
| func consumeSfixed64Iface(b []byte, _ interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (interface{}, int, error) { |
| if wtyp != wire.Fixed64Type { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed64(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| return int64(v), n, nil |
| } |
| |
| var coderSfixed64Iface = ifaceCoderFuncs{ |
| size: sizeSfixed64Iface, |
| marshal: appendSfixed64Iface, |
| unmarshal: consumeSfixed64Iface, |
| } |
| |
| // sizeSfixed64SliceIface returns the size of wire encoding a []int64 value as a repeated Sfixed64. |
| func sizeSfixed64SliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]int64) |
| size = len(s) * (tagsize + wire.SizeFixed64()) |
| return size |
| } |
| |
| // appendSfixed64SliceIface encodes a []int64 value as a repeated Sfixed64. |
| func appendSfixed64SliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]int64) |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed64(b, uint64(v)) |
| } |
| return b, nil |
| } |
| |
| // consumeSfixed64SliceIface wire decodes a []int64 value as a repeated Sfixed64. |
| func consumeSfixed64SliceIface(b []byte, ival interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ interface{}, n int, err error) { |
| sp := ival.(*[]int64) |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeFixed64(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| s = append(s, int64(v)) |
| b = b[n:] |
| } |
| *sp = s |
| return ival, n, nil |
| } |
| if wtyp != wire.Fixed64Type { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed64(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, int64(v)) |
| return ival, n, nil |
| } |
| |
| var coderSfixed64SliceIface = ifaceCoderFuncs{ |
| size: sizeSfixed64SliceIface, |
| marshal: appendSfixed64SliceIface, |
| unmarshal: consumeSfixed64SliceIface, |
| } |
| |
| // sizeSfixed64PackedSliceIface returns the size of wire encoding a []int64 value as a packed repeated Sfixed64. |
| func sizeSfixed64PackedSliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]int64) |
| if len(s) == 0 { |
| return 0 |
| } |
| n := len(s) * wire.SizeFixed64() |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendSfixed64PackedSliceIface encodes a []int64 value as a packed repeated Sfixed64. |
| func appendSfixed64PackedSliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]int64) |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := len(s) * wire.SizeFixed64() |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendFixed64(b, uint64(v)) |
| } |
| return b, nil |
| } |
| |
| var coderSfixed64PackedSliceIface = ifaceCoderFuncs{ |
| size: sizeSfixed64PackedSliceIface, |
| marshal: appendSfixed64PackedSliceIface, |
| unmarshal: consumeSfixed64SliceIface, |
| } |
| |
| // sizeFixed64 returns the size of wire encoding a uint64 pointer as a Fixed64. |
| func sizeFixed64(p pointer, tagsize int, _ marshalOptions) (size int) { |
| |
| return tagsize + wire.SizeFixed64() |
| } |
| |
| // appendFixed64 wire encodes a uint64 pointer as a Fixed64. |
| func appendFixed64(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Uint64() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed64(b, v) |
| return b, nil |
| } |
| |
| // consumeFixed64 wire decodes a uint64 pointer as a Fixed64. |
| func consumeFixed64(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.Fixed64Type { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed64(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *p.Uint64() = v |
| return n, nil |
| } |
| |
| var coderFixed64 = pointerCoderFuncs{ |
| size: sizeFixed64, |
| marshal: appendFixed64, |
| unmarshal: consumeFixed64, |
| } |
| |
| // sizeFixed64NoZero returns the size of wire encoding a uint64 pointer as a Fixed64. |
| // The zero value is not encoded. |
| func sizeFixed64NoZero(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Uint64() |
| if v == 0 { |
| return 0 |
| } |
| return tagsize + wire.SizeFixed64() |
| } |
| |
| // appendFixed64NoZero wire encodes a uint64 pointer as a Fixed64. |
| // The zero value is not encoded. |
| func appendFixed64NoZero(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Uint64() |
| if v == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed64(b, v) |
| return b, nil |
| } |
| |
| var coderFixed64NoZero = pointerCoderFuncs{ |
| size: sizeFixed64NoZero, |
| marshal: appendFixed64NoZero, |
| unmarshal: consumeFixed64, |
| } |
| |
| // sizeFixed64Ptr returns the size of wire encoding a *uint64 pointer as a Fixed64. |
| // It panics if the pointer is nil. |
| func sizeFixed64Ptr(p pointer, tagsize int, _ marshalOptions) (size int) { |
| return tagsize + wire.SizeFixed64() |
| } |
| |
| // appendFixed64Ptr wire encodes a *uint64 pointer as a Fixed64. |
| // It panics if the pointer is nil. |
| func appendFixed64Ptr(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := **p.Uint64Ptr() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed64(b, v) |
| return b, nil |
| } |
| |
| // consumeFixed64Ptr wire decodes a *uint64 pointer as a Fixed64. |
| func consumeFixed64Ptr(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.Fixed64Type { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed64(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| vp := p.Uint64Ptr() |
| if *vp == nil { |
| *vp = new(uint64) |
| } |
| **vp = v |
| return n, nil |
| } |
| |
| var coderFixed64Ptr = pointerCoderFuncs{ |
| size: sizeFixed64Ptr, |
| marshal: appendFixed64Ptr, |
| unmarshal: consumeFixed64Ptr, |
| } |
| |
| // sizeFixed64Slice returns the size of wire encoding a []uint64 pointer as a repeated Fixed64. |
| func sizeFixed64Slice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Uint64Slice() |
| size = len(s) * (tagsize + wire.SizeFixed64()) |
| return size |
| } |
| |
| // appendFixed64Slice encodes a []uint64 pointer as a repeated Fixed64. |
| func appendFixed64Slice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Uint64Slice() |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed64(b, v) |
| } |
| return b, nil |
| } |
| |
| // consumeFixed64Slice wire decodes a []uint64 pointer as a repeated Fixed64. |
| func consumeFixed64Slice(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| sp := p.Uint64Slice() |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeFixed64(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| s = append(s, v) |
| b = b[n:] |
| } |
| *sp = s |
| return n, nil |
| } |
| if wtyp != wire.Fixed64Type { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed64(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, v) |
| return n, nil |
| } |
| |
| var coderFixed64Slice = pointerCoderFuncs{ |
| size: sizeFixed64Slice, |
| marshal: appendFixed64Slice, |
| unmarshal: consumeFixed64Slice, |
| } |
| |
| // sizeFixed64PackedSlice returns the size of wire encoding a []uint64 pointer as a packed repeated Fixed64. |
| func sizeFixed64PackedSlice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Uint64Slice() |
| if len(s) == 0 { |
| return 0 |
| } |
| n := len(s) * wire.SizeFixed64() |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendFixed64PackedSlice encodes a []uint64 pointer as a packed repeated Fixed64. |
| func appendFixed64PackedSlice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Uint64Slice() |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := len(s) * wire.SizeFixed64() |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendFixed64(b, v) |
| } |
| return b, nil |
| } |
| |
| var coderFixed64PackedSlice = pointerCoderFuncs{ |
| size: sizeFixed64PackedSlice, |
| marshal: appendFixed64PackedSlice, |
| unmarshal: consumeFixed64Slice, |
| } |
| |
| // sizeFixed64Iface returns the size of wire encoding a uint64 value as a Fixed64. |
| func sizeFixed64Iface(ival interface{}, tagsize int, _ marshalOptions) int { |
| return tagsize + wire.SizeFixed64() |
| } |
| |
| // appendFixed64Iface encodes a uint64 value as a Fixed64. |
| func appendFixed64Iface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := ival.(uint64) |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed64(b, v) |
| return b, nil |
| } |
| |
| // consumeFixed64Iface decodes a uint64 value as a Fixed64. |
| func consumeFixed64Iface(b []byte, _ interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (interface{}, int, error) { |
| if wtyp != wire.Fixed64Type { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed64(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| return v, n, nil |
| } |
| |
| var coderFixed64Iface = ifaceCoderFuncs{ |
| size: sizeFixed64Iface, |
| marshal: appendFixed64Iface, |
| unmarshal: consumeFixed64Iface, |
| } |
| |
| // sizeFixed64SliceIface returns the size of wire encoding a []uint64 value as a repeated Fixed64. |
| func sizeFixed64SliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]uint64) |
| size = len(s) * (tagsize + wire.SizeFixed64()) |
| return size |
| } |
| |
| // appendFixed64SliceIface encodes a []uint64 value as a repeated Fixed64. |
| func appendFixed64SliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]uint64) |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed64(b, v) |
| } |
| return b, nil |
| } |
| |
| // consumeFixed64SliceIface wire decodes a []uint64 value as a repeated Fixed64. |
| func consumeFixed64SliceIface(b []byte, ival interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ interface{}, n int, err error) { |
| sp := ival.(*[]uint64) |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeFixed64(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| s = append(s, v) |
| b = b[n:] |
| } |
| *sp = s |
| return ival, n, nil |
| } |
| if wtyp != wire.Fixed64Type { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed64(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, v) |
| return ival, n, nil |
| } |
| |
| var coderFixed64SliceIface = ifaceCoderFuncs{ |
| size: sizeFixed64SliceIface, |
| marshal: appendFixed64SliceIface, |
| unmarshal: consumeFixed64SliceIface, |
| } |
| |
| // sizeFixed64PackedSliceIface returns the size of wire encoding a []uint64 value as a packed repeated Fixed64. |
| func sizeFixed64PackedSliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]uint64) |
| if len(s) == 0 { |
| return 0 |
| } |
| n := len(s) * wire.SizeFixed64() |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendFixed64PackedSliceIface encodes a []uint64 value as a packed repeated Fixed64. |
| func appendFixed64PackedSliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]uint64) |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := len(s) * wire.SizeFixed64() |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendFixed64(b, v) |
| } |
| return b, nil |
| } |
| |
| var coderFixed64PackedSliceIface = ifaceCoderFuncs{ |
| size: sizeFixed64PackedSliceIface, |
| marshal: appendFixed64PackedSliceIface, |
| unmarshal: consumeFixed64SliceIface, |
| } |
| |
| // sizeDouble returns the size of wire encoding a float64 pointer as a Double. |
| func sizeDouble(p pointer, tagsize int, _ marshalOptions) (size int) { |
| |
| return tagsize + wire.SizeFixed64() |
| } |
| |
| // appendDouble wire encodes a float64 pointer as a Double. |
| func appendDouble(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Float64() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed64(b, math.Float64bits(v)) |
| return b, nil |
| } |
| |
| // consumeDouble wire decodes a float64 pointer as a Double. |
| func consumeDouble(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.Fixed64Type { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed64(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *p.Float64() = math.Float64frombits(v) |
| return n, nil |
| } |
| |
| var coderDouble = pointerCoderFuncs{ |
| size: sizeDouble, |
| marshal: appendDouble, |
| unmarshal: consumeDouble, |
| } |
| |
| // sizeDoubleNoZero returns the size of wire encoding a float64 pointer as a Double. |
| // The zero value is not encoded. |
| func sizeDoubleNoZero(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Float64() |
| if v == 0 && !math.Signbit(float64(v)) { |
| return 0 |
| } |
| return tagsize + wire.SizeFixed64() |
| } |
| |
| // appendDoubleNoZero wire encodes a float64 pointer as a Double. |
| // The zero value is not encoded. |
| func appendDoubleNoZero(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Float64() |
| if v == 0 && !math.Signbit(float64(v)) { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed64(b, math.Float64bits(v)) |
| return b, nil |
| } |
| |
| var coderDoubleNoZero = pointerCoderFuncs{ |
| size: sizeDoubleNoZero, |
| marshal: appendDoubleNoZero, |
| unmarshal: consumeDouble, |
| } |
| |
| // sizeDoublePtr returns the size of wire encoding a *float64 pointer as a Double. |
| // It panics if the pointer is nil. |
| func sizeDoublePtr(p pointer, tagsize int, _ marshalOptions) (size int) { |
| return tagsize + wire.SizeFixed64() |
| } |
| |
| // appendDoublePtr wire encodes a *float64 pointer as a Double. |
| // It panics if the pointer is nil. |
| func appendDoublePtr(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := **p.Float64Ptr() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed64(b, math.Float64bits(v)) |
| return b, nil |
| } |
| |
| // consumeDoublePtr wire decodes a *float64 pointer as a Double. |
| func consumeDoublePtr(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.Fixed64Type { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed64(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| vp := p.Float64Ptr() |
| if *vp == nil { |
| *vp = new(float64) |
| } |
| **vp = math.Float64frombits(v) |
| return n, nil |
| } |
| |
| var coderDoublePtr = pointerCoderFuncs{ |
| size: sizeDoublePtr, |
| marshal: appendDoublePtr, |
| unmarshal: consumeDoublePtr, |
| } |
| |
| // sizeDoubleSlice returns the size of wire encoding a []float64 pointer as a repeated Double. |
| func sizeDoubleSlice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Float64Slice() |
| size = len(s) * (tagsize + wire.SizeFixed64()) |
| return size |
| } |
| |
| // appendDoubleSlice encodes a []float64 pointer as a repeated Double. |
| func appendDoubleSlice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Float64Slice() |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed64(b, math.Float64bits(v)) |
| } |
| return b, nil |
| } |
| |
| // consumeDoubleSlice wire decodes a []float64 pointer as a repeated Double. |
| func consumeDoubleSlice(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| sp := p.Float64Slice() |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeFixed64(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| s = append(s, math.Float64frombits(v)) |
| b = b[n:] |
| } |
| *sp = s |
| return n, nil |
| } |
| if wtyp != wire.Fixed64Type { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed64(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, math.Float64frombits(v)) |
| return n, nil |
| } |
| |
| var coderDoubleSlice = pointerCoderFuncs{ |
| size: sizeDoubleSlice, |
| marshal: appendDoubleSlice, |
| unmarshal: consumeDoubleSlice, |
| } |
| |
| // sizeDoublePackedSlice returns the size of wire encoding a []float64 pointer as a packed repeated Double. |
| func sizeDoublePackedSlice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.Float64Slice() |
| if len(s) == 0 { |
| return 0 |
| } |
| n := len(s) * wire.SizeFixed64() |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendDoublePackedSlice encodes a []float64 pointer as a packed repeated Double. |
| func appendDoublePackedSlice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.Float64Slice() |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := len(s) * wire.SizeFixed64() |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendFixed64(b, math.Float64bits(v)) |
| } |
| return b, nil |
| } |
| |
| var coderDoublePackedSlice = pointerCoderFuncs{ |
| size: sizeDoublePackedSlice, |
| marshal: appendDoublePackedSlice, |
| unmarshal: consumeDoubleSlice, |
| } |
| |
| // sizeDoubleIface returns the size of wire encoding a float64 value as a Double. |
| func sizeDoubleIface(ival interface{}, tagsize int, _ marshalOptions) int { |
| return tagsize + wire.SizeFixed64() |
| } |
| |
| // appendDoubleIface encodes a float64 value as a Double. |
| func appendDoubleIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := ival.(float64) |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed64(b, math.Float64bits(v)) |
| return b, nil |
| } |
| |
| // consumeDoubleIface decodes a float64 value as a Double. |
| func consumeDoubleIface(b []byte, _ interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (interface{}, int, error) { |
| if wtyp != wire.Fixed64Type { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed64(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| return math.Float64frombits(v), n, nil |
| } |
| |
| var coderDoubleIface = ifaceCoderFuncs{ |
| size: sizeDoubleIface, |
| marshal: appendDoubleIface, |
| unmarshal: consumeDoubleIface, |
| } |
| |
| // sizeDoubleSliceIface returns the size of wire encoding a []float64 value as a repeated Double. |
| func sizeDoubleSliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]float64) |
| size = len(s) * (tagsize + wire.SizeFixed64()) |
| return size |
| } |
| |
| // appendDoubleSliceIface encodes a []float64 value as a repeated Double. |
| func appendDoubleSliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]float64) |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendFixed64(b, math.Float64bits(v)) |
| } |
| return b, nil |
| } |
| |
| // consumeDoubleSliceIface wire decodes a []float64 value as a repeated Double. |
| func consumeDoubleSliceIface(b []byte, ival interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ interface{}, n int, err error) { |
| sp := ival.(*[]float64) |
| if wtyp == wire.BytesType { |
| s := *sp |
| b, n = wire.ConsumeBytes(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| for len(b) > 0 { |
| v, n := wire.ConsumeFixed64(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| s = append(s, math.Float64frombits(v)) |
| b = b[n:] |
| } |
| *sp = s |
| return ival, n, nil |
| } |
| if wtyp != wire.Fixed64Type { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeFixed64(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, math.Float64frombits(v)) |
| return ival, n, nil |
| } |
| |
| var coderDoubleSliceIface = ifaceCoderFuncs{ |
| size: sizeDoubleSliceIface, |
| marshal: appendDoubleSliceIface, |
| unmarshal: consumeDoubleSliceIface, |
| } |
| |
| // sizeDoublePackedSliceIface returns the size of wire encoding a []float64 value as a packed repeated Double. |
| func sizeDoublePackedSliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]float64) |
| if len(s) == 0 { |
| return 0 |
| } |
| n := len(s) * wire.SizeFixed64() |
| return tagsize + wire.SizeBytes(n) |
| } |
| |
| // appendDoublePackedSliceIface encodes a []float64 value as a packed repeated Double. |
| func appendDoublePackedSliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]float64) |
| if len(s) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| n := len(s) * wire.SizeFixed64() |
| b = wire.AppendVarint(b, uint64(n)) |
| for _, v := range s { |
| b = wire.AppendFixed64(b, math.Float64bits(v)) |
| } |
| return b, nil |
| } |
| |
| var coderDoublePackedSliceIface = ifaceCoderFuncs{ |
| size: sizeDoublePackedSliceIface, |
| marshal: appendDoublePackedSliceIface, |
| unmarshal: consumeDoubleSliceIface, |
| } |
| |
| // sizeString returns the size of wire encoding a string pointer as a String. |
| func sizeString(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.String() |
| return tagsize + wire.SizeBytes(len(v)) |
| } |
| |
| // appendString wire encodes a string pointer as a String. |
| func appendString(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.String() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendString(b, v) |
| return b, nil |
| } |
| |
| // consumeString wire decodes a string pointer as a String. |
| func consumeString(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.BytesType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeString(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *p.String() = v |
| return n, nil |
| } |
| |
| var coderString = pointerCoderFuncs{ |
| size: sizeString, |
| marshal: appendString, |
| unmarshal: consumeString, |
| } |
| |
| // appendStringValidateUTF8 wire encodes a string pointer as a String. |
| func appendStringValidateUTF8(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.String() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendString(b, v) |
| if !utf8.ValidString(v) { |
| return b, errInvalidUTF8{} |
| } |
| return b, nil |
| } |
| |
| // consumeStringValidateUTF8 wire decodes a string pointer as a String. |
| func consumeStringValidateUTF8(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.BytesType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeString(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| if !utf8.ValidString(v) { |
| return 0, errInvalidUTF8{} |
| } |
| *p.String() = v |
| return n, nil |
| } |
| |
| var coderStringValidateUTF8 = pointerCoderFuncs{ |
| size: sizeString, |
| marshal: appendStringValidateUTF8, |
| unmarshal: consumeStringValidateUTF8, |
| } |
| |
| // sizeStringNoZero returns the size of wire encoding a string pointer as a String. |
| // The zero value is not encoded. |
| func sizeStringNoZero(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.String() |
| if len(v) == 0 { |
| return 0 |
| } |
| return tagsize + wire.SizeBytes(len(v)) |
| } |
| |
| // appendStringNoZero wire encodes a string pointer as a String. |
| // The zero value is not encoded. |
| func appendStringNoZero(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.String() |
| if len(v) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendString(b, v) |
| return b, nil |
| } |
| |
| var coderStringNoZero = pointerCoderFuncs{ |
| size: sizeStringNoZero, |
| marshal: appendStringNoZero, |
| unmarshal: consumeString, |
| } |
| |
| // appendStringNoZeroValidateUTF8 wire encodes a string pointer as a String. |
| // The zero value is not encoded. |
| func appendStringNoZeroValidateUTF8(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.String() |
| if len(v) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendString(b, v) |
| if !utf8.ValidString(v) { |
| return b, errInvalidUTF8{} |
| } |
| return b, nil |
| } |
| |
| var coderStringNoZeroValidateUTF8 = pointerCoderFuncs{ |
| size: sizeStringNoZero, |
| marshal: appendStringNoZeroValidateUTF8, |
| unmarshal: consumeStringValidateUTF8, |
| } |
| |
| // sizeStringPtr returns the size of wire encoding a *string pointer as a String. |
| // It panics if the pointer is nil. |
| func sizeStringPtr(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := **p.StringPtr() |
| return tagsize + wire.SizeBytes(len(v)) |
| } |
| |
| // appendStringPtr wire encodes a *string pointer as a String. |
| // It panics if the pointer is nil. |
| func appendStringPtr(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := **p.StringPtr() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendString(b, v) |
| return b, nil |
| } |
| |
| // consumeStringPtr wire decodes a *string pointer as a String. |
| func consumeStringPtr(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.BytesType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeString(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| vp := p.StringPtr() |
| if *vp == nil { |
| *vp = new(string) |
| } |
| **vp = v |
| return n, nil |
| } |
| |
| var coderStringPtr = pointerCoderFuncs{ |
| size: sizeStringPtr, |
| marshal: appendStringPtr, |
| unmarshal: consumeStringPtr, |
| } |
| |
| // sizeStringSlice returns the size of wire encoding a []string pointer as a repeated String. |
| func sizeStringSlice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.StringSlice() |
| for _, v := range s { |
| size += tagsize + wire.SizeBytes(len(v)) |
| } |
| return size |
| } |
| |
| // appendStringSlice encodes a []string pointer as a repeated String. |
| func appendStringSlice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.StringSlice() |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendString(b, v) |
| } |
| return b, nil |
| } |
| |
| // consumeStringSlice wire decodes a []string pointer as a repeated String. |
| func consumeStringSlice(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| sp := p.StringSlice() |
| if wtyp != wire.BytesType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeString(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, v) |
| return n, nil |
| } |
| |
| var coderStringSlice = pointerCoderFuncs{ |
| size: sizeStringSlice, |
| marshal: appendStringSlice, |
| unmarshal: consumeStringSlice, |
| } |
| |
| // appendStringSliceValidateUTF8 encodes a []string pointer as a repeated String. |
| func appendStringSliceValidateUTF8(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.StringSlice() |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendString(b, v) |
| if !utf8.ValidString(v) { |
| return b, errInvalidUTF8{} |
| } |
| } |
| return b, nil |
| } |
| |
| // consumeStringSliceValidateUTF8 wire decodes a []string pointer as a repeated String. |
| func consumeStringSliceValidateUTF8(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| sp := p.StringSlice() |
| if wtyp != wire.BytesType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeString(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| if !utf8.ValidString(v) { |
| return 0, errInvalidUTF8{} |
| } |
| *sp = append(*sp, v) |
| return n, nil |
| } |
| |
| var coderStringSliceValidateUTF8 = pointerCoderFuncs{ |
| size: sizeStringSlice, |
| marshal: appendStringSliceValidateUTF8, |
| unmarshal: consumeStringSliceValidateUTF8, |
| } |
| |
| // sizeStringIface returns the size of wire encoding a string value as a String. |
| func sizeStringIface(ival interface{}, tagsize int, _ marshalOptions) int { |
| v := ival.(string) |
| return tagsize + wire.SizeBytes(len(v)) |
| } |
| |
| // appendStringIface encodes a string value as a String. |
| func appendStringIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := ival.(string) |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendString(b, v) |
| return b, nil |
| } |
| |
| // consumeStringIface decodes a string value as a String. |
| func consumeStringIface(b []byte, _ interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (interface{}, int, error) { |
| if wtyp != wire.BytesType { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeString(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| return v, n, nil |
| } |
| |
| var coderStringIface = ifaceCoderFuncs{ |
| size: sizeStringIface, |
| marshal: appendStringIface, |
| unmarshal: consumeStringIface, |
| } |
| |
| // appendStringIfaceValidateUTF8 encodes a string value as a String. |
| func appendStringIfaceValidateUTF8(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := ival.(string) |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendString(b, v) |
| if !utf8.ValidString(v) { |
| return b, errInvalidUTF8{} |
| } |
| return b, nil |
| } |
| |
| // consumeStringIfaceValidateUTF8 decodes a string value as a String. |
| func consumeStringIfaceValidateUTF8(b []byte, _ interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (interface{}, int, error) { |
| if wtyp != wire.BytesType { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeString(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| if !utf8.ValidString(v) { |
| return nil, 0, errInvalidUTF8{} |
| } |
| return v, n, nil |
| } |
| |
| var coderStringIfaceValidateUTF8 = ifaceCoderFuncs{ |
| size: sizeStringIface, |
| marshal: appendStringIfaceValidateUTF8, |
| unmarshal: consumeStringIfaceValidateUTF8, |
| } |
| |
| // sizeStringSliceIface returns the size of wire encoding a []string value as a repeated String. |
| func sizeStringSliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[]string) |
| for _, v := range s { |
| size += tagsize + wire.SizeBytes(len(v)) |
| } |
| return size |
| } |
| |
| // appendStringSliceIface encodes a []string value as a repeated String. |
| func appendStringSliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[]string) |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendString(b, v) |
| } |
| return b, nil |
| } |
| |
| // consumeStringSliceIface wire decodes a []string value as a repeated String. |
| func consumeStringSliceIface(b []byte, ival interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ interface{}, n int, err error) { |
| sp := ival.(*[]string) |
| if wtyp != wire.BytesType { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeString(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, v) |
| return ival, n, nil |
| } |
| |
| var coderStringSliceIface = ifaceCoderFuncs{ |
| size: sizeStringSliceIface, |
| marshal: appendStringSliceIface, |
| unmarshal: consumeStringSliceIface, |
| } |
| |
| // sizeBytes returns the size of wire encoding a []byte pointer as a Bytes. |
| func sizeBytes(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Bytes() |
| return tagsize + wire.SizeBytes(len(v)) |
| } |
| |
| // appendBytes wire encodes a []byte pointer as a Bytes. |
| func appendBytes(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Bytes() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendBytes(b, v) |
| return b, nil |
| } |
| |
| // consumeBytes wire decodes a []byte pointer as a Bytes. |
| func consumeBytes(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.BytesType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeBytes(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *p.Bytes() = append(emptyBuf[:], v...) |
| return n, nil |
| } |
| |
| var coderBytes = pointerCoderFuncs{ |
| size: sizeBytes, |
| marshal: appendBytes, |
| unmarshal: consumeBytes, |
| } |
| |
| // appendBytesValidateUTF8 wire encodes a []byte pointer as a Bytes. |
| func appendBytesValidateUTF8(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Bytes() |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendBytes(b, v) |
| if !utf8.Valid(v) { |
| return b, errInvalidUTF8{} |
| } |
| return b, nil |
| } |
| |
| // consumeBytesValidateUTF8 wire decodes a []byte pointer as a Bytes. |
| func consumeBytesValidateUTF8(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.BytesType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeBytes(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| if !utf8.Valid(v) { |
| return 0, errInvalidUTF8{} |
| } |
| *p.Bytes() = append(emptyBuf[:], v...) |
| return n, nil |
| } |
| |
| var coderBytesValidateUTF8 = pointerCoderFuncs{ |
| size: sizeBytes, |
| marshal: appendBytesValidateUTF8, |
| unmarshal: consumeBytesValidateUTF8, |
| } |
| |
| // sizeBytesNoZero returns the size of wire encoding a []byte pointer as a Bytes. |
| // The zero value is not encoded. |
| func sizeBytesNoZero(p pointer, tagsize int, _ marshalOptions) (size int) { |
| v := *p.Bytes() |
| if len(v) == 0 { |
| return 0 |
| } |
| return tagsize + wire.SizeBytes(len(v)) |
| } |
| |
| // appendBytesNoZero wire encodes a []byte pointer as a Bytes. |
| // The zero value is not encoded. |
| func appendBytesNoZero(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Bytes() |
| if len(v) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendBytes(b, v) |
| return b, nil |
| } |
| |
| // consumeBytesNoZero wire decodes a []byte pointer as a Bytes. |
| // The zero value is not decoded. |
| func consumeBytesNoZero(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.BytesType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeBytes(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *p.Bytes() = append(([]byte)(nil), v...) |
| return n, nil |
| } |
| |
| var coderBytesNoZero = pointerCoderFuncs{ |
| size: sizeBytesNoZero, |
| marshal: appendBytesNoZero, |
| unmarshal: consumeBytesNoZero, |
| } |
| |
| // appendBytesNoZeroValidateUTF8 wire encodes a []byte pointer as a Bytes. |
| // The zero value is not encoded. |
| func appendBytesNoZeroValidateUTF8(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := *p.Bytes() |
| if len(v) == 0 { |
| return b, nil |
| } |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendBytes(b, v) |
| if !utf8.Valid(v) { |
| return b, errInvalidUTF8{} |
| } |
| return b, nil |
| } |
| |
| // consumeBytesNoZeroValidateUTF8 wire decodes a []byte pointer as a Bytes. |
| func consumeBytesNoZeroValidateUTF8(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| if wtyp != wire.BytesType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeBytes(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| if !utf8.Valid(v) { |
| return 0, errInvalidUTF8{} |
| } |
| *p.Bytes() = append(([]byte)(nil), v...) |
| return n, nil |
| } |
| |
| var coderBytesNoZeroValidateUTF8 = pointerCoderFuncs{ |
| size: sizeBytesNoZero, |
| marshal: appendBytesNoZeroValidateUTF8, |
| unmarshal: consumeBytesNoZeroValidateUTF8, |
| } |
| |
| // sizeBytesSlice returns the size of wire encoding a [][]byte pointer as a repeated Bytes. |
| func sizeBytesSlice(p pointer, tagsize int, _ marshalOptions) (size int) { |
| s := *p.BytesSlice() |
| for _, v := range s { |
| size += tagsize + wire.SizeBytes(len(v)) |
| } |
| return size |
| } |
| |
| // appendBytesSlice encodes a [][]byte pointer as a repeated Bytes. |
| func appendBytesSlice(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.BytesSlice() |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendBytes(b, v) |
| } |
| return b, nil |
| } |
| |
| // consumeBytesSlice wire decodes a [][]byte pointer as a repeated Bytes. |
| func consumeBytesSlice(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| sp := p.BytesSlice() |
| if wtyp != wire.BytesType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeBytes(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, append(emptyBuf[:], v...)) |
| return n, nil |
| } |
| |
| var coderBytesSlice = pointerCoderFuncs{ |
| size: sizeBytesSlice, |
| marshal: appendBytesSlice, |
| unmarshal: consumeBytesSlice, |
| } |
| |
| // appendBytesSliceValidateUTF8 encodes a [][]byte pointer as a repeated Bytes. |
| func appendBytesSliceValidateUTF8(b []byte, p pointer, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *p.BytesSlice() |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendBytes(b, v) |
| if !utf8.Valid(v) { |
| return b, errInvalidUTF8{} |
| } |
| } |
| return b, nil |
| } |
| |
| // consumeBytesSliceValidateUTF8 wire decodes a [][]byte pointer as a repeated Bytes. |
| func consumeBytesSliceValidateUTF8(b []byte, p pointer, wtyp wire.Type, _ unmarshalOptions) (n int, err error) { |
| sp := p.BytesSlice() |
| if wtyp != wire.BytesType { |
| return 0, errUnknown |
| } |
| v, n := wire.ConsumeBytes(b) |
| if n < 0 { |
| return 0, wire.ParseError(n) |
| } |
| if !utf8.Valid(v) { |
| return 0, errInvalidUTF8{} |
| } |
| *sp = append(*sp, append(emptyBuf[:], v...)) |
| return n, nil |
| } |
| |
| var coderBytesSliceValidateUTF8 = pointerCoderFuncs{ |
| size: sizeBytesSlice, |
| marshal: appendBytesSliceValidateUTF8, |
| unmarshal: consumeBytesSliceValidateUTF8, |
| } |
| |
| // sizeBytesIface returns the size of wire encoding a []byte value as a Bytes. |
| func sizeBytesIface(ival interface{}, tagsize int, _ marshalOptions) int { |
| v := ival.([]byte) |
| return tagsize + wire.SizeBytes(len(v)) |
| } |
| |
| // appendBytesIface encodes a []byte value as a Bytes. |
| func appendBytesIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := ival.([]byte) |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendBytes(b, v) |
| return b, nil |
| } |
| |
| // consumeBytesIface decodes a []byte value as a Bytes. |
| func consumeBytesIface(b []byte, _ interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (interface{}, int, error) { |
| if wtyp != wire.BytesType { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeBytes(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| return append(emptyBuf[:], v...), n, nil |
| } |
| |
| var coderBytesIface = ifaceCoderFuncs{ |
| size: sizeBytesIface, |
| marshal: appendBytesIface, |
| unmarshal: consumeBytesIface, |
| } |
| |
| // appendBytesIfaceValidateUTF8 encodes a []byte value as a Bytes. |
| func appendBytesIfaceValidateUTF8(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| v := ival.([]byte) |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendBytes(b, v) |
| if !utf8.Valid(v) { |
| return b, errInvalidUTF8{} |
| } |
| return b, nil |
| } |
| |
| // consumeBytesIfaceValidateUTF8 decodes a []byte value as a Bytes. |
| func consumeBytesIfaceValidateUTF8(b []byte, _ interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (interface{}, int, error) { |
| if wtyp != wire.BytesType { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeBytes(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| if !utf8.Valid(v) { |
| return nil, 0, errInvalidUTF8{} |
| } |
| return append(emptyBuf[:], v...), n, nil |
| } |
| |
| var coderBytesIfaceValidateUTF8 = ifaceCoderFuncs{ |
| size: sizeBytesIface, |
| marshal: appendBytesIfaceValidateUTF8, |
| unmarshal: consumeBytesIfaceValidateUTF8, |
| } |
| |
| // sizeBytesSliceIface returns the size of wire encoding a [][]byte value as a repeated Bytes. |
| func sizeBytesSliceIface(ival interface{}, tagsize int, _ marshalOptions) (size int) { |
| s := *ival.(*[][]byte) |
| for _, v := range s { |
| size += tagsize + wire.SizeBytes(len(v)) |
| } |
| return size |
| } |
| |
| // appendBytesSliceIface encodes a [][]byte value as a repeated Bytes. |
| func appendBytesSliceIface(b []byte, ival interface{}, wiretag uint64, _ marshalOptions) ([]byte, error) { |
| s := *ival.(*[][]byte) |
| for _, v := range s { |
| b = wire.AppendVarint(b, wiretag) |
| b = wire.AppendBytes(b, v) |
| } |
| return b, nil |
| } |
| |
| // consumeBytesSliceIface wire decodes a [][]byte value as a repeated Bytes. |
| func consumeBytesSliceIface(b []byte, ival interface{}, _ wire.Number, wtyp wire.Type, _ unmarshalOptions) (_ interface{}, n int, err error) { |
| sp := ival.(*[][]byte) |
| if wtyp != wire.BytesType { |
| return nil, 0, errUnknown |
| } |
| v, n := wire.ConsumeBytes(b) |
| if n < 0 { |
| return nil, 0, wire.ParseError(n) |
| } |
| *sp = append(*sp, append(emptyBuf[:], v...)) |
| return ival, n, nil |
| } |
| |
| var coderBytesSliceIface = ifaceCoderFuncs{ |
| size: sizeBytesSliceIface, |
| marshal: appendBytesSliceIface, |
| unmarshal: consumeBytesSliceIface, |
| } |
| |
| // We append to an empty array rather than a nil []byte to get non-nil zero-length byte slices. |
| var emptyBuf [0]byte |
| |
| var wireTypes = map[protoreflect.Kind]wire.Type{ |
| protoreflect.BoolKind: wire.VarintType, |
| protoreflect.EnumKind: wire.VarintType, |
| protoreflect.Int32Kind: wire.VarintType, |
| protoreflect.Sint32Kind: wire.VarintType, |
| protoreflect.Uint32Kind: wire.VarintType, |
| protoreflect.Int64Kind: wire.VarintType, |
| protoreflect.Sint64Kind: wire.VarintType, |
| protoreflect.Uint64Kind: wire.VarintType, |
| protoreflect.Sfixed32Kind: wire.Fixed32Type, |
| protoreflect.Fixed32Kind: wire.Fixed32Type, |
| protoreflect.FloatKind: wire.Fixed32Type, |
| protoreflect.Sfixed64Kind: wire.Fixed64Type, |
| protoreflect.Fixed64Kind: wire.Fixed64Type, |
| protoreflect.DoubleKind: wire.Fixed64Type, |
| protoreflect.StringKind: wire.BytesType, |
| protoreflect.BytesKind: wire.BytesType, |
| protoreflect.MessageKind: wire.BytesType, |
| protoreflect.GroupKind: wire.StartGroupType, |
| } |