// UnmarshalMsg implements msgp.Unmarshaler
func (z *Error) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var isz uint32
isz, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for isz > 0 {
isz--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "msg":
z.Msg, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
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
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *StructInstance) 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 "StructId":
z.StructId, bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *Snap) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var isz uint32
isz, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for isz > 0 {
isz--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "LowestTrackableValue":
z.LowestTrackableValue, bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
return
}
case "HighestTrackableValue":
z.HighestTrackableValue, bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
return
}
case "SignificantFigures":
z.SignificantFigures, bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
return
}
case "Counts":
var xsz uint32
xsz, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
return
}
if cap(z.Counts) >= int(xsz) {
z.Counts = z.Counts[:xsz]
} else {
z.Counts = make([]int64, xsz)
}
for xvk := range z.Counts {
z.Counts[xvk], bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
return
}
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
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
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *A) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var isz uint32
isz, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for isz > 0 {
isz--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "Name":
z.Name, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "BirthDay":
z.BirthDay, bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
return
}
case "Phone":
z.Phone, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Siblings":
z.Siblings, bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
return
}
case "Spouse":
z.Spouse, bts, err = msgp.ReadUint8Bytes(bts)
if err != nil {
return
}
case "Money":
z.Money, bts, err = msgp.ReadFloat64Bytes(bts)
if err != nil {
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *MethodT) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var zeff uint32
zeff, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for zeff > 0 {
zeff--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "MethodId":
z.MethodId, bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
return
}
case "Name":
z.Name, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Inputs":
bts, err = z.Inputs.UnmarshalMsg(bts)
if err != nil {
return
}
case "Returns":
bts, err = z.Returns.UnmarshalMsg(bts)
if err != nil {
return
}
case "Deprecated":
z.Deprecated, bts, err = msgp.ReadBoolBytes(bts)
if err != nil {
return
}
case "Comment":
z.Comment, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *CacheRegistry) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var bzg uint32
bzg, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for bzg > 0 {
bzg--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "CacheKey":
z.CacheKey, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Payload":
z.Payload, bts, err = msgp.ReadIntfBytes(bts)
if err != nil {
return
}
case "StoreTTL":
z.StoreTTL, bts, err = msgp.ReadFloat64Bytes(bts)
if err != nil {
return
}
case "CacheTime":
z.CacheTime, bts, err = msgp.ReadTimeBytes(bts)
if err != nil {
return
}
case "HasValue":
z.HasValue, bts, err = msgp.ReadBoolBytes(bts)
if err != nil {
return
}
case "TypeName":
z.TypeName, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *InterfaceT) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
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 "Methods":
var zjfb uint32
zjfb, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
return
}
if cap(z.Methods) >= int(zjfb) {
z.Methods = (z.Methods)[:zjfb]
} else {
z.Methods = make([]MethodT, zjfb)
}
for zxhx := range z.Methods {
bts, err = z.Methods[zxhx].UnmarshalMsg(bts)
if err != nil {
return
}
}
case "Deprecated":
z.Deprecated, bts, err = msgp.ReadBoolBytes(bts)
if err != nil {
return
}
case "Comment":
z.Comment, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *ColorGroup) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var isz uint32
isz, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for isz > 0 {
isz--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "id":
z.Id, bts, err = msgp.ReadIntBytes(bts)
if err != nil {
return
}
case "name":
z.Name, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "colors":
var xsz uint32
xsz, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
return
}
if cap(z.Colors) >= int(xsz) {
z.Colors = z.Colors[:xsz]
} else {
z.Colors = make([]string, xsz)
}
for xvk := range z.Colors {
z.Colors[xvk], bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *bitmapContainer) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var zcmr uint32
zcmr, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for zcmr > 0 {
zcmr--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "cardinality":
z.cardinality, bts, err = msgp.ReadIntBytes(bts)
if err != nil {
return
}
case "bitmap":
var zajw uint32
zajw, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
return
}
if cap(z.bitmap) >= int(zajw) {
z.bitmap = (z.bitmap)[:zajw]
} else {
z.bitmap = make([]uint64, zajw)
}
for zxvk := range z.bitmap {
z.bitmap[zxvk], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
return
}
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *Packet) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var isz uint32
isz, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for isz > 0 {
isz--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "type":
z.pType, bts, err = msgp.ReadByteBytes(bts)
if err != nil {
return
}
case "id":
z.id, bts, err = msgp.ReadIntBytes(bts)
if err != nil {
return
}
case "event":
z.eventName, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "payload":
z.payload, bts, err = msgp.ReadBytesBytes(bts, z.payload)
if err != nil {
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *Weather) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var isz uint32
isz, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for isz > 0 {
isz--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "time":
z.Time, bts, err = msgp.ReadTimeBytes(bts)
if err != nil {
return
}
case "size":
z.Size, bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
return
}
case "type":
z.Type, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "details":
z.Details, bts, err = msgp.ReadBytesBytes(bts, z.Details)
if err != nil {
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *Key) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var isz uint32
isz, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for isz > 0 {
isz--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "u":
{
var tmp []byte
tmp, bts, err = msgp.ReadBytesBytes(bts, []byte(z.UUID))
z.UUID = ID(tmp)
}
if err != nil {
return
}
case "v":
z.Value, bts, err = msgp.ReadIntfBytes(bts)
if err != nil {
return
}
case "p":
z.Payload, bts, err = msgp.ReadBytesBytes(bts, z.Payload)
if err != nil {
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *arrayContainer) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var zcmr uint32
zcmr, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for zcmr > 0 {
zcmr--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "content":
var zajw uint32
zajw, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
return
}
if cap(z.content) >= int(zajw) {
z.content = (z.content)[:zajw]
} else {
z.content = make([]uint16, zajw)
}
for zxvk := range z.content {
z.content[zxvk], bts, err = msgp.ReadUint16Bytes(bts)
if err != nil {
return
}
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *Attribute) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var bzg uint32
bzg, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for bzg > 0 {
bzg--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "Id":
z.Id, bts, err = msgp.ReadIntBytes(bts)
if err != nil {
return
}
case "Name":
z.Name, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Value":
z.Value, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *Outgoing) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var isz uint32
isz, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for isz > 0 {
isz--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "time":
z.Time, bts, err = msgp.ReadUint32Bytes(bts)
if err != nil {
return
}
case "from":
z.From, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "message":
z.Message, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *EventHeader) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var isz uint32
isz, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for isz > 0 {
isz--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "message_id":
z.Id, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "v":
z.Version, bts, err = msgp.ReadIntBytes(bts)
if err != nil {
return
}
case "response_to":
z.ResponseTo, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *Date) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var isz uint32
isz, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for isz > 0 {
isz--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "Year":
z.Year, bts, err = msgp.ReadIntBytes(bts)
if err != nil {
return
}
case "Month":
z.Month, bts, err = msgp.ReadIntBytes(bts)
if err != nil {
return
}
case "Day":
z.Day, bts, err = msgp.ReadIntBytes(bts)
if err != nil {
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *Person) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var isz uint32
isz, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for isz > 0 {
isz--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "Name":
z.Name, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Age":
z.Age, bts, err = msgp.ReadUint8Bytes(bts)
if err != nil {
return
}
case "Height":
z.Height, bts, err = msgp.ReadFloat64Bytes(bts)
if err != nil {
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *containerSerz) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var zbai uint32
zbai, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for zbai > 0 {
zbai--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "t":
{
var zcmr uint8
zcmr, bts, err = msgp.ReadUint8Bytes(bts)
z.t = contype(zcmr)
}
if err != nil {
return
}
case "r":
bts, err = z.r.UnmarshalMsg(bts)
if err != nil {
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *ProbeEvent) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var isz uint32
isz, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for isz > 0 {
isz--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "Id":
z.Id, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "EventType":
z.EventType, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "OrgId":
z.OrgId, bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
return
}
case "Severity":
z.Severity, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Source":
z.Source, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Timestamp":
z.Timestamp, bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
return
}
case "Message":
z.Message, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Tags":
var msz uint32
msz, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
if z.Tags == nil && msz > 0 {
z.Tags = make(map[string]string, msz)
} else if len(z.Tags) > 0 {
for key, _ := range z.Tags {
delete(z.Tags, key)
}
}
for msz > 0 {
var xvk string
var bzg string
msz--
xvk, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
bzg, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
z.Tags[xvk] = bzg
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *Group) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var isz uint32
isz, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for isz > 0 {
isz--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "Name":
z.Name, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Members":
var xsz uint32
xsz, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
return
}
if cap(z.Members) >= int(xsz) {
z.Members = z.Members[:xsz]
} else {
z.Members = make([]Person, xsz)
}
for xvk := range z.Members {
var isz uint32
isz, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for isz > 0 {
isz--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "Name":
z.Members[xvk].Name, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Age":
z.Members[xvk].Age, bts, err = msgp.ReadUint8Bytes(bts)
if err != nil {
return
}
case "Height":
z.Members[xvk].Height, bts, err = msgp.ReadFloat64Bytes(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
}
// 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
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *MetricDefinition) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var isz uint32
isz, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for isz > 0 {
isz--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "Id":
z.Id, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "OrgId":
z.OrgId, bts, err = msgp.ReadIntBytes(bts)
if err != nil {
return
}
case "Name":
z.Name, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Metric":
z.Metric, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Interval":
z.Interval, bts, err = msgp.ReadIntBytes(bts)
if err != nil {
return
}
case "Unit":
z.Unit, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "TargetType":
z.TargetType, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Tags":
var xsz uint32
xsz, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
return
}
if cap(z.Tags) >= int(xsz) {
z.Tags = z.Tags[:xsz]
} else {
z.Tags = make([]string, xsz)
}
for hct := range z.Tags {
z.Tags[hct], bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
}
case "LastUpdate":
z.LastUpdate, bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
return
}
case "Nodes":
var msz uint32
msz, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
if z.Nodes == nil && msz > 0 {
z.Nodes = make(map[string]string, msz)
} else if len(z.Nodes) > 0 {
for key, _ := range z.Nodes {
delete(z.Nodes, key)
}
}
for msz > 0 {
var cua string
var xhx string
msz--
cua, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
xhx, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
z.Nodes[cua] = xhx
}
case "NodeCount":
z.NodeCount, bts, err = msgp.ReadIntBytes(bts)
if err != nil {
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *MetricData) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var isz uint32
isz, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for isz > 0 {
isz--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "OrgId":
z.OrgId, bts, err = msgp.ReadIntBytes(bts)
if err != nil {
return
}
case "Name":
z.Name, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Metric":
z.Metric, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Interval":
z.Interval, bts, err = msgp.ReadIntBytes(bts)
if err != nil {
return
}
case "Value":
z.Value, bts, err = msgp.ReadFloat64Bytes(bts)
if err != nil {
return
}
case "Unit":
z.Unit, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Time":
z.Time, bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
return
}
case "TargetType":
z.TargetType, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Tags":
var xsz uint32
xsz, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
return
}
if cap(z.Tags) >= int(xsz) {
z.Tags = z.Tags[:xsz]
} else {
z.Tags = make([]string, xsz)
}
for xvk := range z.Tags {
z.Tags[xvk], bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
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
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *Message) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var isz uint32
isz, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for isz > 0 {
isz--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "id":
z.ID, bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
return
}
case "fn":
z.Func, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "args":
bts, err = z.Args.UnmarshalMsg(bts)
if err != nil {
return
}
case "result":
bts, err = z.Result.UnmarshalMsg(bts)
if err != nil {
return
}
case "error":
if msgp.IsNil(bts) {
bts, err = msgp.ReadNilBytes(bts)
if err != nil {
return
}
z.Error = nil
} else {
if z.Error == nil {
z.Error = new(Error)
}
var isz uint32
isz, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for isz > 0 {
isz--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "msg":
z.Error.Msg, bts, err = msgp.ReadStringBytes(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
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *Car) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var lqf uint32
lqf, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for lqf > 0 {
lqf--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "CarId":
z.CarId, bts, err = msgp.ReadIntBytes(bts)
if err != nil {
return
}
case "CarName":
z.CarName, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Attributes":
var daf uint32
daf, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
return
}
if cap(z.Attributes) >= int(daf) {
z.Attributes = z.Attributes[:daf]
} else {
z.Attributes = make([]Attribute, daf)
}
for bai := range z.Attributes {
var pks uint32
pks, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for pks > 0 {
pks--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "Id":
z.Attributes[bai].Id, bts, err = msgp.ReadIntBytes(bts)
if err != nil {
return
}
case "Name":
z.Attributes[bai].Name, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Value":
z.Attributes[bai].Value, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
}
case "FlagMap":
var jfb uint32
jfb, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
if z.FlagMap == nil && jfb > 0 {
z.FlagMap = make(map[string]string, jfb)
} else if len(z.FlagMap) > 0 {
for key, _ := range z.FlagMap {
delete(z.FlagMap, key)
}
}
for jfb > 0 {
var cmr string
var ajw string
jfb--
cmr, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
ajw, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
z.FlagMap[cmr] = ajw
}
case "Ttl":
z.Ttl, bts, err = msgp.ReadIntBytes(bts)
if err != nil {
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *roaringArray) 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 "keys":
var zxpk uint32
zxpk, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
return
}
if cap(z.keys) >= int(zxpk) {
z.keys = (z.keys)[:zxpk]
} else {
z.keys = make([]uint16, zxpk)
}
for zhct := range z.keys {
z.keys[zhct], bts, err = msgp.ReadUint16Bytes(bts)
if err != nil {
return
}
}
case "needCopyOnWrite":
var zdnj uint32
zdnj, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
return
}
if cap(z.needCopyOnWrite) >= int(zdnj) {
z.needCopyOnWrite = (z.needCopyOnWrite)[:zdnj]
} else {
z.needCopyOnWrite = make([]bool, zdnj)
}
for zcua := range z.needCopyOnWrite {
z.needCopyOnWrite[zcua], bts, err = msgp.ReadBoolBytes(bts)
if err != nil {
return
}
}
case "copyOnWrite":
z.copyOnWrite, bts, err = msgp.ReadBoolBytes(bts)
if err != nil {
return
}
case "conserz":
var zobc uint32
zobc, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
return
}
if cap(z.conserz) >= int(zobc) {
z.conserz = (z.conserz)[:zobc]
} else {
z.conserz = make([]containerSerz, zobc)
}
for zxhx := range z.conserz {
var zsnv uint32
zsnv, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for zsnv > 0 {
zsnv--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "t":
{
var zkgt uint8
zkgt, bts, err = msgp.ReadUint8Bytes(bts)
z.conserz[zxhx].t = contype(zkgt)
}
if err != nil {
return
}
case "r":
bts, err = z.conserz[zxhx].r.UnmarshalMsg(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
}
