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 *bitmapContainer) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var zbzg uint32
zbzg, err = dc.ReadMapHeader()
if err != nil {
return
}
for zbzg > 0 {
zbzg--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "cardinality":
z.cardinality, err = dc.ReadInt()
if err != nil {
return
}
case "bitmap":
var zbai uint32
zbai, err = dc.ReadArrayHeader()
if err != nil {
return
}
if cap(z.bitmap) >= int(zbai) {
z.bitmap = (z.bitmap)[:zbai]
} else {
z.bitmap = make([]uint64, zbai)
}
for zxvk := range z.bitmap {
z.bitmap[zxvk], err = dc.ReadUint64()
if err != nil {
return
}
}
default:
err = dc.Skip()
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 *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 *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 *Date) 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 "Year":
z.Year, err = dc.ReadInt()
if err != nil {
return
}
case "Month":
z.Month, err = dc.ReadInt()
if err != nil {
return
}
case "Day":
z.Day, err = dc.ReadInt()
if err != nil {
return
}
default:
err = dc.Skip()
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 *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 *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 *bitmapContainerShortIterator) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
var zhct uint32
zhct, err = dc.ReadMapHeader()
if err != nil {
return
}
for zhct > 0 {
zhct--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "ptr":
if dc.IsNil() {
err = dc.ReadNil()
if err != nil {
return
}
z.ptr = nil
} else {
if z.ptr == nil {
z.ptr = new(bitmapContainer)
}
var zcua uint32
zcua, err = dc.ReadMapHeader()
if err != nil {
return
}
for zcua > 0 {
zcua--
field, err = dc.ReadMapKeyPtr()
if err != nil {
return
}
switch msgp.UnsafeString(field) {
case "cardinality":
z.ptr.cardinality, err = dc.ReadInt()
if err != nil {
return
}
case "bitmap":
var zxhx uint32
zxhx, err = dc.ReadArrayHeader()
if err != nil {
return
}
if cap(z.ptr.bitmap) >= int(zxhx) {
z.ptr.bitmap = (z.ptr.bitmap)[:zxhx]
} else {
z.ptr.bitmap = make([]uint64, zxhx)
}
for zwht := range z.ptr.bitmap {
z.ptr.bitmap[zwht], err = dc.ReadUint64()
if err != nil {
return
}
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
}
case "i":
z.i, err = dc.ReadInt()
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 *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
}
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 *Incident) 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 "event_name":
z.EventName, err = dc.ReadBytes(z.EventName)
if err != nil {
return
}
case "time":
z.Time, err = dc.ReadInt64()
if err != nil {
return
}
case "id":
z.Id, err = dc.ReadInt64()
if err != nil {
return
}
case "active":
z.Active, err = dc.ReadBool()
if err != nil {
return
}
case "escalation":
z.Escalation, err = dc.ReadString()
if err != nil {
return
}
case "description":
z.Description, err = dc.ReadString()
if err != nil {
return
}
case "policy":
z.Policy, err = dc.ReadString()
if err != nil {
return
}
case "Status":
z.Status, err = dc.ReadInt()
if err != nil {
return
}
case "Event":
err = z.Event.DecodeMsg(dc)
if err != nil {
return
}
default:
err = dc.Skip()
if err != nil {
return
}
}
}
return
}