github.com/minio/madmin-go/v3@v3.0.51/replication-api_gen.go (about)

     1  package madmin
     2  
     3  // Code generated by github.com/tinylib/msgp DO NOT EDIT.
     4  
     5  import (
     6  	"github.com/tinylib/msgp/msgp"
     7  )
     8  
     9  // DecodeMsg implements msgp.Decodable
    10  func (z *LatencyStat) DecodeMsg(dc *msgp.Reader) (err error) {
    11  	var field []byte
    12  	_ = field
    13  	var zb0001 uint32
    14  	zb0001, err = dc.ReadMapHeader()
    15  	if err != nil {
    16  		err = msgp.WrapError(err)
    17  		return
    18  	}
    19  	for zb0001 > 0 {
    20  		zb0001--
    21  		field, err = dc.ReadMapKeyPtr()
    22  		if err != nil {
    23  			err = msgp.WrapError(err)
    24  			return
    25  		}
    26  		switch msgp.UnsafeString(field) {
    27  		case "Curr":
    28  			z.Curr, err = dc.ReadDuration()
    29  			if err != nil {
    30  				err = msgp.WrapError(err, "Curr")
    31  				return
    32  			}
    33  		case "Avg":
    34  			z.Avg, err = dc.ReadDuration()
    35  			if err != nil {
    36  				err = msgp.WrapError(err, "Avg")
    37  				return
    38  			}
    39  		case "Max":
    40  			z.Max, err = dc.ReadDuration()
    41  			if err != nil {
    42  				err = msgp.WrapError(err, "Max")
    43  				return
    44  			}
    45  		default:
    46  			err = dc.Skip()
    47  			if err != nil {
    48  				err = msgp.WrapError(err)
    49  				return
    50  			}
    51  		}
    52  	}
    53  	return
    54  }
    55  
    56  // EncodeMsg implements msgp.Encodable
    57  func (z LatencyStat) EncodeMsg(en *msgp.Writer) (err error) {
    58  	// map header, size 3
    59  	// write "Curr"
    60  	err = en.Append(0x83, 0xa4, 0x43, 0x75, 0x72, 0x72)
    61  	if err != nil {
    62  		return
    63  	}
    64  	err = en.WriteDuration(z.Curr)
    65  	if err != nil {
    66  		err = msgp.WrapError(err, "Curr")
    67  		return
    68  	}
    69  	// write "Avg"
    70  	err = en.Append(0xa3, 0x41, 0x76, 0x67)
    71  	if err != nil {
    72  		return
    73  	}
    74  	err = en.WriteDuration(z.Avg)
    75  	if err != nil {
    76  		err = msgp.WrapError(err, "Avg")
    77  		return
    78  	}
    79  	// write "Max"
    80  	err = en.Append(0xa3, 0x4d, 0x61, 0x78)
    81  	if err != nil {
    82  		return
    83  	}
    84  	err = en.WriteDuration(z.Max)
    85  	if err != nil {
    86  		err = msgp.WrapError(err, "Max")
    87  		return
    88  	}
    89  	return
    90  }
    91  
    92  // MarshalMsg implements msgp.Marshaler
    93  func (z LatencyStat) MarshalMsg(b []byte) (o []byte, err error) {
    94  	o = msgp.Require(b, z.Msgsize())
    95  	// map header, size 3
    96  	// string "Curr"
    97  	o = append(o, 0x83, 0xa4, 0x43, 0x75, 0x72, 0x72)
    98  	o = msgp.AppendDuration(o, z.Curr)
    99  	// string "Avg"
   100  	o = append(o, 0xa3, 0x41, 0x76, 0x67)
   101  	o = msgp.AppendDuration(o, z.Avg)
   102  	// string "Max"
   103  	o = append(o, 0xa3, 0x4d, 0x61, 0x78)
   104  	o = msgp.AppendDuration(o, z.Max)
   105  	return
   106  }
   107  
   108  // UnmarshalMsg implements msgp.Unmarshaler
   109  func (z *LatencyStat) UnmarshalMsg(bts []byte) (o []byte, err error) {
   110  	var field []byte
   111  	_ = field
   112  	var zb0001 uint32
   113  	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
   114  	if err != nil {
   115  		err = msgp.WrapError(err)
   116  		return
   117  	}
   118  	for zb0001 > 0 {
   119  		zb0001--
   120  		field, bts, err = msgp.ReadMapKeyZC(bts)
   121  		if err != nil {
   122  			err = msgp.WrapError(err)
   123  			return
   124  		}
   125  		switch msgp.UnsafeString(field) {
   126  		case "Curr":
   127  			z.Curr, bts, err = msgp.ReadDurationBytes(bts)
   128  			if err != nil {
   129  				err = msgp.WrapError(err, "Curr")
   130  				return
   131  			}
   132  		case "Avg":
   133  			z.Avg, bts, err = msgp.ReadDurationBytes(bts)
   134  			if err != nil {
   135  				err = msgp.WrapError(err, "Avg")
   136  				return
   137  			}
   138  		case "Max":
   139  			z.Max, bts, err = msgp.ReadDurationBytes(bts)
   140  			if err != nil {
   141  				err = msgp.WrapError(err, "Max")
   142  				return
   143  			}
   144  		default:
   145  			bts, err = msgp.Skip(bts)
   146  			if err != nil {
   147  				err = msgp.WrapError(err)
   148  				return
   149  			}
   150  		}
   151  	}
   152  	o = bts
   153  	return
   154  }
   155  
   156  // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
   157  func (z LatencyStat) Msgsize() (s int) {
   158  	s = 1 + 5 + msgp.DurationSize + 4 + msgp.DurationSize + 4 + msgp.DurationSize
   159  	return
   160  }
   161  
   162  // DecodeMsg implements msgp.Decodable
   163  func (z *RStat) DecodeMsg(dc *msgp.Reader) (err error) {
   164  	var field []byte
   165  	_ = field
   166  	var zb0001 uint32
   167  	zb0001, err = dc.ReadMapHeader()
   168  	if err != nil {
   169  		err = msgp.WrapError(err)
   170  		return
   171  	}
   172  	for zb0001 > 0 {
   173  		zb0001--
   174  		field, err = dc.ReadMapKeyPtr()
   175  		if err != nil {
   176  			err = msgp.WrapError(err)
   177  			return
   178  		}
   179  		switch msgp.UnsafeString(field) {
   180  		case "Count":
   181  			z.Count, err = dc.ReadFloat64()
   182  			if err != nil {
   183  				err = msgp.WrapError(err, "Count")
   184  				return
   185  			}
   186  		case "Bytes":
   187  			z.Bytes, err = dc.ReadInt64()
   188  			if err != nil {
   189  				err = msgp.WrapError(err, "Bytes")
   190  				return
   191  			}
   192  		default:
   193  			err = dc.Skip()
   194  			if err != nil {
   195  				err = msgp.WrapError(err)
   196  				return
   197  			}
   198  		}
   199  	}
   200  	return
   201  }
   202  
   203  // EncodeMsg implements msgp.Encodable
   204  func (z RStat) EncodeMsg(en *msgp.Writer) (err error) {
   205  	// map header, size 2
   206  	// write "Count"
   207  	err = en.Append(0x82, 0xa5, 0x43, 0x6f, 0x75, 0x6e, 0x74)
   208  	if err != nil {
   209  		return
   210  	}
   211  	err = en.WriteFloat64(z.Count)
   212  	if err != nil {
   213  		err = msgp.WrapError(err, "Count")
   214  		return
   215  	}
   216  	// write "Bytes"
   217  	err = en.Append(0xa5, 0x42, 0x79, 0x74, 0x65, 0x73)
   218  	if err != nil {
   219  		return
   220  	}
   221  	err = en.WriteInt64(z.Bytes)
   222  	if err != nil {
   223  		err = msgp.WrapError(err, "Bytes")
   224  		return
   225  	}
   226  	return
   227  }
   228  
   229  // MarshalMsg implements msgp.Marshaler
   230  func (z RStat) MarshalMsg(b []byte) (o []byte, err error) {
   231  	o = msgp.Require(b, z.Msgsize())
   232  	// map header, size 2
   233  	// string "Count"
   234  	o = append(o, 0x82, 0xa5, 0x43, 0x6f, 0x75, 0x6e, 0x74)
   235  	o = msgp.AppendFloat64(o, z.Count)
   236  	// string "Bytes"
   237  	o = append(o, 0xa5, 0x42, 0x79, 0x74, 0x65, 0x73)
   238  	o = msgp.AppendInt64(o, z.Bytes)
   239  	return
   240  }
   241  
   242  // UnmarshalMsg implements msgp.Unmarshaler
   243  func (z *RStat) UnmarshalMsg(bts []byte) (o []byte, err error) {
   244  	var field []byte
   245  	_ = field
   246  	var zb0001 uint32
   247  	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
   248  	if err != nil {
   249  		err = msgp.WrapError(err)
   250  		return
   251  	}
   252  	for zb0001 > 0 {
   253  		zb0001--
   254  		field, bts, err = msgp.ReadMapKeyZC(bts)
   255  		if err != nil {
   256  			err = msgp.WrapError(err)
   257  			return
   258  		}
   259  		switch msgp.UnsafeString(field) {
   260  		case "Count":
   261  			z.Count, bts, err = msgp.ReadFloat64Bytes(bts)
   262  			if err != nil {
   263  				err = msgp.WrapError(err, "Count")
   264  				return
   265  			}
   266  		case "Bytes":
   267  			z.Bytes, bts, err = msgp.ReadInt64Bytes(bts)
   268  			if err != nil {
   269  				err = msgp.WrapError(err, "Bytes")
   270  				return
   271  			}
   272  		default:
   273  			bts, err = msgp.Skip(bts)
   274  			if err != nil {
   275  				err = msgp.WrapError(err)
   276  				return
   277  			}
   278  		}
   279  	}
   280  	o = bts
   281  	return
   282  }
   283  
   284  // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
   285  func (z RStat) Msgsize() (s int) {
   286  	s = 1 + 6 + msgp.Float64Size + 6 + msgp.Int64Size
   287  	return
   288  }
   289  
   290  // DecodeMsg implements msgp.Decodable
   291  func (z *ReplicationMRF) DecodeMsg(dc *msgp.Reader) (err error) {
   292  	var field []byte
   293  	_ = field
   294  	var zb0001 uint32
   295  	zb0001, err = dc.ReadMapHeader()
   296  	if err != nil {
   297  		err = msgp.WrapError(err)
   298  		return
   299  	}
   300  	for zb0001 > 0 {
   301  		zb0001--
   302  		field, err = dc.ReadMapKeyPtr()
   303  		if err != nil {
   304  			err = msgp.WrapError(err)
   305  			return
   306  		}
   307  		switch msgp.UnsafeString(field) {
   308  		case "n":
   309  			z.NodeName, err = dc.ReadString()
   310  			if err != nil {
   311  				err = msgp.WrapError(err, "NodeName")
   312  				return
   313  			}
   314  		case "b":
   315  			z.Bucket, err = dc.ReadString()
   316  			if err != nil {
   317  				err = msgp.WrapError(err, "Bucket")
   318  				return
   319  			}
   320  		case "o":
   321  			z.Object, err = dc.ReadString()
   322  			if err != nil {
   323  				err = msgp.WrapError(err, "Object")
   324  				return
   325  			}
   326  		case "v":
   327  			z.VersionID, err = dc.ReadString()
   328  			if err != nil {
   329  				err = msgp.WrapError(err, "VersionID")
   330  				return
   331  			}
   332  		case "rc":
   333  			z.RetryCount, err = dc.ReadInt()
   334  			if err != nil {
   335  				err = msgp.WrapError(err, "RetryCount")
   336  				return
   337  			}
   338  		case "err":
   339  			z.Err, err = dc.ReadString()
   340  			if err != nil {
   341  				err = msgp.WrapError(err, "Err")
   342  				return
   343  			}
   344  		default:
   345  			err = dc.Skip()
   346  			if err != nil {
   347  				err = msgp.WrapError(err)
   348  				return
   349  			}
   350  		}
   351  	}
   352  	return
   353  }
   354  
   355  // EncodeMsg implements msgp.Encodable
   356  func (z *ReplicationMRF) EncodeMsg(en *msgp.Writer) (err error) {
   357  	// map header, size 6
   358  	// write "n"
   359  	err = en.Append(0x86, 0xa1, 0x6e)
   360  	if err != nil {
   361  		return
   362  	}
   363  	err = en.WriteString(z.NodeName)
   364  	if err != nil {
   365  		err = msgp.WrapError(err, "NodeName")
   366  		return
   367  	}
   368  	// write "b"
   369  	err = en.Append(0xa1, 0x62)
   370  	if err != nil {
   371  		return
   372  	}
   373  	err = en.WriteString(z.Bucket)
   374  	if err != nil {
   375  		err = msgp.WrapError(err, "Bucket")
   376  		return
   377  	}
   378  	// write "o"
   379  	err = en.Append(0xa1, 0x6f)
   380  	if err != nil {
   381  		return
   382  	}
   383  	err = en.WriteString(z.Object)
   384  	if err != nil {
   385  		err = msgp.WrapError(err, "Object")
   386  		return
   387  	}
   388  	// write "v"
   389  	err = en.Append(0xa1, 0x76)
   390  	if err != nil {
   391  		return
   392  	}
   393  	err = en.WriteString(z.VersionID)
   394  	if err != nil {
   395  		err = msgp.WrapError(err, "VersionID")
   396  		return
   397  	}
   398  	// write "rc"
   399  	err = en.Append(0xa2, 0x72, 0x63)
   400  	if err != nil {
   401  		return
   402  	}
   403  	err = en.WriteInt(z.RetryCount)
   404  	if err != nil {
   405  		err = msgp.WrapError(err, "RetryCount")
   406  		return
   407  	}
   408  	// write "err"
   409  	err = en.Append(0xa3, 0x65, 0x72, 0x72)
   410  	if err != nil {
   411  		return
   412  	}
   413  	err = en.WriteString(z.Err)
   414  	if err != nil {
   415  		err = msgp.WrapError(err, "Err")
   416  		return
   417  	}
   418  	return
   419  }
   420  
   421  // MarshalMsg implements msgp.Marshaler
   422  func (z *ReplicationMRF) MarshalMsg(b []byte) (o []byte, err error) {
   423  	o = msgp.Require(b, z.Msgsize())
   424  	// map header, size 6
   425  	// string "n"
   426  	o = append(o, 0x86, 0xa1, 0x6e)
   427  	o = msgp.AppendString(o, z.NodeName)
   428  	// string "b"
   429  	o = append(o, 0xa1, 0x62)
   430  	o = msgp.AppendString(o, z.Bucket)
   431  	// string "o"
   432  	o = append(o, 0xa1, 0x6f)
   433  	o = msgp.AppendString(o, z.Object)
   434  	// string "v"
   435  	o = append(o, 0xa1, 0x76)
   436  	o = msgp.AppendString(o, z.VersionID)
   437  	// string "rc"
   438  	o = append(o, 0xa2, 0x72, 0x63)
   439  	o = msgp.AppendInt(o, z.RetryCount)
   440  	// string "err"
   441  	o = append(o, 0xa3, 0x65, 0x72, 0x72)
   442  	o = msgp.AppendString(o, z.Err)
   443  	return
   444  }
   445  
   446  // UnmarshalMsg implements msgp.Unmarshaler
   447  func (z *ReplicationMRF) UnmarshalMsg(bts []byte) (o []byte, err error) {
   448  	var field []byte
   449  	_ = field
   450  	var zb0001 uint32
   451  	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
   452  	if err != nil {
   453  		err = msgp.WrapError(err)
   454  		return
   455  	}
   456  	for zb0001 > 0 {
   457  		zb0001--
   458  		field, bts, err = msgp.ReadMapKeyZC(bts)
   459  		if err != nil {
   460  			err = msgp.WrapError(err)
   461  			return
   462  		}
   463  		switch msgp.UnsafeString(field) {
   464  		case "n":
   465  			z.NodeName, bts, err = msgp.ReadStringBytes(bts)
   466  			if err != nil {
   467  				err = msgp.WrapError(err, "NodeName")
   468  				return
   469  			}
   470  		case "b":
   471  			z.Bucket, bts, err = msgp.ReadStringBytes(bts)
   472  			if err != nil {
   473  				err = msgp.WrapError(err, "Bucket")
   474  				return
   475  			}
   476  		case "o":
   477  			z.Object, bts, err = msgp.ReadStringBytes(bts)
   478  			if err != nil {
   479  				err = msgp.WrapError(err, "Object")
   480  				return
   481  			}
   482  		case "v":
   483  			z.VersionID, bts, err = msgp.ReadStringBytes(bts)
   484  			if err != nil {
   485  				err = msgp.WrapError(err, "VersionID")
   486  				return
   487  			}
   488  		case "rc":
   489  			z.RetryCount, bts, err = msgp.ReadIntBytes(bts)
   490  			if err != nil {
   491  				err = msgp.WrapError(err, "RetryCount")
   492  				return
   493  			}
   494  		case "err":
   495  			z.Err, bts, err = msgp.ReadStringBytes(bts)
   496  			if err != nil {
   497  				err = msgp.WrapError(err, "Err")
   498  				return
   499  			}
   500  		default:
   501  			bts, err = msgp.Skip(bts)
   502  			if err != nil {
   503  				err = msgp.WrapError(err)
   504  				return
   505  			}
   506  		}
   507  	}
   508  	o = bts
   509  	return
   510  }
   511  
   512  // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
   513  func (z *ReplicationMRF) Msgsize() (s int) {
   514  	s = 1 + 2 + msgp.StringPrefixSize + len(z.NodeName) + 2 + msgp.StringPrefixSize + len(z.Bucket) + 2 + msgp.StringPrefixSize + len(z.Object) + 2 + msgp.StringPrefixSize + len(z.VersionID) + 3 + msgp.IntSize + 4 + msgp.StringPrefixSize + len(z.Err)
   515  	return
   516  }
   517  
   518  // DecodeMsg implements msgp.Decodable
   519  func (z *TimedErrStats) DecodeMsg(dc *msgp.Reader) (err error) {
   520  	var field []byte
   521  	_ = field
   522  	var zb0001 uint32
   523  	zb0001, err = dc.ReadMapHeader()
   524  	if err != nil {
   525  		err = msgp.WrapError(err)
   526  		return
   527  	}
   528  	for zb0001 > 0 {
   529  		zb0001--
   530  		field, err = dc.ReadMapKeyPtr()
   531  		if err != nil {
   532  			err = msgp.WrapError(err)
   533  			return
   534  		}
   535  		switch msgp.UnsafeString(field) {
   536  		case "LastMinute":
   537  			var zb0002 uint32
   538  			zb0002, err = dc.ReadMapHeader()
   539  			if err != nil {
   540  				err = msgp.WrapError(err, "LastMinute")
   541  				return
   542  			}
   543  			for zb0002 > 0 {
   544  				zb0002--
   545  				field, err = dc.ReadMapKeyPtr()
   546  				if err != nil {
   547  					err = msgp.WrapError(err, "LastMinute")
   548  					return
   549  				}
   550  				switch msgp.UnsafeString(field) {
   551  				case "Count":
   552  					z.LastMinute.Count, err = dc.ReadFloat64()
   553  					if err != nil {
   554  						err = msgp.WrapError(err, "LastMinute", "Count")
   555  						return
   556  					}
   557  				case "Bytes":
   558  					z.LastMinute.Bytes, err = dc.ReadInt64()
   559  					if err != nil {
   560  						err = msgp.WrapError(err, "LastMinute", "Bytes")
   561  						return
   562  					}
   563  				default:
   564  					err = dc.Skip()
   565  					if err != nil {
   566  						err = msgp.WrapError(err, "LastMinute")
   567  						return
   568  					}
   569  				}
   570  			}
   571  		case "LastHour":
   572  			var zb0003 uint32
   573  			zb0003, err = dc.ReadMapHeader()
   574  			if err != nil {
   575  				err = msgp.WrapError(err, "LastHour")
   576  				return
   577  			}
   578  			for zb0003 > 0 {
   579  				zb0003--
   580  				field, err = dc.ReadMapKeyPtr()
   581  				if err != nil {
   582  					err = msgp.WrapError(err, "LastHour")
   583  					return
   584  				}
   585  				switch msgp.UnsafeString(field) {
   586  				case "Count":
   587  					z.LastHour.Count, err = dc.ReadFloat64()
   588  					if err != nil {
   589  						err = msgp.WrapError(err, "LastHour", "Count")
   590  						return
   591  					}
   592  				case "Bytes":
   593  					z.LastHour.Bytes, err = dc.ReadInt64()
   594  					if err != nil {
   595  						err = msgp.WrapError(err, "LastHour", "Bytes")
   596  						return
   597  					}
   598  				default:
   599  					err = dc.Skip()
   600  					if err != nil {
   601  						err = msgp.WrapError(err, "LastHour")
   602  						return
   603  					}
   604  				}
   605  			}
   606  		case "Totals":
   607  			var zb0004 uint32
   608  			zb0004, err = dc.ReadMapHeader()
   609  			if err != nil {
   610  				err = msgp.WrapError(err, "Totals")
   611  				return
   612  			}
   613  			for zb0004 > 0 {
   614  				zb0004--
   615  				field, err = dc.ReadMapKeyPtr()
   616  				if err != nil {
   617  					err = msgp.WrapError(err, "Totals")
   618  					return
   619  				}
   620  				switch msgp.UnsafeString(field) {
   621  				case "Count":
   622  					z.Totals.Count, err = dc.ReadFloat64()
   623  					if err != nil {
   624  						err = msgp.WrapError(err, "Totals", "Count")
   625  						return
   626  					}
   627  				case "Bytes":
   628  					z.Totals.Bytes, err = dc.ReadInt64()
   629  					if err != nil {
   630  						err = msgp.WrapError(err, "Totals", "Bytes")
   631  						return
   632  					}
   633  				default:
   634  					err = dc.Skip()
   635  					if err != nil {
   636  						err = msgp.WrapError(err, "Totals")
   637  						return
   638  					}
   639  				}
   640  			}
   641  		case "ErrCounts":
   642  			var zb0005 uint32
   643  			zb0005, err = dc.ReadMapHeader()
   644  			if err != nil {
   645  				err = msgp.WrapError(err, "ErrCounts")
   646  				return
   647  			}
   648  			if z.ErrCounts == nil {
   649  				z.ErrCounts = make(map[string]int, zb0005)
   650  			} else if len(z.ErrCounts) > 0 {
   651  				for key := range z.ErrCounts {
   652  					delete(z.ErrCounts, key)
   653  				}
   654  			}
   655  			for zb0005 > 0 {
   656  				zb0005--
   657  				var za0001 string
   658  				var za0002 int
   659  				za0001, err = dc.ReadString()
   660  				if err != nil {
   661  					err = msgp.WrapError(err, "ErrCounts")
   662  					return
   663  				}
   664  				za0002, err = dc.ReadInt()
   665  				if err != nil {
   666  					err = msgp.WrapError(err, "ErrCounts", za0001)
   667  					return
   668  				}
   669  				z.ErrCounts[za0001] = za0002
   670  			}
   671  		default:
   672  			err = dc.Skip()
   673  			if err != nil {
   674  				err = msgp.WrapError(err)
   675  				return
   676  			}
   677  		}
   678  	}
   679  	return
   680  }
   681  
   682  // EncodeMsg implements msgp.Encodable
   683  func (z *TimedErrStats) EncodeMsg(en *msgp.Writer) (err error) {
   684  	// map header, size 4
   685  	// write "LastMinute"
   686  	err = en.Append(0x84, 0xaa, 0x4c, 0x61, 0x73, 0x74, 0x4d, 0x69, 0x6e, 0x75, 0x74, 0x65)
   687  	if err != nil {
   688  		return
   689  	}
   690  	// map header, size 2
   691  	// write "Count"
   692  	err = en.Append(0x82, 0xa5, 0x43, 0x6f, 0x75, 0x6e, 0x74)
   693  	if err != nil {
   694  		return
   695  	}
   696  	err = en.WriteFloat64(z.LastMinute.Count)
   697  	if err != nil {
   698  		err = msgp.WrapError(err, "LastMinute", "Count")
   699  		return
   700  	}
   701  	// write "Bytes"
   702  	err = en.Append(0xa5, 0x42, 0x79, 0x74, 0x65, 0x73)
   703  	if err != nil {
   704  		return
   705  	}
   706  	err = en.WriteInt64(z.LastMinute.Bytes)
   707  	if err != nil {
   708  		err = msgp.WrapError(err, "LastMinute", "Bytes")
   709  		return
   710  	}
   711  	// write "LastHour"
   712  	err = en.Append(0xa8, 0x4c, 0x61, 0x73, 0x74, 0x48, 0x6f, 0x75, 0x72)
   713  	if err != nil {
   714  		return
   715  	}
   716  	// map header, size 2
   717  	// write "Count"
   718  	err = en.Append(0x82, 0xa5, 0x43, 0x6f, 0x75, 0x6e, 0x74)
   719  	if err != nil {
   720  		return
   721  	}
   722  	err = en.WriteFloat64(z.LastHour.Count)
   723  	if err != nil {
   724  		err = msgp.WrapError(err, "LastHour", "Count")
   725  		return
   726  	}
   727  	// write "Bytes"
   728  	err = en.Append(0xa5, 0x42, 0x79, 0x74, 0x65, 0x73)
   729  	if err != nil {
   730  		return
   731  	}
   732  	err = en.WriteInt64(z.LastHour.Bytes)
   733  	if err != nil {
   734  		err = msgp.WrapError(err, "LastHour", "Bytes")
   735  		return
   736  	}
   737  	// write "Totals"
   738  	err = en.Append(0xa6, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x73)
   739  	if err != nil {
   740  		return
   741  	}
   742  	// map header, size 2
   743  	// write "Count"
   744  	err = en.Append(0x82, 0xa5, 0x43, 0x6f, 0x75, 0x6e, 0x74)
   745  	if err != nil {
   746  		return
   747  	}
   748  	err = en.WriteFloat64(z.Totals.Count)
   749  	if err != nil {
   750  		err = msgp.WrapError(err, "Totals", "Count")
   751  		return
   752  	}
   753  	// write "Bytes"
   754  	err = en.Append(0xa5, 0x42, 0x79, 0x74, 0x65, 0x73)
   755  	if err != nil {
   756  		return
   757  	}
   758  	err = en.WriteInt64(z.Totals.Bytes)
   759  	if err != nil {
   760  		err = msgp.WrapError(err, "Totals", "Bytes")
   761  		return
   762  	}
   763  	// write "ErrCounts"
   764  	err = en.Append(0xa9, 0x45, 0x72, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73)
   765  	if err != nil {
   766  		return
   767  	}
   768  	err = en.WriteMapHeader(uint32(len(z.ErrCounts)))
   769  	if err != nil {
   770  		err = msgp.WrapError(err, "ErrCounts")
   771  		return
   772  	}
   773  	for za0001, za0002 := range z.ErrCounts {
   774  		err = en.WriteString(za0001)
   775  		if err != nil {
   776  			err = msgp.WrapError(err, "ErrCounts")
   777  			return
   778  		}
   779  		err = en.WriteInt(za0002)
   780  		if err != nil {
   781  			err = msgp.WrapError(err, "ErrCounts", za0001)
   782  			return
   783  		}
   784  	}
   785  	return
   786  }
   787  
   788  // MarshalMsg implements msgp.Marshaler
   789  func (z *TimedErrStats) MarshalMsg(b []byte) (o []byte, err error) {
   790  	o = msgp.Require(b, z.Msgsize())
   791  	// map header, size 4
   792  	// string "LastMinute"
   793  	o = append(o, 0x84, 0xaa, 0x4c, 0x61, 0x73, 0x74, 0x4d, 0x69, 0x6e, 0x75, 0x74, 0x65)
   794  	// map header, size 2
   795  	// string "Count"
   796  	o = append(o, 0x82, 0xa5, 0x43, 0x6f, 0x75, 0x6e, 0x74)
   797  	o = msgp.AppendFloat64(o, z.LastMinute.Count)
   798  	// string "Bytes"
   799  	o = append(o, 0xa5, 0x42, 0x79, 0x74, 0x65, 0x73)
   800  	o = msgp.AppendInt64(o, z.LastMinute.Bytes)
   801  	// string "LastHour"
   802  	o = append(o, 0xa8, 0x4c, 0x61, 0x73, 0x74, 0x48, 0x6f, 0x75, 0x72)
   803  	// map header, size 2
   804  	// string "Count"
   805  	o = append(o, 0x82, 0xa5, 0x43, 0x6f, 0x75, 0x6e, 0x74)
   806  	o = msgp.AppendFloat64(o, z.LastHour.Count)
   807  	// string "Bytes"
   808  	o = append(o, 0xa5, 0x42, 0x79, 0x74, 0x65, 0x73)
   809  	o = msgp.AppendInt64(o, z.LastHour.Bytes)
   810  	// string "Totals"
   811  	o = append(o, 0xa6, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x73)
   812  	// map header, size 2
   813  	// string "Count"
   814  	o = append(o, 0x82, 0xa5, 0x43, 0x6f, 0x75, 0x6e, 0x74)
   815  	o = msgp.AppendFloat64(o, z.Totals.Count)
   816  	// string "Bytes"
   817  	o = append(o, 0xa5, 0x42, 0x79, 0x74, 0x65, 0x73)
   818  	o = msgp.AppendInt64(o, z.Totals.Bytes)
   819  	// string "ErrCounts"
   820  	o = append(o, 0xa9, 0x45, 0x72, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73)
   821  	o = msgp.AppendMapHeader(o, uint32(len(z.ErrCounts)))
   822  	for za0001, za0002 := range z.ErrCounts {
   823  		o = msgp.AppendString(o, za0001)
   824  		o = msgp.AppendInt(o, za0002)
   825  	}
   826  	return
   827  }
   828  
   829  // UnmarshalMsg implements msgp.Unmarshaler
   830  func (z *TimedErrStats) UnmarshalMsg(bts []byte) (o []byte, err error) {
   831  	var field []byte
   832  	_ = field
   833  	var zb0001 uint32
   834  	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
   835  	if err != nil {
   836  		err = msgp.WrapError(err)
   837  		return
   838  	}
   839  	for zb0001 > 0 {
   840  		zb0001--
   841  		field, bts, err = msgp.ReadMapKeyZC(bts)
   842  		if err != nil {
   843  			err = msgp.WrapError(err)
   844  			return
   845  		}
   846  		switch msgp.UnsafeString(field) {
   847  		case "LastMinute":
   848  			var zb0002 uint32
   849  			zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
   850  			if err != nil {
   851  				err = msgp.WrapError(err, "LastMinute")
   852  				return
   853  			}
   854  			for zb0002 > 0 {
   855  				zb0002--
   856  				field, bts, err = msgp.ReadMapKeyZC(bts)
   857  				if err != nil {
   858  					err = msgp.WrapError(err, "LastMinute")
   859  					return
   860  				}
   861  				switch msgp.UnsafeString(field) {
   862  				case "Count":
   863  					z.LastMinute.Count, bts, err = msgp.ReadFloat64Bytes(bts)
   864  					if err != nil {
   865  						err = msgp.WrapError(err, "LastMinute", "Count")
   866  						return
   867  					}
   868  				case "Bytes":
   869  					z.LastMinute.Bytes, bts, err = msgp.ReadInt64Bytes(bts)
   870  					if err != nil {
   871  						err = msgp.WrapError(err, "LastMinute", "Bytes")
   872  						return
   873  					}
   874  				default:
   875  					bts, err = msgp.Skip(bts)
   876  					if err != nil {
   877  						err = msgp.WrapError(err, "LastMinute")
   878  						return
   879  					}
   880  				}
   881  			}
   882  		case "LastHour":
   883  			var zb0003 uint32
   884  			zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
   885  			if err != nil {
   886  				err = msgp.WrapError(err, "LastHour")
   887  				return
   888  			}
   889  			for zb0003 > 0 {
   890  				zb0003--
   891  				field, bts, err = msgp.ReadMapKeyZC(bts)
   892  				if err != nil {
   893  					err = msgp.WrapError(err, "LastHour")
   894  					return
   895  				}
   896  				switch msgp.UnsafeString(field) {
   897  				case "Count":
   898  					z.LastHour.Count, bts, err = msgp.ReadFloat64Bytes(bts)
   899  					if err != nil {
   900  						err = msgp.WrapError(err, "LastHour", "Count")
   901  						return
   902  					}
   903  				case "Bytes":
   904  					z.LastHour.Bytes, bts, err = msgp.ReadInt64Bytes(bts)
   905  					if err != nil {
   906  						err = msgp.WrapError(err, "LastHour", "Bytes")
   907  						return
   908  					}
   909  				default:
   910  					bts, err = msgp.Skip(bts)
   911  					if err != nil {
   912  						err = msgp.WrapError(err, "LastHour")
   913  						return
   914  					}
   915  				}
   916  			}
   917  		case "Totals":
   918  			var zb0004 uint32
   919  			zb0004, bts, err = msgp.ReadMapHeaderBytes(bts)
   920  			if err != nil {
   921  				err = msgp.WrapError(err, "Totals")
   922  				return
   923  			}
   924  			for zb0004 > 0 {
   925  				zb0004--
   926  				field, bts, err = msgp.ReadMapKeyZC(bts)
   927  				if err != nil {
   928  					err = msgp.WrapError(err, "Totals")
   929  					return
   930  				}
   931  				switch msgp.UnsafeString(field) {
   932  				case "Count":
   933  					z.Totals.Count, bts, err = msgp.ReadFloat64Bytes(bts)
   934  					if err != nil {
   935  						err = msgp.WrapError(err, "Totals", "Count")
   936  						return
   937  					}
   938  				case "Bytes":
   939  					z.Totals.Bytes, bts, err = msgp.ReadInt64Bytes(bts)
   940  					if err != nil {
   941  						err = msgp.WrapError(err, "Totals", "Bytes")
   942  						return
   943  					}
   944  				default:
   945  					bts, err = msgp.Skip(bts)
   946  					if err != nil {
   947  						err = msgp.WrapError(err, "Totals")
   948  						return
   949  					}
   950  				}
   951  			}
   952  		case "ErrCounts":
   953  			var zb0005 uint32
   954  			zb0005, bts, err = msgp.ReadMapHeaderBytes(bts)
   955  			if err != nil {
   956  				err = msgp.WrapError(err, "ErrCounts")
   957  				return
   958  			}
   959  			if z.ErrCounts == nil {
   960  				z.ErrCounts = make(map[string]int, zb0005)
   961  			} else if len(z.ErrCounts) > 0 {
   962  				for key := range z.ErrCounts {
   963  					delete(z.ErrCounts, key)
   964  				}
   965  			}
   966  			for zb0005 > 0 {
   967  				var za0001 string
   968  				var za0002 int
   969  				zb0005--
   970  				za0001, bts, err = msgp.ReadStringBytes(bts)
   971  				if err != nil {
   972  					err = msgp.WrapError(err, "ErrCounts")
   973  					return
   974  				}
   975  				za0002, bts, err = msgp.ReadIntBytes(bts)
   976  				if err != nil {
   977  					err = msgp.WrapError(err, "ErrCounts", za0001)
   978  					return
   979  				}
   980  				z.ErrCounts[za0001] = za0002
   981  			}
   982  		default:
   983  			bts, err = msgp.Skip(bts)
   984  			if err != nil {
   985  				err = msgp.WrapError(err)
   986  				return
   987  			}
   988  		}
   989  	}
   990  	o = bts
   991  	return
   992  }
   993  
   994  // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
   995  func (z *TimedErrStats) Msgsize() (s int) {
   996  	s = 1 + 11 + 1 + 6 + msgp.Float64Size + 6 + msgp.Int64Size + 9 + 1 + 6 + msgp.Float64Size + 6 + msgp.Int64Size + 7 + 1 + 6 + msgp.Float64Size + 6 + msgp.Int64Size + 10 + msgp.MapHeaderSize
   997  	if z.ErrCounts != nil {
   998  		for za0001, za0002 := range z.ErrCounts {
   999  			_ = za0002
  1000  			s += msgp.StringPrefixSize + len(za0001) + msgp.IntSize
  1001  		}
  1002  	}
  1003  	return
  1004  }