// 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 *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 *Message) UnmarshalMsg(bts []byte) (o []byte, err error) {
{
var ssz uint32
ssz, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
return
}
if ssz != 4 {
err = msgp.ArrayError{Wanted: 4, Got: ssz}
return
}
}
z.Tag, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
z.Time, bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
return
}
z.Record, bts, err = msgp.ReadIntfBytes(bts)
if err != nil {
return
}
z.Option, bts, err = msgp.ReadIntfBytes(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 *Forward) UnmarshalMsg(bts []byte) (o []byte, err error) {
{
var ssz uint32
ssz, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
return
}
if ssz != 3 {
err = msgp.ArrayError{Wanted: 3, Got: ssz}
return
}
}
z.Tag, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
var xsz uint32
xsz, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
return
}
if cap(z.Entries) >= int(xsz) {
z.Entries = z.Entries[:xsz]
} else {
z.Entries = make([]Entry, xsz)
}
for xvk := range z.Entries {
{
var ssz uint32
ssz, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
return
}
if ssz != 2 {
err = msgp.ArrayError{Wanted: 2, Got: ssz}
return
}
}
z.Entries[xvk].Time, bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
return
}
z.Entries[xvk].Record, bts, err = msgp.ReadIntfBytes(bts)
if err != nil {
return
}
}
z.Option, bts, err = msgp.ReadIntfBytes(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 *Entry) UnmarshalMsg(bts []byte) (o []byte, err error) {
{
var ssz uint32
ssz, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
return
}
if ssz != 2 {
err = msgp.ArrayError{Wanted: 2, Got: ssz}
return
}
}
z.Time, bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
return
}
z.Record, bts, err = msgp.ReadIntfBytes(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 *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 *FieldT) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var zwht uint32
zwht, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for zwht > 0 {
zwht--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "FieldId":
z.FieldId, bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
return
}
case "Name":
z.Name, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Ztyp":
{
var zhct int32
zhct, bts, err = msgp.ReadInt32Bytes(bts)
z.Ztyp = Ztype(zhct)
}
if err != nil {
return
}
case "IsVarArg":
z.IsVarArg, bts, err = msgp.ReadBoolBytes(bts)
if err != nil {
return
}
case "Tags":
var zcua uint32
zcua, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
if z.Tags == nil && zcua > 0 {
z.Tags = make(map[string]string, zcua)
} else if len(z.Tags) > 0 {
for key, _ := range z.Tags {
delete(z.Tags, key)
}
}
for zcua > 0 {
var zxvk string
var zbzg string
zcua--
zxvk, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
zbzg, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
z.Tags[zxvk] = zbzg
}
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 *StructT) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
var zzpf uint32
zzpf, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
for zzpf > 0 {
zzpf--
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
}
case "StructName":
z.StructName, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Fields":
var zrfe uint32
zrfe, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
return
}
if cap(z.Fields) >= int(zrfe) {
z.Fields = (z.Fields)[:zrfe]
} else {
z.Fields = make([]FieldT, zrfe)
}
for zyzr := range z.Fields {
bts, err = z.Fields[zyzr].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 *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 *Incident) 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 "event_name":
z.EventName, bts, err = msgp.ReadBytesBytes(bts, z.EventName)
if err != nil {
return
}
case "time":
z.Time, bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
return
}
case "id":
z.Id, bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
return
}
case "active":
z.Active, bts, err = msgp.ReadBoolBytes(bts)
if err != nil {
return
}
case "escalation":
z.Escalation, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "description":
z.Description, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "policy":
z.Policy, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Status":
z.Status, bts, err = msgp.ReadIntBytes(bts)
if err != nil {
return
}
case "Event":
bts, err = z.Event.UnmarshalMsg(bts)
if err != nil {
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
o = bts
return
}