// UnmarshalMsg implements msgp.Unmarshaler
func (z *Incoming) 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 "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 *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 "first":
z.First, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "last":
z.Last, 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 *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 *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 *Foo) 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 "bar":
z.Bar, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "baz":
z.Baz, 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 *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 *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 *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 *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 *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 *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 *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 *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 *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 "body":
z.Body, bts, err = msgp.ReadBytesBytes(bts, z.Body)
if err != nil {
return
}
case "meta":
var msz uint32
msz, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
return
}
if z.Meta == nil && msz > 0 {
z.Meta = make(map[string]interface{}, msz)
} else if len(z.Meta) > 0 {
for key, _ := range z.Meta {
delete(z.Meta, key)
}
}
for msz > 0 {
var xvk string
var bzg interface{}
msz--
xvk, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
bzg, bts, err = msgp.ReadIntfBytes(bts)
if err != nil {
return
}
z.Meta[xvk] = bzg
}
case "ct":
z.ContentType, 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 *SchemaT) 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 "PkgPath":
z.PkgPath, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "Structs":
var zema uint32
zema, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
return
}
if cap(z.Structs) >= int(zema) {
z.Structs = (z.Structs)[:zema]
} else {
z.Structs = make([]StructT, zema)
}
for zrsw := range z.Structs {
bts, err = z.Structs[zrsw].UnmarshalMsg(bts)
if err != nil {
return
}
}
case "Interfaces":
var zpez uint32
zpez, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
return
}
if cap(z.Interfaces) >= int(zpez) {
z.Interfaces = (z.Interfaces)[:zpez]
} else {
z.Interfaces = make([]InterfaceT, zpez)
}
for zxpk := range z.Interfaces {
bts, err = z.Interfaces[zxpk].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 *Event) 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 "user":
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 "first":
z.User.First, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "last":
z.User.Last, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
case "flight":
z.Flight, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "pilot":
var xsz uint32
xsz, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
return
}
if cap(z.Pilot) >= int(xsz) {
z.Pilot = z.Pilot[:xsz]
} else {
z.Pilot = make([]string, xsz)
}
for xvk := range z.Pilot {
z.Pilot[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 *Event) 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 "host":
z.Host, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "service":
z.Service, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "sub_service":
z.SubService, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "metric":
z.Metric, bts, err = msgp.ReadFloat64Bytes(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 *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 *ServerResponse) 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
}
}
if msgp.IsNil(bts) {
bts, err = msgp.ReadNilBytes(bts)
if err != nil {
return
}
z.Header = nil
} else {
if z.Header == nil {
z.Header = new(EventHeader)
}
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.Header.Id, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
case "v":
z.Header.Version, bts, err = msgp.ReadIntBytes(bts)
if err != nil {
return
}
case "response_to":
z.Header.ResponseTo, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
return
}
}
}
}
z.Name, 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.Params) >= int(xsz) {
z.Params = z.Params[:xsz]
} else {
z.Params = make([]interface{}, xsz)
}
for bzg := range z.Params {
z.Params[bzg], 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 *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 *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 *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 *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
}
