You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

864 lines
20 KiB

  1. package cmd
  2. // Code generated by github.com/tinylib/msgp DO NOT EDIT.
  3. import (
  4. "time"
  5. "github.com/tinylib/msgp/msgp"
  6. )
  7. // DecodeMsg implements msgp.Decodable
  8. func (z *BatchJobExpire) DecodeMsg(dc *msgp.Reader) (err error) {
  9. var field []byte
  10. _ = field
  11. var zb0001 uint32
  12. zb0001, err = dc.ReadMapHeader()
  13. if err != nil {
  14. err = msgp.WrapError(err)
  15. return
  16. }
  17. for zb0001 > 0 {
  18. zb0001--
  19. field, err = dc.ReadMapKeyPtr()
  20. if err != nil {
  21. err = msgp.WrapError(err)
  22. return
  23. }
  24. switch msgp.UnsafeString(field) {
  25. case "APIVersion":
  26. z.APIVersion, err = dc.ReadString()
  27. if err != nil {
  28. err = msgp.WrapError(err, "APIVersion")
  29. return
  30. }
  31. case "Bucket":
  32. z.Bucket, err = dc.ReadString()
  33. if err != nil {
  34. err = msgp.WrapError(err, "Bucket")
  35. return
  36. }
  37. case "Prefix":
  38. err = z.Prefix.DecodeMsg(dc)
  39. if err != nil {
  40. err = msgp.WrapError(err, "Prefix")
  41. return
  42. }
  43. case "NotificationCfg":
  44. err = z.NotificationCfg.DecodeMsg(dc)
  45. if err != nil {
  46. err = msgp.WrapError(err, "NotificationCfg")
  47. return
  48. }
  49. case "Retry":
  50. err = z.Retry.DecodeMsg(dc)
  51. if err != nil {
  52. err = msgp.WrapError(err, "Retry")
  53. return
  54. }
  55. case "Rules":
  56. var zb0002 uint32
  57. zb0002, err = dc.ReadArrayHeader()
  58. if err != nil {
  59. err = msgp.WrapError(err, "Rules")
  60. return
  61. }
  62. if cap(z.Rules) >= int(zb0002) {
  63. z.Rules = (z.Rules)[:zb0002]
  64. } else {
  65. z.Rules = make([]BatchJobExpireFilter, zb0002)
  66. }
  67. for za0001 := range z.Rules {
  68. err = z.Rules[za0001].DecodeMsg(dc)
  69. if err != nil {
  70. err = msgp.WrapError(err, "Rules", za0001)
  71. return
  72. }
  73. }
  74. default:
  75. err = dc.Skip()
  76. if err != nil {
  77. err = msgp.WrapError(err)
  78. return
  79. }
  80. }
  81. }
  82. return
  83. }
  84. // EncodeMsg implements msgp.Encodable
  85. func (z *BatchJobExpire) EncodeMsg(en *msgp.Writer) (err error) {
  86. // map header, size 6
  87. // write "APIVersion"
  88. err = en.Append(0x86, 0xaa, 0x41, 0x50, 0x49, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
  89. if err != nil {
  90. return
  91. }
  92. err = en.WriteString(z.APIVersion)
  93. if err != nil {
  94. err = msgp.WrapError(err, "APIVersion")
  95. return
  96. }
  97. // write "Bucket"
  98. err = en.Append(0xa6, 0x42, 0x75, 0x63, 0x6b, 0x65, 0x74)
  99. if err != nil {
  100. return
  101. }
  102. err = en.WriteString(z.Bucket)
  103. if err != nil {
  104. err = msgp.WrapError(err, "Bucket")
  105. return
  106. }
  107. // write "Prefix"
  108. err = en.Append(0xa6, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78)
  109. if err != nil {
  110. return
  111. }
  112. err = z.Prefix.EncodeMsg(en)
  113. if err != nil {
  114. err = msgp.WrapError(err, "Prefix")
  115. return
  116. }
  117. // write "NotificationCfg"
  118. err = en.Append(0xaf, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x66, 0x67)
  119. if err != nil {
  120. return
  121. }
  122. err = z.NotificationCfg.EncodeMsg(en)
  123. if err != nil {
  124. err = msgp.WrapError(err, "NotificationCfg")
  125. return
  126. }
  127. // write "Retry"
  128. err = en.Append(0xa5, 0x52, 0x65, 0x74, 0x72, 0x79)
  129. if err != nil {
  130. return
  131. }
  132. err = z.Retry.EncodeMsg(en)
  133. if err != nil {
  134. err = msgp.WrapError(err, "Retry")
  135. return
  136. }
  137. // write "Rules"
  138. err = en.Append(0xa5, 0x52, 0x75, 0x6c, 0x65, 0x73)
  139. if err != nil {
  140. return
  141. }
  142. err = en.WriteArrayHeader(uint32(len(z.Rules)))
  143. if err != nil {
  144. err = msgp.WrapError(err, "Rules")
  145. return
  146. }
  147. for za0001 := range z.Rules {
  148. err = z.Rules[za0001].EncodeMsg(en)
  149. if err != nil {
  150. err = msgp.WrapError(err, "Rules", za0001)
  151. return
  152. }
  153. }
  154. return
  155. }
  156. // MarshalMsg implements msgp.Marshaler
  157. func (z *BatchJobExpire) MarshalMsg(b []byte) (o []byte, err error) {
  158. o = msgp.Require(b, z.Msgsize())
  159. // map header, size 6
  160. // string "APIVersion"
  161. o = append(o, 0x86, 0xaa, 0x41, 0x50, 0x49, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
  162. o = msgp.AppendString(o, z.APIVersion)
  163. // string "Bucket"
  164. o = append(o, 0xa6, 0x42, 0x75, 0x63, 0x6b, 0x65, 0x74)
  165. o = msgp.AppendString(o, z.Bucket)
  166. // string "Prefix"
  167. o = append(o, 0xa6, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78)
  168. o, err = z.Prefix.MarshalMsg(o)
  169. if err != nil {
  170. err = msgp.WrapError(err, "Prefix")
  171. return
  172. }
  173. // string "NotificationCfg"
  174. o = append(o, 0xaf, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x66, 0x67)
  175. o, err = z.NotificationCfg.MarshalMsg(o)
  176. if err != nil {
  177. err = msgp.WrapError(err, "NotificationCfg")
  178. return
  179. }
  180. // string "Retry"
  181. o = append(o, 0xa5, 0x52, 0x65, 0x74, 0x72, 0x79)
  182. o, err = z.Retry.MarshalMsg(o)
  183. if err != nil {
  184. err = msgp.WrapError(err, "Retry")
  185. return
  186. }
  187. // string "Rules"
  188. o = append(o, 0xa5, 0x52, 0x75, 0x6c, 0x65, 0x73)
  189. o = msgp.AppendArrayHeader(o, uint32(len(z.Rules)))
  190. for za0001 := range z.Rules {
  191. o, err = z.Rules[za0001].MarshalMsg(o)
  192. if err != nil {
  193. err = msgp.WrapError(err, "Rules", za0001)
  194. return
  195. }
  196. }
  197. return
  198. }
  199. // UnmarshalMsg implements msgp.Unmarshaler
  200. func (z *BatchJobExpire) UnmarshalMsg(bts []byte) (o []byte, err error) {
  201. var field []byte
  202. _ = field
  203. var zb0001 uint32
  204. zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
  205. if err != nil {
  206. err = msgp.WrapError(err)
  207. return
  208. }
  209. for zb0001 > 0 {
  210. zb0001--
  211. field, bts, err = msgp.ReadMapKeyZC(bts)
  212. if err != nil {
  213. err = msgp.WrapError(err)
  214. return
  215. }
  216. switch msgp.UnsafeString(field) {
  217. case "APIVersion":
  218. z.APIVersion, bts, err = msgp.ReadStringBytes(bts)
  219. if err != nil {
  220. err = msgp.WrapError(err, "APIVersion")
  221. return
  222. }
  223. case "Bucket":
  224. z.Bucket, bts, err = msgp.ReadStringBytes(bts)
  225. if err != nil {
  226. err = msgp.WrapError(err, "Bucket")
  227. return
  228. }
  229. case "Prefix":
  230. bts, err = z.Prefix.UnmarshalMsg(bts)
  231. if err != nil {
  232. err = msgp.WrapError(err, "Prefix")
  233. return
  234. }
  235. case "NotificationCfg":
  236. bts, err = z.NotificationCfg.UnmarshalMsg(bts)
  237. if err != nil {
  238. err = msgp.WrapError(err, "NotificationCfg")
  239. return
  240. }
  241. case "Retry":
  242. bts, err = z.Retry.UnmarshalMsg(bts)
  243. if err != nil {
  244. err = msgp.WrapError(err, "Retry")
  245. return
  246. }
  247. case "Rules":
  248. var zb0002 uint32
  249. zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
  250. if err != nil {
  251. err = msgp.WrapError(err, "Rules")
  252. return
  253. }
  254. if cap(z.Rules) >= int(zb0002) {
  255. z.Rules = (z.Rules)[:zb0002]
  256. } else {
  257. z.Rules = make([]BatchJobExpireFilter, zb0002)
  258. }
  259. for za0001 := range z.Rules {
  260. bts, err = z.Rules[za0001].UnmarshalMsg(bts)
  261. if err != nil {
  262. err = msgp.WrapError(err, "Rules", za0001)
  263. return
  264. }
  265. }
  266. default:
  267. bts, err = msgp.Skip(bts)
  268. if err != nil {
  269. err = msgp.WrapError(err)
  270. return
  271. }
  272. }
  273. }
  274. o = bts
  275. return
  276. }
  277. // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
  278. func (z *BatchJobExpire) Msgsize() (s int) {
  279. s = 1 + 11 + msgp.StringPrefixSize + len(z.APIVersion) + 7 + msgp.StringPrefixSize + len(z.Bucket) + 7 + z.Prefix.Msgsize() + 16 + z.NotificationCfg.Msgsize() + 6 + z.Retry.Msgsize() + 6 + msgp.ArrayHeaderSize
  280. for za0001 := range z.Rules {
  281. s += z.Rules[za0001].Msgsize()
  282. }
  283. return
  284. }
  285. // DecodeMsg implements msgp.Decodable
  286. func (z *BatchJobExpireFilter) DecodeMsg(dc *msgp.Reader) (err error) {
  287. var field []byte
  288. _ = field
  289. var zb0001 uint32
  290. zb0001, err = dc.ReadMapHeader()
  291. if err != nil {
  292. err = msgp.WrapError(err)
  293. return
  294. }
  295. for zb0001 > 0 {
  296. zb0001--
  297. field, err = dc.ReadMapKeyPtr()
  298. if err != nil {
  299. err = msgp.WrapError(err)
  300. return
  301. }
  302. switch msgp.UnsafeString(field) {
  303. case "OlderThan":
  304. err = z.OlderThan.DecodeMsg(dc)
  305. if err != nil {
  306. err = msgp.WrapError(err, "OlderThan")
  307. return
  308. }
  309. case "CreatedBefore":
  310. if dc.IsNil() {
  311. err = dc.ReadNil()
  312. if err != nil {
  313. err = msgp.WrapError(err, "CreatedBefore")
  314. return
  315. }
  316. z.CreatedBefore = nil
  317. } else {
  318. if z.CreatedBefore == nil {
  319. z.CreatedBefore = new(time.Time)
  320. }
  321. *z.CreatedBefore, err = dc.ReadTime()
  322. if err != nil {
  323. err = msgp.WrapError(err, "CreatedBefore")
  324. return
  325. }
  326. }
  327. case "Tags":
  328. var zb0002 uint32
  329. zb0002, err = dc.ReadArrayHeader()
  330. if err != nil {
  331. err = msgp.WrapError(err, "Tags")
  332. return
  333. }
  334. if cap(z.Tags) >= int(zb0002) {
  335. z.Tags = (z.Tags)[:zb0002]
  336. } else {
  337. z.Tags = make([]BatchJobKV, zb0002)
  338. }
  339. for za0001 := range z.Tags {
  340. err = z.Tags[za0001].DecodeMsg(dc)
  341. if err != nil {
  342. err = msgp.WrapError(err, "Tags", za0001)
  343. return
  344. }
  345. }
  346. case "Metadata":
  347. var zb0003 uint32
  348. zb0003, err = dc.ReadArrayHeader()
  349. if err != nil {
  350. err = msgp.WrapError(err, "Metadata")
  351. return
  352. }
  353. if cap(z.Metadata) >= int(zb0003) {
  354. z.Metadata = (z.Metadata)[:zb0003]
  355. } else {
  356. z.Metadata = make([]BatchJobKV, zb0003)
  357. }
  358. for za0002 := range z.Metadata {
  359. err = z.Metadata[za0002].DecodeMsg(dc)
  360. if err != nil {
  361. err = msgp.WrapError(err, "Metadata", za0002)
  362. return
  363. }
  364. }
  365. case "Size":
  366. err = z.Size.DecodeMsg(dc)
  367. if err != nil {
  368. err = msgp.WrapError(err, "Size")
  369. return
  370. }
  371. case "Type":
  372. z.Type, err = dc.ReadString()
  373. if err != nil {
  374. err = msgp.WrapError(err, "Type")
  375. return
  376. }
  377. case "Name":
  378. z.Name, err = dc.ReadString()
  379. if err != nil {
  380. err = msgp.WrapError(err, "Name")
  381. return
  382. }
  383. case "Purge":
  384. var zb0004 uint32
  385. zb0004, err = dc.ReadMapHeader()
  386. if err != nil {
  387. err = msgp.WrapError(err, "Purge")
  388. return
  389. }
  390. for zb0004 > 0 {
  391. zb0004--
  392. field, err = dc.ReadMapKeyPtr()
  393. if err != nil {
  394. err = msgp.WrapError(err, "Purge")
  395. return
  396. }
  397. switch msgp.UnsafeString(field) {
  398. case "RetainVersions":
  399. z.Purge.RetainVersions, err = dc.ReadInt()
  400. if err != nil {
  401. err = msgp.WrapError(err, "Purge", "RetainVersions")
  402. return
  403. }
  404. default:
  405. err = dc.Skip()
  406. if err != nil {
  407. err = msgp.WrapError(err, "Purge")
  408. return
  409. }
  410. }
  411. }
  412. default:
  413. err = dc.Skip()
  414. if err != nil {
  415. err = msgp.WrapError(err)
  416. return
  417. }
  418. }
  419. }
  420. return
  421. }
  422. // EncodeMsg implements msgp.Encodable
  423. func (z *BatchJobExpireFilter) EncodeMsg(en *msgp.Writer) (err error) {
  424. // map header, size 8
  425. // write "OlderThan"
  426. err = en.Append(0x88, 0xa9, 0x4f, 0x6c, 0x64, 0x65, 0x72, 0x54, 0x68, 0x61, 0x6e)
  427. if err != nil {
  428. return
  429. }
  430. err = z.OlderThan.EncodeMsg(en)
  431. if err != nil {
  432. err = msgp.WrapError(err, "OlderThan")
  433. return
  434. }
  435. // write "CreatedBefore"
  436. err = en.Append(0xad, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65)
  437. if err != nil {
  438. return
  439. }
  440. if z.CreatedBefore == nil {
  441. err = en.WriteNil()
  442. if err != nil {
  443. return
  444. }
  445. } else {
  446. err = en.WriteTime(*z.CreatedBefore)
  447. if err != nil {
  448. err = msgp.WrapError(err, "CreatedBefore")
  449. return
  450. }
  451. }
  452. // write "Tags"
  453. err = en.Append(0xa4, 0x54, 0x61, 0x67, 0x73)
  454. if err != nil {
  455. return
  456. }
  457. err = en.WriteArrayHeader(uint32(len(z.Tags)))
  458. if err != nil {
  459. err = msgp.WrapError(err, "Tags")
  460. return
  461. }
  462. for za0001 := range z.Tags {
  463. err = z.Tags[za0001].EncodeMsg(en)
  464. if err != nil {
  465. err = msgp.WrapError(err, "Tags", za0001)
  466. return
  467. }
  468. }
  469. // write "Metadata"
  470. err = en.Append(0xa8, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61)
  471. if err != nil {
  472. return
  473. }
  474. err = en.WriteArrayHeader(uint32(len(z.Metadata)))
  475. if err != nil {
  476. err = msgp.WrapError(err, "Metadata")
  477. return
  478. }
  479. for za0002 := range z.Metadata {
  480. err = z.Metadata[za0002].EncodeMsg(en)
  481. if err != nil {
  482. err = msgp.WrapError(err, "Metadata", za0002)
  483. return
  484. }
  485. }
  486. // write "Size"
  487. err = en.Append(0xa4, 0x53, 0x69, 0x7a, 0x65)
  488. if err != nil {
  489. return
  490. }
  491. err = z.Size.EncodeMsg(en)
  492. if err != nil {
  493. err = msgp.WrapError(err, "Size")
  494. return
  495. }
  496. // write "Type"
  497. err = en.Append(0xa4, 0x54, 0x79, 0x70, 0x65)
  498. if err != nil {
  499. return
  500. }
  501. err = en.WriteString(z.Type)
  502. if err != nil {
  503. err = msgp.WrapError(err, "Type")
  504. return
  505. }
  506. // write "Name"
  507. err = en.Append(0xa4, 0x4e, 0x61, 0x6d, 0x65)
  508. if err != nil {
  509. return
  510. }
  511. err = en.WriteString(z.Name)
  512. if err != nil {
  513. err = msgp.WrapError(err, "Name")
  514. return
  515. }
  516. // write "Purge"
  517. err = en.Append(0xa5, 0x50, 0x75, 0x72, 0x67, 0x65)
  518. if err != nil {
  519. return
  520. }
  521. // map header, size 1
  522. // write "RetainVersions"
  523. err = en.Append(0x81, 0xae, 0x52, 0x65, 0x74, 0x61, 0x69, 0x6e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73)
  524. if err != nil {
  525. return
  526. }
  527. err = en.WriteInt(z.Purge.RetainVersions)
  528. if err != nil {
  529. err = msgp.WrapError(err, "Purge", "RetainVersions")
  530. return
  531. }
  532. return
  533. }
  534. // MarshalMsg implements msgp.Marshaler
  535. func (z *BatchJobExpireFilter) MarshalMsg(b []byte) (o []byte, err error) {
  536. o = msgp.Require(b, z.Msgsize())
  537. // map header, size 8
  538. // string "OlderThan"
  539. o = append(o, 0x88, 0xa9, 0x4f, 0x6c, 0x64, 0x65, 0x72, 0x54, 0x68, 0x61, 0x6e)
  540. o, err = z.OlderThan.MarshalMsg(o)
  541. if err != nil {
  542. err = msgp.WrapError(err, "OlderThan")
  543. return
  544. }
  545. // string "CreatedBefore"
  546. o = append(o, 0xad, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65)
  547. if z.CreatedBefore == nil {
  548. o = msgp.AppendNil(o)
  549. } else {
  550. o = msgp.AppendTime(o, *z.CreatedBefore)
  551. }
  552. // string "Tags"
  553. o = append(o, 0xa4, 0x54, 0x61, 0x67, 0x73)
  554. o = msgp.AppendArrayHeader(o, uint32(len(z.Tags)))
  555. for za0001 := range z.Tags {
  556. o, err = z.Tags[za0001].MarshalMsg(o)
  557. if err != nil {
  558. err = msgp.WrapError(err, "Tags", za0001)
  559. return
  560. }
  561. }
  562. // string "Metadata"
  563. o = append(o, 0xa8, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61)
  564. o = msgp.AppendArrayHeader(o, uint32(len(z.Metadata)))
  565. for za0002 := range z.Metadata {
  566. o, err = z.Metadata[za0002].MarshalMsg(o)
  567. if err != nil {
  568. err = msgp.WrapError(err, "Metadata", za0002)
  569. return
  570. }
  571. }
  572. // string "Size"
  573. o = append(o, 0xa4, 0x53, 0x69, 0x7a, 0x65)
  574. o, err = z.Size.MarshalMsg(o)
  575. if err != nil {
  576. err = msgp.WrapError(err, "Size")
  577. return
  578. }
  579. // string "Type"
  580. o = append(o, 0xa4, 0x54, 0x79, 0x70, 0x65)
  581. o = msgp.AppendString(o, z.Type)
  582. // string "Name"
  583. o = append(o, 0xa4, 0x4e, 0x61, 0x6d, 0x65)
  584. o = msgp.AppendString(o, z.Name)
  585. // string "Purge"
  586. o = append(o, 0xa5, 0x50, 0x75, 0x72, 0x67, 0x65)
  587. // map header, size 1
  588. // string "RetainVersions"
  589. o = append(o, 0x81, 0xae, 0x52, 0x65, 0x74, 0x61, 0x69, 0x6e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73)
  590. o = msgp.AppendInt(o, z.Purge.RetainVersions)
  591. return
  592. }
  593. // UnmarshalMsg implements msgp.Unmarshaler
  594. func (z *BatchJobExpireFilter) UnmarshalMsg(bts []byte) (o []byte, err error) {
  595. var field []byte
  596. _ = field
  597. var zb0001 uint32
  598. zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
  599. if err != nil {
  600. err = msgp.WrapError(err)
  601. return
  602. }
  603. for zb0001 > 0 {
  604. zb0001--
  605. field, bts, err = msgp.ReadMapKeyZC(bts)
  606. if err != nil {
  607. err = msgp.WrapError(err)
  608. return
  609. }
  610. switch msgp.UnsafeString(field) {
  611. case "OlderThan":
  612. bts, err = z.OlderThan.UnmarshalMsg(bts)
  613. if err != nil {
  614. err = msgp.WrapError(err, "OlderThan")
  615. return
  616. }
  617. case "CreatedBefore":
  618. if msgp.IsNil(bts) {
  619. bts, err = msgp.ReadNilBytes(bts)
  620. if err != nil {
  621. return
  622. }
  623. z.CreatedBefore = nil
  624. } else {
  625. if z.CreatedBefore == nil {
  626. z.CreatedBefore = new(time.Time)
  627. }
  628. *z.CreatedBefore, bts, err = msgp.ReadTimeBytes(bts)
  629. if err != nil {
  630. err = msgp.WrapError(err, "CreatedBefore")
  631. return
  632. }
  633. }
  634. case "Tags":
  635. var zb0002 uint32
  636. zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
  637. if err != nil {
  638. err = msgp.WrapError(err, "Tags")
  639. return
  640. }
  641. if cap(z.Tags) >= int(zb0002) {
  642. z.Tags = (z.Tags)[:zb0002]
  643. } else {
  644. z.Tags = make([]BatchJobKV, zb0002)
  645. }
  646. for za0001 := range z.Tags {
  647. bts, err = z.Tags[za0001].UnmarshalMsg(bts)
  648. if err != nil {
  649. err = msgp.WrapError(err, "Tags", za0001)
  650. return
  651. }
  652. }
  653. case "Metadata":
  654. var zb0003 uint32
  655. zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
  656. if err != nil {
  657. err = msgp.WrapError(err, "Metadata")
  658. return
  659. }
  660. if cap(z.Metadata) >= int(zb0003) {
  661. z.Metadata = (z.Metadata)[:zb0003]
  662. } else {
  663. z.Metadata = make([]BatchJobKV, zb0003)
  664. }
  665. for za0002 := range z.Metadata {
  666. bts, err = z.Metadata[za0002].UnmarshalMsg(bts)
  667. if err != nil {
  668. err = msgp.WrapError(err, "Metadata", za0002)
  669. return
  670. }
  671. }
  672. case "Size":
  673. bts, err = z.Size.UnmarshalMsg(bts)
  674. if err != nil {
  675. err = msgp.WrapError(err, "Size")
  676. return
  677. }
  678. case "Type":
  679. z.Type, bts, err = msgp.ReadStringBytes(bts)
  680. if err != nil {
  681. err = msgp.WrapError(err, "Type")
  682. return
  683. }
  684. case "Name":
  685. z.Name, bts, err = msgp.ReadStringBytes(bts)
  686. if err != nil {
  687. err = msgp.WrapError(err, "Name")
  688. return
  689. }
  690. case "Purge":
  691. var zb0004 uint32
  692. zb0004, bts, err = msgp.ReadMapHeaderBytes(bts)
  693. if err != nil {
  694. err = msgp.WrapError(err, "Purge")
  695. return
  696. }
  697. for zb0004 > 0 {
  698. zb0004--
  699. field, bts, err = msgp.ReadMapKeyZC(bts)
  700. if err != nil {
  701. err = msgp.WrapError(err, "Purge")
  702. return
  703. }
  704. switch msgp.UnsafeString(field) {
  705. case "RetainVersions":
  706. z.Purge.RetainVersions, bts, err = msgp.ReadIntBytes(bts)
  707. if err != nil {
  708. err = msgp.WrapError(err, "Purge", "RetainVersions")
  709. return
  710. }
  711. default:
  712. bts, err = msgp.Skip(bts)
  713. if err != nil {
  714. err = msgp.WrapError(err, "Purge")
  715. return
  716. }
  717. }
  718. }
  719. default:
  720. bts, err = msgp.Skip(bts)
  721. if err != nil {
  722. err = msgp.WrapError(err)
  723. return
  724. }
  725. }
  726. }
  727. o = bts
  728. return
  729. }
  730. // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
  731. func (z *BatchJobExpireFilter) Msgsize() (s int) {
  732. s = 1 + 10 + z.OlderThan.Msgsize() + 14
  733. if z.CreatedBefore == nil {
  734. s += msgp.NilSize
  735. } else {
  736. s += msgp.TimeSize
  737. }
  738. s += 5 + msgp.ArrayHeaderSize
  739. for za0001 := range z.Tags {
  740. s += z.Tags[za0001].Msgsize()
  741. }
  742. s += 9 + msgp.ArrayHeaderSize
  743. for za0002 := range z.Metadata {
  744. s += z.Metadata[za0002].Msgsize()
  745. }
  746. s += 5 + z.Size.Msgsize() + 5 + msgp.StringPrefixSize + len(z.Type) + 5 + msgp.StringPrefixSize + len(z.Name) + 6 + 1 + 15 + msgp.IntSize
  747. return
  748. }
  749. // DecodeMsg implements msgp.Decodable
  750. func (z *BatchJobExpirePurge) DecodeMsg(dc *msgp.Reader) (err error) {
  751. var field []byte
  752. _ = field
  753. var zb0001 uint32
  754. zb0001, err = dc.ReadMapHeader()
  755. if err != nil {
  756. err = msgp.WrapError(err)
  757. return
  758. }
  759. for zb0001 > 0 {
  760. zb0001--
  761. field, err = dc.ReadMapKeyPtr()
  762. if err != nil {
  763. err = msgp.WrapError(err)
  764. return
  765. }
  766. switch msgp.UnsafeString(field) {
  767. case "RetainVersions":
  768. z.RetainVersions, err = dc.ReadInt()
  769. if err != nil {
  770. err = msgp.WrapError(err, "RetainVersions")
  771. return
  772. }
  773. default:
  774. err = dc.Skip()
  775. if err != nil {
  776. err = msgp.WrapError(err)
  777. return
  778. }
  779. }
  780. }
  781. return
  782. }
  783. // EncodeMsg implements msgp.Encodable
  784. func (z BatchJobExpirePurge) EncodeMsg(en *msgp.Writer) (err error) {
  785. // map header, size 1
  786. // write "RetainVersions"
  787. err = en.Append(0x81, 0xae, 0x52, 0x65, 0x74, 0x61, 0x69, 0x6e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73)
  788. if err != nil {
  789. return
  790. }
  791. err = en.WriteInt(z.RetainVersions)
  792. if err != nil {
  793. err = msgp.WrapError(err, "RetainVersions")
  794. return
  795. }
  796. return
  797. }
  798. // MarshalMsg implements msgp.Marshaler
  799. func (z BatchJobExpirePurge) MarshalMsg(b []byte) (o []byte, err error) {
  800. o = msgp.Require(b, z.Msgsize())
  801. // map header, size 1
  802. // string "RetainVersions"
  803. o = append(o, 0x81, 0xae, 0x52, 0x65, 0x74, 0x61, 0x69, 0x6e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73)
  804. o = msgp.AppendInt(o, z.RetainVersions)
  805. return
  806. }
  807. // UnmarshalMsg implements msgp.Unmarshaler
  808. func (z *BatchJobExpirePurge) UnmarshalMsg(bts []byte) (o []byte, err error) {
  809. var field []byte
  810. _ = field
  811. var zb0001 uint32
  812. zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
  813. if err != nil {
  814. err = msgp.WrapError(err)
  815. return
  816. }
  817. for zb0001 > 0 {
  818. zb0001--
  819. field, bts, err = msgp.ReadMapKeyZC(bts)
  820. if err != nil {
  821. err = msgp.WrapError(err)
  822. return
  823. }
  824. switch msgp.UnsafeString(field) {
  825. case "RetainVersions":
  826. z.RetainVersions, bts, err = msgp.ReadIntBytes(bts)
  827. if err != nil {
  828. err = msgp.WrapError(err, "RetainVersions")
  829. return
  830. }
  831. default:
  832. bts, err = msgp.Skip(bts)
  833. if err != nil {
  834. err = msgp.WrapError(err)
  835. return
  836. }
  837. }
  838. }
  839. o = bts
  840. return
  841. }
  842. // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
  843. func (z BatchJobExpirePurge) Msgsize() (s int) {
  844. s = 1 + 15 + msgp.IntSize
  845. return
  846. }