1118 lines
23 KiB
Go
1118 lines
23 KiB
Go
package roaring
|
|
|
|
// NOTE: THIS FILE WAS PRODUCED BY THE
|
|
// MSGP CODE GENERATION TOOL (github.com/tinylib/msgp)
|
|
// DO NOT EDIT
|
|
|
|
import "github.com/tinylib/msgp/msgp"
|
|
|
|
// DecodeMsg implements msgp.Decodable
|
|
func (z *addHelper32) DecodeMsg(dc *msgp.Reader) (err error) {
|
|
var field []byte
|
|
_ = field
|
|
var zbai uint32
|
|
zbai, err = dc.ReadMapHeader()
|
|
if err != nil {
|
|
return
|
|
}
|
|
for zbai > 0 {
|
|
zbai--
|
|
field, err = dc.ReadMapKeyPtr()
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch msgp.UnsafeString(field) {
|
|
case "runstart":
|
|
z.runstart, err = dc.ReadUint32()
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "runlen":
|
|
z.runlen, err = dc.ReadUint32()
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "actuallyAdded":
|
|
z.actuallyAdded, err = dc.ReadUint32()
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "m":
|
|
var zcmr uint32
|
|
zcmr, err = dc.ReadArrayHeader()
|
|
if err != nil {
|
|
return
|
|
}
|
|
if cap(z.m) >= int(zcmr) {
|
|
z.m = (z.m)[:zcmr]
|
|
} else {
|
|
z.m = make([]interval32, zcmr)
|
|
}
|
|
for zxvk := range z.m {
|
|
var zajw uint32
|
|
zajw, err = dc.ReadMapHeader()
|
|
if err != nil {
|
|
return
|
|
}
|
|
for zajw > 0 {
|
|
zajw--
|
|
field, err = dc.ReadMapKeyPtr()
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch msgp.UnsafeString(field) {
|
|
case "start":
|
|
z.m[zxvk].start, err = dc.ReadUint32()
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "last":
|
|
z.m[zxvk].last, err = dc.ReadUint32()
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
err = dc.Skip()
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
case "rc":
|
|
if dc.IsNil() {
|
|
err = dc.ReadNil()
|
|
if err != nil {
|
|
return
|
|
}
|
|
z.rc = nil
|
|
} else {
|
|
if z.rc == nil {
|
|
z.rc = new(runContainer32)
|
|
}
|
|
var zwht uint32
|
|
zwht, err = dc.ReadMapHeader()
|
|
if err != nil {
|
|
return
|
|
}
|
|
for zwht > 0 {
|
|
zwht--
|
|
field, err = dc.ReadMapKeyPtr()
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch msgp.UnsafeString(field) {
|
|
case "iv":
|
|
var zhct uint32
|
|
zhct, err = dc.ReadArrayHeader()
|
|
if err != nil {
|
|
return
|
|
}
|
|
if cap(z.rc.iv) >= int(zhct) {
|
|
z.rc.iv = (z.rc.iv)[:zhct]
|
|
} else {
|
|
z.rc.iv = make([]interval32, zhct)
|
|
}
|
|
for zbzg := range z.rc.iv {
|
|
var zcua uint32
|
|
zcua, err = dc.ReadMapHeader()
|
|
if err != nil {
|
|
return
|
|
}
|
|
for zcua > 0 {
|
|
zcua--
|
|
field, err = dc.ReadMapKeyPtr()
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch msgp.UnsafeString(field) {
|
|
case "start":
|
|
z.rc.iv[zbzg].start, err = dc.ReadUint32()
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "last":
|
|
z.rc.iv[zbzg].last, err = dc.ReadUint32()
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
err = dc.Skip()
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
case "card":
|
|
z.rc.card, err = dc.ReadInt64()
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
err = dc.Skip()
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
default:
|
|
err = dc.Skip()
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// EncodeMsg implements msgp.Encodable
|
|
func (z *addHelper32) EncodeMsg(en *msgp.Writer) (err error) {
|
|
// map header, size 5
|
|
// write "runstart"
|
|
err = en.Append(0x85, 0xa8, 0x72, 0x75, 0x6e, 0x73, 0x74, 0x61, 0x72, 0x74)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = en.WriteUint32(z.runstart)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// write "runlen"
|
|
err = en.Append(0xa6, 0x72, 0x75, 0x6e, 0x6c, 0x65, 0x6e)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = en.WriteUint32(z.runlen)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// write "actuallyAdded"
|
|
err = en.Append(0xad, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x41, 0x64, 0x64, 0x65, 0x64)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = en.WriteUint32(z.actuallyAdded)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// write "m"
|
|
err = en.Append(0xa1, 0x6d)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = en.WriteArrayHeader(uint32(len(z.m)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for zxvk := range z.m {
|
|
// map header, size 2
|
|
// write "start"
|
|
err = en.Append(0x82, 0xa5, 0x73, 0x74, 0x61, 0x72, 0x74)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = en.WriteUint32(z.m[zxvk].start)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// write "last"
|
|
err = en.Append(0xa4, 0x6c, 0x61, 0x73, 0x74)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = en.WriteUint32(z.m[zxvk].last)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
// write "rc"
|
|
err = en.Append(0xa2, 0x72, 0x63)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if z.rc == nil {
|
|
err = en.WriteNil()
|
|
if err != nil {
|
|
return
|
|
}
|
|
} else {
|
|
// map header, size 2
|
|
// write "iv"
|
|
err = en.Append(0x82, 0xa2, 0x69, 0x76)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = en.WriteArrayHeader(uint32(len(z.rc.iv)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for zbzg := range z.rc.iv {
|
|
// map header, size 2
|
|
// write "start"
|
|
err = en.Append(0x82, 0xa5, 0x73, 0x74, 0x61, 0x72, 0x74)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = en.WriteUint32(z.rc.iv[zbzg].start)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// write "last"
|
|
err = en.Append(0xa4, 0x6c, 0x61, 0x73, 0x74)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = en.WriteUint32(z.rc.iv[zbzg].last)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
// write "card"
|
|
err = en.Append(0xa4, 0x63, 0x61, 0x72, 0x64)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = en.WriteInt64(z.rc.card)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// MarshalMsg implements msgp.Marshaler
|
|
func (z *addHelper32) MarshalMsg(b []byte) (o []byte, err error) {
|
|
o = msgp.Require(b, z.Msgsize())
|
|
// map header, size 5
|
|
// string "runstart"
|
|
o = append(o, 0x85, 0xa8, 0x72, 0x75, 0x6e, 0x73, 0x74, 0x61, 0x72, 0x74)
|
|
o = msgp.AppendUint32(o, z.runstart)
|
|
// string "runlen"
|
|
o = append(o, 0xa6, 0x72, 0x75, 0x6e, 0x6c, 0x65, 0x6e)
|
|
o = msgp.AppendUint32(o, z.runlen)
|
|
// string "actuallyAdded"
|
|
o = append(o, 0xad, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x41, 0x64, 0x64, 0x65, 0x64)
|
|
o = msgp.AppendUint32(o, z.actuallyAdded)
|
|
// string "m"
|
|
o = append(o, 0xa1, 0x6d)
|
|
o = msgp.AppendArrayHeader(o, uint32(len(z.m)))
|
|
for zxvk := range z.m {
|
|
// map header, size 2
|
|
// string "start"
|
|
o = append(o, 0x82, 0xa5, 0x73, 0x74, 0x61, 0x72, 0x74)
|
|
o = msgp.AppendUint32(o, z.m[zxvk].start)
|
|
// string "last"
|
|
o = append(o, 0xa4, 0x6c, 0x61, 0x73, 0x74)
|
|
o = msgp.AppendUint32(o, z.m[zxvk].last)
|
|
}
|
|
// string "rc"
|
|
o = append(o, 0xa2, 0x72, 0x63)
|
|
if z.rc == nil {
|
|
o = msgp.AppendNil(o)
|
|
} else {
|
|
// map header, size 2
|
|
// string "iv"
|
|
o = append(o, 0x82, 0xa2, 0x69, 0x76)
|
|
o = msgp.AppendArrayHeader(o, uint32(len(z.rc.iv)))
|
|
for zbzg := range z.rc.iv {
|
|
// map header, size 2
|
|
// string "start"
|
|
o = append(o, 0x82, 0xa5, 0x73, 0x74, 0x61, 0x72, 0x74)
|
|
o = msgp.AppendUint32(o, z.rc.iv[zbzg].start)
|
|
// string "last"
|
|
o = append(o, 0xa4, 0x6c, 0x61, 0x73, 0x74)
|
|
o = msgp.AppendUint32(o, z.rc.iv[zbzg].last)
|
|
}
|
|
// string "card"
|
|
o = append(o, 0xa4, 0x63, 0x61, 0x72, 0x64)
|
|
o = msgp.AppendInt64(o, z.rc.card)
|
|
}
|
|
return
|
|
}
|
|
|
|
// UnmarshalMsg implements msgp.Unmarshaler
|
|
func (z *addHelper32) UnmarshalMsg(bts []byte) (o []byte, err error) {
|
|
var field []byte
|
|
_ = field
|
|
var zxhx uint32
|
|
zxhx, bts, err = msgp.ReadMapHeaderBytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for zxhx > 0 {
|
|
zxhx--
|
|
field, bts, err = msgp.ReadMapKeyZC(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch msgp.UnsafeString(field) {
|
|
case "runstart":
|
|
z.runstart, bts, err = msgp.ReadUint32Bytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "runlen":
|
|
z.runlen, bts, err = msgp.ReadUint32Bytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "actuallyAdded":
|
|
z.actuallyAdded, bts, err = msgp.ReadUint32Bytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "m":
|
|
var zlqf uint32
|
|
zlqf, bts, err = msgp.ReadArrayHeaderBytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if cap(z.m) >= int(zlqf) {
|
|
z.m = (z.m)[:zlqf]
|
|
} else {
|
|
z.m = make([]interval32, zlqf)
|
|
}
|
|
for zxvk := range z.m {
|
|
var zdaf uint32
|
|
zdaf, bts, err = msgp.ReadMapHeaderBytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for zdaf > 0 {
|
|
zdaf--
|
|
field, bts, err = msgp.ReadMapKeyZC(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch msgp.UnsafeString(field) {
|
|
case "start":
|
|
z.m[zxvk].start, bts, err = msgp.ReadUint32Bytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "last":
|
|
z.m[zxvk].last, bts, err = msgp.ReadUint32Bytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
bts, err = msgp.Skip(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
case "rc":
|
|
if msgp.IsNil(bts) {
|
|
bts, err = msgp.ReadNilBytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
z.rc = nil
|
|
} else {
|
|
if z.rc == nil {
|
|
z.rc = new(runContainer32)
|
|
}
|
|
var zpks uint32
|
|
zpks, bts, err = msgp.ReadMapHeaderBytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for zpks > 0 {
|
|
zpks--
|
|
field, bts, err = msgp.ReadMapKeyZC(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch msgp.UnsafeString(field) {
|
|
case "iv":
|
|
var zjfb uint32
|
|
zjfb, bts, err = msgp.ReadArrayHeaderBytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if cap(z.rc.iv) >= int(zjfb) {
|
|
z.rc.iv = (z.rc.iv)[:zjfb]
|
|
} else {
|
|
z.rc.iv = make([]interval32, zjfb)
|
|
}
|
|
for zbzg := range z.rc.iv {
|
|
var zcxo uint32
|
|
zcxo, bts, err = msgp.ReadMapHeaderBytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for zcxo > 0 {
|
|
zcxo--
|
|
field, bts, err = msgp.ReadMapKeyZC(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch msgp.UnsafeString(field) {
|
|
case "start":
|
|
z.rc.iv[zbzg].start, bts, err = msgp.ReadUint32Bytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "last":
|
|
z.rc.iv[zbzg].last, bts, err = msgp.ReadUint32Bytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
bts, err = msgp.Skip(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
case "card":
|
|
z.rc.card, bts, err = msgp.ReadInt64Bytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
bts, err = msgp.Skip(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
default:
|
|
bts, err = msgp.Skip(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
o = bts
|
|
return
|
|
}
|
|
|
|
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
|
|
func (z *addHelper32) Msgsize() (s int) {
|
|
s = 1 + 9 + msgp.Uint32Size + 7 + msgp.Uint32Size + 14 + msgp.Uint32Size + 2 + msgp.ArrayHeaderSize + (len(z.m) * (12 + msgp.Uint32Size + msgp.Uint32Size)) + 3
|
|
if z.rc == nil {
|
|
s += msgp.NilSize
|
|
} else {
|
|
s += 1 + 3 + msgp.ArrayHeaderSize + (len(z.rc.iv) * (12 + msgp.Uint32Size + msgp.Uint32Size)) + 5 + msgp.Int64Size
|
|
}
|
|
return
|
|
}
|
|
|
|
// DecodeMsg implements msgp.Decodable
|
|
func (z *interval32) DecodeMsg(dc *msgp.Reader) (err error) {
|
|
var field []byte
|
|
_ = field
|
|
var zeff uint32
|
|
zeff, err = dc.ReadMapHeader()
|
|
if err != nil {
|
|
return
|
|
}
|
|
for zeff > 0 {
|
|
zeff--
|
|
field, err = dc.ReadMapKeyPtr()
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch msgp.UnsafeString(field) {
|
|
case "start":
|
|
z.start, err = dc.ReadUint32()
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "last":
|
|
z.last, err = dc.ReadUint32()
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
err = dc.Skip()
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// EncodeMsg implements msgp.Encodable
|
|
func (z interval32) EncodeMsg(en *msgp.Writer) (err error) {
|
|
// map header, size 2
|
|
// write "start"
|
|
err = en.Append(0x82, 0xa5, 0x73, 0x74, 0x61, 0x72, 0x74)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = en.WriteUint32(z.start)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// write "last"
|
|
err = en.Append(0xa4, 0x6c, 0x61, 0x73, 0x74)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = en.WriteUint32(z.last)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// MarshalMsg implements msgp.Marshaler
|
|
func (z interval32) MarshalMsg(b []byte) (o []byte, err error) {
|
|
o = msgp.Require(b, z.Msgsize())
|
|
// map header, size 2
|
|
// string "start"
|
|
o = append(o, 0x82, 0xa5, 0x73, 0x74, 0x61, 0x72, 0x74)
|
|
o = msgp.AppendUint32(o, z.start)
|
|
// string "last"
|
|
o = append(o, 0xa4, 0x6c, 0x61, 0x73, 0x74)
|
|
o = msgp.AppendUint32(o, z.last)
|
|
return
|
|
}
|
|
|
|
// UnmarshalMsg implements msgp.Unmarshaler
|
|
func (z *interval32) UnmarshalMsg(bts []byte) (o []byte, err error) {
|
|
var field []byte
|
|
_ = field
|
|
var zrsw uint32
|
|
zrsw, bts, err = msgp.ReadMapHeaderBytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for zrsw > 0 {
|
|
zrsw--
|
|
field, bts, err = msgp.ReadMapKeyZC(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch msgp.UnsafeString(field) {
|
|
case "start":
|
|
z.start, bts, err = msgp.ReadUint32Bytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "last":
|
|
z.last, bts, err = msgp.ReadUint32Bytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
bts, err = msgp.Skip(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
o = bts
|
|
return
|
|
}
|
|
|
|
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
|
|
func (z interval32) Msgsize() (s int) {
|
|
s = 1 + 6 + msgp.Uint32Size + 5 + msgp.Uint32Size
|
|
return
|
|
}
|
|
|
|
// DecodeMsg implements msgp.Decodable
|
|
func (z *runContainer32) DecodeMsg(dc *msgp.Reader) (err error) {
|
|
var field []byte
|
|
_ = field
|
|
var zdnj uint32
|
|
zdnj, err = dc.ReadMapHeader()
|
|
if err != nil {
|
|
return
|
|
}
|
|
for zdnj > 0 {
|
|
zdnj--
|
|
field, err = dc.ReadMapKeyPtr()
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch msgp.UnsafeString(field) {
|
|
case "iv":
|
|
var zobc uint32
|
|
zobc, err = dc.ReadArrayHeader()
|
|
if err != nil {
|
|
return
|
|
}
|
|
if cap(z.iv) >= int(zobc) {
|
|
z.iv = (z.iv)[:zobc]
|
|
} else {
|
|
z.iv = make([]interval32, zobc)
|
|
}
|
|
for zxpk := range z.iv {
|
|
var zsnv uint32
|
|
zsnv, err = dc.ReadMapHeader()
|
|
if err != nil {
|
|
return
|
|
}
|
|
for zsnv > 0 {
|
|
zsnv--
|
|
field, err = dc.ReadMapKeyPtr()
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch msgp.UnsafeString(field) {
|
|
case "start":
|
|
z.iv[zxpk].start, err = dc.ReadUint32()
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "last":
|
|
z.iv[zxpk].last, err = dc.ReadUint32()
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
err = dc.Skip()
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
case "card":
|
|
z.card, err = dc.ReadInt64()
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
err = dc.Skip()
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// EncodeMsg implements msgp.Encodable
|
|
func (z *runContainer32) EncodeMsg(en *msgp.Writer) (err error) {
|
|
// map header, size 2
|
|
// write "iv"
|
|
err = en.Append(0x82, 0xa2, 0x69, 0x76)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = en.WriteArrayHeader(uint32(len(z.iv)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for zxpk := range z.iv {
|
|
// map header, size 2
|
|
// write "start"
|
|
err = en.Append(0x82, 0xa5, 0x73, 0x74, 0x61, 0x72, 0x74)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = en.WriteUint32(z.iv[zxpk].start)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// write "last"
|
|
err = en.Append(0xa4, 0x6c, 0x61, 0x73, 0x74)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = en.WriteUint32(z.iv[zxpk].last)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
// write "card"
|
|
err = en.Append(0xa4, 0x63, 0x61, 0x72, 0x64)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = en.WriteInt64(z.card)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// MarshalMsg implements msgp.Marshaler
|
|
func (z *runContainer32) MarshalMsg(b []byte) (o []byte, err error) {
|
|
o = msgp.Require(b, z.Msgsize())
|
|
// map header, size 2
|
|
// string "iv"
|
|
o = append(o, 0x82, 0xa2, 0x69, 0x76)
|
|
o = msgp.AppendArrayHeader(o, uint32(len(z.iv)))
|
|
for zxpk := range z.iv {
|
|
// map header, size 2
|
|
// string "start"
|
|
o = append(o, 0x82, 0xa5, 0x73, 0x74, 0x61, 0x72, 0x74)
|
|
o = msgp.AppendUint32(o, z.iv[zxpk].start)
|
|
// string "last"
|
|
o = append(o, 0xa4, 0x6c, 0x61, 0x73, 0x74)
|
|
o = msgp.AppendUint32(o, z.iv[zxpk].last)
|
|
}
|
|
// string "card"
|
|
o = append(o, 0xa4, 0x63, 0x61, 0x72, 0x64)
|
|
o = msgp.AppendInt64(o, z.card)
|
|
return
|
|
}
|
|
|
|
// UnmarshalMsg implements msgp.Unmarshaler
|
|
func (z *runContainer32) UnmarshalMsg(bts []byte) (o []byte, err error) {
|
|
var field []byte
|
|
_ = field
|
|
var zkgt uint32
|
|
zkgt, bts, err = msgp.ReadMapHeaderBytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for zkgt > 0 {
|
|
zkgt--
|
|
field, bts, err = msgp.ReadMapKeyZC(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch msgp.UnsafeString(field) {
|
|
case "iv":
|
|
var zema uint32
|
|
zema, bts, err = msgp.ReadArrayHeaderBytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if cap(z.iv) >= int(zema) {
|
|
z.iv = (z.iv)[:zema]
|
|
} else {
|
|
z.iv = make([]interval32, zema)
|
|
}
|
|
for zxpk := range z.iv {
|
|
var zpez uint32
|
|
zpez, bts, err = msgp.ReadMapHeaderBytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for zpez > 0 {
|
|
zpez--
|
|
field, bts, err = msgp.ReadMapKeyZC(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch msgp.UnsafeString(field) {
|
|
case "start":
|
|
z.iv[zxpk].start, bts, err = msgp.ReadUint32Bytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "last":
|
|
z.iv[zxpk].last, bts, err = msgp.ReadUint32Bytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
bts, err = msgp.Skip(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
case "card":
|
|
z.card, bts, err = msgp.ReadInt64Bytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
bts, err = msgp.Skip(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
o = bts
|
|
return
|
|
}
|
|
|
|
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
|
|
func (z *runContainer32) Msgsize() (s int) {
|
|
s = 1 + 3 + msgp.ArrayHeaderSize + (len(z.iv) * (12 + msgp.Uint32Size + msgp.Uint32Size)) + 5 + msgp.Int64Size
|
|
return
|
|
}
|
|
|
|
// DecodeMsg implements msgp.Decodable
|
|
func (z *runIterator32) DecodeMsg(dc *msgp.Reader) (err error) {
|
|
var field []byte
|
|
_ = field
|
|
var zqke uint32
|
|
zqke, err = dc.ReadMapHeader()
|
|
if err != nil {
|
|
return
|
|
}
|
|
for zqke > 0 {
|
|
zqke--
|
|
field, err = dc.ReadMapKeyPtr()
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch msgp.UnsafeString(field) {
|
|
case "rc":
|
|
if dc.IsNil() {
|
|
err = dc.ReadNil()
|
|
if err != nil {
|
|
return
|
|
}
|
|
z.rc = nil
|
|
} else {
|
|
if z.rc == nil {
|
|
z.rc = new(runContainer32)
|
|
}
|
|
err = z.rc.DecodeMsg(dc)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case "curIndex":
|
|
z.curIndex, err = dc.ReadInt64()
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "curPosInIndex":
|
|
z.curPosInIndex, err = dc.ReadUint32()
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "curSeq":
|
|
z.curSeq, err = dc.ReadInt64()
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
err = dc.Skip()
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// EncodeMsg implements msgp.Encodable
|
|
func (z *runIterator32) EncodeMsg(en *msgp.Writer) (err error) {
|
|
// map header, size 4
|
|
// write "rc"
|
|
err = en.Append(0x84, 0xa2, 0x72, 0x63)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if z.rc == nil {
|
|
err = en.WriteNil()
|
|
if err != nil {
|
|
return
|
|
}
|
|
} else {
|
|
err = z.rc.EncodeMsg(en)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
// write "curIndex"
|
|
err = en.Append(0xa8, 0x63, 0x75, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = en.WriteInt64(z.curIndex)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// write "curPosInIndex"
|
|
err = en.Append(0xad, 0x63, 0x75, 0x72, 0x50, 0x6f, 0x73, 0x49, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = en.WriteUint32(z.curPosInIndex)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// write "curSeq"
|
|
err = en.Append(0xa6, 0x63, 0x75, 0x72, 0x53, 0x65, 0x71)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = en.WriteInt64(z.curSeq)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// MarshalMsg implements msgp.Marshaler
|
|
func (z *runIterator32) MarshalMsg(b []byte) (o []byte, err error) {
|
|
o = msgp.Require(b, z.Msgsize())
|
|
// map header, size 4
|
|
// string "rc"
|
|
o = append(o, 0x84, 0xa2, 0x72, 0x63)
|
|
if z.rc == nil {
|
|
o = msgp.AppendNil(o)
|
|
} else {
|
|
o, err = z.rc.MarshalMsg(o)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
// string "curIndex"
|
|
o = append(o, 0xa8, 0x63, 0x75, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78)
|
|
o = msgp.AppendInt64(o, z.curIndex)
|
|
// string "curPosInIndex"
|
|
o = append(o, 0xad, 0x63, 0x75, 0x72, 0x50, 0x6f, 0x73, 0x49, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78)
|
|
o = msgp.AppendUint32(o, z.curPosInIndex)
|
|
// string "curSeq"
|
|
o = append(o, 0xa6, 0x63, 0x75, 0x72, 0x53, 0x65, 0x71)
|
|
o = msgp.AppendInt64(o, z.curSeq)
|
|
return
|
|
}
|
|
|
|
// UnmarshalMsg implements msgp.Unmarshaler
|
|
func (z *runIterator32) UnmarshalMsg(bts []byte) (o []byte, err error) {
|
|
var field []byte
|
|
_ = field
|
|
var zqyh uint32
|
|
zqyh, bts, err = msgp.ReadMapHeaderBytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for zqyh > 0 {
|
|
zqyh--
|
|
field, bts, err = msgp.ReadMapKeyZC(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch msgp.UnsafeString(field) {
|
|
case "rc":
|
|
if msgp.IsNil(bts) {
|
|
bts, err = msgp.ReadNilBytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
z.rc = nil
|
|
} else {
|
|
if z.rc == nil {
|
|
z.rc = new(runContainer32)
|
|
}
|
|
bts, err = z.rc.UnmarshalMsg(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
case "curIndex":
|
|
z.curIndex, bts, err = msgp.ReadInt64Bytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "curPosInIndex":
|
|
z.curPosInIndex, bts, err = msgp.ReadUint32Bytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case "curSeq":
|
|
z.curSeq, bts, err = msgp.ReadInt64Bytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
default:
|
|
bts, err = msgp.Skip(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
o = bts
|
|
return
|
|
}
|
|
|
|
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
|
|
func (z *runIterator32) Msgsize() (s int) {
|
|
s = 1 + 3
|
|
if z.rc == nil {
|
|
s += msgp.NilSize
|
|
} else {
|
|
s += z.rc.Msgsize()
|
|
}
|
|
s += 9 + msgp.Int64Size + 14 + msgp.Uint32Size + 7 + msgp.Int64Size
|
|
return
|
|
}
|
|
|
|
// DecodeMsg implements msgp.Decodable
|
|
func (z *uint32Slice) DecodeMsg(dc *msgp.Reader) (err error) {
|
|
var zjpj uint32
|
|
zjpj, err = dc.ReadArrayHeader()
|
|
if err != nil {
|
|
return
|
|
}
|
|
if cap((*z)) >= int(zjpj) {
|
|
(*z) = (*z)[:zjpj]
|
|
} else {
|
|
(*z) = make(uint32Slice, zjpj)
|
|
}
|
|
for zywj := range *z {
|
|
(*z)[zywj], err = dc.ReadUint32()
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// EncodeMsg implements msgp.Encodable
|
|
func (z uint32Slice) EncodeMsg(en *msgp.Writer) (err error) {
|
|
err = en.WriteArrayHeader(uint32(len(z)))
|
|
if err != nil {
|
|
return
|
|
}
|
|
for zzpf := range z {
|
|
err = en.WriteUint32(z[zzpf])
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// MarshalMsg implements msgp.Marshaler
|
|
func (z uint32Slice) MarshalMsg(b []byte) (o []byte, err error) {
|
|
o = msgp.Require(b, z.Msgsize())
|
|
o = msgp.AppendArrayHeader(o, uint32(len(z)))
|
|
for zzpf := range z {
|
|
o = msgp.AppendUint32(o, z[zzpf])
|
|
}
|
|
return
|
|
}
|
|
|
|
// UnmarshalMsg implements msgp.Unmarshaler
|
|
func (z *uint32Slice) UnmarshalMsg(bts []byte) (o []byte, err error) {
|
|
var zgmo uint32
|
|
zgmo, bts, err = msgp.ReadArrayHeaderBytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if cap((*z)) >= int(zgmo) {
|
|
(*z) = (*z)[:zgmo]
|
|
} else {
|
|
(*z) = make(uint32Slice, zgmo)
|
|
}
|
|
for zrfe := range *z {
|
|
(*z)[zrfe], bts, err = msgp.ReadUint32Bytes(bts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
o = bts
|
|
return
|
|
}
|
|
|
|
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
|
|
func (z uint32Slice) Msgsize() (s int) {
|
|
s = msgp.ArrayHeaderSize + (len(z) * (msgp.Uint32Size))
|
|
return
|
|
}
|