1
2
3
4
5
6
7
8
9 package codec
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35 import (
36 "reflect"
37 "sort"
38 )
39
40 const fastpathEnabled = true
41
42 type fastpathT struct{}
43
44 var fastpathTV fastpathT
45
46 type fastpathE struct {
47 rt reflect.Type
48 encfn func(*Encoder, *codecFnInfo, reflect.Value)
49 decfn func(*Decoder, *codecFnInfo, reflect.Value)
50 }
51
52 type fastpathA [56]fastpathE
53 type fastpathARtid [56]uintptr
54
55 var fastpathAv fastpathA
56 var fastpathAvRtid fastpathARtid
57
58 type fastpathAslice struct{}
59
60 func (fastpathAslice) Len() int { return 56 }
61 func (fastpathAslice) Less(i, j int) bool {
62 return fastpathAvRtid[uint(i)] < fastpathAvRtid[uint(j)]
63 }
64 func (fastpathAslice) Swap(i, j int) {
65 fastpathAvRtid[uint(i)], fastpathAvRtid[uint(j)] = fastpathAvRtid[uint(j)], fastpathAvRtid[uint(i)]
66 fastpathAv[uint(i)], fastpathAv[uint(j)] = fastpathAv[uint(j)], fastpathAv[uint(i)]
67 }
68
69 func fastpathAvIndex(rtid uintptr) int {
70
71
72
73 var h, i uint
74 var j uint = 56
75 LOOP:
76 if i < j {
77 h = (i + j) >> 1
78 if fastpathAvRtid[h] < rtid {
79 i = h + 1
80 } else {
81 j = h
82 }
83 goto LOOP
84 }
85 if i < 56 && fastpathAvRtid[i] == rtid {
86 return int(i)
87 }
88 return -1
89 }
90
91
92 func init() {
93 var i uint = 0
94 fn := func(v interface{},
95 fe func(*Encoder, *codecFnInfo, reflect.Value),
96 fd func(*Decoder, *codecFnInfo, reflect.Value)) {
97 xrt := reflect.TypeOf(v)
98 xptr := rt2id(xrt)
99 fastpathAvRtid[i] = xptr
100 fastpathAv[i] = fastpathE{xrt, fe, fd}
101 i++
102 }
103
104 fn([]interface{}(nil), (*Encoder).fastpathEncSliceIntfR, (*Decoder).fastpathDecSliceIntfR)
105 fn([]string(nil), (*Encoder).fastpathEncSliceStringR, (*Decoder).fastpathDecSliceStringR)
106 fn([][]byte(nil), (*Encoder).fastpathEncSliceBytesR, (*Decoder).fastpathDecSliceBytesR)
107 fn([]float32(nil), (*Encoder).fastpathEncSliceFloat32R, (*Decoder).fastpathDecSliceFloat32R)
108 fn([]float64(nil), (*Encoder).fastpathEncSliceFloat64R, (*Decoder).fastpathDecSliceFloat64R)
109 fn([]uint8(nil), (*Encoder).fastpathEncSliceUint8R, (*Decoder).fastpathDecSliceUint8R)
110 fn([]uint64(nil), (*Encoder).fastpathEncSliceUint64R, (*Decoder).fastpathDecSliceUint64R)
111 fn([]int(nil), (*Encoder).fastpathEncSliceIntR, (*Decoder).fastpathDecSliceIntR)
112 fn([]int32(nil), (*Encoder).fastpathEncSliceInt32R, (*Decoder).fastpathDecSliceInt32R)
113 fn([]int64(nil), (*Encoder).fastpathEncSliceInt64R, (*Decoder).fastpathDecSliceInt64R)
114 fn([]bool(nil), (*Encoder).fastpathEncSliceBoolR, (*Decoder).fastpathDecSliceBoolR)
115
116 fn(map[string]interface{}(nil), (*Encoder).fastpathEncMapStringIntfR, (*Decoder).fastpathDecMapStringIntfR)
117 fn(map[string]string(nil), (*Encoder).fastpathEncMapStringStringR, (*Decoder).fastpathDecMapStringStringR)
118 fn(map[string][]byte(nil), (*Encoder).fastpathEncMapStringBytesR, (*Decoder).fastpathDecMapStringBytesR)
119 fn(map[string]uint8(nil), (*Encoder).fastpathEncMapStringUint8R, (*Decoder).fastpathDecMapStringUint8R)
120 fn(map[string]uint64(nil), (*Encoder).fastpathEncMapStringUint64R, (*Decoder).fastpathDecMapStringUint64R)
121 fn(map[string]int(nil), (*Encoder).fastpathEncMapStringIntR, (*Decoder).fastpathDecMapStringIntR)
122 fn(map[string]int32(nil), (*Encoder).fastpathEncMapStringInt32R, (*Decoder).fastpathDecMapStringInt32R)
123 fn(map[string]float64(nil), (*Encoder).fastpathEncMapStringFloat64R, (*Decoder).fastpathDecMapStringFloat64R)
124 fn(map[string]bool(nil), (*Encoder).fastpathEncMapStringBoolR, (*Decoder).fastpathDecMapStringBoolR)
125 fn(map[uint8]interface{}(nil), (*Encoder).fastpathEncMapUint8IntfR, (*Decoder).fastpathDecMapUint8IntfR)
126 fn(map[uint8]string(nil), (*Encoder).fastpathEncMapUint8StringR, (*Decoder).fastpathDecMapUint8StringR)
127 fn(map[uint8][]byte(nil), (*Encoder).fastpathEncMapUint8BytesR, (*Decoder).fastpathDecMapUint8BytesR)
128 fn(map[uint8]uint8(nil), (*Encoder).fastpathEncMapUint8Uint8R, (*Decoder).fastpathDecMapUint8Uint8R)
129 fn(map[uint8]uint64(nil), (*Encoder).fastpathEncMapUint8Uint64R, (*Decoder).fastpathDecMapUint8Uint64R)
130 fn(map[uint8]int(nil), (*Encoder).fastpathEncMapUint8IntR, (*Decoder).fastpathDecMapUint8IntR)
131 fn(map[uint8]int32(nil), (*Encoder).fastpathEncMapUint8Int32R, (*Decoder).fastpathDecMapUint8Int32R)
132 fn(map[uint8]float64(nil), (*Encoder).fastpathEncMapUint8Float64R, (*Decoder).fastpathDecMapUint8Float64R)
133 fn(map[uint8]bool(nil), (*Encoder).fastpathEncMapUint8BoolR, (*Decoder).fastpathDecMapUint8BoolR)
134 fn(map[uint64]interface{}(nil), (*Encoder).fastpathEncMapUint64IntfR, (*Decoder).fastpathDecMapUint64IntfR)
135 fn(map[uint64]string(nil), (*Encoder).fastpathEncMapUint64StringR, (*Decoder).fastpathDecMapUint64StringR)
136 fn(map[uint64][]byte(nil), (*Encoder).fastpathEncMapUint64BytesR, (*Decoder).fastpathDecMapUint64BytesR)
137 fn(map[uint64]uint8(nil), (*Encoder).fastpathEncMapUint64Uint8R, (*Decoder).fastpathDecMapUint64Uint8R)
138 fn(map[uint64]uint64(nil), (*Encoder).fastpathEncMapUint64Uint64R, (*Decoder).fastpathDecMapUint64Uint64R)
139 fn(map[uint64]int(nil), (*Encoder).fastpathEncMapUint64IntR, (*Decoder).fastpathDecMapUint64IntR)
140 fn(map[uint64]int32(nil), (*Encoder).fastpathEncMapUint64Int32R, (*Decoder).fastpathDecMapUint64Int32R)
141 fn(map[uint64]float64(nil), (*Encoder).fastpathEncMapUint64Float64R, (*Decoder).fastpathDecMapUint64Float64R)
142 fn(map[uint64]bool(nil), (*Encoder).fastpathEncMapUint64BoolR, (*Decoder).fastpathDecMapUint64BoolR)
143 fn(map[int]interface{}(nil), (*Encoder).fastpathEncMapIntIntfR, (*Decoder).fastpathDecMapIntIntfR)
144 fn(map[int]string(nil), (*Encoder).fastpathEncMapIntStringR, (*Decoder).fastpathDecMapIntStringR)
145 fn(map[int][]byte(nil), (*Encoder).fastpathEncMapIntBytesR, (*Decoder).fastpathDecMapIntBytesR)
146 fn(map[int]uint8(nil), (*Encoder).fastpathEncMapIntUint8R, (*Decoder).fastpathDecMapIntUint8R)
147 fn(map[int]uint64(nil), (*Encoder).fastpathEncMapIntUint64R, (*Decoder).fastpathDecMapIntUint64R)
148 fn(map[int]int(nil), (*Encoder).fastpathEncMapIntIntR, (*Decoder).fastpathDecMapIntIntR)
149 fn(map[int]int32(nil), (*Encoder).fastpathEncMapIntInt32R, (*Decoder).fastpathDecMapIntInt32R)
150 fn(map[int]float64(nil), (*Encoder).fastpathEncMapIntFloat64R, (*Decoder).fastpathDecMapIntFloat64R)
151 fn(map[int]bool(nil), (*Encoder).fastpathEncMapIntBoolR, (*Decoder).fastpathDecMapIntBoolR)
152 fn(map[int32]interface{}(nil), (*Encoder).fastpathEncMapInt32IntfR, (*Decoder).fastpathDecMapInt32IntfR)
153 fn(map[int32]string(nil), (*Encoder).fastpathEncMapInt32StringR, (*Decoder).fastpathDecMapInt32StringR)
154 fn(map[int32][]byte(nil), (*Encoder).fastpathEncMapInt32BytesR, (*Decoder).fastpathDecMapInt32BytesR)
155 fn(map[int32]uint8(nil), (*Encoder).fastpathEncMapInt32Uint8R, (*Decoder).fastpathDecMapInt32Uint8R)
156 fn(map[int32]uint64(nil), (*Encoder).fastpathEncMapInt32Uint64R, (*Decoder).fastpathDecMapInt32Uint64R)
157 fn(map[int32]int(nil), (*Encoder).fastpathEncMapInt32IntR, (*Decoder).fastpathDecMapInt32IntR)
158 fn(map[int32]int32(nil), (*Encoder).fastpathEncMapInt32Int32R, (*Decoder).fastpathDecMapInt32Int32R)
159 fn(map[int32]float64(nil), (*Encoder).fastpathEncMapInt32Float64R, (*Decoder).fastpathDecMapInt32Float64R)
160 fn(map[int32]bool(nil), (*Encoder).fastpathEncMapInt32BoolR, (*Decoder).fastpathDecMapInt32BoolR)
161
162 sort.Sort(fastpathAslice{})
163 }
164
165
166
167
168 func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool {
169 switch v := iv.(type) {
170 case []interface{}:
171 fastpathTV.EncSliceIntfV(v, e)
172 case *[]interface{}:
173 if *v == nil {
174 e.e.EncodeNil()
175 } else {
176 fastpathTV.EncSliceIntfV(*v, e)
177 }
178 case []string:
179 fastpathTV.EncSliceStringV(v, e)
180 case *[]string:
181 if *v == nil {
182 e.e.EncodeNil()
183 } else {
184 fastpathTV.EncSliceStringV(*v, e)
185 }
186 case [][]byte:
187 fastpathTV.EncSliceBytesV(v, e)
188 case *[][]byte:
189 if *v == nil {
190 e.e.EncodeNil()
191 } else {
192 fastpathTV.EncSliceBytesV(*v, e)
193 }
194 case []float32:
195 fastpathTV.EncSliceFloat32V(v, e)
196 case *[]float32:
197 if *v == nil {
198 e.e.EncodeNil()
199 } else {
200 fastpathTV.EncSliceFloat32V(*v, e)
201 }
202 case []float64:
203 fastpathTV.EncSliceFloat64V(v, e)
204 case *[]float64:
205 if *v == nil {
206 e.e.EncodeNil()
207 } else {
208 fastpathTV.EncSliceFloat64V(*v, e)
209 }
210 case []uint8:
211 fastpathTV.EncSliceUint8V(v, e)
212 case *[]uint8:
213 if *v == nil {
214 e.e.EncodeNil()
215 } else {
216 fastpathTV.EncSliceUint8V(*v, e)
217 }
218 case []uint64:
219 fastpathTV.EncSliceUint64V(v, e)
220 case *[]uint64:
221 if *v == nil {
222 e.e.EncodeNil()
223 } else {
224 fastpathTV.EncSliceUint64V(*v, e)
225 }
226 case []int:
227 fastpathTV.EncSliceIntV(v, e)
228 case *[]int:
229 if *v == nil {
230 e.e.EncodeNil()
231 } else {
232 fastpathTV.EncSliceIntV(*v, e)
233 }
234 case []int32:
235 fastpathTV.EncSliceInt32V(v, e)
236 case *[]int32:
237 if *v == nil {
238 e.e.EncodeNil()
239 } else {
240 fastpathTV.EncSliceInt32V(*v, e)
241 }
242 case []int64:
243 fastpathTV.EncSliceInt64V(v, e)
244 case *[]int64:
245 if *v == nil {
246 e.e.EncodeNil()
247 } else {
248 fastpathTV.EncSliceInt64V(*v, e)
249 }
250 case []bool:
251 fastpathTV.EncSliceBoolV(v, e)
252 case *[]bool:
253 if *v == nil {
254 e.e.EncodeNil()
255 } else {
256 fastpathTV.EncSliceBoolV(*v, e)
257 }
258 case map[string]interface{}:
259 fastpathTV.EncMapStringIntfV(v, e)
260 case *map[string]interface{}:
261 if *v == nil {
262 e.e.EncodeNil()
263 } else {
264 fastpathTV.EncMapStringIntfV(*v, e)
265 }
266 case map[string]string:
267 fastpathTV.EncMapStringStringV(v, e)
268 case *map[string]string:
269 if *v == nil {
270 e.e.EncodeNil()
271 } else {
272 fastpathTV.EncMapStringStringV(*v, e)
273 }
274 case map[string][]byte:
275 fastpathTV.EncMapStringBytesV(v, e)
276 case *map[string][]byte:
277 if *v == nil {
278 e.e.EncodeNil()
279 } else {
280 fastpathTV.EncMapStringBytesV(*v, e)
281 }
282 case map[string]uint8:
283 fastpathTV.EncMapStringUint8V(v, e)
284 case *map[string]uint8:
285 if *v == nil {
286 e.e.EncodeNil()
287 } else {
288 fastpathTV.EncMapStringUint8V(*v, e)
289 }
290 case map[string]uint64:
291 fastpathTV.EncMapStringUint64V(v, e)
292 case *map[string]uint64:
293 if *v == nil {
294 e.e.EncodeNil()
295 } else {
296 fastpathTV.EncMapStringUint64V(*v, e)
297 }
298 case map[string]int:
299 fastpathTV.EncMapStringIntV(v, e)
300 case *map[string]int:
301 if *v == nil {
302 e.e.EncodeNil()
303 } else {
304 fastpathTV.EncMapStringIntV(*v, e)
305 }
306 case map[string]int32:
307 fastpathTV.EncMapStringInt32V(v, e)
308 case *map[string]int32:
309 if *v == nil {
310 e.e.EncodeNil()
311 } else {
312 fastpathTV.EncMapStringInt32V(*v, e)
313 }
314 case map[string]float64:
315 fastpathTV.EncMapStringFloat64V(v, e)
316 case *map[string]float64:
317 if *v == nil {
318 e.e.EncodeNil()
319 } else {
320 fastpathTV.EncMapStringFloat64V(*v, e)
321 }
322 case map[string]bool:
323 fastpathTV.EncMapStringBoolV(v, e)
324 case *map[string]bool:
325 if *v == nil {
326 e.e.EncodeNil()
327 } else {
328 fastpathTV.EncMapStringBoolV(*v, e)
329 }
330 case map[uint8]interface{}:
331 fastpathTV.EncMapUint8IntfV(v, e)
332 case *map[uint8]interface{}:
333 if *v == nil {
334 e.e.EncodeNil()
335 } else {
336 fastpathTV.EncMapUint8IntfV(*v, e)
337 }
338 case map[uint8]string:
339 fastpathTV.EncMapUint8StringV(v, e)
340 case *map[uint8]string:
341 if *v == nil {
342 e.e.EncodeNil()
343 } else {
344 fastpathTV.EncMapUint8StringV(*v, e)
345 }
346 case map[uint8][]byte:
347 fastpathTV.EncMapUint8BytesV(v, e)
348 case *map[uint8][]byte:
349 if *v == nil {
350 e.e.EncodeNil()
351 } else {
352 fastpathTV.EncMapUint8BytesV(*v, e)
353 }
354 case map[uint8]uint8:
355 fastpathTV.EncMapUint8Uint8V(v, e)
356 case *map[uint8]uint8:
357 if *v == nil {
358 e.e.EncodeNil()
359 } else {
360 fastpathTV.EncMapUint8Uint8V(*v, e)
361 }
362 case map[uint8]uint64:
363 fastpathTV.EncMapUint8Uint64V(v, e)
364 case *map[uint8]uint64:
365 if *v == nil {
366 e.e.EncodeNil()
367 } else {
368 fastpathTV.EncMapUint8Uint64V(*v, e)
369 }
370 case map[uint8]int:
371 fastpathTV.EncMapUint8IntV(v, e)
372 case *map[uint8]int:
373 if *v == nil {
374 e.e.EncodeNil()
375 } else {
376 fastpathTV.EncMapUint8IntV(*v, e)
377 }
378 case map[uint8]int32:
379 fastpathTV.EncMapUint8Int32V(v, e)
380 case *map[uint8]int32:
381 if *v == nil {
382 e.e.EncodeNil()
383 } else {
384 fastpathTV.EncMapUint8Int32V(*v, e)
385 }
386 case map[uint8]float64:
387 fastpathTV.EncMapUint8Float64V(v, e)
388 case *map[uint8]float64:
389 if *v == nil {
390 e.e.EncodeNil()
391 } else {
392 fastpathTV.EncMapUint8Float64V(*v, e)
393 }
394 case map[uint8]bool:
395 fastpathTV.EncMapUint8BoolV(v, e)
396 case *map[uint8]bool:
397 if *v == nil {
398 e.e.EncodeNil()
399 } else {
400 fastpathTV.EncMapUint8BoolV(*v, e)
401 }
402 case map[uint64]interface{}:
403 fastpathTV.EncMapUint64IntfV(v, e)
404 case *map[uint64]interface{}:
405 if *v == nil {
406 e.e.EncodeNil()
407 } else {
408 fastpathTV.EncMapUint64IntfV(*v, e)
409 }
410 case map[uint64]string:
411 fastpathTV.EncMapUint64StringV(v, e)
412 case *map[uint64]string:
413 if *v == nil {
414 e.e.EncodeNil()
415 } else {
416 fastpathTV.EncMapUint64StringV(*v, e)
417 }
418 case map[uint64][]byte:
419 fastpathTV.EncMapUint64BytesV(v, e)
420 case *map[uint64][]byte:
421 if *v == nil {
422 e.e.EncodeNil()
423 } else {
424 fastpathTV.EncMapUint64BytesV(*v, e)
425 }
426 case map[uint64]uint8:
427 fastpathTV.EncMapUint64Uint8V(v, e)
428 case *map[uint64]uint8:
429 if *v == nil {
430 e.e.EncodeNil()
431 } else {
432 fastpathTV.EncMapUint64Uint8V(*v, e)
433 }
434 case map[uint64]uint64:
435 fastpathTV.EncMapUint64Uint64V(v, e)
436 case *map[uint64]uint64:
437 if *v == nil {
438 e.e.EncodeNil()
439 } else {
440 fastpathTV.EncMapUint64Uint64V(*v, e)
441 }
442 case map[uint64]int:
443 fastpathTV.EncMapUint64IntV(v, e)
444 case *map[uint64]int:
445 if *v == nil {
446 e.e.EncodeNil()
447 } else {
448 fastpathTV.EncMapUint64IntV(*v, e)
449 }
450 case map[uint64]int32:
451 fastpathTV.EncMapUint64Int32V(v, e)
452 case *map[uint64]int32:
453 if *v == nil {
454 e.e.EncodeNil()
455 } else {
456 fastpathTV.EncMapUint64Int32V(*v, e)
457 }
458 case map[uint64]float64:
459 fastpathTV.EncMapUint64Float64V(v, e)
460 case *map[uint64]float64:
461 if *v == nil {
462 e.e.EncodeNil()
463 } else {
464 fastpathTV.EncMapUint64Float64V(*v, e)
465 }
466 case map[uint64]bool:
467 fastpathTV.EncMapUint64BoolV(v, e)
468 case *map[uint64]bool:
469 if *v == nil {
470 e.e.EncodeNil()
471 } else {
472 fastpathTV.EncMapUint64BoolV(*v, e)
473 }
474 case map[int]interface{}:
475 fastpathTV.EncMapIntIntfV(v, e)
476 case *map[int]interface{}:
477 if *v == nil {
478 e.e.EncodeNil()
479 } else {
480 fastpathTV.EncMapIntIntfV(*v, e)
481 }
482 case map[int]string:
483 fastpathTV.EncMapIntStringV(v, e)
484 case *map[int]string:
485 if *v == nil {
486 e.e.EncodeNil()
487 } else {
488 fastpathTV.EncMapIntStringV(*v, e)
489 }
490 case map[int][]byte:
491 fastpathTV.EncMapIntBytesV(v, e)
492 case *map[int][]byte:
493 if *v == nil {
494 e.e.EncodeNil()
495 } else {
496 fastpathTV.EncMapIntBytesV(*v, e)
497 }
498 case map[int]uint8:
499 fastpathTV.EncMapIntUint8V(v, e)
500 case *map[int]uint8:
501 if *v == nil {
502 e.e.EncodeNil()
503 } else {
504 fastpathTV.EncMapIntUint8V(*v, e)
505 }
506 case map[int]uint64:
507 fastpathTV.EncMapIntUint64V(v, e)
508 case *map[int]uint64:
509 if *v == nil {
510 e.e.EncodeNil()
511 } else {
512 fastpathTV.EncMapIntUint64V(*v, e)
513 }
514 case map[int]int:
515 fastpathTV.EncMapIntIntV(v, e)
516 case *map[int]int:
517 if *v == nil {
518 e.e.EncodeNil()
519 } else {
520 fastpathTV.EncMapIntIntV(*v, e)
521 }
522 case map[int]int32:
523 fastpathTV.EncMapIntInt32V(v, e)
524 case *map[int]int32:
525 if *v == nil {
526 e.e.EncodeNil()
527 } else {
528 fastpathTV.EncMapIntInt32V(*v, e)
529 }
530 case map[int]float64:
531 fastpathTV.EncMapIntFloat64V(v, e)
532 case *map[int]float64:
533 if *v == nil {
534 e.e.EncodeNil()
535 } else {
536 fastpathTV.EncMapIntFloat64V(*v, e)
537 }
538 case map[int]bool:
539 fastpathTV.EncMapIntBoolV(v, e)
540 case *map[int]bool:
541 if *v == nil {
542 e.e.EncodeNil()
543 } else {
544 fastpathTV.EncMapIntBoolV(*v, e)
545 }
546 case map[int32]interface{}:
547 fastpathTV.EncMapInt32IntfV(v, e)
548 case *map[int32]interface{}:
549 if *v == nil {
550 e.e.EncodeNil()
551 } else {
552 fastpathTV.EncMapInt32IntfV(*v, e)
553 }
554 case map[int32]string:
555 fastpathTV.EncMapInt32StringV(v, e)
556 case *map[int32]string:
557 if *v == nil {
558 e.e.EncodeNil()
559 } else {
560 fastpathTV.EncMapInt32StringV(*v, e)
561 }
562 case map[int32][]byte:
563 fastpathTV.EncMapInt32BytesV(v, e)
564 case *map[int32][]byte:
565 if *v == nil {
566 e.e.EncodeNil()
567 } else {
568 fastpathTV.EncMapInt32BytesV(*v, e)
569 }
570 case map[int32]uint8:
571 fastpathTV.EncMapInt32Uint8V(v, e)
572 case *map[int32]uint8:
573 if *v == nil {
574 e.e.EncodeNil()
575 } else {
576 fastpathTV.EncMapInt32Uint8V(*v, e)
577 }
578 case map[int32]uint64:
579 fastpathTV.EncMapInt32Uint64V(v, e)
580 case *map[int32]uint64:
581 if *v == nil {
582 e.e.EncodeNil()
583 } else {
584 fastpathTV.EncMapInt32Uint64V(*v, e)
585 }
586 case map[int32]int:
587 fastpathTV.EncMapInt32IntV(v, e)
588 case *map[int32]int:
589 if *v == nil {
590 e.e.EncodeNil()
591 } else {
592 fastpathTV.EncMapInt32IntV(*v, e)
593 }
594 case map[int32]int32:
595 fastpathTV.EncMapInt32Int32V(v, e)
596 case *map[int32]int32:
597 if *v == nil {
598 e.e.EncodeNil()
599 } else {
600 fastpathTV.EncMapInt32Int32V(*v, e)
601 }
602 case map[int32]float64:
603 fastpathTV.EncMapInt32Float64V(v, e)
604 case *map[int32]float64:
605 if *v == nil {
606 e.e.EncodeNil()
607 } else {
608 fastpathTV.EncMapInt32Float64V(*v, e)
609 }
610 case map[int32]bool:
611 fastpathTV.EncMapInt32BoolV(v, e)
612 case *map[int32]bool:
613 if *v == nil {
614 e.e.EncodeNil()
615 } else {
616 fastpathTV.EncMapInt32BoolV(*v, e)
617 }
618 default:
619 _ = v
620 return false
621 }
622 return true
623 }
624
625
626 func (e *Encoder) fastpathEncSliceIntfR(f *codecFnInfo, rv reflect.Value) {
627 var v []interface{}
628 if rv.Kind() == reflect.Array {
629 rvGetSlice4Array(rv, &v)
630 } else {
631 v = rv2i(rv).([]interface{})
632 }
633 if f.ti.mbs {
634 fastpathTV.EncAsMapSliceIntfV(v, e)
635 } else {
636 fastpathTV.EncSliceIntfV(v, e)
637 }
638 }
639 func (fastpathT) EncSliceIntfV(v []interface{}, e *Encoder) {
640 e.arrayStart(len(v))
641 for j := range v {
642 e.arrayElem()
643 e.encode(v[j])
644 }
645 e.arrayEnd()
646 }
647 func (fastpathT) EncAsMapSliceIntfV(v []interface{}, e *Encoder) {
648 e.haltOnMbsOddLen(len(v))
649 e.mapStart(len(v) >> 1)
650 for j := range v {
651 if j&1 == 0 {
652 e.mapElemKey()
653 } else {
654 e.mapElemValue()
655 }
656 e.encode(v[j])
657 }
658 e.mapEnd()
659 }
660 func (e *Encoder) fastpathEncSliceStringR(f *codecFnInfo, rv reflect.Value) {
661 var v []string
662 if rv.Kind() == reflect.Array {
663 rvGetSlice4Array(rv, &v)
664 } else {
665 v = rv2i(rv).([]string)
666 }
667 if f.ti.mbs {
668 fastpathTV.EncAsMapSliceStringV(v, e)
669 } else {
670 fastpathTV.EncSliceStringV(v, e)
671 }
672 }
673 func (fastpathT) EncSliceStringV(v []string, e *Encoder) {
674 e.arrayStart(len(v))
675 for j := range v {
676 e.arrayElem()
677 e.e.EncodeString(v[j])
678 }
679 e.arrayEnd()
680 }
681 func (fastpathT) EncAsMapSliceStringV(v []string, e *Encoder) {
682 e.haltOnMbsOddLen(len(v))
683 e.mapStart(len(v) >> 1)
684 for j := range v {
685 if j&1 == 0 {
686 e.mapElemKey()
687 } else {
688 e.mapElemValue()
689 }
690 e.e.EncodeString(v[j])
691 }
692 e.mapEnd()
693 }
694 func (e *Encoder) fastpathEncSliceBytesR(f *codecFnInfo, rv reflect.Value) {
695 var v [][]byte
696 if rv.Kind() == reflect.Array {
697 rvGetSlice4Array(rv, &v)
698 } else {
699 v = rv2i(rv).([][]byte)
700 }
701 if f.ti.mbs {
702 fastpathTV.EncAsMapSliceBytesV(v, e)
703 } else {
704 fastpathTV.EncSliceBytesV(v, e)
705 }
706 }
707 func (fastpathT) EncSliceBytesV(v [][]byte, e *Encoder) {
708 e.arrayStart(len(v))
709 for j := range v {
710 e.arrayElem()
711 e.e.EncodeStringBytesRaw(v[j])
712 }
713 e.arrayEnd()
714 }
715 func (fastpathT) EncAsMapSliceBytesV(v [][]byte, e *Encoder) {
716 e.haltOnMbsOddLen(len(v))
717 e.mapStart(len(v) >> 1)
718 for j := range v {
719 if j&1 == 0 {
720 e.mapElemKey()
721 } else {
722 e.mapElemValue()
723 }
724 e.e.EncodeStringBytesRaw(v[j])
725 }
726 e.mapEnd()
727 }
728 func (e *Encoder) fastpathEncSliceFloat32R(f *codecFnInfo, rv reflect.Value) {
729 var v []float32
730 if rv.Kind() == reflect.Array {
731 rvGetSlice4Array(rv, &v)
732 } else {
733 v = rv2i(rv).([]float32)
734 }
735 if f.ti.mbs {
736 fastpathTV.EncAsMapSliceFloat32V(v, e)
737 } else {
738 fastpathTV.EncSliceFloat32V(v, e)
739 }
740 }
741 func (fastpathT) EncSliceFloat32V(v []float32, e *Encoder) {
742 e.arrayStart(len(v))
743 for j := range v {
744 e.arrayElem()
745 e.e.EncodeFloat32(v[j])
746 }
747 e.arrayEnd()
748 }
749 func (fastpathT) EncAsMapSliceFloat32V(v []float32, e *Encoder) {
750 e.haltOnMbsOddLen(len(v))
751 e.mapStart(len(v) >> 1)
752 for j := range v {
753 if j&1 == 0 {
754 e.mapElemKey()
755 } else {
756 e.mapElemValue()
757 }
758 e.e.EncodeFloat32(v[j])
759 }
760 e.mapEnd()
761 }
762 func (e *Encoder) fastpathEncSliceFloat64R(f *codecFnInfo, rv reflect.Value) {
763 var v []float64
764 if rv.Kind() == reflect.Array {
765 rvGetSlice4Array(rv, &v)
766 } else {
767 v = rv2i(rv).([]float64)
768 }
769 if f.ti.mbs {
770 fastpathTV.EncAsMapSliceFloat64V(v, e)
771 } else {
772 fastpathTV.EncSliceFloat64V(v, e)
773 }
774 }
775 func (fastpathT) EncSliceFloat64V(v []float64, e *Encoder) {
776 e.arrayStart(len(v))
777 for j := range v {
778 e.arrayElem()
779 e.e.EncodeFloat64(v[j])
780 }
781 e.arrayEnd()
782 }
783 func (fastpathT) EncAsMapSliceFloat64V(v []float64, e *Encoder) {
784 e.haltOnMbsOddLen(len(v))
785 e.mapStart(len(v) >> 1)
786 for j := range v {
787 if j&1 == 0 {
788 e.mapElemKey()
789 } else {
790 e.mapElemValue()
791 }
792 e.e.EncodeFloat64(v[j])
793 }
794 e.mapEnd()
795 }
796 func (e *Encoder) fastpathEncSliceUint8R(f *codecFnInfo, rv reflect.Value) {
797 var v []uint8
798 if rv.Kind() == reflect.Array {
799 rvGetSlice4Array(rv, &v)
800 } else {
801 v = rv2i(rv).([]uint8)
802 }
803 if f.ti.mbs {
804 fastpathTV.EncAsMapSliceUint8V(v, e)
805 } else {
806 fastpathTV.EncSliceUint8V(v, e)
807 }
808 }
809 func (fastpathT) EncSliceUint8V(v []uint8, e *Encoder) {
810 e.e.EncodeStringBytesRaw(v)
811 }
812 func (fastpathT) EncAsMapSliceUint8V(v []uint8, e *Encoder) {
813 e.haltOnMbsOddLen(len(v))
814 e.mapStart(len(v) >> 1)
815 for j := range v {
816 if j&1 == 0 {
817 e.mapElemKey()
818 } else {
819 e.mapElemValue()
820 }
821 e.e.EncodeUint(uint64(v[j]))
822 }
823 e.mapEnd()
824 }
825 func (e *Encoder) fastpathEncSliceUint64R(f *codecFnInfo, rv reflect.Value) {
826 var v []uint64
827 if rv.Kind() == reflect.Array {
828 rvGetSlice4Array(rv, &v)
829 } else {
830 v = rv2i(rv).([]uint64)
831 }
832 if f.ti.mbs {
833 fastpathTV.EncAsMapSliceUint64V(v, e)
834 } else {
835 fastpathTV.EncSliceUint64V(v, e)
836 }
837 }
838 func (fastpathT) EncSliceUint64V(v []uint64, e *Encoder) {
839 e.arrayStart(len(v))
840 for j := range v {
841 e.arrayElem()
842 e.e.EncodeUint(v[j])
843 }
844 e.arrayEnd()
845 }
846 func (fastpathT) EncAsMapSliceUint64V(v []uint64, e *Encoder) {
847 e.haltOnMbsOddLen(len(v))
848 e.mapStart(len(v) >> 1)
849 for j := range v {
850 if j&1 == 0 {
851 e.mapElemKey()
852 } else {
853 e.mapElemValue()
854 }
855 e.e.EncodeUint(v[j])
856 }
857 e.mapEnd()
858 }
859 func (e *Encoder) fastpathEncSliceIntR(f *codecFnInfo, rv reflect.Value) {
860 var v []int
861 if rv.Kind() == reflect.Array {
862 rvGetSlice4Array(rv, &v)
863 } else {
864 v = rv2i(rv).([]int)
865 }
866 if f.ti.mbs {
867 fastpathTV.EncAsMapSliceIntV(v, e)
868 } else {
869 fastpathTV.EncSliceIntV(v, e)
870 }
871 }
872 func (fastpathT) EncSliceIntV(v []int, e *Encoder) {
873 e.arrayStart(len(v))
874 for j := range v {
875 e.arrayElem()
876 e.e.EncodeInt(int64(v[j]))
877 }
878 e.arrayEnd()
879 }
880 func (fastpathT) EncAsMapSliceIntV(v []int, e *Encoder) {
881 e.haltOnMbsOddLen(len(v))
882 e.mapStart(len(v) >> 1)
883 for j := range v {
884 if j&1 == 0 {
885 e.mapElemKey()
886 } else {
887 e.mapElemValue()
888 }
889 e.e.EncodeInt(int64(v[j]))
890 }
891 e.mapEnd()
892 }
893 func (e *Encoder) fastpathEncSliceInt32R(f *codecFnInfo, rv reflect.Value) {
894 var v []int32
895 if rv.Kind() == reflect.Array {
896 rvGetSlice4Array(rv, &v)
897 } else {
898 v = rv2i(rv).([]int32)
899 }
900 if f.ti.mbs {
901 fastpathTV.EncAsMapSliceInt32V(v, e)
902 } else {
903 fastpathTV.EncSliceInt32V(v, e)
904 }
905 }
906 func (fastpathT) EncSliceInt32V(v []int32, e *Encoder) {
907 e.arrayStart(len(v))
908 for j := range v {
909 e.arrayElem()
910 e.e.EncodeInt(int64(v[j]))
911 }
912 e.arrayEnd()
913 }
914 func (fastpathT) EncAsMapSliceInt32V(v []int32, e *Encoder) {
915 e.haltOnMbsOddLen(len(v))
916 e.mapStart(len(v) >> 1)
917 for j := range v {
918 if j&1 == 0 {
919 e.mapElemKey()
920 } else {
921 e.mapElemValue()
922 }
923 e.e.EncodeInt(int64(v[j]))
924 }
925 e.mapEnd()
926 }
927 func (e *Encoder) fastpathEncSliceInt64R(f *codecFnInfo, rv reflect.Value) {
928 var v []int64
929 if rv.Kind() == reflect.Array {
930 rvGetSlice4Array(rv, &v)
931 } else {
932 v = rv2i(rv).([]int64)
933 }
934 if f.ti.mbs {
935 fastpathTV.EncAsMapSliceInt64V(v, e)
936 } else {
937 fastpathTV.EncSliceInt64V(v, e)
938 }
939 }
940 func (fastpathT) EncSliceInt64V(v []int64, e *Encoder) {
941 e.arrayStart(len(v))
942 for j := range v {
943 e.arrayElem()
944 e.e.EncodeInt(v[j])
945 }
946 e.arrayEnd()
947 }
948 func (fastpathT) EncAsMapSliceInt64V(v []int64, e *Encoder) {
949 e.haltOnMbsOddLen(len(v))
950 e.mapStart(len(v) >> 1)
951 for j := range v {
952 if j&1 == 0 {
953 e.mapElemKey()
954 } else {
955 e.mapElemValue()
956 }
957 e.e.EncodeInt(v[j])
958 }
959 e.mapEnd()
960 }
961 func (e *Encoder) fastpathEncSliceBoolR(f *codecFnInfo, rv reflect.Value) {
962 var v []bool
963 if rv.Kind() == reflect.Array {
964 rvGetSlice4Array(rv, &v)
965 } else {
966 v = rv2i(rv).([]bool)
967 }
968 if f.ti.mbs {
969 fastpathTV.EncAsMapSliceBoolV(v, e)
970 } else {
971 fastpathTV.EncSliceBoolV(v, e)
972 }
973 }
974 func (fastpathT) EncSliceBoolV(v []bool, e *Encoder) {
975 e.arrayStart(len(v))
976 for j := range v {
977 e.arrayElem()
978 e.e.EncodeBool(v[j])
979 }
980 e.arrayEnd()
981 }
982 func (fastpathT) EncAsMapSliceBoolV(v []bool, e *Encoder) {
983 e.haltOnMbsOddLen(len(v))
984 e.mapStart(len(v) >> 1)
985 for j := range v {
986 if j&1 == 0 {
987 e.mapElemKey()
988 } else {
989 e.mapElemValue()
990 }
991 e.e.EncodeBool(v[j])
992 }
993 e.mapEnd()
994 }
995 func (e *Encoder) fastpathEncMapStringIntfR(f *codecFnInfo, rv reflect.Value) {
996 fastpathTV.EncMapStringIntfV(rv2i(rv).(map[string]interface{}), e)
997 }
998 func (fastpathT) EncMapStringIntfV(v map[string]interface{}, e *Encoder) {
999 e.mapStart(len(v))
1000 if e.h.Canonical {
1001 v2 := make([]string, len(v))
1002 var i uint
1003 for k := range v {
1004 v2[i] = k
1005 i++
1006 }
1007 sort.Sort(stringSlice(v2))
1008 for _, k2 := range v2 {
1009 e.mapElemKey()
1010 e.e.EncodeString(k2)
1011 e.mapElemValue()
1012 e.encode(v[k2])
1013 }
1014 } else {
1015 for k2, v2 := range v {
1016 e.mapElemKey()
1017 e.e.EncodeString(k2)
1018 e.mapElemValue()
1019 e.encode(v2)
1020 }
1021 }
1022 e.mapEnd()
1023 }
1024 func (e *Encoder) fastpathEncMapStringStringR(f *codecFnInfo, rv reflect.Value) {
1025 fastpathTV.EncMapStringStringV(rv2i(rv).(map[string]string), e)
1026 }
1027 func (fastpathT) EncMapStringStringV(v map[string]string, e *Encoder) {
1028 e.mapStart(len(v))
1029 if e.h.Canonical {
1030 v2 := make([]string, len(v))
1031 var i uint
1032 for k := range v {
1033 v2[i] = k
1034 i++
1035 }
1036 sort.Sort(stringSlice(v2))
1037 for _, k2 := range v2 {
1038 e.mapElemKey()
1039 e.e.EncodeString(k2)
1040 e.mapElemValue()
1041 e.e.EncodeString(v[k2])
1042 }
1043 } else {
1044 for k2, v2 := range v {
1045 e.mapElemKey()
1046 e.e.EncodeString(k2)
1047 e.mapElemValue()
1048 e.e.EncodeString(v2)
1049 }
1050 }
1051 e.mapEnd()
1052 }
1053 func (e *Encoder) fastpathEncMapStringBytesR(f *codecFnInfo, rv reflect.Value) {
1054 fastpathTV.EncMapStringBytesV(rv2i(rv).(map[string][]byte), e)
1055 }
1056 func (fastpathT) EncMapStringBytesV(v map[string][]byte, e *Encoder) {
1057 e.mapStart(len(v))
1058 if e.h.Canonical {
1059 v2 := make([]string, len(v))
1060 var i uint
1061 for k := range v {
1062 v2[i] = k
1063 i++
1064 }
1065 sort.Sort(stringSlice(v2))
1066 for _, k2 := range v2 {
1067 e.mapElemKey()
1068 e.e.EncodeString(k2)
1069 e.mapElemValue()
1070 e.e.EncodeStringBytesRaw(v[k2])
1071 }
1072 } else {
1073 for k2, v2 := range v {
1074 e.mapElemKey()
1075 e.e.EncodeString(k2)
1076 e.mapElemValue()
1077 e.e.EncodeStringBytesRaw(v2)
1078 }
1079 }
1080 e.mapEnd()
1081 }
1082 func (e *Encoder) fastpathEncMapStringUint8R(f *codecFnInfo, rv reflect.Value) {
1083 fastpathTV.EncMapStringUint8V(rv2i(rv).(map[string]uint8), e)
1084 }
1085 func (fastpathT) EncMapStringUint8V(v map[string]uint8, e *Encoder) {
1086 e.mapStart(len(v))
1087 if e.h.Canonical {
1088 v2 := make([]string, len(v))
1089 var i uint
1090 for k := range v {
1091 v2[i] = k
1092 i++
1093 }
1094 sort.Sort(stringSlice(v2))
1095 for _, k2 := range v2 {
1096 e.mapElemKey()
1097 e.e.EncodeString(k2)
1098 e.mapElemValue()
1099 e.e.EncodeUint(uint64(v[k2]))
1100 }
1101 } else {
1102 for k2, v2 := range v {
1103 e.mapElemKey()
1104 e.e.EncodeString(k2)
1105 e.mapElemValue()
1106 e.e.EncodeUint(uint64(v2))
1107 }
1108 }
1109 e.mapEnd()
1110 }
1111 func (e *Encoder) fastpathEncMapStringUint64R(f *codecFnInfo, rv reflect.Value) {
1112 fastpathTV.EncMapStringUint64V(rv2i(rv).(map[string]uint64), e)
1113 }
1114 func (fastpathT) EncMapStringUint64V(v map[string]uint64, e *Encoder) {
1115 e.mapStart(len(v))
1116 if e.h.Canonical {
1117 v2 := make([]string, len(v))
1118 var i uint
1119 for k := range v {
1120 v2[i] = k
1121 i++
1122 }
1123 sort.Sort(stringSlice(v2))
1124 for _, k2 := range v2 {
1125 e.mapElemKey()
1126 e.e.EncodeString(k2)
1127 e.mapElemValue()
1128 e.e.EncodeUint(v[k2])
1129 }
1130 } else {
1131 for k2, v2 := range v {
1132 e.mapElemKey()
1133 e.e.EncodeString(k2)
1134 e.mapElemValue()
1135 e.e.EncodeUint(v2)
1136 }
1137 }
1138 e.mapEnd()
1139 }
1140 func (e *Encoder) fastpathEncMapStringIntR(f *codecFnInfo, rv reflect.Value) {
1141 fastpathTV.EncMapStringIntV(rv2i(rv).(map[string]int), e)
1142 }
1143 func (fastpathT) EncMapStringIntV(v map[string]int, e *Encoder) {
1144 e.mapStart(len(v))
1145 if e.h.Canonical {
1146 v2 := make([]string, len(v))
1147 var i uint
1148 for k := range v {
1149 v2[i] = k
1150 i++
1151 }
1152 sort.Sort(stringSlice(v2))
1153 for _, k2 := range v2 {
1154 e.mapElemKey()
1155 e.e.EncodeString(k2)
1156 e.mapElemValue()
1157 e.e.EncodeInt(int64(v[k2]))
1158 }
1159 } else {
1160 for k2, v2 := range v {
1161 e.mapElemKey()
1162 e.e.EncodeString(k2)
1163 e.mapElemValue()
1164 e.e.EncodeInt(int64(v2))
1165 }
1166 }
1167 e.mapEnd()
1168 }
1169 func (e *Encoder) fastpathEncMapStringInt32R(f *codecFnInfo, rv reflect.Value) {
1170 fastpathTV.EncMapStringInt32V(rv2i(rv).(map[string]int32), e)
1171 }
1172 func (fastpathT) EncMapStringInt32V(v map[string]int32, e *Encoder) {
1173 e.mapStart(len(v))
1174 if e.h.Canonical {
1175 v2 := make([]string, len(v))
1176 var i uint
1177 for k := range v {
1178 v2[i] = k
1179 i++
1180 }
1181 sort.Sort(stringSlice(v2))
1182 for _, k2 := range v2 {
1183 e.mapElemKey()
1184 e.e.EncodeString(k2)
1185 e.mapElemValue()
1186 e.e.EncodeInt(int64(v[k2]))
1187 }
1188 } else {
1189 for k2, v2 := range v {
1190 e.mapElemKey()
1191 e.e.EncodeString(k2)
1192 e.mapElemValue()
1193 e.e.EncodeInt(int64(v2))
1194 }
1195 }
1196 e.mapEnd()
1197 }
1198 func (e *Encoder) fastpathEncMapStringFloat64R(f *codecFnInfo, rv reflect.Value) {
1199 fastpathTV.EncMapStringFloat64V(rv2i(rv).(map[string]float64), e)
1200 }
1201 func (fastpathT) EncMapStringFloat64V(v map[string]float64, e *Encoder) {
1202 e.mapStart(len(v))
1203 if e.h.Canonical {
1204 v2 := make([]string, len(v))
1205 var i uint
1206 for k := range v {
1207 v2[i] = k
1208 i++
1209 }
1210 sort.Sort(stringSlice(v2))
1211 for _, k2 := range v2 {
1212 e.mapElemKey()
1213 e.e.EncodeString(k2)
1214 e.mapElemValue()
1215 e.e.EncodeFloat64(v[k2])
1216 }
1217 } else {
1218 for k2, v2 := range v {
1219 e.mapElemKey()
1220 e.e.EncodeString(k2)
1221 e.mapElemValue()
1222 e.e.EncodeFloat64(v2)
1223 }
1224 }
1225 e.mapEnd()
1226 }
1227 func (e *Encoder) fastpathEncMapStringBoolR(f *codecFnInfo, rv reflect.Value) {
1228 fastpathTV.EncMapStringBoolV(rv2i(rv).(map[string]bool), e)
1229 }
1230 func (fastpathT) EncMapStringBoolV(v map[string]bool, e *Encoder) {
1231 e.mapStart(len(v))
1232 if e.h.Canonical {
1233 v2 := make([]string, len(v))
1234 var i uint
1235 for k := range v {
1236 v2[i] = k
1237 i++
1238 }
1239 sort.Sort(stringSlice(v2))
1240 for _, k2 := range v2 {
1241 e.mapElemKey()
1242 e.e.EncodeString(k2)
1243 e.mapElemValue()
1244 e.e.EncodeBool(v[k2])
1245 }
1246 } else {
1247 for k2, v2 := range v {
1248 e.mapElemKey()
1249 e.e.EncodeString(k2)
1250 e.mapElemValue()
1251 e.e.EncodeBool(v2)
1252 }
1253 }
1254 e.mapEnd()
1255 }
1256 func (e *Encoder) fastpathEncMapUint8IntfR(f *codecFnInfo, rv reflect.Value) {
1257 fastpathTV.EncMapUint8IntfV(rv2i(rv).(map[uint8]interface{}), e)
1258 }
1259 func (fastpathT) EncMapUint8IntfV(v map[uint8]interface{}, e *Encoder) {
1260 e.mapStart(len(v))
1261 if e.h.Canonical {
1262 v2 := make([]uint8, len(v))
1263 var i uint
1264 for k := range v {
1265 v2[i] = k
1266 i++
1267 }
1268 sort.Sort(uint8Slice(v2))
1269 for _, k2 := range v2 {
1270 e.mapElemKey()
1271 e.e.EncodeUint(uint64(k2))
1272 e.mapElemValue()
1273 e.encode(v[k2])
1274 }
1275 } else {
1276 for k2, v2 := range v {
1277 e.mapElemKey()
1278 e.e.EncodeUint(uint64(k2))
1279 e.mapElemValue()
1280 e.encode(v2)
1281 }
1282 }
1283 e.mapEnd()
1284 }
1285 func (e *Encoder) fastpathEncMapUint8StringR(f *codecFnInfo, rv reflect.Value) {
1286 fastpathTV.EncMapUint8StringV(rv2i(rv).(map[uint8]string), e)
1287 }
1288 func (fastpathT) EncMapUint8StringV(v map[uint8]string, e *Encoder) {
1289 e.mapStart(len(v))
1290 if e.h.Canonical {
1291 v2 := make([]uint8, len(v))
1292 var i uint
1293 for k := range v {
1294 v2[i] = k
1295 i++
1296 }
1297 sort.Sort(uint8Slice(v2))
1298 for _, k2 := range v2 {
1299 e.mapElemKey()
1300 e.e.EncodeUint(uint64(k2))
1301 e.mapElemValue()
1302 e.e.EncodeString(v[k2])
1303 }
1304 } else {
1305 for k2, v2 := range v {
1306 e.mapElemKey()
1307 e.e.EncodeUint(uint64(k2))
1308 e.mapElemValue()
1309 e.e.EncodeString(v2)
1310 }
1311 }
1312 e.mapEnd()
1313 }
1314 func (e *Encoder) fastpathEncMapUint8BytesR(f *codecFnInfo, rv reflect.Value) {
1315 fastpathTV.EncMapUint8BytesV(rv2i(rv).(map[uint8][]byte), e)
1316 }
1317 func (fastpathT) EncMapUint8BytesV(v map[uint8][]byte, e *Encoder) {
1318 e.mapStart(len(v))
1319 if e.h.Canonical {
1320 v2 := make([]uint8, len(v))
1321 var i uint
1322 for k := range v {
1323 v2[i] = k
1324 i++
1325 }
1326 sort.Sort(uint8Slice(v2))
1327 for _, k2 := range v2 {
1328 e.mapElemKey()
1329 e.e.EncodeUint(uint64(k2))
1330 e.mapElemValue()
1331 e.e.EncodeStringBytesRaw(v[k2])
1332 }
1333 } else {
1334 for k2, v2 := range v {
1335 e.mapElemKey()
1336 e.e.EncodeUint(uint64(k2))
1337 e.mapElemValue()
1338 e.e.EncodeStringBytesRaw(v2)
1339 }
1340 }
1341 e.mapEnd()
1342 }
1343 func (e *Encoder) fastpathEncMapUint8Uint8R(f *codecFnInfo, rv reflect.Value) {
1344 fastpathTV.EncMapUint8Uint8V(rv2i(rv).(map[uint8]uint8), e)
1345 }
1346 func (fastpathT) EncMapUint8Uint8V(v map[uint8]uint8, e *Encoder) {
1347 e.mapStart(len(v))
1348 if e.h.Canonical {
1349 v2 := make([]uint8, len(v))
1350 var i uint
1351 for k := range v {
1352 v2[i] = k
1353 i++
1354 }
1355 sort.Sort(uint8Slice(v2))
1356 for _, k2 := range v2 {
1357 e.mapElemKey()
1358 e.e.EncodeUint(uint64(k2))
1359 e.mapElemValue()
1360 e.e.EncodeUint(uint64(v[k2]))
1361 }
1362 } else {
1363 for k2, v2 := range v {
1364 e.mapElemKey()
1365 e.e.EncodeUint(uint64(k2))
1366 e.mapElemValue()
1367 e.e.EncodeUint(uint64(v2))
1368 }
1369 }
1370 e.mapEnd()
1371 }
1372 func (e *Encoder) fastpathEncMapUint8Uint64R(f *codecFnInfo, rv reflect.Value) {
1373 fastpathTV.EncMapUint8Uint64V(rv2i(rv).(map[uint8]uint64), e)
1374 }
1375 func (fastpathT) EncMapUint8Uint64V(v map[uint8]uint64, e *Encoder) {
1376 e.mapStart(len(v))
1377 if e.h.Canonical {
1378 v2 := make([]uint8, len(v))
1379 var i uint
1380 for k := range v {
1381 v2[i] = k
1382 i++
1383 }
1384 sort.Sort(uint8Slice(v2))
1385 for _, k2 := range v2 {
1386 e.mapElemKey()
1387 e.e.EncodeUint(uint64(k2))
1388 e.mapElemValue()
1389 e.e.EncodeUint(v[k2])
1390 }
1391 } else {
1392 for k2, v2 := range v {
1393 e.mapElemKey()
1394 e.e.EncodeUint(uint64(k2))
1395 e.mapElemValue()
1396 e.e.EncodeUint(v2)
1397 }
1398 }
1399 e.mapEnd()
1400 }
1401 func (e *Encoder) fastpathEncMapUint8IntR(f *codecFnInfo, rv reflect.Value) {
1402 fastpathTV.EncMapUint8IntV(rv2i(rv).(map[uint8]int), e)
1403 }
1404 func (fastpathT) EncMapUint8IntV(v map[uint8]int, e *Encoder) {
1405 e.mapStart(len(v))
1406 if e.h.Canonical {
1407 v2 := make([]uint8, len(v))
1408 var i uint
1409 for k := range v {
1410 v2[i] = k
1411 i++
1412 }
1413 sort.Sort(uint8Slice(v2))
1414 for _, k2 := range v2 {
1415 e.mapElemKey()
1416 e.e.EncodeUint(uint64(k2))
1417 e.mapElemValue()
1418 e.e.EncodeInt(int64(v[k2]))
1419 }
1420 } else {
1421 for k2, v2 := range v {
1422 e.mapElemKey()
1423 e.e.EncodeUint(uint64(k2))
1424 e.mapElemValue()
1425 e.e.EncodeInt(int64(v2))
1426 }
1427 }
1428 e.mapEnd()
1429 }
1430 func (e *Encoder) fastpathEncMapUint8Int32R(f *codecFnInfo, rv reflect.Value) {
1431 fastpathTV.EncMapUint8Int32V(rv2i(rv).(map[uint8]int32), e)
1432 }
1433 func (fastpathT) EncMapUint8Int32V(v map[uint8]int32, e *Encoder) {
1434 e.mapStart(len(v))
1435 if e.h.Canonical {
1436 v2 := make([]uint8, len(v))
1437 var i uint
1438 for k := range v {
1439 v2[i] = k
1440 i++
1441 }
1442 sort.Sort(uint8Slice(v2))
1443 for _, k2 := range v2 {
1444 e.mapElemKey()
1445 e.e.EncodeUint(uint64(k2))
1446 e.mapElemValue()
1447 e.e.EncodeInt(int64(v[k2]))
1448 }
1449 } else {
1450 for k2, v2 := range v {
1451 e.mapElemKey()
1452 e.e.EncodeUint(uint64(k2))
1453 e.mapElemValue()
1454 e.e.EncodeInt(int64(v2))
1455 }
1456 }
1457 e.mapEnd()
1458 }
1459 func (e *Encoder) fastpathEncMapUint8Float64R(f *codecFnInfo, rv reflect.Value) {
1460 fastpathTV.EncMapUint8Float64V(rv2i(rv).(map[uint8]float64), e)
1461 }
1462 func (fastpathT) EncMapUint8Float64V(v map[uint8]float64, e *Encoder) {
1463 e.mapStart(len(v))
1464 if e.h.Canonical {
1465 v2 := make([]uint8, len(v))
1466 var i uint
1467 for k := range v {
1468 v2[i] = k
1469 i++
1470 }
1471 sort.Sort(uint8Slice(v2))
1472 for _, k2 := range v2 {
1473 e.mapElemKey()
1474 e.e.EncodeUint(uint64(k2))
1475 e.mapElemValue()
1476 e.e.EncodeFloat64(v[k2])
1477 }
1478 } else {
1479 for k2, v2 := range v {
1480 e.mapElemKey()
1481 e.e.EncodeUint(uint64(k2))
1482 e.mapElemValue()
1483 e.e.EncodeFloat64(v2)
1484 }
1485 }
1486 e.mapEnd()
1487 }
1488 func (e *Encoder) fastpathEncMapUint8BoolR(f *codecFnInfo, rv reflect.Value) {
1489 fastpathTV.EncMapUint8BoolV(rv2i(rv).(map[uint8]bool), e)
1490 }
1491 func (fastpathT) EncMapUint8BoolV(v map[uint8]bool, e *Encoder) {
1492 e.mapStart(len(v))
1493 if e.h.Canonical {
1494 v2 := make([]uint8, len(v))
1495 var i uint
1496 for k := range v {
1497 v2[i] = k
1498 i++
1499 }
1500 sort.Sort(uint8Slice(v2))
1501 for _, k2 := range v2 {
1502 e.mapElemKey()
1503 e.e.EncodeUint(uint64(k2))
1504 e.mapElemValue()
1505 e.e.EncodeBool(v[k2])
1506 }
1507 } else {
1508 for k2, v2 := range v {
1509 e.mapElemKey()
1510 e.e.EncodeUint(uint64(k2))
1511 e.mapElemValue()
1512 e.e.EncodeBool(v2)
1513 }
1514 }
1515 e.mapEnd()
1516 }
1517 func (e *Encoder) fastpathEncMapUint64IntfR(f *codecFnInfo, rv reflect.Value) {
1518 fastpathTV.EncMapUint64IntfV(rv2i(rv).(map[uint64]interface{}), e)
1519 }
1520 func (fastpathT) EncMapUint64IntfV(v map[uint64]interface{}, e *Encoder) {
1521 e.mapStart(len(v))
1522 if e.h.Canonical {
1523 v2 := make([]uint64, len(v))
1524 var i uint
1525 for k := range v {
1526 v2[i] = k
1527 i++
1528 }
1529 sort.Sort(uint64Slice(v2))
1530 for _, k2 := range v2 {
1531 e.mapElemKey()
1532 e.e.EncodeUint(k2)
1533 e.mapElemValue()
1534 e.encode(v[k2])
1535 }
1536 } else {
1537 for k2, v2 := range v {
1538 e.mapElemKey()
1539 e.e.EncodeUint(k2)
1540 e.mapElemValue()
1541 e.encode(v2)
1542 }
1543 }
1544 e.mapEnd()
1545 }
1546 func (e *Encoder) fastpathEncMapUint64StringR(f *codecFnInfo, rv reflect.Value) {
1547 fastpathTV.EncMapUint64StringV(rv2i(rv).(map[uint64]string), e)
1548 }
1549 func (fastpathT) EncMapUint64StringV(v map[uint64]string, e *Encoder) {
1550 e.mapStart(len(v))
1551 if e.h.Canonical {
1552 v2 := make([]uint64, len(v))
1553 var i uint
1554 for k := range v {
1555 v2[i] = k
1556 i++
1557 }
1558 sort.Sort(uint64Slice(v2))
1559 for _, k2 := range v2 {
1560 e.mapElemKey()
1561 e.e.EncodeUint(k2)
1562 e.mapElemValue()
1563 e.e.EncodeString(v[k2])
1564 }
1565 } else {
1566 for k2, v2 := range v {
1567 e.mapElemKey()
1568 e.e.EncodeUint(k2)
1569 e.mapElemValue()
1570 e.e.EncodeString(v2)
1571 }
1572 }
1573 e.mapEnd()
1574 }
1575 func (e *Encoder) fastpathEncMapUint64BytesR(f *codecFnInfo, rv reflect.Value) {
1576 fastpathTV.EncMapUint64BytesV(rv2i(rv).(map[uint64][]byte), e)
1577 }
1578 func (fastpathT) EncMapUint64BytesV(v map[uint64][]byte, e *Encoder) {
1579 e.mapStart(len(v))
1580 if e.h.Canonical {
1581 v2 := make([]uint64, len(v))
1582 var i uint
1583 for k := range v {
1584 v2[i] = k
1585 i++
1586 }
1587 sort.Sort(uint64Slice(v2))
1588 for _, k2 := range v2 {
1589 e.mapElemKey()
1590 e.e.EncodeUint(k2)
1591 e.mapElemValue()
1592 e.e.EncodeStringBytesRaw(v[k2])
1593 }
1594 } else {
1595 for k2, v2 := range v {
1596 e.mapElemKey()
1597 e.e.EncodeUint(k2)
1598 e.mapElemValue()
1599 e.e.EncodeStringBytesRaw(v2)
1600 }
1601 }
1602 e.mapEnd()
1603 }
1604 func (e *Encoder) fastpathEncMapUint64Uint8R(f *codecFnInfo, rv reflect.Value) {
1605 fastpathTV.EncMapUint64Uint8V(rv2i(rv).(map[uint64]uint8), e)
1606 }
1607 func (fastpathT) EncMapUint64Uint8V(v map[uint64]uint8, e *Encoder) {
1608 e.mapStart(len(v))
1609 if e.h.Canonical {
1610 v2 := make([]uint64, len(v))
1611 var i uint
1612 for k := range v {
1613 v2[i] = k
1614 i++
1615 }
1616 sort.Sort(uint64Slice(v2))
1617 for _, k2 := range v2 {
1618 e.mapElemKey()
1619 e.e.EncodeUint(k2)
1620 e.mapElemValue()
1621 e.e.EncodeUint(uint64(v[k2]))
1622 }
1623 } else {
1624 for k2, v2 := range v {
1625 e.mapElemKey()
1626 e.e.EncodeUint(k2)
1627 e.mapElemValue()
1628 e.e.EncodeUint(uint64(v2))
1629 }
1630 }
1631 e.mapEnd()
1632 }
1633 func (e *Encoder) fastpathEncMapUint64Uint64R(f *codecFnInfo, rv reflect.Value) {
1634 fastpathTV.EncMapUint64Uint64V(rv2i(rv).(map[uint64]uint64), e)
1635 }
1636 func (fastpathT) EncMapUint64Uint64V(v map[uint64]uint64, e *Encoder) {
1637 e.mapStart(len(v))
1638 if e.h.Canonical {
1639 v2 := make([]uint64, len(v))
1640 var i uint
1641 for k := range v {
1642 v2[i] = k
1643 i++
1644 }
1645 sort.Sort(uint64Slice(v2))
1646 for _, k2 := range v2 {
1647 e.mapElemKey()
1648 e.e.EncodeUint(k2)
1649 e.mapElemValue()
1650 e.e.EncodeUint(v[k2])
1651 }
1652 } else {
1653 for k2, v2 := range v {
1654 e.mapElemKey()
1655 e.e.EncodeUint(k2)
1656 e.mapElemValue()
1657 e.e.EncodeUint(v2)
1658 }
1659 }
1660 e.mapEnd()
1661 }
1662 func (e *Encoder) fastpathEncMapUint64IntR(f *codecFnInfo, rv reflect.Value) {
1663 fastpathTV.EncMapUint64IntV(rv2i(rv).(map[uint64]int), e)
1664 }
1665 func (fastpathT) EncMapUint64IntV(v map[uint64]int, e *Encoder) {
1666 e.mapStart(len(v))
1667 if e.h.Canonical {
1668 v2 := make([]uint64, len(v))
1669 var i uint
1670 for k := range v {
1671 v2[i] = k
1672 i++
1673 }
1674 sort.Sort(uint64Slice(v2))
1675 for _, k2 := range v2 {
1676 e.mapElemKey()
1677 e.e.EncodeUint(k2)
1678 e.mapElemValue()
1679 e.e.EncodeInt(int64(v[k2]))
1680 }
1681 } else {
1682 for k2, v2 := range v {
1683 e.mapElemKey()
1684 e.e.EncodeUint(k2)
1685 e.mapElemValue()
1686 e.e.EncodeInt(int64(v2))
1687 }
1688 }
1689 e.mapEnd()
1690 }
1691 func (e *Encoder) fastpathEncMapUint64Int32R(f *codecFnInfo, rv reflect.Value) {
1692 fastpathTV.EncMapUint64Int32V(rv2i(rv).(map[uint64]int32), e)
1693 }
1694 func (fastpathT) EncMapUint64Int32V(v map[uint64]int32, e *Encoder) {
1695 e.mapStart(len(v))
1696 if e.h.Canonical {
1697 v2 := make([]uint64, len(v))
1698 var i uint
1699 for k := range v {
1700 v2[i] = k
1701 i++
1702 }
1703 sort.Sort(uint64Slice(v2))
1704 for _, k2 := range v2 {
1705 e.mapElemKey()
1706 e.e.EncodeUint(k2)
1707 e.mapElemValue()
1708 e.e.EncodeInt(int64(v[k2]))
1709 }
1710 } else {
1711 for k2, v2 := range v {
1712 e.mapElemKey()
1713 e.e.EncodeUint(k2)
1714 e.mapElemValue()
1715 e.e.EncodeInt(int64(v2))
1716 }
1717 }
1718 e.mapEnd()
1719 }
1720 func (e *Encoder) fastpathEncMapUint64Float64R(f *codecFnInfo, rv reflect.Value) {
1721 fastpathTV.EncMapUint64Float64V(rv2i(rv).(map[uint64]float64), e)
1722 }
1723 func (fastpathT) EncMapUint64Float64V(v map[uint64]float64, e *Encoder) {
1724 e.mapStart(len(v))
1725 if e.h.Canonical {
1726 v2 := make([]uint64, len(v))
1727 var i uint
1728 for k := range v {
1729 v2[i] = k
1730 i++
1731 }
1732 sort.Sort(uint64Slice(v2))
1733 for _, k2 := range v2 {
1734 e.mapElemKey()
1735 e.e.EncodeUint(k2)
1736 e.mapElemValue()
1737 e.e.EncodeFloat64(v[k2])
1738 }
1739 } else {
1740 for k2, v2 := range v {
1741 e.mapElemKey()
1742 e.e.EncodeUint(k2)
1743 e.mapElemValue()
1744 e.e.EncodeFloat64(v2)
1745 }
1746 }
1747 e.mapEnd()
1748 }
1749 func (e *Encoder) fastpathEncMapUint64BoolR(f *codecFnInfo, rv reflect.Value) {
1750 fastpathTV.EncMapUint64BoolV(rv2i(rv).(map[uint64]bool), e)
1751 }
1752 func (fastpathT) EncMapUint64BoolV(v map[uint64]bool, e *Encoder) {
1753 e.mapStart(len(v))
1754 if e.h.Canonical {
1755 v2 := make([]uint64, len(v))
1756 var i uint
1757 for k := range v {
1758 v2[i] = k
1759 i++
1760 }
1761 sort.Sort(uint64Slice(v2))
1762 for _, k2 := range v2 {
1763 e.mapElemKey()
1764 e.e.EncodeUint(k2)
1765 e.mapElemValue()
1766 e.e.EncodeBool(v[k2])
1767 }
1768 } else {
1769 for k2, v2 := range v {
1770 e.mapElemKey()
1771 e.e.EncodeUint(k2)
1772 e.mapElemValue()
1773 e.e.EncodeBool(v2)
1774 }
1775 }
1776 e.mapEnd()
1777 }
1778 func (e *Encoder) fastpathEncMapIntIntfR(f *codecFnInfo, rv reflect.Value) {
1779 fastpathTV.EncMapIntIntfV(rv2i(rv).(map[int]interface{}), e)
1780 }
1781 func (fastpathT) EncMapIntIntfV(v map[int]interface{}, e *Encoder) {
1782 e.mapStart(len(v))
1783 if e.h.Canonical {
1784 v2 := make([]int, len(v))
1785 var i uint
1786 for k := range v {
1787 v2[i] = k
1788 i++
1789 }
1790 sort.Sort(intSlice(v2))
1791 for _, k2 := range v2 {
1792 e.mapElemKey()
1793 e.e.EncodeInt(int64(k2))
1794 e.mapElemValue()
1795 e.encode(v[k2])
1796 }
1797 } else {
1798 for k2, v2 := range v {
1799 e.mapElemKey()
1800 e.e.EncodeInt(int64(k2))
1801 e.mapElemValue()
1802 e.encode(v2)
1803 }
1804 }
1805 e.mapEnd()
1806 }
1807 func (e *Encoder) fastpathEncMapIntStringR(f *codecFnInfo, rv reflect.Value) {
1808 fastpathTV.EncMapIntStringV(rv2i(rv).(map[int]string), e)
1809 }
1810 func (fastpathT) EncMapIntStringV(v map[int]string, e *Encoder) {
1811 e.mapStart(len(v))
1812 if e.h.Canonical {
1813 v2 := make([]int, len(v))
1814 var i uint
1815 for k := range v {
1816 v2[i] = k
1817 i++
1818 }
1819 sort.Sort(intSlice(v2))
1820 for _, k2 := range v2 {
1821 e.mapElemKey()
1822 e.e.EncodeInt(int64(k2))
1823 e.mapElemValue()
1824 e.e.EncodeString(v[k2])
1825 }
1826 } else {
1827 for k2, v2 := range v {
1828 e.mapElemKey()
1829 e.e.EncodeInt(int64(k2))
1830 e.mapElemValue()
1831 e.e.EncodeString(v2)
1832 }
1833 }
1834 e.mapEnd()
1835 }
1836 func (e *Encoder) fastpathEncMapIntBytesR(f *codecFnInfo, rv reflect.Value) {
1837 fastpathTV.EncMapIntBytesV(rv2i(rv).(map[int][]byte), e)
1838 }
1839 func (fastpathT) EncMapIntBytesV(v map[int][]byte, e *Encoder) {
1840 e.mapStart(len(v))
1841 if e.h.Canonical {
1842 v2 := make([]int, len(v))
1843 var i uint
1844 for k := range v {
1845 v2[i] = k
1846 i++
1847 }
1848 sort.Sort(intSlice(v2))
1849 for _, k2 := range v2 {
1850 e.mapElemKey()
1851 e.e.EncodeInt(int64(k2))
1852 e.mapElemValue()
1853 e.e.EncodeStringBytesRaw(v[k2])
1854 }
1855 } else {
1856 for k2, v2 := range v {
1857 e.mapElemKey()
1858 e.e.EncodeInt(int64(k2))
1859 e.mapElemValue()
1860 e.e.EncodeStringBytesRaw(v2)
1861 }
1862 }
1863 e.mapEnd()
1864 }
1865 func (e *Encoder) fastpathEncMapIntUint8R(f *codecFnInfo, rv reflect.Value) {
1866 fastpathTV.EncMapIntUint8V(rv2i(rv).(map[int]uint8), e)
1867 }
1868 func (fastpathT) EncMapIntUint8V(v map[int]uint8, e *Encoder) {
1869 e.mapStart(len(v))
1870 if e.h.Canonical {
1871 v2 := make([]int, len(v))
1872 var i uint
1873 for k := range v {
1874 v2[i] = k
1875 i++
1876 }
1877 sort.Sort(intSlice(v2))
1878 for _, k2 := range v2 {
1879 e.mapElemKey()
1880 e.e.EncodeInt(int64(k2))
1881 e.mapElemValue()
1882 e.e.EncodeUint(uint64(v[k2]))
1883 }
1884 } else {
1885 for k2, v2 := range v {
1886 e.mapElemKey()
1887 e.e.EncodeInt(int64(k2))
1888 e.mapElemValue()
1889 e.e.EncodeUint(uint64(v2))
1890 }
1891 }
1892 e.mapEnd()
1893 }
1894 func (e *Encoder) fastpathEncMapIntUint64R(f *codecFnInfo, rv reflect.Value) {
1895 fastpathTV.EncMapIntUint64V(rv2i(rv).(map[int]uint64), e)
1896 }
1897 func (fastpathT) EncMapIntUint64V(v map[int]uint64, e *Encoder) {
1898 e.mapStart(len(v))
1899 if e.h.Canonical {
1900 v2 := make([]int, len(v))
1901 var i uint
1902 for k := range v {
1903 v2[i] = k
1904 i++
1905 }
1906 sort.Sort(intSlice(v2))
1907 for _, k2 := range v2 {
1908 e.mapElemKey()
1909 e.e.EncodeInt(int64(k2))
1910 e.mapElemValue()
1911 e.e.EncodeUint(v[k2])
1912 }
1913 } else {
1914 for k2, v2 := range v {
1915 e.mapElemKey()
1916 e.e.EncodeInt(int64(k2))
1917 e.mapElemValue()
1918 e.e.EncodeUint(v2)
1919 }
1920 }
1921 e.mapEnd()
1922 }
1923 func (e *Encoder) fastpathEncMapIntIntR(f *codecFnInfo, rv reflect.Value) {
1924 fastpathTV.EncMapIntIntV(rv2i(rv).(map[int]int), e)
1925 }
1926 func (fastpathT) EncMapIntIntV(v map[int]int, e *Encoder) {
1927 e.mapStart(len(v))
1928 if e.h.Canonical {
1929 v2 := make([]int, len(v))
1930 var i uint
1931 for k := range v {
1932 v2[i] = k
1933 i++
1934 }
1935 sort.Sort(intSlice(v2))
1936 for _, k2 := range v2 {
1937 e.mapElemKey()
1938 e.e.EncodeInt(int64(k2))
1939 e.mapElemValue()
1940 e.e.EncodeInt(int64(v[k2]))
1941 }
1942 } else {
1943 for k2, v2 := range v {
1944 e.mapElemKey()
1945 e.e.EncodeInt(int64(k2))
1946 e.mapElemValue()
1947 e.e.EncodeInt(int64(v2))
1948 }
1949 }
1950 e.mapEnd()
1951 }
1952 func (e *Encoder) fastpathEncMapIntInt32R(f *codecFnInfo, rv reflect.Value) {
1953 fastpathTV.EncMapIntInt32V(rv2i(rv).(map[int]int32), e)
1954 }
1955 func (fastpathT) EncMapIntInt32V(v map[int]int32, e *Encoder) {
1956 e.mapStart(len(v))
1957 if e.h.Canonical {
1958 v2 := make([]int, len(v))
1959 var i uint
1960 for k := range v {
1961 v2[i] = k
1962 i++
1963 }
1964 sort.Sort(intSlice(v2))
1965 for _, k2 := range v2 {
1966 e.mapElemKey()
1967 e.e.EncodeInt(int64(k2))
1968 e.mapElemValue()
1969 e.e.EncodeInt(int64(v[k2]))
1970 }
1971 } else {
1972 for k2, v2 := range v {
1973 e.mapElemKey()
1974 e.e.EncodeInt(int64(k2))
1975 e.mapElemValue()
1976 e.e.EncodeInt(int64(v2))
1977 }
1978 }
1979 e.mapEnd()
1980 }
1981 func (e *Encoder) fastpathEncMapIntFloat64R(f *codecFnInfo, rv reflect.Value) {
1982 fastpathTV.EncMapIntFloat64V(rv2i(rv).(map[int]float64), e)
1983 }
1984 func (fastpathT) EncMapIntFloat64V(v map[int]float64, e *Encoder) {
1985 e.mapStart(len(v))
1986 if e.h.Canonical {
1987 v2 := make([]int, len(v))
1988 var i uint
1989 for k := range v {
1990 v2[i] = k
1991 i++
1992 }
1993 sort.Sort(intSlice(v2))
1994 for _, k2 := range v2 {
1995 e.mapElemKey()
1996 e.e.EncodeInt(int64(k2))
1997 e.mapElemValue()
1998 e.e.EncodeFloat64(v[k2])
1999 }
2000 } else {
2001 for k2, v2 := range v {
2002 e.mapElemKey()
2003 e.e.EncodeInt(int64(k2))
2004 e.mapElemValue()
2005 e.e.EncodeFloat64(v2)
2006 }
2007 }
2008 e.mapEnd()
2009 }
2010 func (e *Encoder) fastpathEncMapIntBoolR(f *codecFnInfo, rv reflect.Value) {
2011 fastpathTV.EncMapIntBoolV(rv2i(rv).(map[int]bool), e)
2012 }
2013 func (fastpathT) EncMapIntBoolV(v map[int]bool, e *Encoder) {
2014 e.mapStart(len(v))
2015 if e.h.Canonical {
2016 v2 := make([]int, len(v))
2017 var i uint
2018 for k := range v {
2019 v2[i] = k
2020 i++
2021 }
2022 sort.Sort(intSlice(v2))
2023 for _, k2 := range v2 {
2024 e.mapElemKey()
2025 e.e.EncodeInt(int64(k2))
2026 e.mapElemValue()
2027 e.e.EncodeBool(v[k2])
2028 }
2029 } else {
2030 for k2, v2 := range v {
2031 e.mapElemKey()
2032 e.e.EncodeInt(int64(k2))
2033 e.mapElemValue()
2034 e.e.EncodeBool(v2)
2035 }
2036 }
2037 e.mapEnd()
2038 }
2039 func (e *Encoder) fastpathEncMapInt32IntfR(f *codecFnInfo, rv reflect.Value) {
2040 fastpathTV.EncMapInt32IntfV(rv2i(rv).(map[int32]interface{}), e)
2041 }
2042 func (fastpathT) EncMapInt32IntfV(v map[int32]interface{}, e *Encoder) {
2043 e.mapStart(len(v))
2044 if e.h.Canonical {
2045 v2 := make([]int32, len(v))
2046 var i uint
2047 for k := range v {
2048 v2[i] = k
2049 i++
2050 }
2051 sort.Sort(int32Slice(v2))
2052 for _, k2 := range v2 {
2053 e.mapElemKey()
2054 e.e.EncodeInt(int64(k2))
2055 e.mapElemValue()
2056 e.encode(v[k2])
2057 }
2058 } else {
2059 for k2, v2 := range v {
2060 e.mapElemKey()
2061 e.e.EncodeInt(int64(k2))
2062 e.mapElemValue()
2063 e.encode(v2)
2064 }
2065 }
2066 e.mapEnd()
2067 }
2068 func (e *Encoder) fastpathEncMapInt32StringR(f *codecFnInfo, rv reflect.Value) {
2069 fastpathTV.EncMapInt32StringV(rv2i(rv).(map[int32]string), e)
2070 }
2071 func (fastpathT) EncMapInt32StringV(v map[int32]string, e *Encoder) {
2072 e.mapStart(len(v))
2073 if e.h.Canonical {
2074 v2 := make([]int32, len(v))
2075 var i uint
2076 for k := range v {
2077 v2[i] = k
2078 i++
2079 }
2080 sort.Sort(int32Slice(v2))
2081 for _, k2 := range v2 {
2082 e.mapElemKey()
2083 e.e.EncodeInt(int64(k2))
2084 e.mapElemValue()
2085 e.e.EncodeString(v[k2])
2086 }
2087 } else {
2088 for k2, v2 := range v {
2089 e.mapElemKey()
2090 e.e.EncodeInt(int64(k2))
2091 e.mapElemValue()
2092 e.e.EncodeString(v2)
2093 }
2094 }
2095 e.mapEnd()
2096 }
2097 func (e *Encoder) fastpathEncMapInt32BytesR(f *codecFnInfo, rv reflect.Value) {
2098 fastpathTV.EncMapInt32BytesV(rv2i(rv).(map[int32][]byte), e)
2099 }
2100 func (fastpathT) EncMapInt32BytesV(v map[int32][]byte, e *Encoder) {
2101 e.mapStart(len(v))
2102 if e.h.Canonical {
2103 v2 := make([]int32, len(v))
2104 var i uint
2105 for k := range v {
2106 v2[i] = k
2107 i++
2108 }
2109 sort.Sort(int32Slice(v2))
2110 for _, k2 := range v2 {
2111 e.mapElemKey()
2112 e.e.EncodeInt(int64(k2))
2113 e.mapElemValue()
2114 e.e.EncodeStringBytesRaw(v[k2])
2115 }
2116 } else {
2117 for k2, v2 := range v {
2118 e.mapElemKey()
2119 e.e.EncodeInt(int64(k2))
2120 e.mapElemValue()
2121 e.e.EncodeStringBytesRaw(v2)
2122 }
2123 }
2124 e.mapEnd()
2125 }
2126 func (e *Encoder) fastpathEncMapInt32Uint8R(f *codecFnInfo, rv reflect.Value) {
2127 fastpathTV.EncMapInt32Uint8V(rv2i(rv).(map[int32]uint8), e)
2128 }
2129 func (fastpathT) EncMapInt32Uint8V(v map[int32]uint8, e *Encoder) {
2130 e.mapStart(len(v))
2131 if e.h.Canonical {
2132 v2 := make([]int32, len(v))
2133 var i uint
2134 for k := range v {
2135 v2[i] = k
2136 i++
2137 }
2138 sort.Sort(int32Slice(v2))
2139 for _, k2 := range v2 {
2140 e.mapElemKey()
2141 e.e.EncodeInt(int64(k2))
2142 e.mapElemValue()
2143 e.e.EncodeUint(uint64(v[k2]))
2144 }
2145 } else {
2146 for k2, v2 := range v {
2147 e.mapElemKey()
2148 e.e.EncodeInt(int64(k2))
2149 e.mapElemValue()
2150 e.e.EncodeUint(uint64(v2))
2151 }
2152 }
2153 e.mapEnd()
2154 }
2155 func (e *Encoder) fastpathEncMapInt32Uint64R(f *codecFnInfo, rv reflect.Value) {
2156 fastpathTV.EncMapInt32Uint64V(rv2i(rv).(map[int32]uint64), e)
2157 }
2158 func (fastpathT) EncMapInt32Uint64V(v map[int32]uint64, e *Encoder) {
2159 e.mapStart(len(v))
2160 if e.h.Canonical {
2161 v2 := make([]int32, len(v))
2162 var i uint
2163 for k := range v {
2164 v2[i] = k
2165 i++
2166 }
2167 sort.Sort(int32Slice(v2))
2168 for _, k2 := range v2 {
2169 e.mapElemKey()
2170 e.e.EncodeInt(int64(k2))
2171 e.mapElemValue()
2172 e.e.EncodeUint(v[k2])
2173 }
2174 } else {
2175 for k2, v2 := range v {
2176 e.mapElemKey()
2177 e.e.EncodeInt(int64(k2))
2178 e.mapElemValue()
2179 e.e.EncodeUint(v2)
2180 }
2181 }
2182 e.mapEnd()
2183 }
2184 func (e *Encoder) fastpathEncMapInt32IntR(f *codecFnInfo, rv reflect.Value) {
2185 fastpathTV.EncMapInt32IntV(rv2i(rv).(map[int32]int), e)
2186 }
2187 func (fastpathT) EncMapInt32IntV(v map[int32]int, e *Encoder) {
2188 e.mapStart(len(v))
2189 if e.h.Canonical {
2190 v2 := make([]int32, len(v))
2191 var i uint
2192 for k := range v {
2193 v2[i] = k
2194 i++
2195 }
2196 sort.Sort(int32Slice(v2))
2197 for _, k2 := range v2 {
2198 e.mapElemKey()
2199 e.e.EncodeInt(int64(k2))
2200 e.mapElemValue()
2201 e.e.EncodeInt(int64(v[k2]))
2202 }
2203 } else {
2204 for k2, v2 := range v {
2205 e.mapElemKey()
2206 e.e.EncodeInt(int64(k2))
2207 e.mapElemValue()
2208 e.e.EncodeInt(int64(v2))
2209 }
2210 }
2211 e.mapEnd()
2212 }
2213 func (e *Encoder) fastpathEncMapInt32Int32R(f *codecFnInfo, rv reflect.Value) {
2214 fastpathTV.EncMapInt32Int32V(rv2i(rv).(map[int32]int32), e)
2215 }
2216 func (fastpathT) EncMapInt32Int32V(v map[int32]int32, e *Encoder) {
2217 e.mapStart(len(v))
2218 if e.h.Canonical {
2219 v2 := make([]int32, len(v))
2220 var i uint
2221 for k := range v {
2222 v2[i] = k
2223 i++
2224 }
2225 sort.Sort(int32Slice(v2))
2226 for _, k2 := range v2 {
2227 e.mapElemKey()
2228 e.e.EncodeInt(int64(k2))
2229 e.mapElemValue()
2230 e.e.EncodeInt(int64(v[k2]))
2231 }
2232 } else {
2233 for k2, v2 := range v {
2234 e.mapElemKey()
2235 e.e.EncodeInt(int64(k2))
2236 e.mapElemValue()
2237 e.e.EncodeInt(int64(v2))
2238 }
2239 }
2240 e.mapEnd()
2241 }
2242 func (e *Encoder) fastpathEncMapInt32Float64R(f *codecFnInfo, rv reflect.Value) {
2243 fastpathTV.EncMapInt32Float64V(rv2i(rv).(map[int32]float64), e)
2244 }
2245 func (fastpathT) EncMapInt32Float64V(v map[int32]float64, e *Encoder) {
2246 e.mapStart(len(v))
2247 if e.h.Canonical {
2248 v2 := make([]int32, len(v))
2249 var i uint
2250 for k := range v {
2251 v2[i] = k
2252 i++
2253 }
2254 sort.Sort(int32Slice(v2))
2255 for _, k2 := range v2 {
2256 e.mapElemKey()
2257 e.e.EncodeInt(int64(k2))
2258 e.mapElemValue()
2259 e.e.EncodeFloat64(v[k2])
2260 }
2261 } else {
2262 for k2, v2 := range v {
2263 e.mapElemKey()
2264 e.e.EncodeInt(int64(k2))
2265 e.mapElemValue()
2266 e.e.EncodeFloat64(v2)
2267 }
2268 }
2269 e.mapEnd()
2270 }
2271 func (e *Encoder) fastpathEncMapInt32BoolR(f *codecFnInfo, rv reflect.Value) {
2272 fastpathTV.EncMapInt32BoolV(rv2i(rv).(map[int32]bool), e)
2273 }
2274 func (fastpathT) EncMapInt32BoolV(v map[int32]bool, e *Encoder) {
2275 e.mapStart(len(v))
2276 if e.h.Canonical {
2277 v2 := make([]int32, len(v))
2278 var i uint
2279 for k := range v {
2280 v2[i] = k
2281 i++
2282 }
2283 sort.Sort(int32Slice(v2))
2284 for _, k2 := range v2 {
2285 e.mapElemKey()
2286 e.e.EncodeInt(int64(k2))
2287 e.mapElemValue()
2288 e.e.EncodeBool(v[k2])
2289 }
2290 } else {
2291 for k2, v2 := range v {
2292 e.mapElemKey()
2293 e.e.EncodeInt(int64(k2))
2294 e.mapElemValue()
2295 e.e.EncodeBool(v2)
2296 }
2297 }
2298 e.mapEnd()
2299 }
2300
2301
2302
2303
2304 func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool {
2305 var changed bool
2306 var containerLen int
2307 switch v := iv.(type) {
2308 case []interface{}:
2309 fastpathTV.DecSliceIntfN(v, d)
2310 case *[]interface{}:
2311 var v2 []interface{}
2312 if v2, changed = fastpathTV.DecSliceIntfY(*v, d); changed {
2313 *v = v2
2314 }
2315 case []string:
2316 fastpathTV.DecSliceStringN(v, d)
2317 case *[]string:
2318 var v2 []string
2319 if v2, changed = fastpathTV.DecSliceStringY(*v, d); changed {
2320 *v = v2
2321 }
2322 case [][]byte:
2323 fastpathTV.DecSliceBytesN(v, d)
2324 case *[][]byte:
2325 var v2 [][]byte
2326 if v2, changed = fastpathTV.DecSliceBytesY(*v, d); changed {
2327 *v = v2
2328 }
2329 case []float32:
2330 fastpathTV.DecSliceFloat32N(v, d)
2331 case *[]float32:
2332 var v2 []float32
2333 if v2, changed = fastpathTV.DecSliceFloat32Y(*v, d); changed {
2334 *v = v2
2335 }
2336 case []float64:
2337 fastpathTV.DecSliceFloat64N(v, d)
2338 case *[]float64:
2339 var v2 []float64
2340 if v2, changed = fastpathTV.DecSliceFloat64Y(*v, d); changed {
2341 *v = v2
2342 }
2343 case []uint8:
2344 fastpathTV.DecSliceUint8N(v, d)
2345 case *[]uint8:
2346 var v2 []uint8
2347 if v2, changed = fastpathTV.DecSliceUint8Y(*v, d); changed {
2348 *v = v2
2349 }
2350 case []uint64:
2351 fastpathTV.DecSliceUint64N(v, d)
2352 case *[]uint64:
2353 var v2 []uint64
2354 if v2, changed = fastpathTV.DecSliceUint64Y(*v, d); changed {
2355 *v = v2
2356 }
2357 case []int:
2358 fastpathTV.DecSliceIntN(v, d)
2359 case *[]int:
2360 var v2 []int
2361 if v2, changed = fastpathTV.DecSliceIntY(*v, d); changed {
2362 *v = v2
2363 }
2364 case []int32:
2365 fastpathTV.DecSliceInt32N(v, d)
2366 case *[]int32:
2367 var v2 []int32
2368 if v2, changed = fastpathTV.DecSliceInt32Y(*v, d); changed {
2369 *v = v2
2370 }
2371 case []int64:
2372 fastpathTV.DecSliceInt64N(v, d)
2373 case *[]int64:
2374 var v2 []int64
2375 if v2, changed = fastpathTV.DecSliceInt64Y(*v, d); changed {
2376 *v = v2
2377 }
2378 case []bool:
2379 fastpathTV.DecSliceBoolN(v, d)
2380 case *[]bool:
2381 var v2 []bool
2382 if v2, changed = fastpathTV.DecSliceBoolY(*v, d); changed {
2383 *v = v2
2384 }
2385 case map[string]interface{}:
2386 containerLen = d.mapStart(d.d.ReadMapStart())
2387 if containerLen != containerLenNil {
2388 if containerLen != 0 {
2389 fastpathTV.DecMapStringIntfL(v, containerLen, d)
2390 }
2391 d.mapEnd()
2392 }
2393 case *map[string]interface{}:
2394 fastpathTV.DecMapStringIntfX(v, d)
2395 case map[string]string:
2396 containerLen = d.mapStart(d.d.ReadMapStart())
2397 if containerLen != containerLenNil {
2398 if containerLen != 0 {
2399 fastpathTV.DecMapStringStringL(v, containerLen, d)
2400 }
2401 d.mapEnd()
2402 }
2403 case *map[string]string:
2404 fastpathTV.DecMapStringStringX(v, d)
2405 case map[string][]byte:
2406 containerLen = d.mapStart(d.d.ReadMapStart())
2407 if containerLen != containerLenNil {
2408 if containerLen != 0 {
2409 fastpathTV.DecMapStringBytesL(v, containerLen, d)
2410 }
2411 d.mapEnd()
2412 }
2413 case *map[string][]byte:
2414 fastpathTV.DecMapStringBytesX(v, d)
2415 case map[string]uint8:
2416 containerLen = d.mapStart(d.d.ReadMapStart())
2417 if containerLen != containerLenNil {
2418 if containerLen != 0 {
2419 fastpathTV.DecMapStringUint8L(v, containerLen, d)
2420 }
2421 d.mapEnd()
2422 }
2423 case *map[string]uint8:
2424 fastpathTV.DecMapStringUint8X(v, d)
2425 case map[string]uint64:
2426 containerLen = d.mapStart(d.d.ReadMapStart())
2427 if containerLen != containerLenNil {
2428 if containerLen != 0 {
2429 fastpathTV.DecMapStringUint64L(v, containerLen, d)
2430 }
2431 d.mapEnd()
2432 }
2433 case *map[string]uint64:
2434 fastpathTV.DecMapStringUint64X(v, d)
2435 case map[string]int:
2436 containerLen = d.mapStart(d.d.ReadMapStart())
2437 if containerLen != containerLenNil {
2438 if containerLen != 0 {
2439 fastpathTV.DecMapStringIntL(v, containerLen, d)
2440 }
2441 d.mapEnd()
2442 }
2443 case *map[string]int:
2444 fastpathTV.DecMapStringIntX(v, d)
2445 case map[string]int32:
2446 containerLen = d.mapStart(d.d.ReadMapStart())
2447 if containerLen != containerLenNil {
2448 if containerLen != 0 {
2449 fastpathTV.DecMapStringInt32L(v, containerLen, d)
2450 }
2451 d.mapEnd()
2452 }
2453 case *map[string]int32:
2454 fastpathTV.DecMapStringInt32X(v, d)
2455 case map[string]float64:
2456 containerLen = d.mapStart(d.d.ReadMapStart())
2457 if containerLen != containerLenNil {
2458 if containerLen != 0 {
2459 fastpathTV.DecMapStringFloat64L(v, containerLen, d)
2460 }
2461 d.mapEnd()
2462 }
2463 case *map[string]float64:
2464 fastpathTV.DecMapStringFloat64X(v, d)
2465 case map[string]bool:
2466 containerLen = d.mapStart(d.d.ReadMapStart())
2467 if containerLen != containerLenNil {
2468 if containerLen != 0 {
2469 fastpathTV.DecMapStringBoolL(v, containerLen, d)
2470 }
2471 d.mapEnd()
2472 }
2473 case *map[string]bool:
2474 fastpathTV.DecMapStringBoolX(v, d)
2475 case map[uint8]interface{}:
2476 containerLen = d.mapStart(d.d.ReadMapStart())
2477 if containerLen != containerLenNil {
2478 if containerLen != 0 {
2479 fastpathTV.DecMapUint8IntfL(v, containerLen, d)
2480 }
2481 d.mapEnd()
2482 }
2483 case *map[uint8]interface{}:
2484 fastpathTV.DecMapUint8IntfX(v, d)
2485 case map[uint8]string:
2486 containerLen = d.mapStart(d.d.ReadMapStart())
2487 if containerLen != containerLenNil {
2488 if containerLen != 0 {
2489 fastpathTV.DecMapUint8StringL(v, containerLen, d)
2490 }
2491 d.mapEnd()
2492 }
2493 case *map[uint8]string:
2494 fastpathTV.DecMapUint8StringX(v, d)
2495 case map[uint8][]byte:
2496 containerLen = d.mapStart(d.d.ReadMapStart())
2497 if containerLen != containerLenNil {
2498 if containerLen != 0 {
2499 fastpathTV.DecMapUint8BytesL(v, containerLen, d)
2500 }
2501 d.mapEnd()
2502 }
2503 case *map[uint8][]byte:
2504 fastpathTV.DecMapUint8BytesX(v, d)
2505 case map[uint8]uint8:
2506 containerLen = d.mapStart(d.d.ReadMapStart())
2507 if containerLen != containerLenNil {
2508 if containerLen != 0 {
2509 fastpathTV.DecMapUint8Uint8L(v, containerLen, d)
2510 }
2511 d.mapEnd()
2512 }
2513 case *map[uint8]uint8:
2514 fastpathTV.DecMapUint8Uint8X(v, d)
2515 case map[uint8]uint64:
2516 containerLen = d.mapStart(d.d.ReadMapStart())
2517 if containerLen != containerLenNil {
2518 if containerLen != 0 {
2519 fastpathTV.DecMapUint8Uint64L(v, containerLen, d)
2520 }
2521 d.mapEnd()
2522 }
2523 case *map[uint8]uint64:
2524 fastpathTV.DecMapUint8Uint64X(v, d)
2525 case map[uint8]int:
2526 containerLen = d.mapStart(d.d.ReadMapStart())
2527 if containerLen != containerLenNil {
2528 if containerLen != 0 {
2529 fastpathTV.DecMapUint8IntL(v, containerLen, d)
2530 }
2531 d.mapEnd()
2532 }
2533 case *map[uint8]int:
2534 fastpathTV.DecMapUint8IntX(v, d)
2535 case map[uint8]int32:
2536 containerLen = d.mapStart(d.d.ReadMapStart())
2537 if containerLen != containerLenNil {
2538 if containerLen != 0 {
2539 fastpathTV.DecMapUint8Int32L(v, containerLen, d)
2540 }
2541 d.mapEnd()
2542 }
2543 case *map[uint8]int32:
2544 fastpathTV.DecMapUint8Int32X(v, d)
2545 case map[uint8]float64:
2546 containerLen = d.mapStart(d.d.ReadMapStart())
2547 if containerLen != containerLenNil {
2548 if containerLen != 0 {
2549 fastpathTV.DecMapUint8Float64L(v, containerLen, d)
2550 }
2551 d.mapEnd()
2552 }
2553 case *map[uint8]float64:
2554 fastpathTV.DecMapUint8Float64X(v, d)
2555 case map[uint8]bool:
2556 containerLen = d.mapStart(d.d.ReadMapStart())
2557 if containerLen != containerLenNil {
2558 if containerLen != 0 {
2559 fastpathTV.DecMapUint8BoolL(v, containerLen, d)
2560 }
2561 d.mapEnd()
2562 }
2563 case *map[uint8]bool:
2564 fastpathTV.DecMapUint8BoolX(v, d)
2565 case map[uint64]interface{}:
2566 containerLen = d.mapStart(d.d.ReadMapStart())
2567 if containerLen != containerLenNil {
2568 if containerLen != 0 {
2569 fastpathTV.DecMapUint64IntfL(v, containerLen, d)
2570 }
2571 d.mapEnd()
2572 }
2573 case *map[uint64]interface{}:
2574 fastpathTV.DecMapUint64IntfX(v, d)
2575 case map[uint64]string:
2576 containerLen = d.mapStart(d.d.ReadMapStart())
2577 if containerLen != containerLenNil {
2578 if containerLen != 0 {
2579 fastpathTV.DecMapUint64StringL(v, containerLen, d)
2580 }
2581 d.mapEnd()
2582 }
2583 case *map[uint64]string:
2584 fastpathTV.DecMapUint64StringX(v, d)
2585 case map[uint64][]byte:
2586 containerLen = d.mapStart(d.d.ReadMapStart())
2587 if containerLen != containerLenNil {
2588 if containerLen != 0 {
2589 fastpathTV.DecMapUint64BytesL(v, containerLen, d)
2590 }
2591 d.mapEnd()
2592 }
2593 case *map[uint64][]byte:
2594 fastpathTV.DecMapUint64BytesX(v, d)
2595 case map[uint64]uint8:
2596 containerLen = d.mapStart(d.d.ReadMapStart())
2597 if containerLen != containerLenNil {
2598 if containerLen != 0 {
2599 fastpathTV.DecMapUint64Uint8L(v, containerLen, d)
2600 }
2601 d.mapEnd()
2602 }
2603 case *map[uint64]uint8:
2604 fastpathTV.DecMapUint64Uint8X(v, d)
2605 case map[uint64]uint64:
2606 containerLen = d.mapStart(d.d.ReadMapStart())
2607 if containerLen != containerLenNil {
2608 if containerLen != 0 {
2609 fastpathTV.DecMapUint64Uint64L(v, containerLen, d)
2610 }
2611 d.mapEnd()
2612 }
2613 case *map[uint64]uint64:
2614 fastpathTV.DecMapUint64Uint64X(v, d)
2615 case map[uint64]int:
2616 containerLen = d.mapStart(d.d.ReadMapStart())
2617 if containerLen != containerLenNil {
2618 if containerLen != 0 {
2619 fastpathTV.DecMapUint64IntL(v, containerLen, d)
2620 }
2621 d.mapEnd()
2622 }
2623 case *map[uint64]int:
2624 fastpathTV.DecMapUint64IntX(v, d)
2625 case map[uint64]int32:
2626 containerLen = d.mapStart(d.d.ReadMapStart())
2627 if containerLen != containerLenNil {
2628 if containerLen != 0 {
2629 fastpathTV.DecMapUint64Int32L(v, containerLen, d)
2630 }
2631 d.mapEnd()
2632 }
2633 case *map[uint64]int32:
2634 fastpathTV.DecMapUint64Int32X(v, d)
2635 case map[uint64]float64:
2636 containerLen = d.mapStart(d.d.ReadMapStart())
2637 if containerLen != containerLenNil {
2638 if containerLen != 0 {
2639 fastpathTV.DecMapUint64Float64L(v, containerLen, d)
2640 }
2641 d.mapEnd()
2642 }
2643 case *map[uint64]float64:
2644 fastpathTV.DecMapUint64Float64X(v, d)
2645 case map[uint64]bool:
2646 containerLen = d.mapStart(d.d.ReadMapStart())
2647 if containerLen != containerLenNil {
2648 if containerLen != 0 {
2649 fastpathTV.DecMapUint64BoolL(v, containerLen, d)
2650 }
2651 d.mapEnd()
2652 }
2653 case *map[uint64]bool:
2654 fastpathTV.DecMapUint64BoolX(v, d)
2655 case map[int]interface{}:
2656 containerLen = d.mapStart(d.d.ReadMapStart())
2657 if containerLen != containerLenNil {
2658 if containerLen != 0 {
2659 fastpathTV.DecMapIntIntfL(v, containerLen, d)
2660 }
2661 d.mapEnd()
2662 }
2663 case *map[int]interface{}:
2664 fastpathTV.DecMapIntIntfX(v, d)
2665 case map[int]string:
2666 containerLen = d.mapStart(d.d.ReadMapStart())
2667 if containerLen != containerLenNil {
2668 if containerLen != 0 {
2669 fastpathTV.DecMapIntStringL(v, containerLen, d)
2670 }
2671 d.mapEnd()
2672 }
2673 case *map[int]string:
2674 fastpathTV.DecMapIntStringX(v, d)
2675 case map[int][]byte:
2676 containerLen = d.mapStart(d.d.ReadMapStart())
2677 if containerLen != containerLenNil {
2678 if containerLen != 0 {
2679 fastpathTV.DecMapIntBytesL(v, containerLen, d)
2680 }
2681 d.mapEnd()
2682 }
2683 case *map[int][]byte:
2684 fastpathTV.DecMapIntBytesX(v, d)
2685 case map[int]uint8:
2686 containerLen = d.mapStart(d.d.ReadMapStart())
2687 if containerLen != containerLenNil {
2688 if containerLen != 0 {
2689 fastpathTV.DecMapIntUint8L(v, containerLen, d)
2690 }
2691 d.mapEnd()
2692 }
2693 case *map[int]uint8:
2694 fastpathTV.DecMapIntUint8X(v, d)
2695 case map[int]uint64:
2696 containerLen = d.mapStart(d.d.ReadMapStart())
2697 if containerLen != containerLenNil {
2698 if containerLen != 0 {
2699 fastpathTV.DecMapIntUint64L(v, containerLen, d)
2700 }
2701 d.mapEnd()
2702 }
2703 case *map[int]uint64:
2704 fastpathTV.DecMapIntUint64X(v, d)
2705 case map[int]int:
2706 containerLen = d.mapStart(d.d.ReadMapStart())
2707 if containerLen != containerLenNil {
2708 if containerLen != 0 {
2709 fastpathTV.DecMapIntIntL(v, containerLen, d)
2710 }
2711 d.mapEnd()
2712 }
2713 case *map[int]int:
2714 fastpathTV.DecMapIntIntX(v, d)
2715 case map[int]int32:
2716 containerLen = d.mapStart(d.d.ReadMapStart())
2717 if containerLen != containerLenNil {
2718 if containerLen != 0 {
2719 fastpathTV.DecMapIntInt32L(v, containerLen, d)
2720 }
2721 d.mapEnd()
2722 }
2723 case *map[int]int32:
2724 fastpathTV.DecMapIntInt32X(v, d)
2725 case map[int]float64:
2726 containerLen = d.mapStart(d.d.ReadMapStart())
2727 if containerLen != containerLenNil {
2728 if containerLen != 0 {
2729 fastpathTV.DecMapIntFloat64L(v, containerLen, d)
2730 }
2731 d.mapEnd()
2732 }
2733 case *map[int]float64:
2734 fastpathTV.DecMapIntFloat64X(v, d)
2735 case map[int]bool:
2736 containerLen = d.mapStart(d.d.ReadMapStart())
2737 if containerLen != containerLenNil {
2738 if containerLen != 0 {
2739 fastpathTV.DecMapIntBoolL(v, containerLen, d)
2740 }
2741 d.mapEnd()
2742 }
2743 case *map[int]bool:
2744 fastpathTV.DecMapIntBoolX(v, d)
2745 case map[int32]interface{}:
2746 containerLen = d.mapStart(d.d.ReadMapStart())
2747 if containerLen != containerLenNil {
2748 if containerLen != 0 {
2749 fastpathTV.DecMapInt32IntfL(v, containerLen, d)
2750 }
2751 d.mapEnd()
2752 }
2753 case *map[int32]interface{}:
2754 fastpathTV.DecMapInt32IntfX(v, d)
2755 case map[int32]string:
2756 containerLen = d.mapStart(d.d.ReadMapStart())
2757 if containerLen != containerLenNil {
2758 if containerLen != 0 {
2759 fastpathTV.DecMapInt32StringL(v, containerLen, d)
2760 }
2761 d.mapEnd()
2762 }
2763 case *map[int32]string:
2764 fastpathTV.DecMapInt32StringX(v, d)
2765 case map[int32][]byte:
2766 containerLen = d.mapStart(d.d.ReadMapStart())
2767 if containerLen != containerLenNil {
2768 if containerLen != 0 {
2769 fastpathTV.DecMapInt32BytesL(v, containerLen, d)
2770 }
2771 d.mapEnd()
2772 }
2773 case *map[int32][]byte:
2774 fastpathTV.DecMapInt32BytesX(v, d)
2775 case map[int32]uint8:
2776 containerLen = d.mapStart(d.d.ReadMapStart())
2777 if containerLen != containerLenNil {
2778 if containerLen != 0 {
2779 fastpathTV.DecMapInt32Uint8L(v, containerLen, d)
2780 }
2781 d.mapEnd()
2782 }
2783 case *map[int32]uint8:
2784 fastpathTV.DecMapInt32Uint8X(v, d)
2785 case map[int32]uint64:
2786 containerLen = d.mapStart(d.d.ReadMapStart())
2787 if containerLen != containerLenNil {
2788 if containerLen != 0 {
2789 fastpathTV.DecMapInt32Uint64L(v, containerLen, d)
2790 }
2791 d.mapEnd()
2792 }
2793 case *map[int32]uint64:
2794 fastpathTV.DecMapInt32Uint64X(v, d)
2795 case map[int32]int:
2796 containerLen = d.mapStart(d.d.ReadMapStart())
2797 if containerLen != containerLenNil {
2798 if containerLen != 0 {
2799 fastpathTV.DecMapInt32IntL(v, containerLen, d)
2800 }
2801 d.mapEnd()
2802 }
2803 case *map[int32]int:
2804 fastpathTV.DecMapInt32IntX(v, d)
2805 case map[int32]int32:
2806 containerLen = d.mapStart(d.d.ReadMapStart())
2807 if containerLen != containerLenNil {
2808 if containerLen != 0 {
2809 fastpathTV.DecMapInt32Int32L(v, containerLen, d)
2810 }
2811 d.mapEnd()
2812 }
2813 case *map[int32]int32:
2814 fastpathTV.DecMapInt32Int32X(v, d)
2815 case map[int32]float64:
2816 containerLen = d.mapStart(d.d.ReadMapStart())
2817 if containerLen != containerLenNil {
2818 if containerLen != 0 {
2819 fastpathTV.DecMapInt32Float64L(v, containerLen, d)
2820 }
2821 d.mapEnd()
2822 }
2823 case *map[int32]float64:
2824 fastpathTV.DecMapInt32Float64X(v, d)
2825 case map[int32]bool:
2826 containerLen = d.mapStart(d.d.ReadMapStart())
2827 if containerLen != containerLenNil {
2828 if containerLen != 0 {
2829 fastpathTV.DecMapInt32BoolL(v, containerLen, d)
2830 }
2831 d.mapEnd()
2832 }
2833 case *map[int32]bool:
2834 fastpathTV.DecMapInt32BoolX(v, d)
2835 default:
2836 _ = v
2837 return false
2838 }
2839 return true
2840 }
2841
2842 func fastpathDecodeSetZeroTypeSwitch(iv interface{}) bool {
2843 switch v := iv.(type) {
2844 case *[]interface{}:
2845 *v = nil
2846 case *[]string:
2847 *v = nil
2848 case *[][]byte:
2849 *v = nil
2850 case *[]float32:
2851 *v = nil
2852 case *[]float64:
2853 *v = nil
2854 case *[]uint8:
2855 *v = nil
2856 case *[]uint64:
2857 *v = nil
2858 case *[]int:
2859 *v = nil
2860 case *[]int32:
2861 *v = nil
2862 case *[]int64:
2863 *v = nil
2864 case *[]bool:
2865 *v = nil
2866
2867 case *map[string]interface{}:
2868 *v = nil
2869 case *map[string]string:
2870 *v = nil
2871 case *map[string][]byte:
2872 *v = nil
2873 case *map[string]uint8:
2874 *v = nil
2875 case *map[string]uint64:
2876 *v = nil
2877 case *map[string]int:
2878 *v = nil
2879 case *map[string]int32:
2880 *v = nil
2881 case *map[string]float64:
2882 *v = nil
2883 case *map[string]bool:
2884 *v = nil
2885 case *map[uint8]interface{}:
2886 *v = nil
2887 case *map[uint8]string:
2888 *v = nil
2889 case *map[uint8][]byte:
2890 *v = nil
2891 case *map[uint8]uint8:
2892 *v = nil
2893 case *map[uint8]uint64:
2894 *v = nil
2895 case *map[uint8]int:
2896 *v = nil
2897 case *map[uint8]int32:
2898 *v = nil
2899 case *map[uint8]float64:
2900 *v = nil
2901 case *map[uint8]bool:
2902 *v = nil
2903 case *map[uint64]interface{}:
2904 *v = nil
2905 case *map[uint64]string:
2906 *v = nil
2907 case *map[uint64][]byte:
2908 *v = nil
2909 case *map[uint64]uint8:
2910 *v = nil
2911 case *map[uint64]uint64:
2912 *v = nil
2913 case *map[uint64]int:
2914 *v = nil
2915 case *map[uint64]int32:
2916 *v = nil
2917 case *map[uint64]float64:
2918 *v = nil
2919 case *map[uint64]bool:
2920 *v = nil
2921 case *map[int]interface{}:
2922 *v = nil
2923 case *map[int]string:
2924 *v = nil
2925 case *map[int][]byte:
2926 *v = nil
2927 case *map[int]uint8:
2928 *v = nil
2929 case *map[int]uint64:
2930 *v = nil
2931 case *map[int]int:
2932 *v = nil
2933 case *map[int]int32:
2934 *v = nil
2935 case *map[int]float64:
2936 *v = nil
2937 case *map[int]bool:
2938 *v = nil
2939 case *map[int32]interface{}:
2940 *v = nil
2941 case *map[int32]string:
2942 *v = nil
2943 case *map[int32][]byte:
2944 *v = nil
2945 case *map[int32]uint8:
2946 *v = nil
2947 case *map[int32]uint64:
2948 *v = nil
2949 case *map[int32]int:
2950 *v = nil
2951 case *map[int32]int32:
2952 *v = nil
2953 case *map[int32]float64:
2954 *v = nil
2955 case *map[int32]bool:
2956 *v = nil
2957
2958 default:
2959 _ = v
2960 return false
2961 }
2962 return true
2963 }
2964
2965
2966
2967 func (d *Decoder) fastpathDecSliceIntfR(f *codecFnInfo, rv reflect.Value) {
2968 var v []interface{}
2969 switch rv.Kind() {
2970 case reflect.Ptr:
2971 vp := rv2i(rv).(*[]interface{})
2972 var changed bool
2973 if v, changed = fastpathTV.DecSliceIntfY(*vp, d); changed {
2974 *vp = v
2975 }
2976 case reflect.Array:
2977 rvGetSlice4Array(rv, &v)
2978 fastpathTV.DecSliceIntfN(v, d)
2979 default:
2980 fastpathTV.DecSliceIntfN(rv2i(rv).([]interface{}), d)
2981 }
2982 }
2983 func (f fastpathT) DecSliceIntfX(vp *[]interface{}, d *Decoder) {
2984 if v, changed := f.DecSliceIntfY(*vp, d); changed {
2985 *vp = v
2986 }
2987 }
2988 func (fastpathT) DecSliceIntfY(v []interface{}, d *Decoder) (v2 []interface{}, changed bool) {
2989 slh, containerLenS := d.decSliceHelperStart()
2990 if slh.IsNil {
2991 if v == nil {
2992 return
2993 }
2994 return nil, true
2995 }
2996 if containerLenS == 0 {
2997 if v == nil {
2998 v = []interface{}{}
2999 } else if len(v) != 0 {
3000 v = v[:0]
3001 }
3002 slh.End()
3003 return v, true
3004 }
3005 hasLen := containerLenS > 0
3006 var xlen int
3007 if hasLen {
3008 if containerLenS > cap(v) {
3009 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
3010 if xlen <= cap(v) {
3011 v = v[:uint(xlen)]
3012 } else {
3013 v = make([]interface{}, uint(xlen))
3014 }
3015 changed = true
3016 } else if containerLenS != len(v) {
3017 v = v[:containerLenS]
3018 changed = true
3019 }
3020 }
3021 var j int
3022 for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
3023 if j == 0 && len(v) == 0 {
3024 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
3025 v = make([]interface{}, uint(xlen))
3026 changed = true
3027 }
3028 if j >= len(v) {
3029 v = append(v, nil)
3030 changed = true
3031 }
3032 slh.ElemContainerState(j)
3033 d.decode(&v[uint(j)])
3034 }
3035 if j < len(v) {
3036 v = v[:uint(j)]
3037 changed = true
3038 } else if j == 0 && v == nil {
3039 v = []interface{}{}
3040 changed = true
3041 }
3042 slh.End()
3043 return v, changed
3044 }
3045 func (fastpathT) DecSliceIntfN(v []interface{}, d *Decoder) {
3046 slh, containerLenS := d.decSliceHelperStart()
3047 if slh.IsNil {
3048 return
3049 }
3050 if containerLenS == 0 {
3051 slh.End()
3052 return
3053 }
3054 hasLen := containerLenS > 0
3055 for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
3056 if j >= len(v) {
3057 slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
3058 return
3059 }
3060 slh.ElemContainerState(j)
3061 d.decode(&v[uint(j)])
3062 }
3063 slh.End()
3064 }
3065
3066 func (d *Decoder) fastpathDecSliceStringR(f *codecFnInfo, rv reflect.Value) {
3067 var v []string
3068 switch rv.Kind() {
3069 case reflect.Ptr:
3070 vp := rv2i(rv).(*[]string)
3071 var changed bool
3072 if v, changed = fastpathTV.DecSliceStringY(*vp, d); changed {
3073 *vp = v
3074 }
3075 case reflect.Array:
3076 rvGetSlice4Array(rv, &v)
3077 fastpathTV.DecSliceStringN(v, d)
3078 default:
3079 fastpathTV.DecSliceStringN(rv2i(rv).([]string), d)
3080 }
3081 }
3082 func (f fastpathT) DecSliceStringX(vp *[]string, d *Decoder) {
3083 if v, changed := f.DecSliceStringY(*vp, d); changed {
3084 *vp = v
3085 }
3086 }
3087 func (fastpathT) DecSliceStringY(v []string, d *Decoder) (v2 []string, changed bool) {
3088 slh, containerLenS := d.decSliceHelperStart()
3089 if slh.IsNil {
3090 if v == nil {
3091 return
3092 }
3093 return nil, true
3094 }
3095 if containerLenS == 0 {
3096 if v == nil {
3097 v = []string{}
3098 } else if len(v) != 0 {
3099 v = v[:0]
3100 }
3101 slh.End()
3102 return v, true
3103 }
3104 hasLen := containerLenS > 0
3105 var xlen int
3106 if hasLen {
3107 if containerLenS > cap(v) {
3108 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
3109 if xlen <= cap(v) {
3110 v = v[:uint(xlen)]
3111 } else {
3112 v = make([]string, uint(xlen))
3113 }
3114 changed = true
3115 } else if containerLenS != len(v) {
3116 v = v[:containerLenS]
3117 changed = true
3118 }
3119 }
3120 var j int
3121 for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
3122 if j == 0 && len(v) == 0 {
3123 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
3124 v = make([]string, uint(xlen))
3125 changed = true
3126 }
3127 if j >= len(v) {
3128 v = append(v, "")
3129 changed = true
3130 }
3131 slh.ElemContainerState(j)
3132 v[uint(j)] = d.stringZC(d.d.DecodeStringAsBytes())
3133 }
3134 if j < len(v) {
3135 v = v[:uint(j)]
3136 changed = true
3137 } else if j == 0 && v == nil {
3138 v = []string{}
3139 changed = true
3140 }
3141 slh.End()
3142 return v, changed
3143 }
3144 func (fastpathT) DecSliceStringN(v []string, d *Decoder) {
3145 slh, containerLenS := d.decSliceHelperStart()
3146 if slh.IsNil {
3147 return
3148 }
3149 if containerLenS == 0 {
3150 slh.End()
3151 return
3152 }
3153 hasLen := containerLenS > 0
3154 for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
3155 if j >= len(v) {
3156 slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
3157 return
3158 }
3159 slh.ElemContainerState(j)
3160 v[uint(j)] = d.stringZC(d.d.DecodeStringAsBytes())
3161 }
3162 slh.End()
3163 }
3164
3165 func (d *Decoder) fastpathDecSliceBytesR(f *codecFnInfo, rv reflect.Value) {
3166 var v [][]byte
3167 switch rv.Kind() {
3168 case reflect.Ptr:
3169 vp := rv2i(rv).(*[][]byte)
3170 var changed bool
3171 if v, changed = fastpathTV.DecSliceBytesY(*vp, d); changed {
3172 *vp = v
3173 }
3174 case reflect.Array:
3175 rvGetSlice4Array(rv, &v)
3176 fastpathTV.DecSliceBytesN(v, d)
3177 default:
3178 fastpathTV.DecSliceBytesN(rv2i(rv).([][]byte), d)
3179 }
3180 }
3181 func (f fastpathT) DecSliceBytesX(vp *[][]byte, d *Decoder) {
3182 if v, changed := f.DecSliceBytesY(*vp, d); changed {
3183 *vp = v
3184 }
3185 }
3186 func (fastpathT) DecSliceBytesY(v [][]byte, d *Decoder) (v2 [][]byte, changed bool) {
3187 slh, containerLenS := d.decSliceHelperStart()
3188 if slh.IsNil {
3189 if v == nil {
3190 return
3191 }
3192 return nil, true
3193 }
3194 if containerLenS == 0 {
3195 if v == nil {
3196 v = [][]byte{}
3197 } else if len(v) != 0 {
3198 v = v[:0]
3199 }
3200 slh.End()
3201 return v, true
3202 }
3203 hasLen := containerLenS > 0
3204 var xlen int
3205 if hasLen {
3206 if containerLenS > cap(v) {
3207 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 24)
3208 if xlen <= cap(v) {
3209 v = v[:uint(xlen)]
3210 } else {
3211 v = make([][]byte, uint(xlen))
3212 }
3213 changed = true
3214 } else if containerLenS != len(v) {
3215 v = v[:containerLenS]
3216 changed = true
3217 }
3218 }
3219 var j int
3220 for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
3221 if j == 0 && len(v) == 0 {
3222 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 24)
3223 v = make([][]byte, uint(xlen))
3224 changed = true
3225 }
3226 if j >= len(v) {
3227 v = append(v, nil)
3228 changed = true
3229 }
3230 slh.ElemContainerState(j)
3231 v[uint(j)] = d.d.DecodeBytes([]byte{})
3232 }
3233 if j < len(v) {
3234 v = v[:uint(j)]
3235 changed = true
3236 } else if j == 0 && v == nil {
3237 v = [][]byte{}
3238 changed = true
3239 }
3240 slh.End()
3241 return v, changed
3242 }
3243 func (fastpathT) DecSliceBytesN(v [][]byte, d *Decoder) {
3244 slh, containerLenS := d.decSliceHelperStart()
3245 if slh.IsNil {
3246 return
3247 }
3248 if containerLenS == 0 {
3249 slh.End()
3250 return
3251 }
3252 hasLen := containerLenS > 0
3253 for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
3254 if j >= len(v) {
3255 slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
3256 return
3257 }
3258 slh.ElemContainerState(j)
3259 v[uint(j)] = d.d.DecodeBytes([]byte{})
3260 }
3261 slh.End()
3262 }
3263
3264 func (d *Decoder) fastpathDecSliceFloat32R(f *codecFnInfo, rv reflect.Value) {
3265 var v []float32
3266 switch rv.Kind() {
3267 case reflect.Ptr:
3268 vp := rv2i(rv).(*[]float32)
3269 var changed bool
3270 if v, changed = fastpathTV.DecSliceFloat32Y(*vp, d); changed {
3271 *vp = v
3272 }
3273 case reflect.Array:
3274 rvGetSlice4Array(rv, &v)
3275 fastpathTV.DecSliceFloat32N(v, d)
3276 default:
3277 fastpathTV.DecSliceFloat32N(rv2i(rv).([]float32), d)
3278 }
3279 }
3280 func (f fastpathT) DecSliceFloat32X(vp *[]float32, d *Decoder) {
3281 if v, changed := f.DecSliceFloat32Y(*vp, d); changed {
3282 *vp = v
3283 }
3284 }
3285 func (fastpathT) DecSliceFloat32Y(v []float32, d *Decoder) (v2 []float32, changed bool) {
3286 slh, containerLenS := d.decSliceHelperStart()
3287 if slh.IsNil {
3288 if v == nil {
3289 return
3290 }
3291 return nil, true
3292 }
3293 if containerLenS == 0 {
3294 if v == nil {
3295 v = []float32{}
3296 } else if len(v) != 0 {
3297 v = v[:0]
3298 }
3299 slh.End()
3300 return v, true
3301 }
3302 hasLen := containerLenS > 0
3303 var xlen int
3304 if hasLen {
3305 if containerLenS > cap(v) {
3306 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
3307 if xlen <= cap(v) {
3308 v = v[:uint(xlen)]
3309 } else {
3310 v = make([]float32, uint(xlen))
3311 }
3312 changed = true
3313 } else if containerLenS != len(v) {
3314 v = v[:containerLenS]
3315 changed = true
3316 }
3317 }
3318 var j int
3319 for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
3320 if j == 0 && len(v) == 0 {
3321 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
3322 v = make([]float32, uint(xlen))
3323 changed = true
3324 }
3325 if j >= len(v) {
3326 v = append(v, 0)
3327 changed = true
3328 }
3329 slh.ElemContainerState(j)
3330 v[uint(j)] = float32(d.decodeFloat32())
3331 }
3332 if j < len(v) {
3333 v = v[:uint(j)]
3334 changed = true
3335 } else if j == 0 && v == nil {
3336 v = []float32{}
3337 changed = true
3338 }
3339 slh.End()
3340 return v, changed
3341 }
3342 func (fastpathT) DecSliceFloat32N(v []float32, d *Decoder) {
3343 slh, containerLenS := d.decSliceHelperStart()
3344 if slh.IsNil {
3345 return
3346 }
3347 if containerLenS == 0 {
3348 slh.End()
3349 return
3350 }
3351 hasLen := containerLenS > 0
3352 for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
3353 if j >= len(v) {
3354 slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
3355 return
3356 }
3357 slh.ElemContainerState(j)
3358 v[uint(j)] = float32(d.decodeFloat32())
3359 }
3360 slh.End()
3361 }
3362
3363 func (d *Decoder) fastpathDecSliceFloat64R(f *codecFnInfo, rv reflect.Value) {
3364 var v []float64
3365 switch rv.Kind() {
3366 case reflect.Ptr:
3367 vp := rv2i(rv).(*[]float64)
3368 var changed bool
3369 if v, changed = fastpathTV.DecSliceFloat64Y(*vp, d); changed {
3370 *vp = v
3371 }
3372 case reflect.Array:
3373 rvGetSlice4Array(rv, &v)
3374 fastpathTV.DecSliceFloat64N(v, d)
3375 default:
3376 fastpathTV.DecSliceFloat64N(rv2i(rv).([]float64), d)
3377 }
3378 }
3379 func (f fastpathT) DecSliceFloat64X(vp *[]float64, d *Decoder) {
3380 if v, changed := f.DecSliceFloat64Y(*vp, d); changed {
3381 *vp = v
3382 }
3383 }
3384 func (fastpathT) DecSliceFloat64Y(v []float64, d *Decoder) (v2 []float64, changed bool) {
3385 slh, containerLenS := d.decSliceHelperStart()
3386 if slh.IsNil {
3387 if v == nil {
3388 return
3389 }
3390 return nil, true
3391 }
3392 if containerLenS == 0 {
3393 if v == nil {
3394 v = []float64{}
3395 } else if len(v) != 0 {
3396 v = v[:0]
3397 }
3398 slh.End()
3399 return v, true
3400 }
3401 hasLen := containerLenS > 0
3402 var xlen int
3403 if hasLen {
3404 if containerLenS > cap(v) {
3405 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
3406 if xlen <= cap(v) {
3407 v = v[:uint(xlen)]
3408 } else {
3409 v = make([]float64, uint(xlen))
3410 }
3411 changed = true
3412 } else if containerLenS != len(v) {
3413 v = v[:containerLenS]
3414 changed = true
3415 }
3416 }
3417 var j int
3418 for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
3419 if j == 0 && len(v) == 0 {
3420 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
3421 v = make([]float64, uint(xlen))
3422 changed = true
3423 }
3424 if j >= len(v) {
3425 v = append(v, 0)
3426 changed = true
3427 }
3428 slh.ElemContainerState(j)
3429 v[uint(j)] = d.d.DecodeFloat64()
3430 }
3431 if j < len(v) {
3432 v = v[:uint(j)]
3433 changed = true
3434 } else if j == 0 && v == nil {
3435 v = []float64{}
3436 changed = true
3437 }
3438 slh.End()
3439 return v, changed
3440 }
3441 func (fastpathT) DecSliceFloat64N(v []float64, d *Decoder) {
3442 slh, containerLenS := d.decSliceHelperStart()
3443 if slh.IsNil {
3444 return
3445 }
3446 if containerLenS == 0 {
3447 slh.End()
3448 return
3449 }
3450 hasLen := containerLenS > 0
3451 for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
3452 if j >= len(v) {
3453 slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
3454 return
3455 }
3456 slh.ElemContainerState(j)
3457 v[uint(j)] = d.d.DecodeFloat64()
3458 }
3459 slh.End()
3460 }
3461
3462 func (d *Decoder) fastpathDecSliceUint8R(f *codecFnInfo, rv reflect.Value) {
3463 var v []uint8
3464 switch rv.Kind() {
3465 case reflect.Ptr:
3466 vp := rv2i(rv).(*[]uint8)
3467 var changed bool
3468 if v, changed = fastpathTV.DecSliceUint8Y(*vp, d); changed {
3469 *vp = v
3470 }
3471 case reflect.Array:
3472 rvGetSlice4Array(rv, &v)
3473 fastpathTV.DecSliceUint8N(v, d)
3474 default:
3475 fastpathTV.DecSliceUint8N(rv2i(rv).([]uint8), d)
3476 }
3477 }
3478 func (f fastpathT) DecSliceUint8X(vp *[]uint8, d *Decoder) {
3479 if v, changed := f.DecSliceUint8Y(*vp, d); changed {
3480 *vp = v
3481 }
3482 }
3483 func (fastpathT) DecSliceUint8Y(v []uint8, d *Decoder) (v2 []uint8, changed bool) {
3484 switch d.d.ContainerType() {
3485 case valueTypeNil, valueTypeMap:
3486 break
3487 default:
3488 v2 = d.decodeBytesInto(v[:len(v):len(v)])
3489 changed = !(len(v2) > 0 && len(v2) == len(v) && &v2[0] == &v[0])
3490 return
3491 }
3492 slh, containerLenS := d.decSliceHelperStart()
3493 if slh.IsNil {
3494 if v == nil {
3495 return
3496 }
3497 return nil, true
3498 }
3499 if containerLenS == 0 {
3500 if v == nil {
3501 v = []uint8{}
3502 } else if len(v) != 0 {
3503 v = v[:0]
3504 }
3505 slh.End()
3506 return v, true
3507 }
3508 hasLen := containerLenS > 0
3509 var xlen int
3510 if hasLen {
3511 if containerLenS > cap(v) {
3512 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
3513 if xlen <= cap(v) {
3514 v = v[:uint(xlen)]
3515 } else {
3516 v = make([]uint8, uint(xlen))
3517 }
3518 changed = true
3519 } else if containerLenS != len(v) {
3520 v = v[:containerLenS]
3521 changed = true
3522 }
3523 }
3524 var j int
3525 for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
3526 if j == 0 && len(v) == 0 {
3527 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
3528 v = make([]uint8, uint(xlen))
3529 changed = true
3530 }
3531 if j >= len(v) {
3532 v = append(v, 0)
3533 changed = true
3534 }
3535 slh.ElemContainerState(j)
3536 v[uint(j)] = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
3537 }
3538 if j < len(v) {
3539 v = v[:uint(j)]
3540 changed = true
3541 } else if j == 0 && v == nil {
3542 v = []uint8{}
3543 changed = true
3544 }
3545 slh.End()
3546 return v, changed
3547 }
3548 func (fastpathT) DecSliceUint8N(v []uint8, d *Decoder) {
3549 switch d.d.ContainerType() {
3550 case valueTypeNil, valueTypeMap:
3551 break
3552 default:
3553 v2 := d.decodeBytesInto(v[:len(v):len(v)])
3554 if !(len(v2) > 0 && len(v2) == len(v) && &v2[0] == &v[0]) {
3555 copy(v, v2)
3556 }
3557 return
3558 }
3559 slh, containerLenS := d.decSliceHelperStart()
3560 if slh.IsNil {
3561 return
3562 }
3563 if containerLenS == 0 {
3564 slh.End()
3565 return
3566 }
3567 hasLen := containerLenS > 0
3568 for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
3569 if j >= len(v) {
3570 slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
3571 return
3572 }
3573 slh.ElemContainerState(j)
3574 v[uint(j)] = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
3575 }
3576 slh.End()
3577 }
3578
3579 func (d *Decoder) fastpathDecSliceUint64R(f *codecFnInfo, rv reflect.Value) {
3580 var v []uint64
3581 switch rv.Kind() {
3582 case reflect.Ptr:
3583 vp := rv2i(rv).(*[]uint64)
3584 var changed bool
3585 if v, changed = fastpathTV.DecSliceUint64Y(*vp, d); changed {
3586 *vp = v
3587 }
3588 case reflect.Array:
3589 rvGetSlice4Array(rv, &v)
3590 fastpathTV.DecSliceUint64N(v, d)
3591 default:
3592 fastpathTV.DecSliceUint64N(rv2i(rv).([]uint64), d)
3593 }
3594 }
3595 func (f fastpathT) DecSliceUint64X(vp *[]uint64, d *Decoder) {
3596 if v, changed := f.DecSliceUint64Y(*vp, d); changed {
3597 *vp = v
3598 }
3599 }
3600 func (fastpathT) DecSliceUint64Y(v []uint64, d *Decoder) (v2 []uint64, changed bool) {
3601 slh, containerLenS := d.decSliceHelperStart()
3602 if slh.IsNil {
3603 if v == nil {
3604 return
3605 }
3606 return nil, true
3607 }
3608 if containerLenS == 0 {
3609 if v == nil {
3610 v = []uint64{}
3611 } else if len(v) != 0 {
3612 v = v[:0]
3613 }
3614 slh.End()
3615 return v, true
3616 }
3617 hasLen := containerLenS > 0
3618 var xlen int
3619 if hasLen {
3620 if containerLenS > cap(v) {
3621 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
3622 if xlen <= cap(v) {
3623 v = v[:uint(xlen)]
3624 } else {
3625 v = make([]uint64, uint(xlen))
3626 }
3627 changed = true
3628 } else if containerLenS != len(v) {
3629 v = v[:containerLenS]
3630 changed = true
3631 }
3632 }
3633 var j int
3634 for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
3635 if j == 0 && len(v) == 0 {
3636 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
3637 v = make([]uint64, uint(xlen))
3638 changed = true
3639 }
3640 if j >= len(v) {
3641 v = append(v, 0)
3642 changed = true
3643 }
3644 slh.ElemContainerState(j)
3645 v[uint(j)] = d.d.DecodeUint64()
3646 }
3647 if j < len(v) {
3648 v = v[:uint(j)]
3649 changed = true
3650 } else if j == 0 && v == nil {
3651 v = []uint64{}
3652 changed = true
3653 }
3654 slh.End()
3655 return v, changed
3656 }
3657 func (fastpathT) DecSliceUint64N(v []uint64, d *Decoder) {
3658 slh, containerLenS := d.decSliceHelperStart()
3659 if slh.IsNil {
3660 return
3661 }
3662 if containerLenS == 0 {
3663 slh.End()
3664 return
3665 }
3666 hasLen := containerLenS > 0
3667 for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
3668 if j >= len(v) {
3669 slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
3670 return
3671 }
3672 slh.ElemContainerState(j)
3673 v[uint(j)] = d.d.DecodeUint64()
3674 }
3675 slh.End()
3676 }
3677
3678 func (d *Decoder) fastpathDecSliceIntR(f *codecFnInfo, rv reflect.Value) {
3679 var v []int
3680 switch rv.Kind() {
3681 case reflect.Ptr:
3682 vp := rv2i(rv).(*[]int)
3683 var changed bool
3684 if v, changed = fastpathTV.DecSliceIntY(*vp, d); changed {
3685 *vp = v
3686 }
3687 case reflect.Array:
3688 rvGetSlice4Array(rv, &v)
3689 fastpathTV.DecSliceIntN(v, d)
3690 default:
3691 fastpathTV.DecSliceIntN(rv2i(rv).([]int), d)
3692 }
3693 }
3694 func (f fastpathT) DecSliceIntX(vp *[]int, d *Decoder) {
3695 if v, changed := f.DecSliceIntY(*vp, d); changed {
3696 *vp = v
3697 }
3698 }
3699 func (fastpathT) DecSliceIntY(v []int, d *Decoder) (v2 []int, changed bool) {
3700 slh, containerLenS := d.decSliceHelperStart()
3701 if slh.IsNil {
3702 if v == nil {
3703 return
3704 }
3705 return nil, true
3706 }
3707 if containerLenS == 0 {
3708 if v == nil {
3709 v = []int{}
3710 } else if len(v) != 0 {
3711 v = v[:0]
3712 }
3713 slh.End()
3714 return v, true
3715 }
3716 hasLen := containerLenS > 0
3717 var xlen int
3718 if hasLen {
3719 if containerLenS > cap(v) {
3720 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
3721 if xlen <= cap(v) {
3722 v = v[:uint(xlen)]
3723 } else {
3724 v = make([]int, uint(xlen))
3725 }
3726 changed = true
3727 } else if containerLenS != len(v) {
3728 v = v[:containerLenS]
3729 changed = true
3730 }
3731 }
3732 var j int
3733 for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
3734 if j == 0 && len(v) == 0 {
3735 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
3736 v = make([]int, uint(xlen))
3737 changed = true
3738 }
3739 if j >= len(v) {
3740 v = append(v, 0)
3741 changed = true
3742 }
3743 slh.ElemContainerState(j)
3744 v[uint(j)] = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
3745 }
3746 if j < len(v) {
3747 v = v[:uint(j)]
3748 changed = true
3749 } else if j == 0 && v == nil {
3750 v = []int{}
3751 changed = true
3752 }
3753 slh.End()
3754 return v, changed
3755 }
3756 func (fastpathT) DecSliceIntN(v []int, d *Decoder) {
3757 slh, containerLenS := d.decSliceHelperStart()
3758 if slh.IsNil {
3759 return
3760 }
3761 if containerLenS == 0 {
3762 slh.End()
3763 return
3764 }
3765 hasLen := containerLenS > 0
3766 for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
3767 if j >= len(v) {
3768 slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
3769 return
3770 }
3771 slh.ElemContainerState(j)
3772 v[uint(j)] = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
3773 }
3774 slh.End()
3775 }
3776
3777 func (d *Decoder) fastpathDecSliceInt32R(f *codecFnInfo, rv reflect.Value) {
3778 var v []int32
3779 switch rv.Kind() {
3780 case reflect.Ptr:
3781 vp := rv2i(rv).(*[]int32)
3782 var changed bool
3783 if v, changed = fastpathTV.DecSliceInt32Y(*vp, d); changed {
3784 *vp = v
3785 }
3786 case reflect.Array:
3787 rvGetSlice4Array(rv, &v)
3788 fastpathTV.DecSliceInt32N(v, d)
3789 default:
3790 fastpathTV.DecSliceInt32N(rv2i(rv).([]int32), d)
3791 }
3792 }
3793 func (f fastpathT) DecSliceInt32X(vp *[]int32, d *Decoder) {
3794 if v, changed := f.DecSliceInt32Y(*vp, d); changed {
3795 *vp = v
3796 }
3797 }
3798 func (fastpathT) DecSliceInt32Y(v []int32, d *Decoder) (v2 []int32, changed bool) {
3799 slh, containerLenS := d.decSliceHelperStart()
3800 if slh.IsNil {
3801 if v == nil {
3802 return
3803 }
3804 return nil, true
3805 }
3806 if containerLenS == 0 {
3807 if v == nil {
3808 v = []int32{}
3809 } else if len(v) != 0 {
3810 v = v[:0]
3811 }
3812 slh.End()
3813 return v, true
3814 }
3815 hasLen := containerLenS > 0
3816 var xlen int
3817 if hasLen {
3818 if containerLenS > cap(v) {
3819 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
3820 if xlen <= cap(v) {
3821 v = v[:uint(xlen)]
3822 } else {
3823 v = make([]int32, uint(xlen))
3824 }
3825 changed = true
3826 } else if containerLenS != len(v) {
3827 v = v[:containerLenS]
3828 changed = true
3829 }
3830 }
3831 var j int
3832 for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
3833 if j == 0 && len(v) == 0 {
3834 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
3835 v = make([]int32, uint(xlen))
3836 changed = true
3837 }
3838 if j >= len(v) {
3839 v = append(v, 0)
3840 changed = true
3841 }
3842 slh.ElemContainerState(j)
3843 v[uint(j)] = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
3844 }
3845 if j < len(v) {
3846 v = v[:uint(j)]
3847 changed = true
3848 } else if j == 0 && v == nil {
3849 v = []int32{}
3850 changed = true
3851 }
3852 slh.End()
3853 return v, changed
3854 }
3855 func (fastpathT) DecSliceInt32N(v []int32, d *Decoder) {
3856 slh, containerLenS := d.decSliceHelperStart()
3857 if slh.IsNil {
3858 return
3859 }
3860 if containerLenS == 0 {
3861 slh.End()
3862 return
3863 }
3864 hasLen := containerLenS > 0
3865 for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
3866 if j >= len(v) {
3867 slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
3868 return
3869 }
3870 slh.ElemContainerState(j)
3871 v[uint(j)] = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
3872 }
3873 slh.End()
3874 }
3875
3876 func (d *Decoder) fastpathDecSliceInt64R(f *codecFnInfo, rv reflect.Value) {
3877 var v []int64
3878 switch rv.Kind() {
3879 case reflect.Ptr:
3880 vp := rv2i(rv).(*[]int64)
3881 var changed bool
3882 if v, changed = fastpathTV.DecSliceInt64Y(*vp, d); changed {
3883 *vp = v
3884 }
3885 case reflect.Array:
3886 rvGetSlice4Array(rv, &v)
3887 fastpathTV.DecSliceInt64N(v, d)
3888 default:
3889 fastpathTV.DecSliceInt64N(rv2i(rv).([]int64), d)
3890 }
3891 }
3892 func (f fastpathT) DecSliceInt64X(vp *[]int64, d *Decoder) {
3893 if v, changed := f.DecSliceInt64Y(*vp, d); changed {
3894 *vp = v
3895 }
3896 }
3897 func (fastpathT) DecSliceInt64Y(v []int64, d *Decoder) (v2 []int64, changed bool) {
3898 slh, containerLenS := d.decSliceHelperStart()
3899 if slh.IsNil {
3900 if v == nil {
3901 return
3902 }
3903 return nil, true
3904 }
3905 if containerLenS == 0 {
3906 if v == nil {
3907 v = []int64{}
3908 } else if len(v) != 0 {
3909 v = v[:0]
3910 }
3911 slh.End()
3912 return v, true
3913 }
3914 hasLen := containerLenS > 0
3915 var xlen int
3916 if hasLen {
3917 if containerLenS > cap(v) {
3918 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
3919 if xlen <= cap(v) {
3920 v = v[:uint(xlen)]
3921 } else {
3922 v = make([]int64, uint(xlen))
3923 }
3924 changed = true
3925 } else if containerLenS != len(v) {
3926 v = v[:containerLenS]
3927 changed = true
3928 }
3929 }
3930 var j int
3931 for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
3932 if j == 0 && len(v) == 0 {
3933 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
3934 v = make([]int64, uint(xlen))
3935 changed = true
3936 }
3937 if j >= len(v) {
3938 v = append(v, 0)
3939 changed = true
3940 }
3941 slh.ElemContainerState(j)
3942 v[uint(j)] = d.d.DecodeInt64()
3943 }
3944 if j < len(v) {
3945 v = v[:uint(j)]
3946 changed = true
3947 } else if j == 0 && v == nil {
3948 v = []int64{}
3949 changed = true
3950 }
3951 slh.End()
3952 return v, changed
3953 }
3954 func (fastpathT) DecSliceInt64N(v []int64, d *Decoder) {
3955 slh, containerLenS := d.decSliceHelperStart()
3956 if slh.IsNil {
3957 return
3958 }
3959 if containerLenS == 0 {
3960 slh.End()
3961 return
3962 }
3963 hasLen := containerLenS > 0
3964 for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
3965 if j >= len(v) {
3966 slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
3967 return
3968 }
3969 slh.ElemContainerState(j)
3970 v[uint(j)] = d.d.DecodeInt64()
3971 }
3972 slh.End()
3973 }
3974
3975 func (d *Decoder) fastpathDecSliceBoolR(f *codecFnInfo, rv reflect.Value) {
3976 var v []bool
3977 switch rv.Kind() {
3978 case reflect.Ptr:
3979 vp := rv2i(rv).(*[]bool)
3980 var changed bool
3981 if v, changed = fastpathTV.DecSliceBoolY(*vp, d); changed {
3982 *vp = v
3983 }
3984 case reflect.Array:
3985 rvGetSlice4Array(rv, &v)
3986 fastpathTV.DecSliceBoolN(v, d)
3987 default:
3988 fastpathTV.DecSliceBoolN(rv2i(rv).([]bool), d)
3989 }
3990 }
3991 func (f fastpathT) DecSliceBoolX(vp *[]bool, d *Decoder) {
3992 if v, changed := f.DecSliceBoolY(*vp, d); changed {
3993 *vp = v
3994 }
3995 }
3996 func (fastpathT) DecSliceBoolY(v []bool, d *Decoder) (v2 []bool, changed bool) {
3997 slh, containerLenS := d.decSliceHelperStart()
3998 if slh.IsNil {
3999 if v == nil {
4000 return
4001 }
4002 return nil, true
4003 }
4004 if containerLenS == 0 {
4005 if v == nil {
4006 v = []bool{}
4007 } else if len(v) != 0 {
4008 v = v[:0]
4009 }
4010 slh.End()
4011 return v, true
4012 }
4013 hasLen := containerLenS > 0
4014 var xlen int
4015 if hasLen {
4016 if containerLenS > cap(v) {
4017 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
4018 if xlen <= cap(v) {
4019 v = v[:uint(xlen)]
4020 } else {
4021 v = make([]bool, uint(xlen))
4022 }
4023 changed = true
4024 } else if containerLenS != len(v) {
4025 v = v[:containerLenS]
4026 changed = true
4027 }
4028 }
4029 var j int
4030 for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
4031 if j == 0 && len(v) == 0 {
4032 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
4033 v = make([]bool, uint(xlen))
4034 changed = true
4035 }
4036 if j >= len(v) {
4037 v = append(v, false)
4038 changed = true
4039 }
4040 slh.ElemContainerState(j)
4041 v[uint(j)] = d.d.DecodeBool()
4042 }
4043 if j < len(v) {
4044 v = v[:uint(j)]
4045 changed = true
4046 } else if j == 0 && v == nil {
4047 v = []bool{}
4048 changed = true
4049 }
4050 slh.End()
4051 return v, changed
4052 }
4053 func (fastpathT) DecSliceBoolN(v []bool, d *Decoder) {
4054 slh, containerLenS := d.decSliceHelperStart()
4055 if slh.IsNil {
4056 return
4057 }
4058 if containerLenS == 0 {
4059 slh.End()
4060 return
4061 }
4062 hasLen := containerLenS > 0
4063 for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
4064 if j >= len(v) {
4065 slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
4066 return
4067 }
4068 slh.ElemContainerState(j)
4069 v[uint(j)] = d.d.DecodeBool()
4070 }
4071 slh.End()
4072 }
4073 func (d *Decoder) fastpathDecMapStringIntfR(f *codecFnInfo, rv reflect.Value) {
4074 containerLen := d.mapStart(d.d.ReadMapStart())
4075 if rv.Kind() == reflect.Ptr {
4076 vp, _ := rv2i(rv).(*map[string]interface{})
4077 if *vp == nil {
4078 *vp = make(map[string]interface{}, decInferLen(containerLen, d.h.MaxInitLen, 32))
4079 }
4080 if containerLen != 0 {
4081 fastpathTV.DecMapStringIntfL(*vp, containerLen, d)
4082 }
4083 } else if containerLen != 0 {
4084 fastpathTV.DecMapStringIntfL(rv2i(rv).(map[string]interface{}), containerLen, d)
4085 }
4086 d.mapEnd()
4087 }
4088 func (f fastpathT) DecMapStringIntfX(vp *map[string]interface{}, d *Decoder) {
4089 containerLen := d.mapStart(d.d.ReadMapStart())
4090 if containerLen == containerLenNil {
4091 *vp = nil
4092 } else {
4093 if *vp == nil {
4094 *vp = make(map[string]interface{}, decInferLen(containerLen, d.h.MaxInitLen, 32))
4095 }
4096 if containerLen != 0 {
4097 f.DecMapStringIntfL(*vp, containerLen, d)
4098 }
4099 d.mapEnd()
4100 }
4101 }
4102 func (fastpathT) DecMapStringIntfL(v map[string]interface{}, containerLen int, d *Decoder) {
4103 if v == nil {
4104 d.errorf("cannot decode into nil map[string]interface{} given stream length: %v", containerLen)
4105 return
4106 }
4107 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
4108 var mk string
4109 var mv interface{}
4110 hasLen := containerLen > 0
4111 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
4112 d.mapElemKey()
4113 mk = d.stringZC(d.d.DecodeStringAsBytes())
4114 d.mapElemValue()
4115 if mapGet {
4116 mv = v[mk]
4117 } else {
4118 mv = nil
4119 }
4120 d.decode(&mv)
4121 v[mk] = mv
4122 }
4123 }
4124 func (d *Decoder) fastpathDecMapStringStringR(f *codecFnInfo, rv reflect.Value) {
4125 containerLen := d.mapStart(d.d.ReadMapStart())
4126 if rv.Kind() == reflect.Ptr {
4127 vp, _ := rv2i(rv).(*map[string]string)
4128 if *vp == nil {
4129 *vp = make(map[string]string, decInferLen(containerLen, d.h.MaxInitLen, 32))
4130 }
4131 if containerLen != 0 {
4132 fastpathTV.DecMapStringStringL(*vp, containerLen, d)
4133 }
4134 } else if containerLen != 0 {
4135 fastpathTV.DecMapStringStringL(rv2i(rv).(map[string]string), containerLen, d)
4136 }
4137 d.mapEnd()
4138 }
4139 func (f fastpathT) DecMapStringStringX(vp *map[string]string, d *Decoder) {
4140 containerLen := d.mapStart(d.d.ReadMapStart())
4141 if containerLen == containerLenNil {
4142 *vp = nil
4143 } else {
4144 if *vp == nil {
4145 *vp = make(map[string]string, decInferLen(containerLen, d.h.MaxInitLen, 32))
4146 }
4147 if containerLen != 0 {
4148 f.DecMapStringStringL(*vp, containerLen, d)
4149 }
4150 d.mapEnd()
4151 }
4152 }
4153 func (fastpathT) DecMapStringStringL(v map[string]string, containerLen int, d *Decoder) {
4154 if v == nil {
4155 d.errorf("cannot decode into nil map[string]string given stream length: %v", containerLen)
4156 return
4157 }
4158 var mk string
4159 var mv string
4160 hasLen := containerLen > 0
4161 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
4162 d.mapElemKey()
4163 mk = d.stringZC(d.d.DecodeStringAsBytes())
4164 d.mapElemValue()
4165 mv = d.stringZC(d.d.DecodeStringAsBytes())
4166 v[mk] = mv
4167 }
4168 }
4169 func (d *Decoder) fastpathDecMapStringBytesR(f *codecFnInfo, rv reflect.Value) {
4170 containerLen := d.mapStart(d.d.ReadMapStart())
4171 if rv.Kind() == reflect.Ptr {
4172 vp, _ := rv2i(rv).(*map[string][]byte)
4173 if *vp == nil {
4174 *vp = make(map[string][]byte, decInferLen(containerLen, d.h.MaxInitLen, 40))
4175 }
4176 if containerLen != 0 {
4177 fastpathTV.DecMapStringBytesL(*vp, containerLen, d)
4178 }
4179 } else if containerLen != 0 {
4180 fastpathTV.DecMapStringBytesL(rv2i(rv).(map[string][]byte), containerLen, d)
4181 }
4182 d.mapEnd()
4183 }
4184 func (f fastpathT) DecMapStringBytesX(vp *map[string][]byte, d *Decoder) {
4185 containerLen := d.mapStart(d.d.ReadMapStart())
4186 if containerLen == containerLenNil {
4187 *vp = nil
4188 } else {
4189 if *vp == nil {
4190 *vp = make(map[string][]byte, decInferLen(containerLen, d.h.MaxInitLen, 40))
4191 }
4192 if containerLen != 0 {
4193 f.DecMapStringBytesL(*vp, containerLen, d)
4194 }
4195 d.mapEnd()
4196 }
4197 }
4198 func (fastpathT) DecMapStringBytesL(v map[string][]byte, containerLen int, d *Decoder) {
4199 if v == nil {
4200 d.errorf("cannot decode into nil map[string][]byte given stream length: %v", containerLen)
4201 return
4202 }
4203 mapGet := v != nil && !d.h.MapValueReset
4204 var mk string
4205 var mv []byte
4206 hasLen := containerLen > 0
4207 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
4208 d.mapElemKey()
4209 mk = d.stringZC(d.d.DecodeStringAsBytes())
4210 d.mapElemValue()
4211 if mapGet {
4212 mv = v[mk]
4213 } else {
4214 mv = nil
4215 }
4216 mv = d.decodeBytesInto(mv)
4217 v[mk] = mv
4218 }
4219 }
4220 func (d *Decoder) fastpathDecMapStringUint8R(f *codecFnInfo, rv reflect.Value) {
4221 containerLen := d.mapStart(d.d.ReadMapStart())
4222 if rv.Kind() == reflect.Ptr {
4223 vp, _ := rv2i(rv).(*map[string]uint8)
4224 if *vp == nil {
4225 *vp = make(map[string]uint8, decInferLen(containerLen, d.h.MaxInitLen, 17))
4226 }
4227 if containerLen != 0 {
4228 fastpathTV.DecMapStringUint8L(*vp, containerLen, d)
4229 }
4230 } else if containerLen != 0 {
4231 fastpathTV.DecMapStringUint8L(rv2i(rv).(map[string]uint8), containerLen, d)
4232 }
4233 d.mapEnd()
4234 }
4235 func (f fastpathT) DecMapStringUint8X(vp *map[string]uint8, d *Decoder) {
4236 containerLen := d.mapStart(d.d.ReadMapStart())
4237 if containerLen == containerLenNil {
4238 *vp = nil
4239 } else {
4240 if *vp == nil {
4241 *vp = make(map[string]uint8, decInferLen(containerLen, d.h.MaxInitLen, 17))
4242 }
4243 if containerLen != 0 {
4244 f.DecMapStringUint8L(*vp, containerLen, d)
4245 }
4246 d.mapEnd()
4247 }
4248 }
4249 func (fastpathT) DecMapStringUint8L(v map[string]uint8, containerLen int, d *Decoder) {
4250 if v == nil {
4251 d.errorf("cannot decode into nil map[string]uint8 given stream length: %v", containerLen)
4252 return
4253 }
4254 var mk string
4255 var mv uint8
4256 hasLen := containerLen > 0
4257 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
4258 d.mapElemKey()
4259 mk = d.stringZC(d.d.DecodeStringAsBytes())
4260 d.mapElemValue()
4261 mv = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
4262 v[mk] = mv
4263 }
4264 }
4265 func (d *Decoder) fastpathDecMapStringUint64R(f *codecFnInfo, rv reflect.Value) {
4266 containerLen := d.mapStart(d.d.ReadMapStart())
4267 if rv.Kind() == reflect.Ptr {
4268 vp, _ := rv2i(rv).(*map[string]uint64)
4269 if *vp == nil {
4270 *vp = make(map[string]uint64, decInferLen(containerLen, d.h.MaxInitLen, 24))
4271 }
4272 if containerLen != 0 {
4273 fastpathTV.DecMapStringUint64L(*vp, containerLen, d)
4274 }
4275 } else if containerLen != 0 {
4276 fastpathTV.DecMapStringUint64L(rv2i(rv).(map[string]uint64), containerLen, d)
4277 }
4278 d.mapEnd()
4279 }
4280 func (f fastpathT) DecMapStringUint64X(vp *map[string]uint64, d *Decoder) {
4281 containerLen := d.mapStart(d.d.ReadMapStart())
4282 if containerLen == containerLenNil {
4283 *vp = nil
4284 } else {
4285 if *vp == nil {
4286 *vp = make(map[string]uint64, decInferLen(containerLen, d.h.MaxInitLen, 24))
4287 }
4288 if containerLen != 0 {
4289 f.DecMapStringUint64L(*vp, containerLen, d)
4290 }
4291 d.mapEnd()
4292 }
4293 }
4294 func (fastpathT) DecMapStringUint64L(v map[string]uint64, containerLen int, d *Decoder) {
4295 if v == nil {
4296 d.errorf("cannot decode into nil map[string]uint64 given stream length: %v", containerLen)
4297 return
4298 }
4299 var mk string
4300 var mv uint64
4301 hasLen := containerLen > 0
4302 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
4303 d.mapElemKey()
4304 mk = d.stringZC(d.d.DecodeStringAsBytes())
4305 d.mapElemValue()
4306 mv = d.d.DecodeUint64()
4307 v[mk] = mv
4308 }
4309 }
4310 func (d *Decoder) fastpathDecMapStringIntR(f *codecFnInfo, rv reflect.Value) {
4311 containerLen := d.mapStart(d.d.ReadMapStart())
4312 if rv.Kind() == reflect.Ptr {
4313 vp, _ := rv2i(rv).(*map[string]int)
4314 if *vp == nil {
4315 *vp = make(map[string]int, decInferLen(containerLen, d.h.MaxInitLen, 24))
4316 }
4317 if containerLen != 0 {
4318 fastpathTV.DecMapStringIntL(*vp, containerLen, d)
4319 }
4320 } else if containerLen != 0 {
4321 fastpathTV.DecMapStringIntL(rv2i(rv).(map[string]int), containerLen, d)
4322 }
4323 d.mapEnd()
4324 }
4325 func (f fastpathT) DecMapStringIntX(vp *map[string]int, d *Decoder) {
4326 containerLen := d.mapStart(d.d.ReadMapStart())
4327 if containerLen == containerLenNil {
4328 *vp = nil
4329 } else {
4330 if *vp == nil {
4331 *vp = make(map[string]int, decInferLen(containerLen, d.h.MaxInitLen, 24))
4332 }
4333 if containerLen != 0 {
4334 f.DecMapStringIntL(*vp, containerLen, d)
4335 }
4336 d.mapEnd()
4337 }
4338 }
4339 func (fastpathT) DecMapStringIntL(v map[string]int, containerLen int, d *Decoder) {
4340 if v == nil {
4341 d.errorf("cannot decode into nil map[string]int given stream length: %v", containerLen)
4342 return
4343 }
4344 var mk string
4345 var mv int
4346 hasLen := containerLen > 0
4347 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
4348 d.mapElemKey()
4349 mk = d.stringZC(d.d.DecodeStringAsBytes())
4350 d.mapElemValue()
4351 mv = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
4352 v[mk] = mv
4353 }
4354 }
4355 func (d *Decoder) fastpathDecMapStringInt32R(f *codecFnInfo, rv reflect.Value) {
4356 containerLen := d.mapStart(d.d.ReadMapStart())
4357 if rv.Kind() == reflect.Ptr {
4358 vp, _ := rv2i(rv).(*map[string]int32)
4359 if *vp == nil {
4360 *vp = make(map[string]int32, decInferLen(containerLen, d.h.MaxInitLen, 20))
4361 }
4362 if containerLen != 0 {
4363 fastpathTV.DecMapStringInt32L(*vp, containerLen, d)
4364 }
4365 } else if containerLen != 0 {
4366 fastpathTV.DecMapStringInt32L(rv2i(rv).(map[string]int32), containerLen, d)
4367 }
4368 d.mapEnd()
4369 }
4370 func (f fastpathT) DecMapStringInt32X(vp *map[string]int32, d *Decoder) {
4371 containerLen := d.mapStart(d.d.ReadMapStart())
4372 if containerLen == containerLenNil {
4373 *vp = nil
4374 } else {
4375 if *vp == nil {
4376 *vp = make(map[string]int32, decInferLen(containerLen, d.h.MaxInitLen, 20))
4377 }
4378 if containerLen != 0 {
4379 f.DecMapStringInt32L(*vp, containerLen, d)
4380 }
4381 d.mapEnd()
4382 }
4383 }
4384 func (fastpathT) DecMapStringInt32L(v map[string]int32, containerLen int, d *Decoder) {
4385 if v == nil {
4386 d.errorf("cannot decode into nil map[string]int32 given stream length: %v", containerLen)
4387 return
4388 }
4389 var mk string
4390 var mv int32
4391 hasLen := containerLen > 0
4392 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
4393 d.mapElemKey()
4394 mk = d.stringZC(d.d.DecodeStringAsBytes())
4395 d.mapElemValue()
4396 mv = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
4397 v[mk] = mv
4398 }
4399 }
4400 func (d *Decoder) fastpathDecMapStringFloat64R(f *codecFnInfo, rv reflect.Value) {
4401 containerLen := d.mapStart(d.d.ReadMapStart())
4402 if rv.Kind() == reflect.Ptr {
4403 vp, _ := rv2i(rv).(*map[string]float64)
4404 if *vp == nil {
4405 *vp = make(map[string]float64, decInferLen(containerLen, d.h.MaxInitLen, 24))
4406 }
4407 if containerLen != 0 {
4408 fastpathTV.DecMapStringFloat64L(*vp, containerLen, d)
4409 }
4410 } else if containerLen != 0 {
4411 fastpathTV.DecMapStringFloat64L(rv2i(rv).(map[string]float64), containerLen, d)
4412 }
4413 d.mapEnd()
4414 }
4415 func (f fastpathT) DecMapStringFloat64X(vp *map[string]float64, d *Decoder) {
4416 containerLen := d.mapStart(d.d.ReadMapStart())
4417 if containerLen == containerLenNil {
4418 *vp = nil
4419 } else {
4420 if *vp == nil {
4421 *vp = make(map[string]float64, decInferLen(containerLen, d.h.MaxInitLen, 24))
4422 }
4423 if containerLen != 0 {
4424 f.DecMapStringFloat64L(*vp, containerLen, d)
4425 }
4426 d.mapEnd()
4427 }
4428 }
4429 func (fastpathT) DecMapStringFloat64L(v map[string]float64, containerLen int, d *Decoder) {
4430 if v == nil {
4431 d.errorf("cannot decode into nil map[string]float64 given stream length: %v", containerLen)
4432 return
4433 }
4434 var mk string
4435 var mv float64
4436 hasLen := containerLen > 0
4437 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
4438 d.mapElemKey()
4439 mk = d.stringZC(d.d.DecodeStringAsBytes())
4440 d.mapElemValue()
4441 mv = d.d.DecodeFloat64()
4442 v[mk] = mv
4443 }
4444 }
4445 func (d *Decoder) fastpathDecMapStringBoolR(f *codecFnInfo, rv reflect.Value) {
4446 containerLen := d.mapStart(d.d.ReadMapStart())
4447 if rv.Kind() == reflect.Ptr {
4448 vp, _ := rv2i(rv).(*map[string]bool)
4449 if *vp == nil {
4450 *vp = make(map[string]bool, decInferLen(containerLen, d.h.MaxInitLen, 17))
4451 }
4452 if containerLen != 0 {
4453 fastpathTV.DecMapStringBoolL(*vp, containerLen, d)
4454 }
4455 } else if containerLen != 0 {
4456 fastpathTV.DecMapStringBoolL(rv2i(rv).(map[string]bool), containerLen, d)
4457 }
4458 d.mapEnd()
4459 }
4460 func (f fastpathT) DecMapStringBoolX(vp *map[string]bool, d *Decoder) {
4461 containerLen := d.mapStart(d.d.ReadMapStart())
4462 if containerLen == containerLenNil {
4463 *vp = nil
4464 } else {
4465 if *vp == nil {
4466 *vp = make(map[string]bool, decInferLen(containerLen, d.h.MaxInitLen, 17))
4467 }
4468 if containerLen != 0 {
4469 f.DecMapStringBoolL(*vp, containerLen, d)
4470 }
4471 d.mapEnd()
4472 }
4473 }
4474 func (fastpathT) DecMapStringBoolL(v map[string]bool, containerLen int, d *Decoder) {
4475 if v == nil {
4476 d.errorf("cannot decode into nil map[string]bool given stream length: %v", containerLen)
4477 return
4478 }
4479 var mk string
4480 var mv bool
4481 hasLen := containerLen > 0
4482 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
4483 d.mapElemKey()
4484 mk = d.stringZC(d.d.DecodeStringAsBytes())
4485 d.mapElemValue()
4486 mv = d.d.DecodeBool()
4487 v[mk] = mv
4488 }
4489 }
4490 func (d *Decoder) fastpathDecMapUint8IntfR(f *codecFnInfo, rv reflect.Value) {
4491 containerLen := d.mapStart(d.d.ReadMapStart())
4492 if rv.Kind() == reflect.Ptr {
4493 vp, _ := rv2i(rv).(*map[uint8]interface{})
4494 if *vp == nil {
4495 *vp = make(map[uint8]interface{}, decInferLen(containerLen, d.h.MaxInitLen, 17))
4496 }
4497 if containerLen != 0 {
4498 fastpathTV.DecMapUint8IntfL(*vp, containerLen, d)
4499 }
4500 } else if containerLen != 0 {
4501 fastpathTV.DecMapUint8IntfL(rv2i(rv).(map[uint8]interface{}), containerLen, d)
4502 }
4503 d.mapEnd()
4504 }
4505 func (f fastpathT) DecMapUint8IntfX(vp *map[uint8]interface{}, d *Decoder) {
4506 containerLen := d.mapStart(d.d.ReadMapStart())
4507 if containerLen == containerLenNil {
4508 *vp = nil
4509 } else {
4510 if *vp == nil {
4511 *vp = make(map[uint8]interface{}, decInferLen(containerLen, d.h.MaxInitLen, 17))
4512 }
4513 if containerLen != 0 {
4514 f.DecMapUint8IntfL(*vp, containerLen, d)
4515 }
4516 d.mapEnd()
4517 }
4518 }
4519 func (fastpathT) DecMapUint8IntfL(v map[uint8]interface{}, containerLen int, d *Decoder) {
4520 if v == nil {
4521 d.errorf("cannot decode into nil map[uint8]interface{} given stream length: %v", containerLen)
4522 return
4523 }
4524 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
4525 var mk uint8
4526 var mv interface{}
4527 hasLen := containerLen > 0
4528 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
4529 d.mapElemKey()
4530 mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
4531 d.mapElemValue()
4532 if mapGet {
4533 mv = v[mk]
4534 } else {
4535 mv = nil
4536 }
4537 d.decode(&mv)
4538 v[mk] = mv
4539 }
4540 }
4541 func (d *Decoder) fastpathDecMapUint8StringR(f *codecFnInfo, rv reflect.Value) {
4542 containerLen := d.mapStart(d.d.ReadMapStart())
4543 if rv.Kind() == reflect.Ptr {
4544 vp, _ := rv2i(rv).(*map[uint8]string)
4545 if *vp == nil {
4546 *vp = make(map[uint8]string, decInferLen(containerLen, d.h.MaxInitLen, 17))
4547 }
4548 if containerLen != 0 {
4549 fastpathTV.DecMapUint8StringL(*vp, containerLen, d)
4550 }
4551 } else if containerLen != 0 {
4552 fastpathTV.DecMapUint8StringL(rv2i(rv).(map[uint8]string), containerLen, d)
4553 }
4554 d.mapEnd()
4555 }
4556 func (f fastpathT) DecMapUint8StringX(vp *map[uint8]string, d *Decoder) {
4557 containerLen := d.mapStart(d.d.ReadMapStart())
4558 if containerLen == containerLenNil {
4559 *vp = nil
4560 } else {
4561 if *vp == nil {
4562 *vp = make(map[uint8]string, decInferLen(containerLen, d.h.MaxInitLen, 17))
4563 }
4564 if containerLen != 0 {
4565 f.DecMapUint8StringL(*vp, containerLen, d)
4566 }
4567 d.mapEnd()
4568 }
4569 }
4570 func (fastpathT) DecMapUint8StringL(v map[uint8]string, containerLen int, d *Decoder) {
4571 if v == nil {
4572 d.errorf("cannot decode into nil map[uint8]string given stream length: %v", containerLen)
4573 return
4574 }
4575 var mk uint8
4576 var mv string
4577 hasLen := containerLen > 0
4578 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
4579 d.mapElemKey()
4580 mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
4581 d.mapElemValue()
4582 mv = d.stringZC(d.d.DecodeStringAsBytes())
4583 v[mk] = mv
4584 }
4585 }
4586 func (d *Decoder) fastpathDecMapUint8BytesR(f *codecFnInfo, rv reflect.Value) {
4587 containerLen := d.mapStart(d.d.ReadMapStart())
4588 if rv.Kind() == reflect.Ptr {
4589 vp, _ := rv2i(rv).(*map[uint8][]byte)
4590 if *vp == nil {
4591 *vp = make(map[uint8][]byte, decInferLen(containerLen, d.h.MaxInitLen, 25))
4592 }
4593 if containerLen != 0 {
4594 fastpathTV.DecMapUint8BytesL(*vp, containerLen, d)
4595 }
4596 } else if containerLen != 0 {
4597 fastpathTV.DecMapUint8BytesL(rv2i(rv).(map[uint8][]byte), containerLen, d)
4598 }
4599 d.mapEnd()
4600 }
4601 func (f fastpathT) DecMapUint8BytesX(vp *map[uint8][]byte, d *Decoder) {
4602 containerLen := d.mapStart(d.d.ReadMapStart())
4603 if containerLen == containerLenNil {
4604 *vp = nil
4605 } else {
4606 if *vp == nil {
4607 *vp = make(map[uint8][]byte, decInferLen(containerLen, d.h.MaxInitLen, 25))
4608 }
4609 if containerLen != 0 {
4610 f.DecMapUint8BytesL(*vp, containerLen, d)
4611 }
4612 d.mapEnd()
4613 }
4614 }
4615 func (fastpathT) DecMapUint8BytesL(v map[uint8][]byte, containerLen int, d *Decoder) {
4616 if v == nil {
4617 d.errorf("cannot decode into nil map[uint8][]byte given stream length: %v", containerLen)
4618 return
4619 }
4620 mapGet := v != nil && !d.h.MapValueReset
4621 var mk uint8
4622 var mv []byte
4623 hasLen := containerLen > 0
4624 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
4625 d.mapElemKey()
4626 mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
4627 d.mapElemValue()
4628 if mapGet {
4629 mv = v[mk]
4630 } else {
4631 mv = nil
4632 }
4633 mv = d.decodeBytesInto(mv)
4634 v[mk] = mv
4635 }
4636 }
4637 func (d *Decoder) fastpathDecMapUint8Uint8R(f *codecFnInfo, rv reflect.Value) {
4638 containerLen := d.mapStart(d.d.ReadMapStart())
4639 if rv.Kind() == reflect.Ptr {
4640 vp, _ := rv2i(rv).(*map[uint8]uint8)
4641 if *vp == nil {
4642 *vp = make(map[uint8]uint8, decInferLen(containerLen, d.h.MaxInitLen, 2))
4643 }
4644 if containerLen != 0 {
4645 fastpathTV.DecMapUint8Uint8L(*vp, containerLen, d)
4646 }
4647 } else if containerLen != 0 {
4648 fastpathTV.DecMapUint8Uint8L(rv2i(rv).(map[uint8]uint8), containerLen, d)
4649 }
4650 d.mapEnd()
4651 }
4652 func (f fastpathT) DecMapUint8Uint8X(vp *map[uint8]uint8, d *Decoder) {
4653 containerLen := d.mapStart(d.d.ReadMapStart())
4654 if containerLen == containerLenNil {
4655 *vp = nil
4656 } else {
4657 if *vp == nil {
4658 *vp = make(map[uint8]uint8, decInferLen(containerLen, d.h.MaxInitLen, 2))
4659 }
4660 if containerLen != 0 {
4661 f.DecMapUint8Uint8L(*vp, containerLen, d)
4662 }
4663 d.mapEnd()
4664 }
4665 }
4666 func (fastpathT) DecMapUint8Uint8L(v map[uint8]uint8, containerLen int, d *Decoder) {
4667 if v == nil {
4668 d.errorf("cannot decode into nil map[uint8]uint8 given stream length: %v", containerLen)
4669 return
4670 }
4671 var mk uint8
4672 var mv uint8
4673 hasLen := containerLen > 0
4674 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
4675 d.mapElemKey()
4676 mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
4677 d.mapElemValue()
4678 mv = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
4679 v[mk] = mv
4680 }
4681 }
4682 func (d *Decoder) fastpathDecMapUint8Uint64R(f *codecFnInfo, rv reflect.Value) {
4683 containerLen := d.mapStart(d.d.ReadMapStart())
4684 if rv.Kind() == reflect.Ptr {
4685 vp, _ := rv2i(rv).(*map[uint8]uint64)
4686 if *vp == nil {
4687 *vp = make(map[uint8]uint64, decInferLen(containerLen, d.h.MaxInitLen, 9))
4688 }
4689 if containerLen != 0 {
4690 fastpathTV.DecMapUint8Uint64L(*vp, containerLen, d)
4691 }
4692 } else if containerLen != 0 {
4693 fastpathTV.DecMapUint8Uint64L(rv2i(rv).(map[uint8]uint64), containerLen, d)
4694 }
4695 d.mapEnd()
4696 }
4697 func (f fastpathT) DecMapUint8Uint64X(vp *map[uint8]uint64, d *Decoder) {
4698 containerLen := d.mapStart(d.d.ReadMapStart())
4699 if containerLen == containerLenNil {
4700 *vp = nil
4701 } else {
4702 if *vp == nil {
4703 *vp = make(map[uint8]uint64, decInferLen(containerLen, d.h.MaxInitLen, 9))
4704 }
4705 if containerLen != 0 {
4706 f.DecMapUint8Uint64L(*vp, containerLen, d)
4707 }
4708 d.mapEnd()
4709 }
4710 }
4711 func (fastpathT) DecMapUint8Uint64L(v map[uint8]uint64, containerLen int, d *Decoder) {
4712 if v == nil {
4713 d.errorf("cannot decode into nil map[uint8]uint64 given stream length: %v", containerLen)
4714 return
4715 }
4716 var mk uint8
4717 var mv uint64
4718 hasLen := containerLen > 0
4719 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
4720 d.mapElemKey()
4721 mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
4722 d.mapElemValue()
4723 mv = d.d.DecodeUint64()
4724 v[mk] = mv
4725 }
4726 }
4727 func (d *Decoder) fastpathDecMapUint8IntR(f *codecFnInfo, rv reflect.Value) {
4728 containerLen := d.mapStart(d.d.ReadMapStart())
4729 if rv.Kind() == reflect.Ptr {
4730 vp, _ := rv2i(rv).(*map[uint8]int)
4731 if *vp == nil {
4732 *vp = make(map[uint8]int, decInferLen(containerLen, d.h.MaxInitLen, 9))
4733 }
4734 if containerLen != 0 {
4735 fastpathTV.DecMapUint8IntL(*vp, containerLen, d)
4736 }
4737 } else if containerLen != 0 {
4738 fastpathTV.DecMapUint8IntL(rv2i(rv).(map[uint8]int), containerLen, d)
4739 }
4740 d.mapEnd()
4741 }
4742 func (f fastpathT) DecMapUint8IntX(vp *map[uint8]int, d *Decoder) {
4743 containerLen := d.mapStart(d.d.ReadMapStart())
4744 if containerLen == containerLenNil {
4745 *vp = nil
4746 } else {
4747 if *vp == nil {
4748 *vp = make(map[uint8]int, decInferLen(containerLen, d.h.MaxInitLen, 9))
4749 }
4750 if containerLen != 0 {
4751 f.DecMapUint8IntL(*vp, containerLen, d)
4752 }
4753 d.mapEnd()
4754 }
4755 }
4756 func (fastpathT) DecMapUint8IntL(v map[uint8]int, containerLen int, d *Decoder) {
4757 if v == nil {
4758 d.errorf("cannot decode into nil map[uint8]int given stream length: %v", containerLen)
4759 return
4760 }
4761 var mk uint8
4762 var mv int
4763 hasLen := containerLen > 0
4764 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
4765 d.mapElemKey()
4766 mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
4767 d.mapElemValue()
4768 mv = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
4769 v[mk] = mv
4770 }
4771 }
4772 func (d *Decoder) fastpathDecMapUint8Int32R(f *codecFnInfo, rv reflect.Value) {
4773 containerLen := d.mapStart(d.d.ReadMapStart())
4774 if rv.Kind() == reflect.Ptr {
4775 vp, _ := rv2i(rv).(*map[uint8]int32)
4776 if *vp == nil {
4777 *vp = make(map[uint8]int32, decInferLen(containerLen, d.h.MaxInitLen, 5))
4778 }
4779 if containerLen != 0 {
4780 fastpathTV.DecMapUint8Int32L(*vp, containerLen, d)
4781 }
4782 } else if containerLen != 0 {
4783 fastpathTV.DecMapUint8Int32L(rv2i(rv).(map[uint8]int32), containerLen, d)
4784 }
4785 d.mapEnd()
4786 }
4787 func (f fastpathT) DecMapUint8Int32X(vp *map[uint8]int32, d *Decoder) {
4788 containerLen := d.mapStart(d.d.ReadMapStart())
4789 if containerLen == containerLenNil {
4790 *vp = nil
4791 } else {
4792 if *vp == nil {
4793 *vp = make(map[uint8]int32, decInferLen(containerLen, d.h.MaxInitLen, 5))
4794 }
4795 if containerLen != 0 {
4796 f.DecMapUint8Int32L(*vp, containerLen, d)
4797 }
4798 d.mapEnd()
4799 }
4800 }
4801 func (fastpathT) DecMapUint8Int32L(v map[uint8]int32, containerLen int, d *Decoder) {
4802 if v == nil {
4803 d.errorf("cannot decode into nil map[uint8]int32 given stream length: %v", containerLen)
4804 return
4805 }
4806 var mk uint8
4807 var mv int32
4808 hasLen := containerLen > 0
4809 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
4810 d.mapElemKey()
4811 mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
4812 d.mapElemValue()
4813 mv = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
4814 v[mk] = mv
4815 }
4816 }
4817 func (d *Decoder) fastpathDecMapUint8Float64R(f *codecFnInfo, rv reflect.Value) {
4818 containerLen := d.mapStart(d.d.ReadMapStart())
4819 if rv.Kind() == reflect.Ptr {
4820 vp, _ := rv2i(rv).(*map[uint8]float64)
4821 if *vp == nil {
4822 *vp = make(map[uint8]float64, decInferLen(containerLen, d.h.MaxInitLen, 9))
4823 }
4824 if containerLen != 0 {
4825 fastpathTV.DecMapUint8Float64L(*vp, containerLen, d)
4826 }
4827 } else if containerLen != 0 {
4828 fastpathTV.DecMapUint8Float64L(rv2i(rv).(map[uint8]float64), containerLen, d)
4829 }
4830 d.mapEnd()
4831 }
4832 func (f fastpathT) DecMapUint8Float64X(vp *map[uint8]float64, d *Decoder) {
4833 containerLen := d.mapStart(d.d.ReadMapStart())
4834 if containerLen == containerLenNil {
4835 *vp = nil
4836 } else {
4837 if *vp == nil {
4838 *vp = make(map[uint8]float64, decInferLen(containerLen, d.h.MaxInitLen, 9))
4839 }
4840 if containerLen != 0 {
4841 f.DecMapUint8Float64L(*vp, containerLen, d)
4842 }
4843 d.mapEnd()
4844 }
4845 }
4846 func (fastpathT) DecMapUint8Float64L(v map[uint8]float64, containerLen int, d *Decoder) {
4847 if v == nil {
4848 d.errorf("cannot decode into nil map[uint8]float64 given stream length: %v", containerLen)
4849 return
4850 }
4851 var mk uint8
4852 var mv float64
4853 hasLen := containerLen > 0
4854 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
4855 d.mapElemKey()
4856 mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
4857 d.mapElemValue()
4858 mv = d.d.DecodeFloat64()
4859 v[mk] = mv
4860 }
4861 }
4862 func (d *Decoder) fastpathDecMapUint8BoolR(f *codecFnInfo, rv reflect.Value) {
4863 containerLen := d.mapStart(d.d.ReadMapStart())
4864 if rv.Kind() == reflect.Ptr {
4865 vp, _ := rv2i(rv).(*map[uint8]bool)
4866 if *vp == nil {
4867 *vp = make(map[uint8]bool, decInferLen(containerLen, d.h.MaxInitLen, 2))
4868 }
4869 if containerLen != 0 {
4870 fastpathTV.DecMapUint8BoolL(*vp, containerLen, d)
4871 }
4872 } else if containerLen != 0 {
4873 fastpathTV.DecMapUint8BoolL(rv2i(rv).(map[uint8]bool), containerLen, d)
4874 }
4875 d.mapEnd()
4876 }
4877 func (f fastpathT) DecMapUint8BoolX(vp *map[uint8]bool, d *Decoder) {
4878 containerLen := d.mapStart(d.d.ReadMapStart())
4879 if containerLen == containerLenNil {
4880 *vp = nil
4881 } else {
4882 if *vp == nil {
4883 *vp = make(map[uint8]bool, decInferLen(containerLen, d.h.MaxInitLen, 2))
4884 }
4885 if containerLen != 0 {
4886 f.DecMapUint8BoolL(*vp, containerLen, d)
4887 }
4888 d.mapEnd()
4889 }
4890 }
4891 func (fastpathT) DecMapUint8BoolL(v map[uint8]bool, containerLen int, d *Decoder) {
4892 if v == nil {
4893 d.errorf("cannot decode into nil map[uint8]bool given stream length: %v", containerLen)
4894 return
4895 }
4896 var mk uint8
4897 var mv bool
4898 hasLen := containerLen > 0
4899 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
4900 d.mapElemKey()
4901 mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
4902 d.mapElemValue()
4903 mv = d.d.DecodeBool()
4904 v[mk] = mv
4905 }
4906 }
4907 func (d *Decoder) fastpathDecMapUint64IntfR(f *codecFnInfo, rv reflect.Value) {
4908 containerLen := d.mapStart(d.d.ReadMapStart())
4909 if rv.Kind() == reflect.Ptr {
4910 vp, _ := rv2i(rv).(*map[uint64]interface{})
4911 if *vp == nil {
4912 *vp = make(map[uint64]interface{}, decInferLen(containerLen, d.h.MaxInitLen, 24))
4913 }
4914 if containerLen != 0 {
4915 fastpathTV.DecMapUint64IntfL(*vp, containerLen, d)
4916 }
4917 } else if containerLen != 0 {
4918 fastpathTV.DecMapUint64IntfL(rv2i(rv).(map[uint64]interface{}), containerLen, d)
4919 }
4920 d.mapEnd()
4921 }
4922 func (f fastpathT) DecMapUint64IntfX(vp *map[uint64]interface{}, d *Decoder) {
4923 containerLen := d.mapStart(d.d.ReadMapStart())
4924 if containerLen == containerLenNil {
4925 *vp = nil
4926 } else {
4927 if *vp == nil {
4928 *vp = make(map[uint64]interface{}, decInferLen(containerLen, d.h.MaxInitLen, 24))
4929 }
4930 if containerLen != 0 {
4931 f.DecMapUint64IntfL(*vp, containerLen, d)
4932 }
4933 d.mapEnd()
4934 }
4935 }
4936 func (fastpathT) DecMapUint64IntfL(v map[uint64]interface{}, containerLen int, d *Decoder) {
4937 if v == nil {
4938 d.errorf("cannot decode into nil map[uint64]interface{} given stream length: %v", containerLen)
4939 return
4940 }
4941 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
4942 var mk uint64
4943 var mv interface{}
4944 hasLen := containerLen > 0
4945 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
4946 d.mapElemKey()
4947 mk = d.d.DecodeUint64()
4948 d.mapElemValue()
4949 if mapGet {
4950 mv = v[mk]
4951 } else {
4952 mv = nil
4953 }
4954 d.decode(&mv)
4955 v[mk] = mv
4956 }
4957 }
4958 func (d *Decoder) fastpathDecMapUint64StringR(f *codecFnInfo, rv reflect.Value) {
4959 containerLen := d.mapStart(d.d.ReadMapStart())
4960 if rv.Kind() == reflect.Ptr {
4961 vp, _ := rv2i(rv).(*map[uint64]string)
4962 if *vp == nil {
4963 *vp = make(map[uint64]string, decInferLen(containerLen, d.h.MaxInitLen, 24))
4964 }
4965 if containerLen != 0 {
4966 fastpathTV.DecMapUint64StringL(*vp, containerLen, d)
4967 }
4968 } else if containerLen != 0 {
4969 fastpathTV.DecMapUint64StringL(rv2i(rv).(map[uint64]string), containerLen, d)
4970 }
4971 d.mapEnd()
4972 }
4973 func (f fastpathT) DecMapUint64StringX(vp *map[uint64]string, d *Decoder) {
4974 containerLen := d.mapStart(d.d.ReadMapStart())
4975 if containerLen == containerLenNil {
4976 *vp = nil
4977 } else {
4978 if *vp == nil {
4979 *vp = make(map[uint64]string, decInferLen(containerLen, d.h.MaxInitLen, 24))
4980 }
4981 if containerLen != 0 {
4982 f.DecMapUint64StringL(*vp, containerLen, d)
4983 }
4984 d.mapEnd()
4985 }
4986 }
4987 func (fastpathT) DecMapUint64StringL(v map[uint64]string, containerLen int, d *Decoder) {
4988 if v == nil {
4989 d.errorf("cannot decode into nil map[uint64]string given stream length: %v", containerLen)
4990 return
4991 }
4992 var mk uint64
4993 var mv string
4994 hasLen := containerLen > 0
4995 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
4996 d.mapElemKey()
4997 mk = d.d.DecodeUint64()
4998 d.mapElemValue()
4999 mv = d.stringZC(d.d.DecodeStringAsBytes())
5000 v[mk] = mv
5001 }
5002 }
5003 func (d *Decoder) fastpathDecMapUint64BytesR(f *codecFnInfo, rv reflect.Value) {
5004 containerLen := d.mapStart(d.d.ReadMapStart())
5005 if rv.Kind() == reflect.Ptr {
5006 vp, _ := rv2i(rv).(*map[uint64][]byte)
5007 if *vp == nil {
5008 *vp = make(map[uint64][]byte, decInferLen(containerLen, d.h.MaxInitLen, 32))
5009 }
5010 if containerLen != 0 {
5011 fastpathTV.DecMapUint64BytesL(*vp, containerLen, d)
5012 }
5013 } else if containerLen != 0 {
5014 fastpathTV.DecMapUint64BytesL(rv2i(rv).(map[uint64][]byte), containerLen, d)
5015 }
5016 d.mapEnd()
5017 }
5018 func (f fastpathT) DecMapUint64BytesX(vp *map[uint64][]byte, d *Decoder) {
5019 containerLen := d.mapStart(d.d.ReadMapStart())
5020 if containerLen == containerLenNil {
5021 *vp = nil
5022 } else {
5023 if *vp == nil {
5024 *vp = make(map[uint64][]byte, decInferLen(containerLen, d.h.MaxInitLen, 32))
5025 }
5026 if containerLen != 0 {
5027 f.DecMapUint64BytesL(*vp, containerLen, d)
5028 }
5029 d.mapEnd()
5030 }
5031 }
5032 func (fastpathT) DecMapUint64BytesL(v map[uint64][]byte, containerLen int, d *Decoder) {
5033 if v == nil {
5034 d.errorf("cannot decode into nil map[uint64][]byte given stream length: %v", containerLen)
5035 return
5036 }
5037 mapGet := v != nil && !d.h.MapValueReset
5038 var mk uint64
5039 var mv []byte
5040 hasLen := containerLen > 0
5041 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
5042 d.mapElemKey()
5043 mk = d.d.DecodeUint64()
5044 d.mapElemValue()
5045 if mapGet {
5046 mv = v[mk]
5047 } else {
5048 mv = nil
5049 }
5050 mv = d.decodeBytesInto(mv)
5051 v[mk] = mv
5052 }
5053 }
5054 func (d *Decoder) fastpathDecMapUint64Uint8R(f *codecFnInfo, rv reflect.Value) {
5055 containerLen := d.mapStart(d.d.ReadMapStart())
5056 if rv.Kind() == reflect.Ptr {
5057 vp, _ := rv2i(rv).(*map[uint64]uint8)
5058 if *vp == nil {
5059 *vp = make(map[uint64]uint8, decInferLen(containerLen, d.h.MaxInitLen, 9))
5060 }
5061 if containerLen != 0 {
5062 fastpathTV.DecMapUint64Uint8L(*vp, containerLen, d)
5063 }
5064 } else if containerLen != 0 {
5065 fastpathTV.DecMapUint64Uint8L(rv2i(rv).(map[uint64]uint8), containerLen, d)
5066 }
5067 d.mapEnd()
5068 }
5069 func (f fastpathT) DecMapUint64Uint8X(vp *map[uint64]uint8, d *Decoder) {
5070 containerLen := d.mapStart(d.d.ReadMapStart())
5071 if containerLen == containerLenNil {
5072 *vp = nil
5073 } else {
5074 if *vp == nil {
5075 *vp = make(map[uint64]uint8, decInferLen(containerLen, d.h.MaxInitLen, 9))
5076 }
5077 if containerLen != 0 {
5078 f.DecMapUint64Uint8L(*vp, containerLen, d)
5079 }
5080 d.mapEnd()
5081 }
5082 }
5083 func (fastpathT) DecMapUint64Uint8L(v map[uint64]uint8, containerLen int, d *Decoder) {
5084 if v == nil {
5085 d.errorf("cannot decode into nil map[uint64]uint8 given stream length: %v", containerLen)
5086 return
5087 }
5088 var mk uint64
5089 var mv uint8
5090 hasLen := containerLen > 0
5091 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
5092 d.mapElemKey()
5093 mk = d.d.DecodeUint64()
5094 d.mapElemValue()
5095 mv = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
5096 v[mk] = mv
5097 }
5098 }
5099 func (d *Decoder) fastpathDecMapUint64Uint64R(f *codecFnInfo, rv reflect.Value) {
5100 containerLen := d.mapStart(d.d.ReadMapStart())
5101 if rv.Kind() == reflect.Ptr {
5102 vp, _ := rv2i(rv).(*map[uint64]uint64)
5103 if *vp == nil {
5104 *vp = make(map[uint64]uint64, decInferLen(containerLen, d.h.MaxInitLen, 16))
5105 }
5106 if containerLen != 0 {
5107 fastpathTV.DecMapUint64Uint64L(*vp, containerLen, d)
5108 }
5109 } else if containerLen != 0 {
5110 fastpathTV.DecMapUint64Uint64L(rv2i(rv).(map[uint64]uint64), containerLen, d)
5111 }
5112 d.mapEnd()
5113 }
5114 func (f fastpathT) DecMapUint64Uint64X(vp *map[uint64]uint64, d *Decoder) {
5115 containerLen := d.mapStart(d.d.ReadMapStart())
5116 if containerLen == containerLenNil {
5117 *vp = nil
5118 } else {
5119 if *vp == nil {
5120 *vp = make(map[uint64]uint64, decInferLen(containerLen, d.h.MaxInitLen, 16))
5121 }
5122 if containerLen != 0 {
5123 f.DecMapUint64Uint64L(*vp, containerLen, d)
5124 }
5125 d.mapEnd()
5126 }
5127 }
5128 func (fastpathT) DecMapUint64Uint64L(v map[uint64]uint64, containerLen int, d *Decoder) {
5129 if v == nil {
5130 d.errorf("cannot decode into nil map[uint64]uint64 given stream length: %v", containerLen)
5131 return
5132 }
5133 var mk uint64
5134 var mv uint64
5135 hasLen := containerLen > 0
5136 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
5137 d.mapElemKey()
5138 mk = d.d.DecodeUint64()
5139 d.mapElemValue()
5140 mv = d.d.DecodeUint64()
5141 v[mk] = mv
5142 }
5143 }
5144 func (d *Decoder) fastpathDecMapUint64IntR(f *codecFnInfo, rv reflect.Value) {
5145 containerLen := d.mapStart(d.d.ReadMapStart())
5146 if rv.Kind() == reflect.Ptr {
5147 vp, _ := rv2i(rv).(*map[uint64]int)
5148 if *vp == nil {
5149 *vp = make(map[uint64]int, decInferLen(containerLen, d.h.MaxInitLen, 16))
5150 }
5151 if containerLen != 0 {
5152 fastpathTV.DecMapUint64IntL(*vp, containerLen, d)
5153 }
5154 } else if containerLen != 0 {
5155 fastpathTV.DecMapUint64IntL(rv2i(rv).(map[uint64]int), containerLen, d)
5156 }
5157 d.mapEnd()
5158 }
5159 func (f fastpathT) DecMapUint64IntX(vp *map[uint64]int, d *Decoder) {
5160 containerLen := d.mapStart(d.d.ReadMapStart())
5161 if containerLen == containerLenNil {
5162 *vp = nil
5163 } else {
5164 if *vp == nil {
5165 *vp = make(map[uint64]int, decInferLen(containerLen, d.h.MaxInitLen, 16))
5166 }
5167 if containerLen != 0 {
5168 f.DecMapUint64IntL(*vp, containerLen, d)
5169 }
5170 d.mapEnd()
5171 }
5172 }
5173 func (fastpathT) DecMapUint64IntL(v map[uint64]int, containerLen int, d *Decoder) {
5174 if v == nil {
5175 d.errorf("cannot decode into nil map[uint64]int given stream length: %v", containerLen)
5176 return
5177 }
5178 var mk uint64
5179 var mv int
5180 hasLen := containerLen > 0
5181 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
5182 d.mapElemKey()
5183 mk = d.d.DecodeUint64()
5184 d.mapElemValue()
5185 mv = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
5186 v[mk] = mv
5187 }
5188 }
5189 func (d *Decoder) fastpathDecMapUint64Int32R(f *codecFnInfo, rv reflect.Value) {
5190 containerLen := d.mapStart(d.d.ReadMapStart())
5191 if rv.Kind() == reflect.Ptr {
5192 vp, _ := rv2i(rv).(*map[uint64]int32)
5193 if *vp == nil {
5194 *vp = make(map[uint64]int32, decInferLen(containerLen, d.h.MaxInitLen, 12))
5195 }
5196 if containerLen != 0 {
5197 fastpathTV.DecMapUint64Int32L(*vp, containerLen, d)
5198 }
5199 } else if containerLen != 0 {
5200 fastpathTV.DecMapUint64Int32L(rv2i(rv).(map[uint64]int32), containerLen, d)
5201 }
5202 d.mapEnd()
5203 }
5204 func (f fastpathT) DecMapUint64Int32X(vp *map[uint64]int32, d *Decoder) {
5205 containerLen := d.mapStart(d.d.ReadMapStart())
5206 if containerLen == containerLenNil {
5207 *vp = nil
5208 } else {
5209 if *vp == nil {
5210 *vp = make(map[uint64]int32, decInferLen(containerLen, d.h.MaxInitLen, 12))
5211 }
5212 if containerLen != 0 {
5213 f.DecMapUint64Int32L(*vp, containerLen, d)
5214 }
5215 d.mapEnd()
5216 }
5217 }
5218 func (fastpathT) DecMapUint64Int32L(v map[uint64]int32, containerLen int, d *Decoder) {
5219 if v == nil {
5220 d.errorf("cannot decode into nil map[uint64]int32 given stream length: %v", containerLen)
5221 return
5222 }
5223 var mk uint64
5224 var mv int32
5225 hasLen := containerLen > 0
5226 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
5227 d.mapElemKey()
5228 mk = d.d.DecodeUint64()
5229 d.mapElemValue()
5230 mv = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
5231 v[mk] = mv
5232 }
5233 }
5234 func (d *Decoder) fastpathDecMapUint64Float64R(f *codecFnInfo, rv reflect.Value) {
5235 containerLen := d.mapStart(d.d.ReadMapStart())
5236 if rv.Kind() == reflect.Ptr {
5237 vp, _ := rv2i(rv).(*map[uint64]float64)
5238 if *vp == nil {
5239 *vp = make(map[uint64]float64, decInferLen(containerLen, d.h.MaxInitLen, 16))
5240 }
5241 if containerLen != 0 {
5242 fastpathTV.DecMapUint64Float64L(*vp, containerLen, d)
5243 }
5244 } else if containerLen != 0 {
5245 fastpathTV.DecMapUint64Float64L(rv2i(rv).(map[uint64]float64), containerLen, d)
5246 }
5247 d.mapEnd()
5248 }
5249 func (f fastpathT) DecMapUint64Float64X(vp *map[uint64]float64, d *Decoder) {
5250 containerLen := d.mapStart(d.d.ReadMapStart())
5251 if containerLen == containerLenNil {
5252 *vp = nil
5253 } else {
5254 if *vp == nil {
5255 *vp = make(map[uint64]float64, decInferLen(containerLen, d.h.MaxInitLen, 16))
5256 }
5257 if containerLen != 0 {
5258 f.DecMapUint64Float64L(*vp, containerLen, d)
5259 }
5260 d.mapEnd()
5261 }
5262 }
5263 func (fastpathT) DecMapUint64Float64L(v map[uint64]float64, containerLen int, d *Decoder) {
5264 if v == nil {
5265 d.errorf("cannot decode into nil map[uint64]float64 given stream length: %v", containerLen)
5266 return
5267 }
5268 var mk uint64
5269 var mv float64
5270 hasLen := containerLen > 0
5271 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
5272 d.mapElemKey()
5273 mk = d.d.DecodeUint64()
5274 d.mapElemValue()
5275 mv = d.d.DecodeFloat64()
5276 v[mk] = mv
5277 }
5278 }
5279 func (d *Decoder) fastpathDecMapUint64BoolR(f *codecFnInfo, rv reflect.Value) {
5280 containerLen := d.mapStart(d.d.ReadMapStart())
5281 if rv.Kind() == reflect.Ptr {
5282 vp, _ := rv2i(rv).(*map[uint64]bool)
5283 if *vp == nil {
5284 *vp = make(map[uint64]bool, decInferLen(containerLen, d.h.MaxInitLen, 9))
5285 }
5286 if containerLen != 0 {
5287 fastpathTV.DecMapUint64BoolL(*vp, containerLen, d)
5288 }
5289 } else if containerLen != 0 {
5290 fastpathTV.DecMapUint64BoolL(rv2i(rv).(map[uint64]bool), containerLen, d)
5291 }
5292 d.mapEnd()
5293 }
5294 func (f fastpathT) DecMapUint64BoolX(vp *map[uint64]bool, d *Decoder) {
5295 containerLen := d.mapStart(d.d.ReadMapStart())
5296 if containerLen == containerLenNil {
5297 *vp = nil
5298 } else {
5299 if *vp == nil {
5300 *vp = make(map[uint64]bool, decInferLen(containerLen, d.h.MaxInitLen, 9))
5301 }
5302 if containerLen != 0 {
5303 f.DecMapUint64BoolL(*vp, containerLen, d)
5304 }
5305 d.mapEnd()
5306 }
5307 }
5308 func (fastpathT) DecMapUint64BoolL(v map[uint64]bool, containerLen int, d *Decoder) {
5309 if v == nil {
5310 d.errorf("cannot decode into nil map[uint64]bool given stream length: %v", containerLen)
5311 return
5312 }
5313 var mk uint64
5314 var mv bool
5315 hasLen := containerLen > 0
5316 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
5317 d.mapElemKey()
5318 mk = d.d.DecodeUint64()
5319 d.mapElemValue()
5320 mv = d.d.DecodeBool()
5321 v[mk] = mv
5322 }
5323 }
5324 func (d *Decoder) fastpathDecMapIntIntfR(f *codecFnInfo, rv reflect.Value) {
5325 containerLen := d.mapStart(d.d.ReadMapStart())
5326 if rv.Kind() == reflect.Ptr {
5327 vp, _ := rv2i(rv).(*map[int]interface{})
5328 if *vp == nil {
5329 *vp = make(map[int]interface{}, decInferLen(containerLen, d.h.MaxInitLen, 24))
5330 }
5331 if containerLen != 0 {
5332 fastpathTV.DecMapIntIntfL(*vp, containerLen, d)
5333 }
5334 } else if containerLen != 0 {
5335 fastpathTV.DecMapIntIntfL(rv2i(rv).(map[int]interface{}), containerLen, d)
5336 }
5337 d.mapEnd()
5338 }
5339 func (f fastpathT) DecMapIntIntfX(vp *map[int]interface{}, d *Decoder) {
5340 containerLen := d.mapStart(d.d.ReadMapStart())
5341 if containerLen == containerLenNil {
5342 *vp = nil
5343 } else {
5344 if *vp == nil {
5345 *vp = make(map[int]interface{}, decInferLen(containerLen, d.h.MaxInitLen, 24))
5346 }
5347 if containerLen != 0 {
5348 f.DecMapIntIntfL(*vp, containerLen, d)
5349 }
5350 d.mapEnd()
5351 }
5352 }
5353 func (fastpathT) DecMapIntIntfL(v map[int]interface{}, containerLen int, d *Decoder) {
5354 if v == nil {
5355 d.errorf("cannot decode into nil map[int]interface{} given stream length: %v", containerLen)
5356 return
5357 }
5358 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
5359 var mk int
5360 var mv interface{}
5361 hasLen := containerLen > 0
5362 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
5363 d.mapElemKey()
5364 mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
5365 d.mapElemValue()
5366 if mapGet {
5367 mv = v[mk]
5368 } else {
5369 mv = nil
5370 }
5371 d.decode(&mv)
5372 v[mk] = mv
5373 }
5374 }
5375 func (d *Decoder) fastpathDecMapIntStringR(f *codecFnInfo, rv reflect.Value) {
5376 containerLen := d.mapStart(d.d.ReadMapStart())
5377 if rv.Kind() == reflect.Ptr {
5378 vp, _ := rv2i(rv).(*map[int]string)
5379 if *vp == nil {
5380 *vp = make(map[int]string, decInferLen(containerLen, d.h.MaxInitLen, 24))
5381 }
5382 if containerLen != 0 {
5383 fastpathTV.DecMapIntStringL(*vp, containerLen, d)
5384 }
5385 } else if containerLen != 0 {
5386 fastpathTV.DecMapIntStringL(rv2i(rv).(map[int]string), containerLen, d)
5387 }
5388 d.mapEnd()
5389 }
5390 func (f fastpathT) DecMapIntStringX(vp *map[int]string, d *Decoder) {
5391 containerLen := d.mapStart(d.d.ReadMapStart())
5392 if containerLen == containerLenNil {
5393 *vp = nil
5394 } else {
5395 if *vp == nil {
5396 *vp = make(map[int]string, decInferLen(containerLen, d.h.MaxInitLen, 24))
5397 }
5398 if containerLen != 0 {
5399 f.DecMapIntStringL(*vp, containerLen, d)
5400 }
5401 d.mapEnd()
5402 }
5403 }
5404 func (fastpathT) DecMapIntStringL(v map[int]string, containerLen int, d *Decoder) {
5405 if v == nil {
5406 d.errorf("cannot decode into nil map[int]string given stream length: %v", containerLen)
5407 return
5408 }
5409 var mk int
5410 var mv string
5411 hasLen := containerLen > 0
5412 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
5413 d.mapElemKey()
5414 mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
5415 d.mapElemValue()
5416 mv = d.stringZC(d.d.DecodeStringAsBytes())
5417 v[mk] = mv
5418 }
5419 }
5420 func (d *Decoder) fastpathDecMapIntBytesR(f *codecFnInfo, rv reflect.Value) {
5421 containerLen := d.mapStart(d.d.ReadMapStart())
5422 if rv.Kind() == reflect.Ptr {
5423 vp, _ := rv2i(rv).(*map[int][]byte)
5424 if *vp == nil {
5425 *vp = make(map[int][]byte, decInferLen(containerLen, d.h.MaxInitLen, 32))
5426 }
5427 if containerLen != 0 {
5428 fastpathTV.DecMapIntBytesL(*vp, containerLen, d)
5429 }
5430 } else if containerLen != 0 {
5431 fastpathTV.DecMapIntBytesL(rv2i(rv).(map[int][]byte), containerLen, d)
5432 }
5433 d.mapEnd()
5434 }
5435 func (f fastpathT) DecMapIntBytesX(vp *map[int][]byte, d *Decoder) {
5436 containerLen := d.mapStart(d.d.ReadMapStart())
5437 if containerLen == containerLenNil {
5438 *vp = nil
5439 } else {
5440 if *vp == nil {
5441 *vp = make(map[int][]byte, decInferLen(containerLen, d.h.MaxInitLen, 32))
5442 }
5443 if containerLen != 0 {
5444 f.DecMapIntBytesL(*vp, containerLen, d)
5445 }
5446 d.mapEnd()
5447 }
5448 }
5449 func (fastpathT) DecMapIntBytesL(v map[int][]byte, containerLen int, d *Decoder) {
5450 if v == nil {
5451 d.errorf("cannot decode into nil map[int][]byte given stream length: %v", containerLen)
5452 return
5453 }
5454 mapGet := v != nil && !d.h.MapValueReset
5455 var mk int
5456 var mv []byte
5457 hasLen := containerLen > 0
5458 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
5459 d.mapElemKey()
5460 mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
5461 d.mapElemValue()
5462 if mapGet {
5463 mv = v[mk]
5464 } else {
5465 mv = nil
5466 }
5467 mv = d.decodeBytesInto(mv)
5468 v[mk] = mv
5469 }
5470 }
5471 func (d *Decoder) fastpathDecMapIntUint8R(f *codecFnInfo, rv reflect.Value) {
5472 containerLen := d.mapStart(d.d.ReadMapStart())
5473 if rv.Kind() == reflect.Ptr {
5474 vp, _ := rv2i(rv).(*map[int]uint8)
5475 if *vp == nil {
5476 *vp = make(map[int]uint8, decInferLen(containerLen, d.h.MaxInitLen, 9))
5477 }
5478 if containerLen != 0 {
5479 fastpathTV.DecMapIntUint8L(*vp, containerLen, d)
5480 }
5481 } else if containerLen != 0 {
5482 fastpathTV.DecMapIntUint8L(rv2i(rv).(map[int]uint8), containerLen, d)
5483 }
5484 d.mapEnd()
5485 }
5486 func (f fastpathT) DecMapIntUint8X(vp *map[int]uint8, d *Decoder) {
5487 containerLen := d.mapStart(d.d.ReadMapStart())
5488 if containerLen == containerLenNil {
5489 *vp = nil
5490 } else {
5491 if *vp == nil {
5492 *vp = make(map[int]uint8, decInferLen(containerLen, d.h.MaxInitLen, 9))
5493 }
5494 if containerLen != 0 {
5495 f.DecMapIntUint8L(*vp, containerLen, d)
5496 }
5497 d.mapEnd()
5498 }
5499 }
5500 func (fastpathT) DecMapIntUint8L(v map[int]uint8, containerLen int, d *Decoder) {
5501 if v == nil {
5502 d.errorf("cannot decode into nil map[int]uint8 given stream length: %v", containerLen)
5503 return
5504 }
5505 var mk int
5506 var mv uint8
5507 hasLen := containerLen > 0
5508 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
5509 d.mapElemKey()
5510 mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
5511 d.mapElemValue()
5512 mv = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
5513 v[mk] = mv
5514 }
5515 }
5516 func (d *Decoder) fastpathDecMapIntUint64R(f *codecFnInfo, rv reflect.Value) {
5517 containerLen := d.mapStart(d.d.ReadMapStart())
5518 if rv.Kind() == reflect.Ptr {
5519 vp, _ := rv2i(rv).(*map[int]uint64)
5520 if *vp == nil {
5521 *vp = make(map[int]uint64, decInferLen(containerLen, d.h.MaxInitLen, 16))
5522 }
5523 if containerLen != 0 {
5524 fastpathTV.DecMapIntUint64L(*vp, containerLen, d)
5525 }
5526 } else if containerLen != 0 {
5527 fastpathTV.DecMapIntUint64L(rv2i(rv).(map[int]uint64), containerLen, d)
5528 }
5529 d.mapEnd()
5530 }
5531 func (f fastpathT) DecMapIntUint64X(vp *map[int]uint64, d *Decoder) {
5532 containerLen := d.mapStart(d.d.ReadMapStart())
5533 if containerLen == containerLenNil {
5534 *vp = nil
5535 } else {
5536 if *vp == nil {
5537 *vp = make(map[int]uint64, decInferLen(containerLen, d.h.MaxInitLen, 16))
5538 }
5539 if containerLen != 0 {
5540 f.DecMapIntUint64L(*vp, containerLen, d)
5541 }
5542 d.mapEnd()
5543 }
5544 }
5545 func (fastpathT) DecMapIntUint64L(v map[int]uint64, containerLen int, d *Decoder) {
5546 if v == nil {
5547 d.errorf("cannot decode into nil map[int]uint64 given stream length: %v", containerLen)
5548 return
5549 }
5550 var mk int
5551 var mv uint64
5552 hasLen := containerLen > 0
5553 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
5554 d.mapElemKey()
5555 mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
5556 d.mapElemValue()
5557 mv = d.d.DecodeUint64()
5558 v[mk] = mv
5559 }
5560 }
5561 func (d *Decoder) fastpathDecMapIntIntR(f *codecFnInfo, rv reflect.Value) {
5562 containerLen := d.mapStart(d.d.ReadMapStart())
5563 if rv.Kind() == reflect.Ptr {
5564 vp, _ := rv2i(rv).(*map[int]int)
5565 if *vp == nil {
5566 *vp = make(map[int]int, decInferLen(containerLen, d.h.MaxInitLen, 16))
5567 }
5568 if containerLen != 0 {
5569 fastpathTV.DecMapIntIntL(*vp, containerLen, d)
5570 }
5571 } else if containerLen != 0 {
5572 fastpathTV.DecMapIntIntL(rv2i(rv).(map[int]int), containerLen, d)
5573 }
5574 d.mapEnd()
5575 }
5576 func (f fastpathT) DecMapIntIntX(vp *map[int]int, d *Decoder) {
5577 containerLen := d.mapStart(d.d.ReadMapStart())
5578 if containerLen == containerLenNil {
5579 *vp = nil
5580 } else {
5581 if *vp == nil {
5582 *vp = make(map[int]int, decInferLen(containerLen, d.h.MaxInitLen, 16))
5583 }
5584 if containerLen != 0 {
5585 f.DecMapIntIntL(*vp, containerLen, d)
5586 }
5587 d.mapEnd()
5588 }
5589 }
5590 func (fastpathT) DecMapIntIntL(v map[int]int, containerLen int, d *Decoder) {
5591 if v == nil {
5592 d.errorf("cannot decode into nil map[int]int given stream length: %v", containerLen)
5593 return
5594 }
5595 var mk int
5596 var mv int
5597 hasLen := containerLen > 0
5598 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
5599 d.mapElemKey()
5600 mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
5601 d.mapElemValue()
5602 mv = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
5603 v[mk] = mv
5604 }
5605 }
5606 func (d *Decoder) fastpathDecMapIntInt32R(f *codecFnInfo, rv reflect.Value) {
5607 containerLen := d.mapStart(d.d.ReadMapStart())
5608 if rv.Kind() == reflect.Ptr {
5609 vp, _ := rv2i(rv).(*map[int]int32)
5610 if *vp == nil {
5611 *vp = make(map[int]int32, decInferLen(containerLen, d.h.MaxInitLen, 12))
5612 }
5613 if containerLen != 0 {
5614 fastpathTV.DecMapIntInt32L(*vp, containerLen, d)
5615 }
5616 } else if containerLen != 0 {
5617 fastpathTV.DecMapIntInt32L(rv2i(rv).(map[int]int32), containerLen, d)
5618 }
5619 d.mapEnd()
5620 }
5621 func (f fastpathT) DecMapIntInt32X(vp *map[int]int32, d *Decoder) {
5622 containerLen := d.mapStart(d.d.ReadMapStart())
5623 if containerLen == containerLenNil {
5624 *vp = nil
5625 } else {
5626 if *vp == nil {
5627 *vp = make(map[int]int32, decInferLen(containerLen, d.h.MaxInitLen, 12))
5628 }
5629 if containerLen != 0 {
5630 f.DecMapIntInt32L(*vp, containerLen, d)
5631 }
5632 d.mapEnd()
5633 }
5634 }
5635 func (fastpathT) DecMapIntInt32L(v map[int]int32, containerLen int, d *Decoder) {
5636 if v == nil {
5637 d.errorf("cannot decode into nil map[int]int32 given stream length: %v", containerLen)
5638 return
5639 }
5640 var mk int
5641 var mv int32
5642 hasLen := containerLen > 0
5643 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
5644 d.mapElemKey()
5645 mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
5646 d.mapElemValue()
5647 mv = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
5648 v[mk] = mv
5649 }
5650 }
5651 func (d *Decoder) fastpathDecMapIntFloat64R(f *codecFnInfo, rv reflect.Value) {
5652 containerLen := d.mapStart(d.d.ReadMapStart())
5653 if rv.Kind() == reflect.Ptr {
5654 vp, _ := rv2i(rv).(*map[int]float64)
5655 if *vp == nil {
5656 *vp = make(map[int]float64, decInferLen(containerLen, d.h.MaxInitLen, 16))
5657 }
5658 if containerLen != 0 {
5659 fastpathTV.DecMapIntFloat64L(*vp, containerLen, d)
5660 }
5661 } else if containerLen != 0 {
5662 fastpathTV.DecMapIntFloat64L(rv2i(rv).(map[int]float64), containerLen, d)
5663 }
5664 d.mapEnd()
5665 }
5666 func (f fastpathT) DecMapIntFloat64X(vp *map[int]float64, d *Decoder) {
5667 containerLen := d.mapStart(d.d.ReadMapStart())
5668 if containerLen == containerLenNil {
5669 *vp = nil
5670 } else {
5671 if *vp == nil {
5672 *vp = make(map[int]float64, decInferLen(containerLen, d.h.MaxInitLen, 16))
5673 }
5674 if containerLen != 0 {
5675 f.DecMapIntFloat64L(*vp, containerLen, d)
5676 }
5677 d.mapEnd()
5678 }
5679 }
5680 func (fastpathT) DecMapIntFloat64L(v map[int]float64, containerLen int, d *Decoder) {
5681 if v == nil {
5682 d.errorf("cannot decode into nil map[int]float64 given stream length: %v", containerLen)
5683 return
5684 }
5685 var mk int
5686 var mv float64
5687 hasLen := containerLen > 0
5688 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
5689 d.mapElemKey()
5690 mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
5691 d.mapElemValue()
5692 mv = d.d.DecodeFloat64()
5693 v[mk] = mv
5694 }
5695 }
5696 func (d *Decoder) fastpathDecMapIntBoolR(f *codecFnInfo, rv reflect.Value) {
5697 containerLen := d.mapStart(d.d.ReadMapStart())
5698 if rv.Kind() == reflect.Ptr {
5699 vp, _ := rv2i(rv).(*map[int]bool)
5700 if *vp == nil {
5701 *vp = make(map[int]bool, decInferLen(containerLen, d.h.MaxInitLen, 9))
5702 }
5703 if containerLen != 0 {
5704 fastpathTV.DecMapIntBoolL(*vp, containerLen, d)
5705 }
5706 } else if containerLen != 0 {
5707 fastpathTV.DecMapIntBoolL(rv2i(rv).(map[int]bool), containerLen, d)
5708 }
5709 d.mapEnd()
5710 }
5711 func (f fastpathT) DecMapIntBoolX(vp *map[int]bool, d *Decoder) {
5712 containerLen := d.mapStart(d.d.ReadMapStart())
5713 if containerLen == containerLenNil {
5714 *vp = nil
5715 } else {
5716 if *vp == nil {
5717 *vp = make(map[int]bool, decInferLen(containerLen, d.h.MaxInitLen, 9))
5718 }
5719 if containerLen != 0 {
5720 f.DecMapIntBoolL(*vp, containerLen, d)
5721 }
5722 d.mapEnd()
5723 }
5724 }
5725 func (fastpathT) DecMapIntBoolL(v map[int]bool, containerLen int, d *Decoder) {
5726 if v == nil {
5727 d.errorf("cannot decode into nil map[int]bool given stream length: %v", containerLen)
5728 return
5729 }
5730 var mk int
5731 var mv bool
5732 hasLen := containerLen > 0
5733 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
5734 d.mapElemKey()
5735 mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
5736 d.mapElemValue()
5737 mv = d.d.DecodeBool()
5738 v[mk] = mv
5739 }
5740 }
5741 func (d *Decoder) fastpathDecMapInt32IntfR(f *codecFnInfo, rv reflect.Value) {
5742 containerLen := d.mapStart(d.d.ReadMapStart())
5743 if rv.Kind() == reflect.Ptr {
5744 vp, _ := rv2i(rv).(*map[int32]interface{})
5745 if *vp == nil {
5746 *vp = make(map[int32]interface{}, decInferLen(containerLen, d.h.MaxInitLen, 20))
5747 }
5748 if containerLen != 0 {
5749 fastpathTV.DecMapInt32IntfL(*vp, containerLen, d)
5750 }
5751 } else if containerLen != 0 {
5752 fastpathTV.DecMapInt32IntfL(rv2i(rv).(map[int32]interface{}), containerLen, d)
5753 }
5754 d.mapEnd()
5755 }
5756 func (f fastpathT) DecMapInt32IntfX(vp *map[int32]interface{}, d *Decoder) {
5757 containerLen := d.mapStart(d.d.ReadMapStart())
5758 if containerLen == containerLenNil {
5759 *vp = nil
5760 } else {
5761 if *vp == nil {
5762 *vp = make(map[int32]interface{}, decInferLen(containerLen, d.h.MaxInitLen, 20))
5763 }
5764 if containerLen != 0 {
5765 f.DecMapInt32IntfL(*vp, containerLen, d)
5766 }
5767 d.mapEnd()
5768 }
5769 }
5770 func (fastpathT) DecMapInt32IntfL(v map[int32]interface{}, containerLen int, d *Decoder) {
5771 if v == nil {
5772 d.errorf("cannot decode into nil map[int32]interface{} given stream length: %v", containerLen)
5773 return
5774 }
5775 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
5776 var mk int32
5777 var mv interface{}
5778 hasLen := containerLen > 0
5779 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
5780 d.mapElemKey()
5781 mk = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
5782 d.mapElemValue()
5783 if mapGet {
5784 mv = v[mk]
5785 } else {
5786 mv = nil
5787 }
5788 d.decode(&mv)
5789 v[mk] = mv
5790 }
5791 }
5792 func (d *Decoder) fastpathDecMapInt32StringR(f *codecFnInfo, rv reflect.Value) {
5793 containerLen := d.mapStart(d.d.ReadMapStart())
5794 if rv.Kind() == reflect.Ptr {
5795 vp, _ := rv2i(rv).(*map[int32]string)
5796 if *vp == nil {
5797 *vp = make(map[int32]string, decInferLen(containerLen, d.h.MaxInitLen, 20))
5798 }
5799 if containerLen != 0 {
5800 fastpathTV.DecMapInt32StringL(*vp, containerLen, d)
5801 }
5802 } else if containerLen != 0 {
5803 fastpathTV.DecMapInt32StringL(rv2i(rv).(map[int32]string), containerLen, d)
5804 }
5805 d.mapEnd()
5806 }
5807 func (f fastpathT) DecMapInt32StringX(vp *map[int32]string, d *Decoder) {
5808 containerLen := d.mapStart(d.d.ReadMapStart())
5809 if containerLen == containerLenNil {
5810 *vp = nil
5811 } else {
5812 if *vp == nil {
5813 *vp = make(map[int32]string, decInferLen(containerLen, d.h.MaxInitLen, 20))
5814 }
5815 if containerLen != 0 {
5816 f.DecMapInt32StringL(*vp, containerLen, d)
5817 }
5818 d.mapEnd()
5819 }
5820 }
5821 func (fastpathT) DecMapInt32StringL(v map[int32]string, containerLen int, d *Decoder) {
5822 if v == nil {
5823 d.errorf("cannot decode into nil map[int32]string given stream length: %v", containerLen)
5824 return
5825 }
5826 var mk int32
5827 var mv string
5828 hasLen := containerLen > 0
5829 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
5830 d.mapElemKey()
5831 mk = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
5832 d.mapElemValue()
5833 mv = d.stringZC(d.d.DecodeStringAsBytes())
5834 v[mk] = mv
5835 }
5836 }
5837 func (d *Decoder) fastpathDecMapInt32BytesR(f *codecFnInfo, rv reflect.Value) {
5838 containerLen := d.mapStart(d.d.ReadMapStart())
5839 if rv.Kind() == reflect.Ptr {
5840 vp, _ := rv2i(rv).(*map[int32][]byte)
5841 if *vp == nil {
5842 *vp = make(map[int32][]byte, decInferLen(containerLen, d.h.MaxInitLen, 28))
5843 }
5844 if containerLen != 0 {
5845 fastpathTV.DecMapInt32BytesL(*vp, containerLen, d)
5846 }
5847 } else if containerLen != 0 {
5848 fastpathTV.DecMapInt32BytesL(rv2i(rv).(map[int32][]byte), containerLen, d)
5849 }
5850 d.mapEnd()
5851 }
5852 func (f fastpathT) DecMapInt32BytesX(vp *map[int32][]byte, d *Decoder) {
5853 containerLen := d.mapStart(d.d.ReadMapStart())
5854 if containerLen == containerLenNil {
5855 *vp = nil
5856 } else {
5857 if *vp == nil {
5858 *vp = make(map[int32][]byte, decInferLen(containerLen, d.h.MaxInitLen, 28))
5859 }
5860 if containerLen != 0 {
5861 f.DecMapInt32BytesL(*vp, containerLen, d)
5862 }
5863 d.mapEnd()
5864 }
5865 }
5866 func (fastpathT) DecMapInt32BytesL(v map[int32][]byte, containerLen int, d *Decoder) {
5867 if v == nil {
5868 d.errorf("cannot decode into nil map[int32][]byte given stream length: %v", containerLen)
5869 return
5870 }
5871 mapGet := v != nil && !d.h.MapValueReset
5872 var mk int32
5873 var mv []byte
5874 hasLen := containerLen > 0
5875 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
5876 d.mapElemKey()
5877 mk = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
5878 d.mapElemValue()
5879 if mapGet {
5880 mv = v[mk]
5881 } else {
5882 mv = nil
5883 }
5884 mv = d.decodeBytesInto(mv)
5885 v[mk] = mv
5886 }
5887 }
5888 func (d *Decoder) fastpathDecMapInt32Uint8R(f *codecFnInfo, rv reflect.Value) {
5889 containerLen := d.mapStart(d.d.ReadMapStart())
5890 if rv.Kind() == reflect.Ptr {
5891 vp, _ := rv2i(rv).(*map[int32]uint8)
5892 if *vp == nil {
5893 *vp = make(map[int32]uint8, decInferLen(containerLen, d.h.MaxInitLen, 5))
5894 }
5895 if containerLen != 0 {
5896 fastpathTV.DecMapInt32Uint8L(*vp, containerLen, d)
5897 }
5898 } else if containerLen != 0 {
5899 fastpathTV.DecMapInt32Uint8L(rv2i(rv).(map[int32]uint8), containerLen, d)
5900 }
5901 d.mapEnd()
5902 }
5903 func (f fastpathT) DecMapInt32Uint8X(vp *map[int32]uint8, d *Decoder) {
5904 containerLen := d.mapStart(d.d.ReadMapStart())
5905 if containerLen == containerLenNil {
5906 *vp = nil
5907 } else {
5908 if *vp == nil {
5909 *vp = make(map[int32]uint8, decInferLen(containerLen, d.h.MaxInitLen, 5))
5910 }
5911 if containerLen != 0 {
5912 f.DecMapInt32Uint8L(*vp, containerLen, d)
5913 }
5914 d.mapEnd()
5915 }
5916 }
5917 func (fastpathT) DecMapInt32Uint8L(v map[int32]uint8, containerLen int, d *Decoder) {
5918 if v == nil {
5919 d.errorf("cannot decode into nil map[int32]uint8 given stream length: %v", containerLen)
5920 return
5921 }
5922 var mk int32
5923 var mv uint8
5924 hasLen := containerLen > 0
5925 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
5926 d.mapElemKey()
5927 mk = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
5928 d.mapElemValue()
5929 mv = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
5930 v[mk] = mv
5931 }
5932 }
5933 func (d *Decoder) fastpathDecMapInt32Uint64R(f *codecFnInfo, rv reflect.Value) {
5934 containerLen := d.mapStart(d.d.ReadMapStart())
5935 if rv.Kind() == reflect.Ptr {
5936 vp, _ := rv2i(rv).(*map[int32]uint64)
5937 if *vp == nil {
5938 *vp = make(map[int32]uint64, decInferLen(containerLen, d.h.MaxInitLen, 12))
5939 }
5940 if containerLen != 0 {
5941 fastpathTV.DecMapInt32Uint64L(*vp, containerLen, d)
5942 }
5943 } else if containerLen != 0 {
5944 fastpathTV.DecMapInt32Uint64L(rv2i(rv).(map[int32]uint64), containerLen, d)
5945 }
5946 d.mapEnd()
5947 }
5948 func (f fastpathT) DecMapInt32Uint64X(vp *map[int32]uint64, d *Decoder) {
5949 containerLen := d.mapStart(d.d.ReadMapStart())
5950 if containerLen == containerLenNil {
5951 *vp = nil
5952 } else {
5953 if *vp == nil {
5954 *vp = make(map[int32]uint64, decInferLen(containerLen, d.h.MaxInitLen, 12))
5955 }
5956 if containerLen != 0 {
5957 f.DecMapInt32Uint64L(*vp, containerLen, d)
5958 }
5959 d.mapEnd()
5960 }
5961 }
5962 func (fastpathT) DecMapInt32Uint64L(v map[int32]uint64, containerLen int, d *Decoder) {
5963 if v == nil {
5964 d.errorf("cannot decode into nil map[int32]uint64 given stream length: %v", containerLen)
5965 return
5966 }
5967 var mk int32
5968 var mv uint64
5969 hasLen := containerLen > 0
5970 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
5971 d.mapElemKey()
5972 mk = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
5973 d.mapElemValue()
5974 mv = d.d.DecodeUint64()
5975 v[mk] = mv
5976 }
5977 }
5978 func (d *Decoder) fastpathDecMapInt32IntR(f *codecFnInfo, rv reflect.Value) {
5979 containerLen := d.mapStart(d.d.ReadMapStart())
5980 if rv.Kind() == reflect.Ptr {
5981 vp, _ := rv2i(rv).(*map[int32]int)
5982 if *vp == nil {
5983 *vp = make(map[int32]int, decInferLen(containerLen, d.h.MaxInitLen, 12))
5984 }
5985 if containerLen != 0 {
5986 fastpathTV.DecMapInt32IntL(*vp, containerLen, d)
5987 }
5988 } else if containerLen != 0 {
5989 fastpathTV.DecMapInt32IntL(rv2i(rv).(map[int32]int), containerLen, d)
5990 }
5991 d.mapEnd()
5992 }
5993 func (f fastpathT) DecMapInt32IntX(vp *map[int32]int, d *Decoder) {
5994 containerLen := d.mapStart(d.d.ReadMapStart())
5995 if containerLen == containerLenNil {
5996 *vp = nil
5997 } else {
5998 if *vp == nil {
5999 *vp = make(map[int32]int, decInferLen(containerLen, d.h.MaxInitLen, 12))
6000 }
6001 if containerLen != 0 {
6002 f.DecMapInt32IntL(*vp, containerLen, d)
6003 }
6004 d.mapEnd()
6005 }
6006 }
6007 func (fastpathT) DecMapInt32IntL(v map[int32]int, containerLen int, d *Decoder) {
6008 if v == nil {
6009 d.errorf("cannot decode into nil map[int32]int given stream length: %v", containerLen)
6010 return
6011 }
6012 var mk int32
6013 var mv int
6014 hasLen := containerLen > 0
6015 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
6016 d.mapElemKey()
6017 mk = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
6018 d.mapElemValue()
6019 mv = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
6020 v[mk] = mv
6021 }
6022 }
6023 func (d *Decoder) fastpathDecMapInt32Int32R(f *codecFnInfo, rv reflect.Value) {
6024 containerLen := d.mapStart(d.d.ReadMapStart())
6025 if rv.Kind() == reflect.Ptr {
6026 vp, _ := rv2i(rv).(*map[int32]int32)
6027 if *vp == nil {
6028 *vp = make(map[int32]int32, decInferLen(containerLen, d.h.MaxInitLen, 8))
6029 }
6030 if containerLen != 0 {
6031 fastpathTV.DecMapInt32Int32L(*vp, containerLen, d)
6032 }
6033 } else if containerLen != 0 {
6034 fastpathTV.DecMapInt32Int32L(rv2i(rv).(map[int32]int32), containerLen, d)
6035 }
6036 d.mapEnd()
6037 }
6038 func (f fastpathT) DecMapInt32Int32X(vp *map[int32]int32, d *Decoder) {
6039 containerLen := d.mapStart(d.d.ReadMapStart())
6040 if containerLen == containerLenNil {
6041 *vp = nil
6042 } else {
6043 if *vp == nil {
6044 *vp = make(map[int32]int32, decInferLen(containerLen, d.h.MaxInitLen, 8))
6045 }
6046 if containerLen != 0 {
6047 f.DecMapInt32Int32L(*vp, containerLen, d)
6048 }
6049 d.mapEnd()
6050 }
6051 }
6052 func (fastpathT) DecMapInt32Int32L(v map[int32]int32, containerLen int, d *Decoder) {
6053 if v == nil {
6054 d.errorf("cannot decode into nil map[int32]int32 given stream length: %v", containerLen)
6055 return
6056 }
6057 var mk int32
6058 var mv int32
6059 hasLen := containerLen > 0
6060 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
6061 d.mapElemKey()
6062 mk = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
6063 d.mapElemValue()
6064 mv = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
6065 v[mk] = mv
6066 }
6067 }
6068 func (d *Decoder) fastpathDecMapInt32Float64R(f *codecFnInfo, rv reflect.Value) {
6069 containerLen := d.mapStart(d.d.ReadMapStart())
6070 if rv.Kind() == reflect.Ptr {
6071 vp, _ := rv2i(rv).(*map[int32]float64)
6072 if *vp == nil {
6073 *vp = make(map[int32]float64, decInferLen(containerLen, d.h.MaxInitLen, 12))
6074 }
6075 if containerLen != 0 {
6076 fastpathTV.DecMapInt32Float64L(*vp, containerLen, d)
6077 }
6078 } else if containerLen != 0 {
6079 fastpathTV.DecMapInt32Float64L(rv2i(rv).(map[int32]float64), containerLen, d)
6080 }
6081 d.mapEnd()
6082 }
6083 func (f fastpathT) DecMapInt32Float64X(vp *map[int32]float64, d *Decoder) {
6084 containerLen := d.mapStart(d.d.ReadMapStart())
6085 if containerLen == containerLenNil {
6086 *vp = nil
6087 } else {
6088 if *vp == nil {
6089 *vp = make(map[int32]float64, decInferLen(containerLen, d.h.MaxInitLen, 12))
6090 }
6091 if containerLen != 0 {
6092 f.DecMapInt32Float64L(*vp, containerLen, d)
6093 }
6094 d.mapEnd()
6095 }
6096 }
6097 func (fastpathT) DecMapInt32Float64L(v map[int32]float64, containerLen int, d *Decoder) {
6098 if v == nil {
6099 d.errorf("cannot decode into nil map[int32]float64 given stream length: %v", containerLen)
6100 return
6101 }
6102 var mk int32
6103 var mv float64
6104 hasLen := containerLen > 0
6105 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
6106 d.mapElemKey()
6107 mk = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
6108 d.mapElemValue()
6109 mv = d.d.DecodeFloat64()
6110 v[mk] = mv
6111 }
6112 }
6113 func (d *Decoder) fastpathDecMapInt32BoolR(f *codecFnInfo, rv reflect.Value) {
6114 containerLen := d.mapStart(d.d.ReadMapStart())
6115 if rv.Kind() == reflect.Ptr {
6116 vp, _ := rv2i(rv).(*map[int32]bool)
6117 if *vp == nil {
6118 *vp = make(map[int32]bool, decInferLen(containerLen, d.h.MaxInitLen, 5))
6119 }
6120 if containerLen != 0 {
6121 fastpathTV.DecMapInt32BoolL(*vp, containerLen, d)
6122 }
6123 } else if containerLen != 0 {
6124 fastpathTV.DecMapInt32BoolL(rv2i(rv).(map[int32]bool), containerLen, d)
6125 }
6126 d.mapEnd()
6127 }
6128 func (f fastpathT) DecMapInt32BoolX(vp *map[int32]bool, d *Decoder) {
6129 containerLen := d.mapStart(d.d.ReadMapStart())
6130 if containerLen == containerLenNil {
6131 *vp = nil
6132 } else {
6133 if *vp == nil {
6134 *vp = make(map[int32]bool, decInferLen(containerLen, d.h.MaxInitLen, 5))
6135 }
6136 if containerLen != 0 {
6137 f.DecMapInt32BoolL(*vp, containerLen, d)
6138 }
6139 d.mapEnd()
6140 }
6141 }
6142 func (fastpathT) DecMapInt32BoolL(v map[int32]bool, containerLen int, d *Decoder) {
6143 if v == nil {
6144 d.errorf("cannot decode into nil map[int32]bool given stream length: %v", containerLen)
6145 return
6146 }
6147 var mk int32
6148 var mv bool
6149 hasLen := containerLen > 0
6150 for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
6151 d.mapElemKey()
6152 mk = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
6153 d.mapElemValue()
6154 mv = d.d.DecodeBool()
6155 v[mk] = mv
6156 }
6157 }
6158
View as plain text