Платформа ЦРНП "Мирокод" для разработки проектов
https://git.mirocod.ru
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1118 lines
23 KiB
1118 lines
23 KiB
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 |
|
}
|
|
|