// DecodeMsg implements msgp.Decodable
func (z *Message) DecodeMsg(dc *msgp.Reader) (err error) {
var ssz uint32
ssz, err = dc.ReadArrayHeader()
if err != nil {
return
}
if ssz != 4 {
err = msgp.ArrayError{Wanted: 4, Got: ssz}
return
}
z.Tag, err = dc.ReadString()
if err != nil {
return
}
z.Time, err = dc.ReadInt64()
if err != nil {
return
}
z.Record, err = dc.ReadIntf()
if err != nil {
return
}
z.Option, err = dc.ReadIntf()
if err != nil {
return
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *Error) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var isz uint32
isz, err = dc.ReadMapHeader()
if err != nil {
return
}
for isz > 0 {
isz--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "msg":
z.Msg, err = dc.ReadString()
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
func (r *Request) DecodeMsg(mr *msgp.Reader) error {
var bm msgp.Decodable
if r.Body != nil {
var ok bool
bm, ok = r.Body.(msgp.Decodable)
if !ok {
return ErrNotDecodable
}
}
if size, err := mr.ReadArrayHeader(); err != nil {
return err
} else if size != RequestPackSize {
return ErrBadPackSize
}
if typ, err := mr.ReadInt(); err != nil {
return err
} else if typ != RequestType {
return ErrBadMessageType
}
id, err := mr.ReadUint32()
if err != nil {
return err
}
r.ID = id
method, err := mr.ReadString()
if err != nil {
return err
}
r.Method = method
// The request body is packed in an array.
l, err := mr.ReadArrayHeader()
if err != nil {
return err
}
if l > 1 {
return ErrUnexpectedParams
} else if l == 0 {
return nil
}
r.hasBody = true
// Skip decoding the body if no value is present to decode into.
// The caller is expected to decode the body or skip it.
if bm != nil {
return decodeBody(mr, bm)
}
return nil
}
// DecodeMsg implements msgp.Decodable
func (z *CacheRegistry) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var xvk uint32
xvk, err = dc.ReadMapHeader()
if err != nil {
return
}
for xvk > 0 {
xvk--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "CacheKey":
z.CacheKey, err = dc.ReadString()
if err != nil {
return
}
case "Payload":
z.Payload, err = dc.ReadIntf()
if err != nil {
return
}
case "StoreTTL":
z.StoreTTL, err = dc.ReadFloat64()
if err != nil {
return
}
case "CacheTime":
z.CacheTime, err = dc.ReadTime()
if err != nil {
return
}
case "HasValue":
z.HasValue, err = dc.ReadBool()
if err != nil {
return
}
case "TypeName":
z.TypeName, err = dc.ReadString()
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *MethodT) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var zcxo uint32
zcxo, err = dc.ReadMapHeader()
if err != nil {
return
}
for zcxo > 0 {
zcxo--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "MethodId":
z.MethodId, err = dc.ReadInt64()
if err != nil {
return
}
case "Name":
z.Name, err = dc.ReadString()
if err != nil {
return
}
case "Inputs":
err = z.Inputs.DecodeMsg(dc)
if err != nil {
return
}
case "Returns":
err = z.Returns.DecodeMsg(dc)
if err != nil {
return
}
case "Deprecated":
z.Deprecated, err = dc.ReadBool()
if err != nil {
return
}
case "Comment":
z.Comment, err = dc.ReadString()
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *A) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var isz uint32
isz, err = dc.ReadMapHeader()
if err != nil {
return
}
for isz > 0 {
isz--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "Name":
z.Name, err = dc.ReadString()
if err != nil {
return
}
case "BirthDay":
z.BirthDay, err = dc.ReadInt64()
if err != nil {
return
}
case "Phone":
z.Phone, err = dc.ReadString()
if err != nil {
return
}
case "Siblings":
z.Siblings, err = dc.ReadInt64()
if err != nil {
return
}
case "Spouse":
z.Spouse, err = dc.ReadUint8()
if err != nil {
return
}
case "Money":
z.Money, err = dc.ReadFloat64()
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *InterfaceT) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var zlqf uint32
zlqf, err = dc.ReadMapHeader()
if err != nil {
return
}
for zlqf > 0 {
zlqf--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "Methods":
var zdaf uint32
zdaf, err = dc.ReadArrayHeader()
if err != nil {
return
}
if cap(z.Methods) >= int(zdaf) {
z.Methods = (z.Methods)[:zdaf]
} else {
z.Methods = make([]MethodT, zdaf)
}
for zxhx := range z.Methods {
err = z.Methods[zxhx].DecodeMsg(dc)
if err != nil {
return
}
}
case "Deprecated":
z.Deprecated, err = dc.ReadBool()
if err != nil {
return
}
case "Comment":
z.Comment, err = dc.ReadString()
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *Forward) DecodeMsg(dc *msgp.Reader) (err error) {
var ssz uint32
ssz, err = dc.ReadArrayHeader()
if err != nil {
return
}
if ssz != 3 {
err = msgp.ArrayError{Wanted: 3, Got: ssz}
return
}
z.Tag, err = dc.ReadString()
if err != nil {
return
}
var xsz uint32
xsz, err = dc.ReadArrayHeader()
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, err = dc.ReadArrayHeader()
if err != nil {
return
}
if ssz != 2 {
err = msgp.ArrayError{Wanted: 2, Got: ssz}
return
}
z.Entries[xvk].Time, err = dc.ReadInt64()
if err != nil {
return
}
z.Entries[xvk].Record, err = dc.ReadIntf()
if err != nil {
return
}
}
z.Option, err = dc.ReadIntf()
if err != nil {
return
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *Packet) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var isz uint32
isz, err = dc.ReadMapHeader()
if err != nil {
return
}
for isz > 0 {
isz--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "type":
z.pType, err = dc.ReadByte()
if err != nil {
return
}
case "id":
z.id, err = dc.ReadInt()
if err != nil {
return
}
case "event":
z.eventName, err = dc.ReadString()
if err != nil {
return
}
case "payload":
z.payload, err = dc.ReadBytes(z.payload)
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *Weather) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var isz uint32
isz, err = dc.ReadMapHeader()
if err != nil {
return
}
for isz > 0 {
isz--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "time":
z.Time, err = dc.ReadTime()
if err != nil {
return
}
case "size":
z.Size, err = dc.ReadInt64()
if err != nil {
return
}
case "type":
z.Type, err = dc.ReadString()
if err != nil {
return
}
case "details":
z.Details, err = dc.ReadBytes(z.Details)
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *Attribute) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var xvk uint32
xvk, err = dc.ReadMapHeader()
if err != nil {
return
}
for xvk > 0 {
xvk--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "Id":
z.Id, err = dc.ReadInt()
if err != nil {
return
}
case "Name":
z.Name, err = dc.ReadString()
if err != nil {
return
}
case "Value":
z.Value, err = dc.ReadString()
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *Person) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var isz uint32
isz, err = dc.ReadMapHeader()
if err != nil {
return
}
for isz > 0 {
isz--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "Name":
z.Name, err = dc.ReadString()
if err != nil {
return
}
case "Age":
z.Age, err = dc.ReadUint8()
if err != nil {
return
}
case "Height":
z.Height, err = dc.ReadFloat64()
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *EventHeader) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var isz uint32
isz, err = dc.ReadMapHeader()
if err != nil {
return
}
for isz > 0 {
isz--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "message_id":
z.Id, err = dc.ReadString()
if err != nil {
return
}
case "v":
z.Version, err = dc.ReadInt()
if err != nil {
return
}
case "response_to":
z.ResponseTo, err = dc.ReadString()
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *Outgoing) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var isz uint32
isz, err = dc.ReadMapHeader()
if err != nil {
return
}
for isz > 0 {
isz--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "time":
z.Time, err = dc.ReadUint32()
if err != nil {
return
}
case "from":
z.From, err = dc.ReadString()
if err != nil {
return
}
case "message":
z.Message, err = dc.ReadString()
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
func readMapStrStr(r *msgp.Reader, mp map[string]string) (err error) {
var sz uint32
sz, err = r.ReadMapHeader()
if err != nil {
return err
}
for i := uint32(0); i < sz; i++ {
var key string
var val string
key, err = r.ReadString()
if err != nil {
return err
}
val, err = r.ReadString()
if err != nil {
return err
}
mp[key] = val
}
return
}
func (d *initialDispatch) Handle(id uint64, r *msgp.Reader) (Dispatcher, error) {
var err error
switch id {
case spool:
var opts = make(Profile)
var name string
if err = checkSize(_onSpoolArgsNum, r); err != nil {
return nil, err
}
if err = r.ReadMapStrIntf(opts); err != nil {
return nil, err
}
if name, err = r.ReadString(); err != nil {
return nil, err
}
return d.onSpool(opts, name)
case spawn:
var (
opts = make(Profile)
name, executable string
args = make(map[string]string)
env = make(map[string]string)
)
if err = checkSize(_onSpawnArgsNum, r); err != nil {
return nil, err
}
if err = r.ReadMapStrIntf(opts); err != nil {
return nil, err
}
if name, err = r.ReadString(); err != nil {
return nil, err
}
if executable, err = r.ReadString(); err != nil {
return nil, err
}
if err = readMapStrStr(r, args); err != nil {
return nil, err
}
if err = readMapStrStr(r, env); err != nil {
return nil, err
}
return d.onSpawn(opts, name, executable, args, env)
default:
return nil, fmt.Errorf("unknown transition id: %d", id)
}
}
// DecodeMsg implements msgp.Decodable
func (z *Message) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var isz uint32
isz, err = dc.ReadMapHeader()
if err != nil {
return
}
for isz > 0 {
isz--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "id":
z.ID, err = dc.ReadUint64()
if err != nil {
return
}
case "fn":
z.Func, err = dc.ReadString()
if err != nil {
return
}
case "args":
err = z.Args.DecodeMsg(dc)
if err != nil {
return
}
case "result":
err = z.Result.DecodeMsg(dc)
if err != nil {
return
}
case "error":
if dc.IsNil() {
err = dc.ReadNil()
if err != nil {
return
}
z.Error = nil
} else {
if z.Error == nil {
z.Error = new(Error)
}
var isz uint32
isz, err = dc.ReadMapHeader()
if err != nil {
return
}
for isz > 0 {
isz--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "msg":
z.Error.Msg, err = dc.ReadString()
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *Car) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var wht uint32
wht, err = dc.ReadMapHeader()
if err != nil {
return
}
for wht > 0 {
wht--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "CarId":
z.CarId, err = dc.ReadInt()
if err != nil {
return
}
case "CarName":
z.CarName, err = dc.ReadString()
if err != nil {
return
}
case "Attributes":
var hct uint32
hct, err = dc.ReadArrayHeader()
if err != nil {
return
}
if cap(z.Attributes) >= int(hct) {
z.Attributes = z.Attributes[:hct]
} else {
z.Attributes = make([]Attribute, hct)
}
for bai := range z.Attributes {
var cua uint32
cua, err = dc.ReadMapHeader()
if err != nil {
return
}
for cua > 0 {
cua--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "Id":
z.Attributes[bai].Id, err = dc.ReadInt()
if err != nil {
return
}
case "Name":
z.Attributes[bai].Name, err = dc.ReadString()
if err != nil {
return
}
case "Value":
z.Attributes[bai].Value, err = dc.ReadString()
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
}
case "FlagMap":
var xhx uint32
xhx, err = dc.ReadMapHeader()
if err != nil {
return
}
if z.FlagMap == nil && xhx > 0 {
z.FlagMap = make(map[string]string, xhx)
} else if len(z.FlagMap) > 0 {
for key, _ := range z.FlagMap {
delete(z.FlagMap, key)
}
}
for xhx > 0 {
xhx--
var cmr string
var ajw string
cmr, err = dc.ReadString()
if err != nil {
return
}
ajw, err = dc.ReadString()
if err != nil {
return
}
z.FlagMap[cmr] = ajw
}
case "Ttl":
z.Ttl, err = dc.ReadInt()
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *SchemaT) 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 "PkgPath":
z.PkgPath, err = dc.ReadString()
if err != nil {
return
}
case "Structs":
var zobc uint32
zobc, err = dc.ReadArrayHeader()
if err != nil {
return
}
if cap(z.Structs) >= int(zobc) {
z.Structs = (z.Structs)[:zobc]
} else {
z.Structs = make([]StructT, zobc)
}
for zrsw := range z.Structs {
err = z.Structs[zrsw].DecodeMsg(dc)
if err != nil {
return
}
}
case "Interfaces":
var zsnv uint32
zsnv, err = dc.ReadArrayHeader()
if err != nil {
return
}
if cap(z.Interfaces) >= int(zsnv) {
z.Interfaces = (z.Interfaces)[:zsnv]
} else {
z.Interfaces = make([]InterfaceT, zsnv)
}
for zxpk := range z.Interfaces {
err = z.Interfaces[zxpk].DecodeMsg(dc)
if err != nil {
return
}
}
case "Deprecated":
z.Deprecated, err = dc.ReadBool()
if err != nil {
return
}
case "Comment":
z.Comment, err = dc.ReadString()
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
func (r *Response) DecodeMsg(mr *msgp.Reader) error {
var bm msgp.Decodable
if r.Body != nil {
var ok bool
bm, ok = r.Body.(msgp.Decodable)
if !ok {
return ErrNotDecodable
}
}
if size, err := mr.ReadArrayHeader(); err != nil {
return err
} else if size != ResponsePackSize {
return ErrBadPackSize
}
if typ, err := mr.ReadInt(); err != nil {
return err
} else if typ != ResponseType {
return ErrBadMessageType
}
id, err := mr.ReadUint32()
if err != nil {
return err
}
r.ID = id
// Error can be nil or a string.
typ, err := mr.NextType()
if err != nil {
return err
}
switch typ {
case msgp.StrType:
s, err := mr.ReadString()
if err != nil {
return err
}
r.Error = s
case msgp.NilType:
if err := mr.ReadNil(); err != nil {
return err
}
r.Error = ""
default:
return ErrBadErrorType
}
// Body can be nil.
typ, err = mr.NextType()
if err != nil {
return err
}
if typ == msgp.NilType {
r.hasBody = false
return mr.ReadNil()
}
r.hasBody = true
// Skip decoding the body if no value is present to decode into.
// The caller is expected to read the body or skip it.
if bm != nil {
return decodeBody(mr, bm)
}
return nil
}
// DecodeMsg implements msgp.Decodable
func (z *Message) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var isz uint32
isz, err = dc.ReadMapHeader()
if err != nil {
return
}
for isz > 0 {
isz--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "body":
z.Body, err = dc.ReadBytes(z.Body)
if err != nil {
return
}
case "meta":
var msz uint32
msz, err = dc.ReadMapHeader()
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 {
msz--
var xvk string
var bzg interface{}
xvk, err = dc.ReadString()
if err != nil {
return
}
bzg, err = dc.ReadIntf()
if err != nil {
return
}
z.Meta[xvk] = bzg
}
case "ct":
z.ContentType, err = dc.ReadString()
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *Event) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var isz uint32
isz, err = dc.ReadMapHeader()
if err != nil {
return
}
for isz > 0 {
isz--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "id":
z.Id, err = dc.ReadInt()
if err != nil {
return
}
case "user":
var isz uint32
isz, err = dc.ReadMapHeader()
if err != nil {
return
}
for isz > 0 {
isz--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "first":
z.User.First, err = dc.ReadString()
if err != nil {
return
}
case "last":
z.User.Last, err = dc.ReadString()
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
case "flight":
z.Flight, err = dc.ReadString()
if err != nil {
return
}
case "pilot":
var xsz uint32
xsz, err = dc.ReadArrayHeader()
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], err = dc.ReadString()
if err != nil {
return
}
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *MetricData) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var isz uint32
isz, err = dc.ReadMapHeader()
if err != nil {
return
}
for isz > 0 {
isz--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "OrgId":
z.OrgId, err = dc.ReadInt()
if err != nil {
return
}
case "Name":
z.Name, err = dc.ReadString()
if err != nil {
return
}
case "Metric":
z.Metric, err = dc.ReadString()
if err != nil {
return
}
case "Interval":
z.Interval, err = dc.ReadInt()
if err != nil {
return
}
case "Value":
z.Value, err = dc.ReadFloat64()
if err != nil {
return
}
case "Unit":
z.Unit, err = dc.ReadString()
if err != nil {
return
}
case "Time":
z.Time, err = dc.ReadInt64()
if err != nil {
return
}
case "TargetType":
z.TargetType, err = dc.ReadString()
if err != nil {
return
}
case "Tags":
var xsz uint32
xsz, err = dc.ReadArrayHeader()
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], err = dc.ReadString()
if err != nil {
return
}
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *ServerResponse) DecodeMsg(dc *msgp.Reader) (err error) {
{
var ssz uint32
ssz, err = dc.ReadArrayHeader()
if err != nil {
return
}
if ssz != 3 {
err = msgp.ArrayError{Wanted: 3, Got: ssz}
return
}
}
if dc.IsNil() {
err = dc.ReadNil()
if err != nil {
return
}
z.Header = nil
} else {
if z.Header == nil {
z.Header = new(EventHeader)
}
var field []byte
_ = field
var isz uint32
isz, err = dc.ReadMapHeader()
if err != nil {
return
}
for isz > 0 {
isz--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "message_id":
z.Header.Id, err = dc.ReadString()
if err != nil {
return
}
case "v":
z.Header.Version, err = dc.ReadInt()
if err != nil {
return
}
case "response_to":
z.Header.ResponseTo, err = dc.ReadString()
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
}
z.Name, err = dc.ReadString()
if err != nil {
return
}
var xsz uint32
xsz, err = dc.ReadArrayHeader()
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], err = dc.ReadIntf()
if err != nil {
return
}
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *MetricDefinition) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var isz uint32
isz, err = dc.ReadMapHeader()
if err != nil {
return
}
for isz > 0 {
isz--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "Id":
z.Id, err = dc.ReadString()
if err != nil {
return
}
case "OrgId":
z.OrgId, err = dc.ReadInt()
if err != nil {
return
}
case "Name":
z.Name, err = dc.ReadString()
if err != nil {
return
}
case "Metric":
z.Metric, err = dc.ReadString()
if err != nil {
return
}
case "Interval":
z.Interval, err = dc.ReadInt()
if err != nil {
return
}
case "Unit":
z.Unit, err = dc.ReadString()
if err != nil {
return
}
case "TargetType":
z.TargetType, err = dc.ReadString()
if err != nil {
return
}
case "Tags":
var xsz uint32
xsz, err = dc.ReadArrayHeader()
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], err = dc.ReadString()
if err != nil {
return
}
}
case "LastUpdate":
z.LastUpdate, err = dc.ReadInt64()
if err != nil {
return
}
case "Nodes":
var msz uint32
msz, err = dc.ReadMapHeader()
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 {
msz--
var cua string
var xhx string
cua, err = dc.ReadString()
if err != nil {
return
}
xhx, err = dc.ReadString()
if err != nil {
return
}
z.Nodes[cua] = xhx
}
case "NodeCount":
z.NodeCount, err = dc.ReadInt()
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *StructT) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var zywj uint32
zywj, err = dc.ReadMapHeader()
if err != nil {
return
}
for zywj > 0 {
zywj--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "StructId":
z.StructId, err = dc.ReadInt64()
if err != nil {
return
}
case "StructName":
z.StructName, err = dc.ReadString()
if err != nil {
return
}
case "Fields":
var zjpj uint32
zjpj, err = dc.ReadArrayHeader()
if err != nil {
return
}
if cap(z.Fields) >= int(zjpj) {
z.Fields = (z.Fields)[:zjpj]
} else {
z.Fields = make([]FieldT, zjpj)
}
for zyzr := range z.Fields {
err = z.Fields[zyzr].DecodeMsg(dc)
if err != nil {
return
}
}
case "Deprecated":
z.Deprecated, err = dc.ReadBool()
if err != nil {
return
}
case "Comment":
z.Comment, err = dc.ReadString()
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *Group) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var isz uint32
isz, err = dc.ReadMapHeader()
if err != nil {
return
}
for isz > 0 {
isz--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "Name":
z.Name, err = dc.ReadString()
if err != nil {
return
}
case "Members":
var xsz uint32
xsz, err = dc.ReadArrayHeader()
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, err = dc.ReadMapHeader()
if err != nil {
return
}
for isz > 0 {
isz--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "Name":
z.Members[xvk].Name, err = dc.ReadString()
if err != nil {
return
}
case "Age":
z.Members[xvk].Age, err = dc.ReadUint8()
if err != nil {
return
}
case "Height":
z.Members[xvk].Height, err = dc.ReadFloat64()
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *FieldT) 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 "FieldId":
z.FieldId, err = dc.ReadInt64()
if err != nil {
return
}
case "Name":
z.Name, err = dc.ReadString()
if err != nil {
return
}
case "Ztyp":
{
var zcmr int32
zcmr, err = dc.ReadInt32()
z.Ztyp = Ztype(zcmr)
}
if err != nil {
return
}
case "IsVarArg":
z.IsVarArg, err = dc.ReadBool()
if err != nil {
return
}
case "Tags":
var zajw uint32
zajw, err = dc.ReadMapHeader()
if err != nil {
return
}
if z.Tags == nil && zajw > 0 {
z.Tags = make(map[string]string, zajw)
} else if len(z.Tags) > 0 {
for key, _ := range z.Tags {
delete(z.Tags, key)
}
}
for zajw > 0 {
zajw--
var zxvk string
var zbzg string
zxvk, err = dc.ReadString()
if err != nil {
return
}
zbzg, err = dc.ReadString()
if err != nil {
return
}
z.Tags[zxvk] = zbzg
}
case "Deprecated":
z.Deprecated, err = dc.ReadBool()
if err != nil {
return
}
case "Comment":
z.Comment, err = dc.ReadString()
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *ProbeEvent) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var isz uint32
isz, err = dc.ReadMapHeader()
if err != nil {
return
}
for isz > 0 {
isz--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "Id":
z.Id, err = dc.ReadString()
if err != nil {
return
}
case "EventType":
z.EventType, err = dc.ReadString()
if err != nil {
return
}
case "OrgId":
z.OrgId, err = dc.ReadInt64()
if err != nil {
return
}
case "Severity":
z.Severity, err = dc.ReadString()
if err != nil {
return
}
case "Source":
z.Source, err = dc.ReadString()
if err != nil {
return
}
case "Timestamp":
z.Timestamp, err = dc.ReadInt64()
if err != nil {
return
}
case "Message":
z.Message, err = dc.ReadString()
if err != nil {
return
}
case "Tags":
var msz uint32
msz, err = dc.ReadMapHeader()
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 {
msz--
var xvk string
var bzg string
xvk, err = dc.ReadString()
if err != nil {
return
}
bzg, err = dc.ReadString()
if err != nil {
return
}
z.Tags[xvk] = bzg
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}
// DecodeMsg implements msgp.Decodable
func (z *Event) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var isz uint32
isz, err = dc.ReadMapHeader()
if err != nil {
return
}
for isz > 0 {
isz--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "host":
z.Host, err = dc.ReadString()
if err != nil {
return
}
case "service":
z.Service, err = dc.ReadString()
if err != nil {
return
}
case "sub_service":
z.SubService, err = dc.ReadString()
if err != nil {
return
}
case "metric":
z.Metric, err = dc.ReadFloat64()
if err != nil {
return
}
case "tags":
var msz uint32
msz, err = dc.ReadMapHeader()
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 {
msz--
var xvk string
var bzg string
xvk, err = dc.ReadString()
if err != nil {
return
}
bzg, err = dc.ReadString()
if err != nil {
return
}
z.Tags[xvk] = bzg
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}