osbzr
/
com
项目红包剩余9514，下一贡献奖励5%，即 476个红包
Watch 15
Star 7
Wiki 捐赠
本站源代码
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.
Tree: 4f0cac5ea6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4f0cac5ea6'
${ noResults }
com/vendor/github.com/RoaringBitmap/roaring/roaringarray_gen.go

530 lines
11KB
Raw Blame History 

  1. package roaring

  2. 

  3. // NOTE: THIS FILE WAS PRODUCED BY THE

  4. // MSGP CODE GENERATION TOOL (github.com/tinylib/msgp)

  5. // DO NOT EDIT

  6. 

  7. import (

  8. 	"github.com/tinylib/msgp/msgp"

  9. )

  10. 

  11. // DecodeMsg implements msgp.Decodable

  12. func (z *containerSerz) DecodeMsg(dc *msgp.Reader) (err error) {

  13. 	var field []byte

  14. 	_ = field

  15. 	var zxvk uint32

  16. 	zxvk, err = dc.ReadMapHeader()

  17. 	if err != nil {

  18. 		return

  19. 	}

  20. 	for zxvk > 0 {

  21. 		zxvk--

  22. 		field, err = dc.ReadMapKeyPtr()

  23. 		if err != nil {

  24. 			return

  25. 		}

  26. 		switch msgp.UnsafeString(field) {

  27. 		case "t":

  28. 			{

  29. 				var zbzg uint8

  30. 				zbzg, err = dc.ReadUint8()

  31. 				z.t = contype(zbzg)

  32. 			}

  33. 			if err != nil {

  34. 				return

  35. 			}

  36. 		case "r":

  37. 			err = z.r.DecodeMsg(dc)

  38. 			if err != nil {

  39. 				return

  40. 			}

  41. 		default:

  42. 			err = dc.Skip()

  43. 			if err != nil {

  44. 				return

  45. 			}

  46. 		}

  47. 	}

  48. 	return

  49. }

  50. 

  51. // EncodeMsg implements msgp.Encodable

  52. func (z *containerSerz) EncodeMsg(en *msgp.Writer) (err error) {

  53. 	// map header, size 2

  54. 	// write "t"

  55. 	err = en.Append(0x82, 0xa1, 0x74)

  56. 	if err != nil {

  57. 		return err

  58. 	}

  59. 	err = en.WriteUint8(uint8(z.t))

  60. 	if err != nil {

  61. 		return

  62. 	}

  63. 	// write "r"

  64. 	err = en.Append(0xa1, 0x72)

  65. 	if err != nil {

  66. 		return err

  67. 	}

  68. 	err = z.r.EncodeMsg(en)

  69. 	if err != nil {

  70. 		return

  71. 	}

  72. 	return

  73. }

  74. 

  75. // MarshalMsg implements msgp.Marshaler

  76. func (z *containerSerz) MarshalMsg(b []byte) (o []byte, err error) {

  77. 	o = msgp.Require(b, z.Msgsize())

  78. 	// map header, size 2

  79. 	// string "t"

  80. 	o = append(o, 0x82, 0xa1, 0x74)

  81. 	o = msgp.AppendUint8(o, uint8(z.t))

  82. 	// string "r"

  83. 	o = append(o, 0xa1, 0x72)

  84. 	o, err = z.r.MarshalMsg(o)

  85. 	if err != nil {

  86. 		return

  87. 	}

  88. 	return

  89. }

  90. 

  91. // UnmarshalMsg implements msgp.Unmarshaler

  92. func (z *containerSerz) UnmarshalMsg(bts []byte) (o []byte, err error) {

  93. 	var field []byte

  94. 	_ = field

  95. 	var zbai uint32

  96. 	zbai, bts, err = msgp.ReadMapHeaderBytes(bts)

  97. 	if err != nil {

  98. 		return

  99. 	}

  100. 	for zbai > 0 {

  101. 		zbai--

  102. 		field, bts, err = msgp.ReadMapKeyZC(bts)

  103. 		if err != nil {

  104. 			return

  105. 		}

  106. 		switch msgp.UnsafeString(field) {

  107. 		case "t":

  108. 			{

  109. 				var zcmr uint8

  110. 				zcmr, bts, err = msgp.ReadUint8Bytes(bts)

  111. 				z.t = contype(zcmr)

  112. 			}

  113. 			if err != nil {

  114. 				return

  115. 			}

  116. 		case "r":

  117. 			bts, err = z.r.UnmarshalMsg(bts)

  118. 			if err != nil {

  119. 				return

  120. 			}

  121. 		default:

  122. 			bts, err = msgp.Skip(bts)

  123. 			if err != nil {

  124. 				return

  125. 			}

  126. 		}

  127. 	}

  128. 	o = bts

  129. 	return

  130. }

  131. 

  132. // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

  133. func (z *containerSerz) Msgsize() (s int) {

  134. 	s = 1 + 2 + msgp.Uint8Size + 2 + z.r.Msgsize()

  135. 	return

  136. }

  137. 

  138. // DecodeMsg implements msgp.Decodable

  139. func (z *contype) DecodeMsg(dc *msgp.Reader) (err error) {

  140. 	{

  141. 		var zajw uint8

  142. 		zajw, err = dc.ReadUint8()

  143. 		(*z) = contype(zajw)

  144. 	}

  145. 	if err != nil {

  146. 		return

  147. 	}

  148. 	return

  149. }

  150. 

  151. // EncodeMsg implements msgp.Encodable

  152. func (z contype) EncodeMsg(en *msgp.Writer) (err error) {

  153. 	err = en.WriteUint8(uint8(z))

  154. 	if err != nil {

  155. 		return

  156. 	}

  157. 	return

  158. }

  159. 

  160. // MarshalMsg implements msgp.Marshaler

  161. func (z contype) MarshalMsg(b []byte) (o []byte, err error) {

  162. 	o = msgp.Require(b, z.Msgsize())

  163. 	o = msgp.AppendUint8(o, uint8(z))

  164. 	return

  165. }

  166. 

  167. // UnmarshalMsg implements msgp.Unmarshaler

  168. func (z *contype) UnmarshalMsg(bts []byte) (o []byte, err error) {

  169. 	{

  170. 		var zwht uint8

  171. 		zwht, bts, err = msgp.ReadUint8Bytes(bts)

  172. 		(*z) = contype(zwht)

  173. 	}

  174. 	if err != nil {

  175. 		return

  176. 	}

  177. 	o = bts

  178. 	return

  179. }

  180. 

  181. // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

  182. func (z contype) Msgsize() (s int) {

  183. 	s = msgp.Uint8Size

  184. 	return

  185. }

  186. 

  187. // DecodeMsg implements msgp.Decodable

  188. func (z *roaringArray) DecodeMsg(dc *msgp.Reader) (err error) {

  189. 	var field []byte

  190. 	_ = field

  191. 	var zlqf uint32

  192. 	zlqf, err = dc.ReadMapHeader()

  193. 	if err != nil {

  194. 		return

  195. 	}

  196. 	for zlqf > 0 {

  197. 		zlqf--

  198. 		field, err = dc.ReadMapKeyPtr()

  199. 		if err != nil {

  200. 			return

  201. 		}

  202. 		switch msgp.UnsafeString(field) {

  203. 		case "keys":

  204. 			var zdaf uint32

  205. 			zdaf, err = dc.ReadArrayHeader()

  206. 			if err != nil {

  207. 				return

  208. 			}

  209. 			if cap(z.keys) >= int(zdaf) {

  210. 				z.keys = (z.keys)[:zdaf]

  211. 			} else {

  212. 				z.keys = make([]uint16, zdaf)

  213. 			}

  214. 			for zhct := range z.keys {

  215. 				z.keys[zhct], err = dc.ReadUint16()

  216. 				if err != nil {

  217. 					return

  218. 				}

  219. 			}

  220. 		case "needCopyOnWrite":

  221. 			var zpks uint32

  222. 			zpks, err = dc.ReadArrayHeader()

  223. 			if err != nil {

  224. 				return

  225. 			}

  226. 			if cap(z.needCopyOnWrite) >= int(zpks) {

  227. 				z.needCopyOnWrite = (z.needCopyOnWrite)[:zpks]

  228. 			} else {

  229. 				z.needCopyOnWrite = make([]bool, zpks)

  230. 			}

  231. 			for zcua := range z.needCopyOnWrite {

  232. 				z.needCopyOnWrite[zcua], err = dc.ReadBool()

  233. 				if err != nil {

  234. 					return

  235. 				}

  236. 			}

  237. 		case "copyOnWrite":

  238. 			z.copyOnWrite, err = dc.ReadBool()

  239. 			if err != nil {

  240. 				return

  241. 			}

  242. 		case "conserz":

  243. 			var zjfb uint32

  244. 			zjfb, err = dc.ReadArrayHeader()

  245. 			if err != nil {

  246. 				return

  247. 			}

  248. 			if cap(z.conserz) >= int(zjfb) {

  249. 				z.conserz = (z.conserz)[:zjfb]

  250. 			} else {

  251. 				z.conserz = make([]containerSerz, zjfb)

  252. 			}

  253. 			for zxhx := range z.conserz {

  254. 				var zcxo uint32

  255. 				zcxo, err = dc.ReadMapHeader()

  256. 				if err != nil {

  257. 					return

  258. 				}

  259. 				for zcxo > 0 {

  260. 					zcxo--

  261. 					field, err = dc.ReadMapKeyPtr()

  262. 					if err != nil {

  263. 						return

  264. 					}

  265. 					switch msgp.UnsafeString(field) {

  266. 					case "t":

  267. 						{

  268. 							var zeff uint8

  269. 							zeff, err = dc.ReadUint8()

  270. 							z.conserz[zxhx].t = contype(zeff)

  271. 						}

  272. 						if err != nil {

  273. 							return

  274. 						}

  275. 					case "r":

  276. 						err = z.conserz[zxhx].r.DecodeMsg(dc)

  277. 						if err != nil {

  278. 							return

  279. 						}

  280. 					default:

  281. 						err = dc.Skip()

  282. 						if err != nil {

  283. 							return

  284. 						}

  285. 					}

  286. 				}

  287. 			}

  288. 		default:

  289. 			err = dc.Skip()

  290. 			if err != nil {

  291. 				return

  292. 			}

  293. 		}

  294. 	}

  295. 	return

  296. }

  297. 

  298. // EncodeMsg implements msgp.Encodable

  299. func (z *roaringArray) EncodeMsg(en *msgp.Writer) (err error) {

  300. 	// map header, size 4

  301. 	// write "keys"

  302. 	err = en.Append(0x84, 0xa4, 0x6b, 0x65, 0x79, 0x73)

  303. 	if err != nil {

  304. 		return err

  305. 	}

  306. 	err = en.WriteArrayHeader(uint32(len(z.keys)))

  307. 	if err != nil {

  308. 		return

  309. 	}

  310. 	for zhct := range z.keys {

  311. 		err = en.WriteUint16(z.keys[zhct])

  312. 		if err != nil {

  313. 			return

  314. 		}

  315. 	}

  316. 	// write "needCopyOnWrite"

  317. 	err = en.Append(0xaf, 0x6e, 0x65, 0x65, 0x64, 0x43, 0x6f, 0x70, 0x79, 0x4f, 0x6e, 0x57, 0x72, 0x69, 0x74, 0x65)

  318. 	if err != nil {

  319. 		return err

  320. 	}

  321. 	err = en.WriteArrayHeader(uint32(len(z.needCopyOnWrite)))

  322. 	if err != nil {

  323. 		return

  324. 	}

  325. 	for zcua := range z.needCopyOnWrite {

  326. 		err = en.WriteBool(z.needCopyOnWrite[zcua])

  327. 		if err != nil {

  328. 			return

  329. 		}

  330. 	}

  331. 	// write "copyOnWrite"

  332. 	err = en.Append(0xab, 0x63, 0x6f, 0x70, 0x79, 0x4f, 0x6e, 0x57, 0x72, 0x69, 0x74, 0x65)

  333. 	if err != nil {

  334. 		return err

  335. 	}

  336. 	err = en.WriteBool(z.copyOnWrite)

  337. 	if err != nil {

  338. 		return

  339. 	}

  340. 	// write "conserz"

  341. 	err = en.Append(0xa7, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x72, 0x7a)

  342. 	if err != nil {

  343. 		return err

  344. 	}

  345. 	err = en.WriteArrayHeader(uint32(len(z.conserz)))

  346. 	if err != nil {

  347. 		return

  348. 	}

  349. 	for zxhx := range z.conserz {

  350. 		// map header, size 2

  351. 		// write "t"

  352. 		err = en.Append(0x82, 0xa1, 0x74)

  353. 		if err != nil {

  354. 			return err

  355. 		}

  356. 		err = en.WriteUint8(uint8(z.conserz[zxhx].t))

  357. 		if err != nil {

  358. 			return

  359. 		}

  360. 		// write "r"

  361. 		err = en.Append(0xa1, 0x72)

  362. 		if err != nil {

  363. 			return err

  364. 		}

  365. 		err = z.conserz[zxhx].r.EncodeMsg(en)

  366. 		if err != nil {

  367. 			return

  368. 		}

  369. 	}

  370. 	return

  371. }

  372. 

  373. // MarshalMsg implements msgp.Marshaler

  374. func (z *roaringArray) MarshalMsg(b []byte) (o []byte, err error) {

  375. 	o = msgp.Require(b, z.Msgsize())

  376. 	// map header, size 4

  377. 	// string "keys"

  378. 	o = append(o, 0x84, 0xa4, 0x6b, 0x65, 0x79, 0x73)

  379. 	o = msgp.AppendArrayHeader(o, uint32(len(z.keys)))

  380. 	for zhct := range z.keys {

  381. 		o = msgp.AppendUint16(o, z.keys[zhct])

  382. 	}

  383. 	// string "needCopyOnWrite"

  384. 	o = append(o, 0xaf, 0x6e, 0x65, 0x65, 0x64, 0x43, 0x6f, 0x70, 0x79, 0x4f, 0x6e, 0x57, 0x72, 0x69, 0x74, 0x65)

  385. 	o = msgp.AppendArrayHeader(o, uint32(len(z.needCopyOnWrite)))

  386. 	for zcua := range z.needCopyOnWrite {

  387. 		o = msgp.AppendBool(o, z.needCopyOnWrite[zcua])

  388. 	}

  389. 	// string "copyOnWrite"

  390. 	o = append(o, 0xab, 0x63, 0x6f, 0x70, 0x79, 0x4f, 0x6e, 0x57, 0x72, 0x69, 0x74, 0x65)

  391. 	o = msgp.AppendBool(o, z.copyOnWrite)

  392. 	// string "conserz"

  393. 	o = append(o, 0xa7, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x72, 0x7a)

  394. 	o = msgp.AppendArrayHeader(o, uint32(len(z.conserz)))

  395. 	for zxhx := range z.conserz {

  396. 		// map header, size 2

  397. 		// string "t"

  398. 		o = append(o, 0x82, 0xa1, 0x74)

  399. 		o = msgp.AppendUint8(o, uint8(z.conserz[zxhx].t))

  400. 		// string "r"

  401. 		o = append(o, 0xa1, 0x72)

  402. 		o, err = z.conserz[zxhx].r.MarshalMsg(o)

  403. 		if err != nil {

  404. 			return

  405. 		}

  406. 	}

  407. 	return

  408. }

  409. 

  410. // UnmarshalMsg implements msgp.Unmarshaler

  411. func (z *roaringArray) UnmarshalMsg(bts []byte) (o []byte, err error) {

  412. 	var field []byte

  413. 	_ = field

  414. 	var zrsw uint32

  415. 	zrsw, bts, err = msgp.ReadMapHeaderBytes(bts)

  416. 	if err != nil {

  417. 		return

  418. 	}

  419. 	for zrsw > 0 {

  420. 		zrsw--

  421. 		field, bts, err = msgp.ReadMapKeyZC(bts)

  422. 		if err != nil {

  423. 			return

  424. 		}

  425. 		switch msgp.UnsafeString(field) {

  426. 		case "keys":

  427. 			var zxpk uint32

  428. 			zxpk, bts, err = msgp.ReadArrayHeaderBytes(bts)

  429. 			if err != nil {

  430. 				return

  431. 			}

  432. 			if cap(z.keys) >= int(zxpk) {

  433. 				z.keys = (z.keys)[:zxpk]

  434. 			} else {

  435. 				z.keys = make([]uint16, zxpk)

  436. 			}

  437. 			for zhct := range z.keys {

  438. 				z.keys[zhct], bts, err = msgp.ReadUint16Bytes(bts)

  439. 				if err != nil {

  440. 					return

  441. 				}

  442. 			}

  443. 		case "needCopyOnWrite":

  444. 			var zdnj uint32

  445. 			zdnj, bts, err = msgp.ReadArrayHeaderBytes(bts)

  446. 			if err != nil {

  447. 				return

  448. 			}

  449. 			if cap(z.needCopyOnWrite) >= int(zdnj) {

  450. 				z.needCopyOnWrite = (z.needCopyOnWrite)[:zdnj]

  451. 			} else {

  452. 				z.needCopyOnWrite = make([]bool, zdnj)

  453. 			}

  454. 			for zcua := range z.needCopyOnWrite {

  455. 				z.needCopyOnWrite[zcua], bts, err = msgp.ReadBoolBytes(bts)

  456. 				if err != nil {

  457. 					return

  458. 				}

  459. 			}

  460. 		case "copyOnWrite":

  461. 			z.copyOnWrite, bts, err = msgp.ReadBoolBytes(bts)

  462. 			if err != nil {

  463. 				return

  464. 			}

  465. 		case "conserz":

  466. 			var zobc uint32

  467. 			zobc, bts, err = msgp.ReadArrayHeaderBytes(bts)

  468. 			if err != nil {

  469. 				return

  470. 			}

  471. 			if cap(z.conserz) >= int(zobc) {

  472. 				z.conserz = (z.conserz)[:zobc]

  473. 			} else {

  474. 				z.conserz = make([]containerSerz, zobc)

  475. 			}

  476. 			for zxhx := range z.conserz {

  477. 				var zsnv uint32

  478. 				zsnv, bts, err = msgp.ReadMapHeaderBytes(bts)

  479. 				if err != nil {

  480. 					return

  481. 				}

  482. 				for zsnv > 0 {

  483. 					zsnv--

  484. 					field, bts, err = msgp.ReadMapKeyZC(bts)

  485. 					if err != nil {

  486. 						return

  487. 					}

  488. 					switch msgp.UnsafeString(field) {

  489. 					case "t":

  490. 						{

  491. 							var zkgt uint8

  492. 							zkgt, bts, err = msgp.ReadUint8Bytes(bts)

  493. 							z.conserz[zxhx].t = contype(zkgt)

  494. 						}

  495. 						if err != nil {

  496. 							return

  497. 						}

  498. 					case "r":

  499. 						bts, err = z.conserz[zxhx].r.UnmarshalMsg(bts)

  500. 						if err != nil {

  501. 							return

  502. 						}

  503. 					default:

  504. 						bts, err = msgp.Skip(bts)

  505. 						if err != nil {

  506. 							return

  507. 						}

  508. 					}

  509. 				}

  510. 			}

  511. 		default:

  512. 			bts, err = msgp.Skip(bts)

  513. 			if err != nil {

  514. 				return

  515. 			}

  516. 		}

  517. 	}

  518. 	o = bts

  519. 	return

  520. }

  521. 

  522. // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

  523. func (z *roaringArray) Msgsize() (s int) {

  524. 	s = 1 + 5 + msgp.ArrayHeaderSize + (len(z.keys) * (msgp.Uint16Size)) + 16 + msgp.ArrayHeaderSize + (len(z.needCopyOnWrite) * (msgp.BoolSize)) + 12 + msgp.BoolSize + 8 + msgp.ArrayHeaderSize

  525. 	for zxhx := range z.conserz {

  526. 		s += 1 + 2 + msgp.Uint8Size + 2 + z.conserz[zxhx].r.Msgsize()

  527. 	}

  528. 	return

  529. }
上海开阖软件有限公司 沪ICP备12045867号-1