3 // Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
4 // Use of this source code is governed by a MIT license found in the LICENSE file.
6 // Code generated from fast-path.go.tmpl - DO NOT EDIT.
10 // Fast path functions try to create a fast path encode or decode implementation
11 // for common maps and slices.
13 // We define the functions and register then in this single file
14 // so as not to pollute the encode.go and decode.go, and create a dependency in there.
15 // This file can be omitted without causing a build failure.
17 // The advantage of fast paths is:
18 // - Many calls bypass reflection altogether
21 // - slice of all builtin types,
22 // - map of all builtin types to string or interface value
23 // - symmetrical maps of all builtin types (e.g. str-str, uint8-uint8)
24 // This should provide adequate "typical" implementations.
26 // Note that fast track decode functions must handle values for which an address cannot be obtained.
28 // m2 := map[string]int{}
29 // p2 := []interface{}{m2}
30 // // decoding into p2 will bomb if fast track functions do not treat like unaddressable.
38 const fastpathEnabled = true
40 type fastpathT struct{}
42 var fastpathTV fastpathT
44 type fastpathE struct {
47 encfn func(*Encoder, *codecFnInfo, reflect.Value)
48 decfn func(*Decoder, *codecFnInfo, reflect.Value)
51 type fastpathA [271]fastpathE
53 func (x *fastpathA) index(rtid uintptr) int {
54 // use binary search to grab the index (adapted from sort/search.go)
55 h, i, j := 0, 0, 271 // len(x)
64 if i < 271 && x[i].rtid == rtid {
70 type fastpathAslice []fastpathE
72 func (x fastpathAslice) Len() int { return len(x) }
73 func (x fastpathAslice) Less(i, j int) bool { return x[i].rtid < x[j].rtid }
74 func (x fastpathAslice) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
76 var fastpathAV fastpathA
78 // due to possible initialization loop error, make fastpath in an init()
81 fn := func(v interface{},
82 fe func(*Encoder, *codecFnInfo, reflect.Value),
83 fd func(*Decoder, *codecFnInfo, reflect.Value)) (f fastpathE) {
84 xrt := reflect.TypeOf(v)
86 fastpathAV[i] = fastpathE{xptr, xrt, fe, fd}
91 fn([]interface{}(nil), (*Encoder).fastpathEncSliceIntfR, (*Decoder).fastpathDecSliceIntfR)
92 fn([]string(nil), (*Encoder).fastpathEncSliceStringR, (*Decoder).fastpathDecSliceStringR)
93 fn([]float32(nil), (*Encoder).fastpathEncSliceFloat32R, (*Decoder).fastpathDecSliceFloat32R)
94 fn([]float64(nil), (*Encoder).fastpathEncSliceFloat64R, (*Decoder).fastpathDecSliceFloat64R)
95 fn([]uint(nil), (*Encoder).fastpathEncSliceUintR, (*Decoder).fastpathDecSliceUintR)
96 fn([]uint16(nil), (*Encoder).fastpathEncSliceUint16R, (*Decoder).fastpathDecSliceUint16R)
97 fn([]uint32(nil), (*Encoder).fastpathEncSliceUint32R, (*Decoder).fastpathDecSliceUint32R)
98 fn([]uint64(nil), (*Encoder).fastpathEncSliceUint64R, (*Decoder).fastpathDecSliceUint64R)
99 fn([]uintptr(nil), (*Encoder).fastpathEncSliceUintptrR, (*Decoder).fastpathDecSliceUintptrR)
100 fn([]int(nil), (*Encoder).fastpathEncSliceIntR, (*Decoder).fastpathDecSliceIntR)
101 fn([]int8(nil), (*Encoder).fastpathEncSliceInt8R, (*Decoder).fastpathDecSliceInt8R)
102 fn([]int16(nil), (*Encoder).fastpathEncSliceInt16R, (*Decoder).fastpathDecSliceInt16R)
103 fn([]int32(nil), (*Encoder).fastpathEncSliceInt32R, (*Decoder).fastpathDecSliceInt32R)
104 fn([]int64(nil), (*Encoder).fastpathEncSliceInt64R, (*Decoder).fastpathDecSliceInt64R)
105 fn([]bool(nil), (*Encoder).fastpathEncSliceBoolR, (*Decoder).fastpathDecSliceBoolR)
107 fn(map[interface{}]interface{}(nil), (*Encoder).fastpathEncMapIntfIntfR, (*Decoder).fastpathDecMapIntfIntfR)
108 fn(map[interface{}]string(nil), (*Encoder).fastpathEncMapIntfStringR, (*Decoder).fastpathDecMapIntfStringR)
109 fn(map[interface{}]uint(nil), (*Encoder).fastpathEncMapIntfUintR, (*Decoder).fastpathDecMapIntfUintR)
110 fn(map[interface{}]uint8(nil), (*Encoder).fastpathEncMapIntfUint8R, (*Decoder).fastpathDecMapIntfUint8R)
111 fn(map[interface{}]uint16(nil), (*Encoder).fastpathEncMapIntfUint16R, (*Decoder).fastpathDecMapIntfUint16R)
112 fn(map[interface{}]uint32(nil), (*Encoder).fastpathEncMapIntfUint32R, (*Decoder).fastpathDecMapIntfUint32R)
113 fn(map[interface{}]uint64(nil), (*Encoder).fastpathEncMapIntfUint64R, (*Decoder).fastpathDecMapIntfUint64R)
114 fn(map[interface{}]uintptr(nil), (*Encoder).fastpathEncMapIntfUintptrR, (*Decoder).fastpathDecMapIntfUintptrR)
115 fn(map[interface{}]int(nil), (*Encoder).fastpathEncMapIntfIntR, (*Decoder).fastpathDecMapIntfIntR)
116 fn(map[interface{}]int8(nil), (*Encoder).fastpathEncMapIntfInt8R, (*Decoder).fastpathDecMapIntfInt8R)
117 fn(map[interface{}]int16(nil), (*Encoder).fastpathEncMapIntfInt16R, (*Decoder).fastpathDecMapIntfInt16R)
118 fn(map[interface{}]int32(nil), (*Encoder).fastpathEncMapIntfInt32R, (*Decoder).fastpathDecMapIntfInt32R)
119 fn(map[interface{}]int64(nil), (*Encoder).fastpathEncMapIntfInt64R, (*Decoder).fastpathDecMapIntfInt64R)
120 fn(map[interface{}]float32(nil), (*Encoder).fastpathEncMapIntfFloat32R, (*Decoder).fastpathDecMapIntfFloat32R)
121 fn(map[interface{}]float64(nil), (*Encoder).fastpathEncMapIntfFloat64R, (*Decoder).fastpathDecMapIntfFloat64R)
122 fn(map[interface{}]bool(nil), (*Encoder).fastpathEncMapIntfBoolR, (*Decoder).fastpathDecMapIntfBoolR)
123 fn(map[string]interface{}(nil), (*Encoder).fastpathEncMapStringIntfR, (*Decoder).fastpathDecMapStringIntfR)
124 fn(map[string]string(nil), (*Encoder).fastpathEncMapStringStringR, (*Decoder).fastpathDecMapStringStringR)
125 fn(map[string]uint(nil), (*Encoder).fastpathEncMapStringUintR, (*Decoder).fastpathDecMapStringUintR)
126 fn(map[string]uint8(nil), (*Encoder).fastpathEncMapStringUint8R, (*Decoder).fastpathDecMapStringUint8R)
127 fn(map[string]uint16(nil), (*Encoder).fastpathEncMapStringUint16R, (*Decoder).fastpathDecMapStringUint16R)
128 fn(map[string]uint32(nil), (*Encoder).fastpathEncMapStringUint32R, (*Decoder).fastpathDecMapStringUint32R)
129 fn(map[string]uint64(nil), (*Encoder).fastpathEncMapStringUint64R, (*Decoder).fastpathDecMapStringUint64R)
130 fn(map[string]uintptr(nil), (*Encoder).fastpathEncMapStringUintptrR, (*Decoder).fastpathDecMapStringUintptrR)
131 fn(map[string]int(nil), (*Encoder).fastpathEncMapStringIntR, (*Decoder).fastpathDecMapStringIntR)
132 fn(map[string]int8(nil), (*Encoder).fastpathEncMapStringInt8R, (*Decoder).fastpathDecMapStringInt8R)
133 fn(map[string]int16(nil), (*Encoder).fastpathEncMapStringInt16R, (*Decoder).fastpathDecMapStringInt16R)
134 fn(map[string]int32(nil), (*Encoder).fastpathEncMapStringInt32R, (*Decoder).fastpathDecMapStringInt32R)
135 fn(map[string]int64(nil), (*Encoder).fastpathEncMapStringInt64R, (*Decoder).fastpathDecMapStringInt64R)
136 fn(map[string]float32(nil), (*Encoder).fastpathEncMapStringFloat32R, (*Decoder).fastpathDecMapStringFloat32R)
137 fn(map[string]float64(nil), (*Encoder).fastpathEncMapStringFloat64R, (*Decoder).fastpathDecMapStringFloat64R)
138 fn(map[string]bool(nil), (*Encoder).fastpathEncMapStringBoolR, (*Decoder).fastpathDecMapStringBoolR)
139 fn(map[float32]interface{}(nil), (*Encoder).fastpathEncMapFloat32IntfR, (*Decoder).fastpathDecMapFloat32IntfR)
140 fn(map[float32]string(nil), (*Encoder).fastpathEncMapFloat32StringR, (*Decoder).fastpathDecMapFloat32StringR)
141 fn(map[float32]uint(nil), (*Encoder).fastpathEncMapFloat32UintR, (*Decoder).fastpathDecMapFloat32UintR)
142 fn(map[float32]uint8(nil), (*Encoder).fastpathEncMapFloat32Uint8R, (*Decoder).fastpathDecMapFloat32Uint8R)
143 fn(map[float32]uint16(nil), (*Encoder).fastpathEncMapFloat32Uint16R, (*Decoder).fastpathDecMapFloat32Uint16R)
144 fn(map[float32]uint32(nil), (*Encoder).fastpathEncMapFloat32Uint32R, (*Decoder).fastpathDecMapFloat32Uint32R)
145 fn(map[float32]uint64(nil), (*Encoder).fastpathEncMapFloat32Uint64R, (*Decoder).fastpathDecMapFloat32Uint64R)
146 fn(map[float32]uintptr(nil), (*Encoder).fastpathEncMapFloat32UintptrR, (*Decoder).fastpathDecMapFloat32UintptrR)
147 fn(map[float32]int(nil), (*Encoder).fastpathEncMapFloat32IntR, (*Decoder).fastpathDecMapFloat32IntR)
148 fn(map[float32]int8(nil), (*Encoder).fastpathEncMapFloat32Int8R, (*Decoder).fastpathDecMapFloat32Int8R)
149 fn(map[float32]int16(nil), (*Encoder).fastpathEncMapFloat32Int16R, (*Decoder).fastpathDecMapFloat32Int16R)
150 fn(map[float32]int32(nil), (*Encoder).fastpathEncMapFloat32Int32R, (*Decoder).fastpathDecMapFloat32Int32R)
151 fn(map[float32]int64(nil), (*Encoder).fastpathEncMapFloat32Int64R, (*Decoder).fastpathDecMapFloat32Int64R)
152 fn(map[float32]float32(nil), (*Encoder).fastpathEncMapFloat32Float32R, (*Decoder).fastpathDecMapFloat32Float32R)
153 fn(map[float32]float64(nil), (*Encoder).fastpathEncMapFloat32Float64R, (*Decoder).fastpathDecMapFloat32Float64R)
154 fn(map[float32]bool(nil), (*Encoder).fastpathEncMapFloat32BoolR, (*Decoder).fastpathDecMapFloat32BoolR)
155 fn(map[float64]interface{}(nil), (*Encoder).fastpathEncMapFloat64IntfR, (*Decoder).fastpathDecMapFloat64IntfR)
156 fn(map[float64]string(nil), (*Encoder).fastpathEncMapFloat64StringR, (*Decoder).fastpathDecMapFloat64StringR)
157 fn(map[float64]uint(nil), (*Encoder).fastpathEncMapFloat64UintR, (*Decoder).fastpathDecMapFloat64UintR)
158 fn(map[float64]uint8(nil), (*Encoder).fastpathEncMapFloat64Uint8R, (*Decoder).fastpathDecMapFloat64Uint8R)
159 fn(map[float64]uint16(nil), (*Encoder).fastpathEncMapFloat64Uint16R, (*Decoder).fastpathDecMapFloat64Uint16R)
160 fn(map[float64]uint32(nil), (*Encoder).fastpathEncMapFloat64Uint32R, (*Decoder).fastpathDecMapFloat64Uint32R)
161 fn(map[float64]uint64(nil), (*Encoder).fastpathEncMapFloat64Uint64R, (*Decoder).fastpathDecMapFloat64Uint64R)
162 fn(map[float64]uintptr(nil), (*Encoder).fastpathEncMapFloat64UintptrR, (*Decoder).fastpathDecMapFloat64UintptrR)
163 fn(map[float64]int(nil), (*Encoder).fastpathEncMapFloat64IntR, (*Decoder).fastpathDecMapFloat64IntR)
164 fn(map[float64]int8(nil), (*Encoder).fastpathEncMapFloat64Int8R, (*Decoder).fastpathDecMapFloat64Int8R)
165 fn(map[float64]int16(nil), (*Encoder).fastpathEncMapFloat64Int16R, (*Decoder).fastpathDecMapFloat64Int16R)
166 fn(map[float64]int32(nil), (*Encoder).fastpathEncMapFloat64Int32R, (*Decoder).fastpathDecMapFloat64Int32R)
167 fn(map[float64]int64(nil), (*Encoder).fastpathEncMapFloat64Int64R, (*Decoder).fastpathDecMapFloat64Int64R)
168 fn(map[float64]float32(nil), (*Encoder).fastpathEncMapFloat64Float32R, (*Decoder).fastpathDecMapFloat64Float32R)
169 fn(map[float64]float64(nil), (*Encoder).fastpathEncMapFloat64Float64R, (*Decoder).fastpathDecMapFloat64Float64R)
170 fn(map[float64]bool(nil), (*Encoder).fastpathEncMapFloat64BoolR, (*Decoder).fastpathDecMapFloat64BoolR)
171 fn(map[uint]interface{}(nil), (*Encoder).fastpathEncMapUintIntfR, (*Decoder).fastpathDecMapUintIntfR)
172 fn(map[uint]string(nil), (*Encoder).fastpathEncMapUintStringR, (*Decoder).fastpathDecMapUintStringR)
173 fn(map[uint]uint(nil), (*Encoder).fastpathEncMapUintUintR, (*Decoder).fastpathDecMapUintUintR)
174 fn(map[uint]uint8(nil), (*Encoder).fastpathEncMapUintUint8R, (*Decoder).fastpathDecMapUintUint8R)
175 fn(map[uint]uint16(nil), (*Encoder).fastpathEncMapUintUint16R, (*Decoder).fastpathDecMapUintUint16R)
176 fn(map[uint]uint32(nil), (*Encoder).fastpathEncMapUintUint32R, (*Decoder).fastpathDecMapUintUint32R)
177 fn(map[uint]uint64(nil), (*Encoder).fastpathEncMapUintUint64R, (*Decoder).fastpathDecMapUintUint64R)
178 fn(map[uint]uintptr(nil), (*Encoder).fastpathEncMapUintUintptrR, (*Decoder).fastpathDecMapUintUintptrR)
179 fn(map[uint]int(nil), (*Encoder).fastpathEncMapUintIntR, (*Decoder).fastpathDecMapUintIntR)
180 fn(map[uint]int8(nil), (*Encoder).fastpathEncMapUintInt8R, (*Decoder).fastpathDecMapUintInt8R)
181 fn(map[uint]int16(nil), (*Encoder).fastpathEncMapUintInt16R, (*Decoder).fastpathDecMapUintInt16R)
182 fn(map[uint]int32(nil), (*Encoder).fastpathEncMapUintInt32R, (*Decoder).fastpathDecMapUintInt32R)
183 fn(map[uint]int64(nil), (*Encoder).fastpathEncMapUintInt64R, (*Decoder).fastpathDecMapUintInt64R)
184 fn(map[uint]float32(nil), (*Encoder).fastpathEncMapUintFloat32R, (*Decoder).fastpathDecMapUintFloat32R)
185 fn(map[uint]float64(nil), (*Encoder).fastpathEncMapUintFloat64R, (*Decoder).fastpathDecMapUintFloat64R)
186 fn(map[uint]bool(nil), (*Encoder).fastpathEncMapUintBoolR, (*Decoder).fastpathDecMapUintBoolR)
187 fn(map[uint8]interface{}(nil), (*Encoder).fastpathEncMapUint8IntfR, (*Decoder).fastpathDecMapUint8IntfR)
188 fn(map[uint8]string(nil), (*Encoder).fastpathEncMapUint8StringR, (*Decoder).fastpathDecMapUint8StringR)
189 fn(map[uint8]uint(nil), (*Encoder).fastpathEncMapUint8UintR, (*Decoder).fastpathDecMapUint8UintR)
190 fn(map[uint8]uint8(nil), (*Encoder).fastpathEncMapUint8Uint8R, (*Decoder).fastpathDecMapUint8Uint8R)
191 fn(map[uint8]uint16(nil), (*Encoder).fastpathEncMapUint8Uint16R, (*Decoder).fastpathDecMapUint8Uint16R)
192 fn(map[uint8]uint32(nil), (*Encoder).fastpathEncMapUint8Uint32R, (*Decoder).fastpathDecMapUint8Uint32R)
193 fn(map[uint8]uint64(nil), (*Encoder).fastpathEncMapUint8Uint64R, (*Decoder).fastpathDecMapUint8Uint64R)
194 fn(map[uint8]uintptr(nil), (*Encoder).fastpathEncMapUint8UintptrR, (*Decoder).fastpathDecMapUint8UintptrR)
195 fn(map[uint8]int(nil), (*Encoder).fastpathEncMapUint8IntR, (*Decoder).fastpathDecMapUint8IntR)
196 fn(map[uint8]int8(nil), (*Encoder).fastpathEncMapUint8Int8R, (*Decoder).fastpathDecMapUint8Int8R)
197 fn(map[uint8]int16(nil), (*Encoder).fastpathEncMapUint8Int16R, (*Decoder).fastpathDecMapUint8Int16R)
198 fn(map[uint8]int32(nil), (*Encoder).fastpathEncMapUint8Int32R, (*Decoder).fastpathDecMapUint8Int32R)
199 fn(map[uint8]int64(nil), (*Encoder).fastpathEncMapUint8Int64R, (*Decoder).fastpathDecMapUint8Int64R)
200 fn(map[uint8]float32(nil), (*Encoder).fastpathEncMapUint8Float32R, (*Decoder).fastpathDecMapUint8Float32R)
201 fn(map[uint8]float64(nil), (*Encoder).fastpathEncMapUint8Float64R, (*Decoder).fastpathDecMapUint8Float64R)
202 fn(map[uint8]bool(nil), (*Encoder).fastpathEncMapUint8BoolR, (*Decoder).fastpathDecMapUint8BoolR)
203 fn(map[uint16]interface{}(nil), (*Encoder).fastpathEncMapUint16IntfR, (*Decoder).fastpathDecMapUint16IntfR)
204 fn(map[uint16]string(nil), (*Encoder).fastpathEncMapUint16StringR, (*Decoder).fastpathDecMapUint16StringR)
205 fn(map[uint16]uint(nil), (*Encoder).fastpathEncMapUint16UintR, (*Decoder).fastpathDecMapUint16UintR)
206 fn(map[uint16]uint8(nil), (*Encoder).fastpathEncMapUint16Uint8R, (*Decoder).fastpathDecMapUint16Uint8R)
207 fn(map[uint16]uint16(nil), (*Encoder).fastpathEncMapUint16Uint16R, (*Decoder).fastpathDecMapUint16Uint16R)
208 fn(map[uint16]uint32(nil), (*Encoder).fastpathEncMapUint16Uint32R, (*Decoder).fastpathDecMapUint16Uint32R)
209 fn(map[uint16]uint64(nil), (*Encoder).fastpathEncMapUint16Uint64R, (*Decoder).fastpathDecMapUint16Uint64R)
210 fn(map[uint16]uintptr(nil), (*Encoder).fastpathEncMapUint16UintptrR, (*Decoder).fastpathDecMapUint16UintptrR)
211 fn(map[uint16]int(nil), (*Encoder).fastpathEncMapUint16IntR, (*Decoder).fastpathDecMapUint16IntR)
212 fn(map[uint16]int8(nil), (*Encoder).fastpathEncMapUint16Int8R, (*Decoder).fastpathDecMapUint16Int8R)
213 fn(map[uint16]int16(nil), (*Encoder).fastpathEncMapUint16Int16R, (*Decoder).fastpathDecMapUint16Int16R)
214 fn(map[uint16]int32(nil), (*Encoder).fastpathEncMapUint16Int32R, (*Decoder).fastpathDecMapUint16Int32R)
215 fn(map[uint16]int64(nil), (*Encoder).fastpathEncMapUint16Int64R, (*Decoder).fastpathDecMapUint16Int64R)
216 fn(map[uint16]float32(nil), (*Encoder).fastpathEncMapUint16Float32R, (*Decoder).fastpathDecMapUint16Float32R)
217 fn(map[uint16]float64(nil), (*Encoder).fastpathEncMapUint16Float64R, (*Decoder).fastpathDecMapUint16Float64R)
218 fn(map[uint16]bool(nil), (*Encoder).fastpathEncMapUint16BoolR, (*Decoder).fastpathDecMapUint16BoolR)
219 fn(map[uint32]interface{}(nil), (*Encoder).fastpathEncMapUint32IntfR, (*Decoder).fastpathDecMapUint32IntfR)
220 fn(map[uint32]string(nil), (*Encoder).fastpathEncMapUint32StringR, (*Decoder).fastpathDecMapUint32StringR)
221 fn(map[uint32]uint(nil), (*Encoder).fastpathEncMapUint32UintR, (*Decoder).fastpathDecMapUint32UintR)
222 fn(map[uint32]uint8(nil), (*Encoder).fastpathEncMapUint32Uint8R, (*Decoder).fastpathDecMapUint32Uint8R)
223 fn(map[uint32]uint16(nil), (*Encoder).fastpathEncMapUint32Uint16R, (*Decoder).fastpathDecMapUint32Uint16R)
224 fn(map[uint32]uint32(nil), (*Encoder).fastpathEncMapUint32Uint32R, (*Decoder).fastpathDecMapUint32Uint32R)
225 fn(map[uint32]uint64(nil), (*Encoder).fastpathEncMapUint32Uint64R, (*Decoder).fastpathDecMapUint32Uint64R)
226 fn(map[uint32]uintptr(nil), (*Encoder).fastpathEncMapUint32UintptrR, (*Decoder).fastpathDecMapUint32UintptrR)
227 fn(map[uint32]int(nil), (*Encoder).fastpathEncMapUint32IntR, (*Decoder).fastpathDecMapUint32IntR)
228 fn(map[uint32]int8(nil), (*Encoder).fastpathEncMapUint32Int8R, (*Decoder).fastpathDecMapUint32Int8R)
229 fn(map[uint32]int16(nil), (*Encoder).fastpathEncMapUint32Int16R, (*Decoder).fastpathDecMapUint32Int16R)
230 fn(map[uint32]int32(nil), (*Encoder).fastpathEncMapUint32Int32R, (*Decoder).fastpathDecMapUint32Int32R)
231 fn(map[uint32]int64(nil), (*Encoder).fastpathEncMapUint32Int64R, (*Decoder).fastpathDecMapUint32Int64R)
232 fn(map[uint32]float32(nil), (*Encoder).fastpathEncMapUint32Float32R, (*Decoder).fastpathDecMapUint32Float32R)
233 fn(map[uint32]float64(nil), (*Encoder).fastpathEncMapUint32Float64R, (*Decoder).fastpathDecMapUint32Float64R)
234 fn(map[uint32]bool(nil), (*Encoder).fastpathEncMapUint32BoolR, (*Decoder).fastpathDecMapUint32BoolR)
235 fn(map[uint64]interface{}(nil), (*Encoder).fastpathEncMapUint64IntfR, (*Decoder).fastpathDecMapUint64IntfR)
236 fn(map[uint64]string(nil), (*Encoder).fastpathEncMapUint64StringR, (*Decoder).fastpathDecMapUint64StringR)
237 fn(map[uint64]uint(nil), (*Encoder).fastpathEncMapUint64UintR, (*Decoder).fastpathDecMapUint64UintR)
238 fn(map[uint64]uint8(nil), (*Encoder).fastpathEncMapUint64Uint8R, (*Decoder).fastpathDecMapUint64Uint8R)
239 fn(map[uint64]uint16(nil), (*Encoder).fastpathEncMapUint64Uint16R, (*Decoder).fastpathDecMapUint64Uint16R)
240 fn(map[uint64]uint32(nil), (*Encoder).fastpathEncMapUint64Uint32R, (*Decoder).fastpathDecMapUint64Uint32R)
241 fn(map[uint64]uint64(nil), (*Encoder).fastpathEncMapUint64Uint64R, (*Decoder).fastpathDecMapUint64Uint64R)
242 fn(map[uint64]uintptr(nil), (*Encoder).fastpathEncMapUint64UintptrR, (*Decoder).fastpathDecMapUint64UintptrR)
243 fn(map[uint64]int(nil), (*Encoder).fastpathEncMapUint64IntR, (*Decoder).fastpathDecMapUint64IntR)
244 fn(map[uint64]int8(nil), (*Encoder).fastpathEncMapUint64Int8R, (*Decoder).fastpathDecMapUint64Int8R)
245 fn(map[uint64]int16(nil), (*Encoder).fastpathEncMapUint64Int16R, (*Decoder).fastpathDecMapUint64Int16R)
246 fn(map[uint64]int32(nil), (*Encoder).fastpathEncMapUint64Int32R, (*Decoder).fastpathDecMapUint64Int32R)
247 fn(map[uint64]int64(nil), (*Encoder).fastpathEncMapUint64Int64R, (*Decoder).fastpathDecMapUint64Int64R)
248 fn(map[uint64]float32(nil), (*Encoder).fastpathEncMapUint64Float32R, (*Decoder).fastpathDecMapUint64Float32R)
249 fn(map[uint64]float64(nil), (*Encoder).fastpathEncMapUint64Float64R, (*Decoder).fastpathDecMapUint64Float64R)
250 fn(map[uint64]bool(nil), (*Encoder).fastpathEncMapUint64BoolR, (*Decoder).fastpathDecMapUint64BoolR)
251 fn(map[uintptr]interface{}(nil), (*Encoder).fastpathEncMapUintptrIntfR, (*Decoder).fastpathDecMapUintptrIntfR)
252 fn(map[uintptr]string(nil), (*Encoder).fastpathEncMapUintptrStringR, (*Decoder).fastpathDecMapUintptrStringR)
253 fn(map[uintptr]uint(nil), (*Encoder).fastpathEncMapUintptrUintR, (*Decoder).fastpathDecMapUintptrUintR)
254 fn(map[uintptr]uint8(nil), (*Encoder).fastpathEncMapUintptrUint8R, (*Decoder).fastpathDecMapUintptrUint8R)
255 fn(map[uintptr]uint16(nil), (*Encoder).fastpathEncMapUintptrUint16R, (*Decoder).fastpathDecMapUintptrUint16R)
256 fn(map[uintptr]uint32(nil), (*Encoder).fastpathEncMapUintptrUint32R, (*Decoder).fastpathDecMapUintptrUint32R)
257 fn(map[uintptr]uint64(nil), (*Encoder).fastpathEncMapUintptrUint64R, (*Decoder).fastpathDecMapUintptrUint64R)
258 fn(map[uintptr]uintptr(nil), (*Encoder).fastpathEncMapUintptrUintptrR, (*Decoder).fastpathDecMapUintptrUintptrR)
259 fn(map[uintptr]int(nil), (*Encoder).fastpathEncMapUintptrIntR, (*Decoder).fastpathDecMapUintptrIntR)
260 fn(map[uintptr]int8(nil), (*Encoder).fastpathEncMapUintptrInt8R, (*Decoder).fastpathDecMapUintptrInt8R)
261 fn(map[uintptr]int16(nil), (*Encoder).fastpathEncMapUintptrInt16R, (*Decoder).fastpathDecMapUintptrInt16R)
262 fn(map[uintptr]int32(nil), (*Encoder).fastpathEncMapUintptrInt32R, (*Decoder).fastpathDecMapUintptrInt32R)
263 fn(map[uintptr]int64(nil), (*Encoder).fastpathEncMapUintptrInt64R, (*Decoder).fastpathDecMapUintptrInt64R)
264 fn(map[uintptr]float32(nil), (*Encoder).fastpathEncMapUintptrFloat32R, (*Decoder).fastpathDecMapUintptrFloat32R)
265 fn(map[uintptr]float64(nil), (*Encoder).fastpathEncMapUintptrFloat64R, (*Decoder).fastpathDecMapUintptrFloat64R)
266 fn(map[uintptr]bool(nil), (*Encoder).fastpathEncMapUintptrBoolR, (*Decoder).fastpathDecMapUintptrBoolR)
267 fn(map[int]interface{}(nil), (*Encoder).fastpathEncMapIntIntfR, (*Decoder).fastpathDecMapIntIntfR)
268 fn(map[int]string(nil), (*Encoder).fastpathEncMapIntStringR, (*Decoder).fastpathDecMapIntStringR)
269 fn(map[int]uint(nil), (*Encoder).fastpathEncMapIntUintR, (*Decoder).fastpathDecMapIntUintR)
270 fn(map[int]uint8(nil), (*Encoder).fastpathEncMapIntUint8R, (*Decoder).fastpathDecMapIntUint8R)
271 fn(map[int]uint16(nil), (*Encoder).fastpathEncMapIntUint16R, (*Decoder).fastpathDecMapIntUint16R)
272 fn(map[int]uint32(nil), (*Encoder).fastpathEncMapIntUint32R, (*Decoder).fastpathDecMapIntUint32R)
273 fn(map[int]uint64(nil), (*Encoder).fastpathEncMapIntUint64R, (*Decoder).fastpathDecMapIntUint64R)
274 fn(map[int]uintptr(nil), (*Encoder).fastpathEncMapIntUintptrR, (*Decoder).fastpathDecMapIntUintptrR)
275 fn(map[int]int(nil), (*Encoder).fastpathEncMapIntIntR, (*Decoder).fastpathDecMapIntIntR)
276 fn(map[int]int8(nil), (*Encoder).fastpathEncMapIntInt8R, (*Decoder).fastpathDecMapIntInt8R)
277 fn(map[int]int16(nil), (*Encoder).fastpathEncMapIntInt16R, (*Decoder).fastpathDecMapIntInt16R)
278 fn(map[int]int32(nil), (*Encoder).fastpathEncMapIntInt32R, (*Decoder).fastpathDecMapIntInt32R)
279 fn(map[int]int64(nil), (*Encoder).fastpathEncMapIntInt64R, (*Decoder).fastpathDecMapIntInt64R)
280 fn(map[int]float32(nil), (*Encoder).fastpathEncMapIntFloat32R, (*Decoder).fastpathDecMapIntFloat32R)
281 fn(map[int]float64(nil), (*Encoder).fastpathEncMapIntFloat64R, (*Decoder).fastpathDecMapIntFloat64R)
282 fn(map[int]bool(nil), (*Encoder).fastpathEncMapIntBoolR, (*Decoder).fastpathDecMapIntBoolR)
283 fn(map[int8]interface{}(nil), (*Encoder).fastpathEncMapInt8IntfR, (*Decoder).fastpathDecMapInt8IntfR)
284 fn(map[int8]string(nil), (*Encoder).fastpathEncMapInt8StringR, (*Decoder).fastpathDecMapInt8StringR)
285 fn(map[int8]uint(nil), (*Encoder).fastpathEncMapInt8UintR, (*Decoder).fastpathDecMapInt8UintR)
286 fn(map[int8]uint8(nil), (*Encoder).fastpathEncMapInt8Uint8R, (*Decoder).fastpathDecMapInt8Uint8R)
287 fn(map[int8]uint16(nil), (*Encoder).fastpathEncMapInt8Uint16R, (*Decoder).fastpathDecMapInt8Uint16R)
288 fn(map[int8]uint32(nil), (*Encoder).fastpathEncMapInt8Uint32R, (*Decoder).fastpathDecMapInt8Uint32R)
289 fn(map[int8]uint64(nil), (*Encoder).fastpathEncMapInt8Uint64R, (*Decoder).fastpathDecMapInt8Uint64R)
290 fn(map[int8]uintptr(nil), (*Encoder).fastpathEncMapInt8UintptrR, (*Decoder).fastpathDecMapInt8UintptrR)
291 fn(map[int8]int(nil), (*Encoder).fastpathEncMapInt8IntR, (*Decoder).fastpathDecMapInt8IntR)
292 fn(map[int8]int8(nil), (*Encoder).fastpathEncMapInt8Int8R, (*Decoder).fastpathDecMapInt8Int8R)
293 fn(map[int8]int16(nil), (*Encoder).fastpathEncMapInt8Int16R, (*Decoder).fastpathDecMapInt8Int16R)
294 fn(map[int8]int32(nil), (*Encoder).fastpathEncMapInt8Int32R, (*Decoder).fastpathDecMapInt8Int32R)
295 fn(map[int8]int64(nil), (*Encoder).fastpathEncMapInt8Int64R, (*Decoder).fastpathDecMapInt8Int64R)
296 fn(map[int8]float32(nil), (*Encoder).fastpathEncMapInt8Float32R, (*Decoder).fastpathDecMapInt8Float32R)
297 fn(map[int8]float64(nil), (*Encoder).fastpathEncMapInt8Float64R, (*Decoder).fastpathDecMapInt8Float64R)
298 fn(map[int8]bool(nil), (*Encoder).fastpathEncMapInt8BoolR, (*Decoder).fastpathDecMapInt8BoolR)
299 fn(map[int16]interface{}(nil), (*Encoder).fastpathEncMapInt16IntfR, (*Decoder).fastpathDecMapInt16IntfR)
300 fn(map[int16]string(nil), (*Encoder).fastpathEncMapInt16StringR, (*Decoder).fastpathDecMapInt16StringR)
301 fn(map[int16]uint(nil), (*Encoder).fastpathEncMapInt16UintR, (*Decoder).fastpathDecMapInt16UintR)
302 fn(map[int16]uint8(nil), (*Encoder).fastpathEncMapInt16Uint8R, (*Decoder).fastpathDecMapInt16Uint8R)
303 fn(map[int16]uint16(nil), (*Encoder).fastpathEncMapInt16Uint16R, (*Decoder).fastpathDecMapInt16Uint16R)
304 fn(map[int16]uint32(nil), (*Encoder).fastpathEncMapInt16Uint32R, (*Decoder).fastpathDecMapInt16Uint32R)
305 fn(map[int16]uint64(nil), (*Encoder).fastpathEncMapInt16Uint64R, (*Decoder).fastpathDecMapInt16Uint64R)
306 fn(map[int16]uintptr(nil), (*Encoder).fastpathEncMapInt16UintptrR, (*Decoder).fastpathDecMapInt16UintptrR)
307 fn(map[int16]int(nil), (*Encoder).fastpathEncMapInt16IntR, (*Decoder).fastpathDecMapInt16IntR)
308 fn(map[int16]int8(nil), (*Encoder).fastpathEncMapInt16Int8R, (*Decoder).fastpathDecMapInt16Int8R)
309 fn(map[int16]int16(nil), (*Encoder).fastpathEncMapInt16Int16R, (*Decoder).fastpathDecMapInt16Int16R)
310 fn(map[int16]int32(nil), (*Encoder).fastpathEncMapInt16Int32R, (*Decoder).fastpathDecMapInt16Int32R)
311 fn(map[int16]int64(nil), (*Encoder).fastpathEncMapInt16Int64R, (*Decoder).fastpathDecMapInt16Int64R)
312 fn(map[int16]float32(nil), (*Encoder).fastpathEncMapInt16Float32R, (*Decoder).fastpathDecMapInt16Float32R)
313 fn(map[int16]float64(nil), (*Encoder).fastpathEncMapInt16Float64R, (*Decoder).fastpathDecMapInt16Float64R)
314 fn(map[int16]bool(nil), (*Encoder).fastpathEncMapInt16BoolR, (*Decoder).fastpathDecMapInt16BoolR)
315 fn(map[int32]interface{}(nil), (*Encoder).fastpathEncMapInt32IntfR, (*Decoder).fastpathDecMapInt32IntfR)
316 fn(map[int32]string(nil), (*Encoder).fastpathEncMapInt32StringR, (*Decoder).fastpathDecMapInt32StringR)
317 fn(map[int32]uint(nil), (*Encoder).fastpathEncMapInt32UintR, (*Decoder).fastpathDecMapInt32UintR)
318 fn(map[int32]uint8(nil), (*Encoder).fastpathEncMapInt32Uint8R, (*Decoder).fastpathDecMapInt32Uint8R)
319 fn(map[int32]uint16(nil), (*Encoder).fastpathEncMapInt32Uint16R, (*Decoder).fastpathDecMapInt32Uint16R)
320 fn(map[int32]uint32(nil), (*Encoder).fastpathEncMapInt32Uint32R, (*Decoder).fastpathDecMapInt32Uint32R)
321 fn(map[int32]uint64(nil), (*Encoder).fastpathEncMapInt32Uint64R, (*Decoder).fastpathDecMapInt32Uint64R)
322 fn(map[int32]uintptr(nil), (*Encoder).fastpathEncMapInt32UintptrR, (*Decoder).fastpathDecMapInt32UintptrR)
323 fn(map[int32]int(nil), (*Encoder).fastpathEncMapInt32IntR, (*Decoder).fastpathDecMapInt32IntR)
324 fn(map[int32]int8(nil), (*Encoder).fastpathEncMapInt32Int8R, (*Decoder).fastpathDecMapInt32Int8R)
325 fn(map[int32]int16(nil), (*Encoder).fastpathEncMapInt32Int16R, (*Decoder).fastpathDecMapInt32Int16R)
326 fn(map[int32]int32(nil), (*Encoder).fastpathEncMapInt32Int32R, (*Decoder).fastpathDecMapInt32Int32R)
327 fn(map[int32]int64(nil), (*Encoder).fastpathEncMapInt32Int64R, (*Decoder).fastpathDecMapInt32Int64R)
328 fn(map[int32]float32(nil), (*Encoder).fastpathEncMapInt32Float32R, (*Decoder).fastpathDecMapInt32Float32R)
329 fn(map[int32]float64(nil), (*Encoder).fastpathEncMapInt32Float64R, (*Decoder).fastpathDecMapInt32Float64R)
330 fn(map[int32]bool(nil), (*Encoder).fastpathEncMapInt32BoolR, (*Decoder).fastpathDecMapInt32BoolR)
331 fn(map[int64]interface{}(nil), (*Encoder).fastpathEncMapInt64IntfR, (*Decoder).fastpathDecMapInt64IntfR)
332 fn(map[int64]string(nil), (*Encoder).fastpathEncMapInt64StringR, (*Decoder).fastpathDecMapInt64StringR)
333 fn(map[int64]uint(nil), (*Encoder).fastpathEncMapInt64UintR, (*Decoder).fastpathDecMapInt64UintR)
334 fn(map[int64]uint8(nil), (*Encoder).fastpathEncMapInt64Uint8R, (*Decoder).fastpathDecMapInt64Uint8R)
335 fn(map[int64]uint16(nil), (*Encoder).fastpathEncMapInt64Uint16R, (*Decoder).fastpathDecMapInt64Uint16R)
336 fn(map[int64]uint32(nil), (*Encoder).fastpathEncMapInt64Uint32R, (*Decoder).fastpathDecMapInt64Uint32R)
337 fn(map[int64]uint64(nil), (*Encoder).fastpathEncMapInt64Uint64R, (*Decoder).fastpathDecMapInt64Uint64R)
338 fn(map[int64]uintptr(nil), (*Encoder).fastpathEncMapInt64UintptrR, (*Decoder).fastpathDecMapInt64UintptrR)
339 fn(map[int64]int(nil), (*Encoder).fastpathEncMapInt64IntR, (*Decoder).fastpathDecMapInt64IntR)
340 fn(map[int64]int8(nil), (*Encoder).fastpathEncMapInt64Int8R, (*Decoder).fastpathDecMapInt64Int8R)
341 fn(map[int64]int16(nil), (*Encoder).fastpathEncMapInt64Int16R, (*Decoder).fastpathDecMapInt64Int16R)
342 fn(map[int64]int32(nil), (*Encoder).fastpathEncMapInt64Int32R, (*Decoder).fastpathDecMapInt64Int32R)
343 fn(map[int64]int64(nil), (*Encoder).fastpathEncMapInt64Int64R, (*Decoder).fastpathDecMapInt64Int64R)
344 fn(map[int64]float32(nil), (*Encoder).fastpathEncMapInt64Float32R, (*Decoder).fastpathDecMapInt64Float32R)
345 fn(map[int64]float64(nil), (*Encoder).fastpathEncMapInt64Float64R, (*Decoder).fastpathDecMapInt64Float64R)
346 fn(map[int64]bool(nil), (*Encoder).fastpathEncMapInt64BoolR, (*Decoder).fastpathDecMapInt64BoolR)
347 fn(map[bool]interface{}(nil), (*Encoder).fastpathEncMapBoolIntfR, (*Decoder).fastpathDecMapBoolIntfR)
348 fn(map[bool]string(nil), (*Encoder).fastpathEncMapBoolStringR, (*Decoder).fastpathDecMapBoolStringR)
349 fn(map[bool]uint(nil), (*Encoder).fastpathEncMapBoolUintR, (*Decoder).fastpathDecMapBoolUintR)
350 fn(map[bool]uint8(nil), (*Encoder).fastpathEncMapBoolUint8R, (*Decoder).fastpathDecMapBoolUint8R)
351 fn(map[bool]uint16(nil), (*Encoder).fastpathEncMapBoolUint16R, (*Decoder).fastpathDecMapBoolUint16R)
352 fn(map[bool]uint32(nil), (*Encoder).fastpathEncMapBoolUint32R, (*Decoder).fastpathDecMapBoolUint32R)
353 fn(map[bool]uint64(nil), (*Encoder).fastpathEncMapBoolUint64R, (*Decoder).fastpathDecMapBoolUint64R)
354 fn(map[bool]uintptr(nil), (*Encoder).fastpathEncMapBoolUintptrR, (*Decoder).fastpathDecMapBoolUintptrR)
355 fn(map[bool]int(nil), (*Encoder).fastpathEncMapBoolIntR, (*Decoder).fastpathDecMapBoolIntR)
356 fn(map[bool]int8(nil), (*Encoder).fastpathEncMapBoolInt8R, (*Decoder).fastpathDecMapBoolInt8R)
357 fn(map[bool]int16(nil), (*Encoder).fastpathEncMapBoolInt16R, (*Decoder).fastpathDecMapBoolInt16R)
358 fn(map[bool]int32(nil), (*Encoder).fastpathEncMapBoolInt32R, (*Decoder).fastpathDecMapBoolInt32R)
359 fn(map[bool]int64(nil), (*Encoder).fastpathEncMapBoolInt64R, (*Decoder).fastpathDecMapBoolInt64R)
360 fn(map[bool]float32(nil), (*Encoder).fastpathEncMapBoolFloat32R, (*Decoder).fastpathDecMapBoolFloat32R)
361 fn(map[bool]float64(nil), (*Encoder).fastpathEncMapBoolFloat64R, (*Decoder).fastpathDecMapBoolFloat64R)
362 fn(map[bool]bool(nil), (*Encoder).fastpathEncMapBoolBoolR, (*Decoder).fastpathDecMapBoolBoolR)
364 sort.Sort(fastpathAslice(fastpathAV[:]))
369 // -- -- fast path type switch
370 func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool {
371 switch v := iv.(type) {
374 fastpathTV.EncSliceIntfV(v, e)
376 fastpathTV.EncSliceIntfV(*v, e)
378 fastpathTV.EncSliceStringV(v, e)
380 fastpathTV.EncSliceStringV(*v, e)
382 fastpathTV.EncSliceFloat32V(v, e)
384 fastpathTV.EncSliceFloat32V(*v, e)
386 fastpathTV.EncSliceFloat64V(v, e)
388 fastpathTV.EncSliceFloat64V(*v, e)
390 fastpathTV.EncSliceUintV(v, e)
392 fastpathTV.EncSliceUintV(*v, e)
394 fastpathTV.EncSliceUint16V(v, e)
396 fastpathTV.EncSliceUint16V(*v, e)
398 fastpathTV.EncSliceUint32V(v, e)
400 fastpathTV.EncSliceUint32V(*v, e)
402 fastpathTV.EncSliceUint64V(v, e)
404 fastpathTV.EncSliceUint64V(*v, e)
406 fastpathTV.EncSliceUintptrV(v, e)
408 fastpathTV.EncSliceUintptrV(*v, e)
410 fastpathTV.EncSliceIntV(v, e)
412 fastpathTV.EncSliceIntV(*v, e)
414 fastpathTV.EncSliceInt8V(v, e)
416 fastpathTV.EncSliceInt8V(*v, e)
418 fastpathTV.EncSliceInt16V(v, e)
420 fastpathTV.EncSliceInt16V(*v, e)
422 fastpathTV.EncSliceInt32V(v, e)
424 fastpathTV.EncSliceInt32V(*v, e)
426 fastpathTV.EncSliceInt64V(v, e)
428 fastpathTV.EncSliceInt64V(*v, e)
430 fastpathTV.EncSliceBoolV(v, e)
432 fastpathTV.EncSliceBoolV(*v, e)
434 case map[interface{}]interface{}:
435 fastpathTV.EncMapIntfIntfV(v, e)
436 case *map[interface{}]interface{}:
437 fastpathTV.EncMapIntfIntfV(*v, e)
438 case map[interface{}]string:
439 fastpathTV.EncMapIntfStringV(v, e)
440 case *map[interface{}]string:
441 fastpathTV.EncMapIntfStringV(*v, e)
442 case map[interface{}]uint:
443 fastpathTV.EncMapIntfUintV(v, e)
444 case *map[interface{}]uint:
445 fastpathTV.EncMapIntfUintV(*v, e)
446 case map[interface{}]uint8:
447 fastpathTV.EncMapIntfUint8V(v, e)
448 case *map[interface{}]uint8:
449 fastpathTV.EncMapIntfUint8V(*v, e)
450 case map[interface{}]uint16:
451 fastpathTV.EncMapIntfUint16V(v, e)
452 case *map[interface{}]uint16:
453 fastpathTV.EncMapIntfUint16V(*v, e)
454 case map[interface{}]uint32:
455 fastpathTV.EncMapIntfUint32V(v, e)
456 case *map[interface{}]uint32:
457 fastpathTV.EncMapIntfUint32V(*v, e)
458 case map[interface{}]uint64:
459 fastpathTV.EncMapIntfUint64V(v, e)
460 case *map[interface{}]uint64:
461 fastpathTV.EncMapIntfUint64V(*v, e)
462 case map[interface{}]uintptr:
463 fastpathTV.EncMapIntfUintptrV(v, e)
464 case *map[interface{}]uintptr:
465 fastpathTV.EncMapIntfUintptrV(*v, e)
466 case map[interface{}]int:
467 fastpathTV.EncMapIntfIntV(v, e)
468 case *map[interface{}]int:
469 fastpathTV.EncMapIntfIntV(*v, e)
470 case map[interface{}]int8:
471 fastpathTV.EncMapIntfInt8V(v, e)
472 case *map[interface{}]int8:
473 fastpathTV.EncMapIntfInt8V(*v, e)
474 case map[interface{}]int16:
475 fastpathTV.EncMapIntfInt16V(v, e)
476 case *map[interface{}]int16:
477 fastpathTV.EncMapIntfInt16V(*v, e)
478 case map[interface{}]int32:
479 fastpathTV.EncMapIntfInt32V(v, e)
480 case *map[interface{}]int32:
481 fastpathTV.EncMapIntfInt32V(*v, e)
482 case map[interface{}]int64:
483 fastpathTV.EncMapIntfInt64V(v, e)
484 case *map[interface{}]int64:
485 fastpathTV.EncMapIntfInt64V(*v, e)
486 case map[interface{}]float32:
487 fastpathTV.EncMapIntfFloat32V(v, e)
488 case *map[interface{}]float32:
489 fastpathTV.EncMapIntfFloat32V(*v, e)
490 case map[interface{}]float64:
491 fastpathTV.EncMapIntfFloat64V(v, e)
492 case *map[interface{}]float64:
493 fastpathTV.EncMapIntfFloat64V(*v, e)
494 case map[interface{}]bool:
495 fastpathTV.EncMapIntfBoolV(v, e)
496 case *map[interface{}]bool:
497 fastpathTV.EncMapIntfBoolV(*v, e)
498 case map[string]interface{}:
499 fastpathTV.EncMapStringIntfV(v, e)
500 case *map[string]interface{}:
501 fastpathTV.EncMapStringIntfV(*v, e)
502 case map[string]string:
503 fastpathTV.EncMapStringStringV(v, e)
504 case *map[string]string:
505 fastpathTV.EncMapStringStringV(*v, e)
506 case map[string]uint:
507 fastpathTV.EncMapStringUintV(v, e)
508 case *map[string]uint:
509 fastpathTV.EncMapStringUintV(*v, e)
510 case map[string]uint8:
511 fastpathTV.EncMapStringUint8V(v, e)
512 case *map[string]uint8:
513 fastpathTV.EncMapStringUint8V(*v, e)
514 case map[string]uint16:
515 fastpathTV.EncMapStringUint16V(v, e)
516 case *map[string]uint16:
517 fastpathTV.EncMapStringUint16V(*v, e)
518 case map[string]uint32:
519 fastpathTV.EncMapStringUint32V(v, e)
520 case *map[string]uint32:
521 fastpathTV.EncMapStringUint32V(*v, e)
522 case map[string]uint64:
523 fastpathTV.EncMapStringUint64V(v, e)
524 case *map[string]uint64:
525 fastpathTV.EncMapStringUint64V(*v, e)
526 case map[string]uintptr:
527 fastpathTV.EncMapStringUintptrV(v, e)
528 case *map[string]uintptr:
529 fastpathTV.EncMapStringUintptrV(*v, e)
531 fastpathTV.EncMapStringIntV(v, e)
532 case *map[string]int:
533 fastpathTV.EncMapStringIntV(*v, e)
534 case map[string]int8:
535 fastpathTV.EncMapStringInt8V(v, e)
536 case *map[string]int8:
537 fastpathTV.EncMapStringInt8V(*v, e)
538 case map[string]int16:
539 fastpathTV.EncMapStringInt16V(v, e)
540 case *map[string]int16:
541 fastpathTV.EncMapStringInt16V(*v, e)
542 case map[string]int32:
543 fastpathTV.EncMapStringInt32V(v, e)
544 case *map[string]int32:
545 fastpathTV.EncMapStringInt32V(*v, e)
546 case map[string]int64:
547 fastpathTV.EncMapStringInt64V(v, e)
548 case *map[string]int64:
549 fastpathTV.EncMapStringInt64V(*v, e)
550 case map[string]float32:
551 fastpathTV.EncMapStringFloat32V(v, e)
552 case *map[string]float32:
553 fastpathTV.EncMapStringFloat32V(*v, e)
554 case map[string]float64:
555 fastpathTV.EncMapStringFloat64V(v, e)
556 case *map[string]float64:
557 fastpathTV.EncMapStringFloat64V(*v, e)
558 case map[string]bool:
559 fastpathTV.EncMapStringBoolV(v, e)
560 case *map[string]bool:
561 fastpathTV.EncMapStringBoolV(*v, e)
562 case map[float32]interface{}:
563 fastpathTV.EncMapFloat32IntfV(v, e)
564 case *map[float32]interface{}:
565 fastpathTV.EncMapFloat32IntfV(*v, e)
566 case map[float32]string:
567 fastpathTV.EncMapFloat32StringV(v, e)
568 case *map[float32]string:
569 fastpathTV.EncMapFloat32StringV(*v, e)
570 case map[float32]uint:
571 fastpathTV.EncMapFloat32UintV(v, e)
572 case *map[float32]uint:
573 fastpathTV.EncMapFloat32UintV(*v, e)
574 case map[float32]uint8:
575 fastpathTV.EncMapFloat32Uint8V(v, e)
576 case *map[float32]uint8:
577 fastpathTV.EncMapFloat32Uint8V(*v, e)
578 case map[float32]uint16:
579 fastpathTV.EncMapFloat32Uint16V(v, e)
580 case *map[float32]uint16:
581 fastpathTV.EncMapFloat32Uint16V(*v, e)
582 case map[float32]uint32:
583 fastpathTV.EncMapFloat32Uint32V(v, e)
584 case *map[float32]uint32:
585 fastpathTV.EncMapFloat32Uint32V(*v, e)
586 case map[float32]uint64:
587 fastpathTV.EncMapFloat32Uint64V(v, e)
588 case *map[float32]uint64:
589 fastpathTV.EncMapFloat32Uint64V(*v, e)
590 case map[float32]uintptr:
591 fastpathTV.EncMapFloat32UintptrV(v, e)
592 case *map[float32]uintptr:
593 fastpathTV.EncMapFloat32UintptrV(*v, e)
594 case map[float32]int:
595 fastpathTV.EncMapFloat32IntV(v, e)
596 case *map[float32]int:
597 fastpathTV.EncMapFloat32IntV(*v, e)
598 case map[float32]int8:
599 fastpathTV.EncMapFloat32Int8V(v, e)
600 case *map[float32]int8:
601 fastpathTV.EncMapFloat32Int8V(*v, e)
602 case map[float32]int16:
603 fastpathTV.EncMapFloat32Int16V(v, e)
604 case *map[float32]int16:
605 fastpathTV.EncMapFloat32Int16V(*v, e)
606 case map[float32]int32:
607 fastpathTV.EncMapFloat32Int32V(v, e)
608 case *map[float32]int32:
609 fastpathTV.EncMapFloat32Int32V(*v, e)
610 case map[float32]int64:
611 fastpathTV.EncMapFloat32Int64V(v, e)
612 case *map[float32]int64:
613 fastpathTV.EncMapFloat32Int64V(*v, e)
614 case map[float32]float32:
615 fastpathTV.EncMapFloat32Float32V(v, e)
616 case *map[float32]float32:
617 fastpathTV.EncMapFloat32Float32V(*v, e)
618 case map[float32]float64:
619 fastpathTV.EncMapFloat32Float64V(v, e)
620 case *map[float32]float64:
621 fastpathTV.EncMapFloat32Float64V(*v, e)
622 case map[float32]bool:
623 fastpathTV.EncMapFloat32BoolV(v, e)
624 case *map[float32]bool:
625 fastpathTV.EncMapFloat32BoolV(*v, e)
626 case map[float64]interface{}:
627 fastpathTV.EncMapFloat64IntfV(v, e)
628 case *map[float64]interface{}:
629 fastpathTV.EncMapFloat64IntfV(*v, e)
630 case map[float64]string:
631 fastpathTV.EncMapFloat64StringV(v, e)
632 case *map[float64]string:
633 fastpathTV.EncMapFloat64StringV(*v, e)
634 case map[float64]uint:
635 fastpathTV.EncMapFloat64UintV(v, e)
636 case *map[float64]uint:
637 fastpathTV.EncMapFloat64UintV(*v, e)
638 case map[float64]uint8:
639 fastpathTV.EncMapFloat64Uint8V(v, e)
640 case *map[float64]uint8:
641 fastpathTV.EncMapFloat64Uint8V(*v, e)
642 case map[float64]uint16:
643 fastpathTV.EncMapFloat64Uint16V(v, e)
644 case *map[float64]uint16:
645 fastpathTV.EncMapFloat64Uint16V(*v, e)
646 case map[float64]uint32:
647 fastpathTV.EncMapFloat64Uint32V(v, e)
648 case *map[float64]uint32:
649 fastpathTV.EncMapFloat64Uint32V(*v, e)
650 case map[float64]uint64:
651 fastpathTV.EncMapFloat64Uint64V(v, e)
652 case *map[float64]uint64:
653 fastpathTV.EncMapFloat64Uint64V(*v, e)
654 case map[float64]uintptr:
655 fastpathTV.EncMapFloat64UintptrV(v, e)
656 case *map[float64]uintptr:
657 fastpathTV.EncMapFloat64UintptrV(*v, e)
658 case map[float64]int:
659 fastpathTV.EncMapFloat64IntV(v, e)
660 case *map[float64]int:
661 fastpathTV.EncMapFloat64IntV(*v, e)
662 case map[float64]int8:
663 fastpathTV.EncMapFloat64Int8V(v, e)
664 case *map[float64]int8:
665 fastpathTV.EncMapFloat64Int8V(*v, e)
666 case map[float64]int16:
667 fastpathTV.EncMapFloat64Int16V(v, e)
668 case *map[float64]int16:
669 fastpathTV.EncMapFloat64Int16V(*v, e)
670 case map[float64]int32:
671 fastpathTV.EncMapFloat64Int32V(v, e)
672 case *map[float64]int32:
673 fastpathTV.EncMapFloat64Int32V(*v, e)
674 case map[float64]int64:
675 fastpathTV.EncMapFloat64Int64V(v, e)
676 case *map[float64]int64:
677 fastpathTV.EncMapFloat64Int64V(*v, e)
678 case map[float64]float32:
679 fastpathTV.EncMapFloat64Float32V(v, e)
680 case *map[float64]float32:
681 fastpathTV.EncMapFloat64Float32V(*v, e)
682 case map[float64]float64:
683 fastpathTV.EncMapFloat64Float64V(v, e)
684 case *map[float64]float64:
685 fastpathTV.EncMapFloat64Float64V(*v, e)
686 case map[float64]bool:
687 fastpathTV.EncMapFloat64BoolV(v, e)
688 case *map[float64]bool:
689 fastpathTV.EncMapFloat64BoolV(*v, e)
690 case map[uint]interface{}:
691 fastpathTV.EncMapUintIntfV(v, e)
692 case *map[uint]interface{}:
693 fastpathTV.EncMapUintIntfV(*v, e)
694 case map[uint]string:
695 fastpathTV.EncMapUintStringV(v, e)
696 case *map[uint]string:
697 fastpathTV.EncMapUintStringV(*v, e)
699 fastpathTV.EncMapUintUintV(v, e)
701 fastpathTV.EncMapUintUintV(*v, e)
703 fastpathTV.EncMapUintUint8V(v, e)
704 case *map[uint]uint8:
705 fastpathTV.EncMapUintUint8V(*v, e)
706 case map[uint]uint16:
707 fastpathTV.EncMapUintUint16V(v, e)
708 case *map[uint]uint16:
709 fastpathTV.EncMapUintUint16V(*v, e)
710 case map[uint]uint32:
711 fastpathTV.EncMapUintUint32V(v, e)
712 case *map[uint]uint32:
713 fastpathTV.EncMapUintUint32V(*v, e)
714 case map[uint]uint64:
715 fastpathTV.EncMapUintUint64V(v, e)
716 case *map[uint]uint64:
717 fastpathTV.EncMapUintUint64V(*v, e)
718 case map[uint]uintptr:
719 fastpathTV.EncMapUintUintptrV(v, e)
720 case *map[uint]uintptr:
721 fastpathTV.EncMapUintUintptrV(*v, e)
723 fastpathTV.EncMapUintIntV(v, e)
725 fastpathTV.EncMapUintIntV(*v, e)
727 fastpathTV.EncMapUintInt8V(v, e)
729 fastpathTV.EncMapUintInt8V(*v, e)
731 fastpathTV.EncMapUintInt16V(v, e)
732 case *map[uint]int16:
733 fastpathTV.EncMapUintInt16V(*v, e)
735 fastpathTV.EncMapUintInt32V(v, e)
736 case *map[uint]int32:
737 fastpathTV.EncMapUintInt32V(*v, e)
739 fastpathTV.EncMapUintInt64V(v, e)
740 case *map[uint]int64:
741 fastpathTV.EncMapUintInt64V(*v, e)
742 case map[uint]float32:
743 fastpathTV.EncMapUintFloat32V(v, e)
744 case *map[uint]float32:
745 fastpathTV.EncMapUintFloat32V(*v, e)
746 case map[uint]float64:
747 fastpathTV.EncMapUintFloat64V(v, e)
748 case *map[uint]float64:
749 fastpathTV.EncMapUintFloat64V(*v, e)
751 fastpathTV.EncMapUintBoolV(v, e)
753 fastpathTV.EncMapUintBoolV(*v, e)
754 case map[uint8]interface{}:
755 fastpathTV.EncMapUint8IntfV(v, e)
756 case *map[uint8]interface{}:
757 fastpathTV.EncMapUint8IntfV(*v, e)
758 case map[uint8]string:
759 fastpathTV.EncMapUint8StringV(v, e)
760 case *map[uint8]string:
761 fastpathTV.EncMapUint8StringV(*v, e)
763 fastpathTV.EncMapUint8UintV(v, e)
764 case *map[uint8]uint:
765 fastpathTV.EncMapUint8UintV(*v, e)
766 case map[uint8]uint8:
767 fastpathTV.EncMapUint8Uint8V(v, e)
768 case *map[uint8]uint8:
769 fastpathTV.EncMapUint8Uint8V(*v, e)
770 case map[uint8]uint16:
771 fastpathTV.EncMapUint8Uint16V(v, e)
772 case *map[uint8]uint16:
773 fastpathTV.EncMapUint8Uint16V(*v, e)
774 case map[uint8]uint32:
775 fastpathTV.EncMapUint8Uint32V(v, e)
776 case *map[uint8]uint32:
777 fastpathTV.EncMapUint8Uint32V(*v, e)
778 case map[uint8]uint64:
779 fastpathTV.EncMapUint8Uint64V(v, e)
780 case *map[uint8]uint64:
781 fastpathTV.EncMapUint8Uint64V(*v, e)
782 case map[uint8]uintptr:
783 fastpathTV.EncMapUint8UintptrV(v, e)
784 case *map[uint8]uintptr:
785 fastpathTV.EncMapUint8UintptrV(*v, e)
787 fastpathTV.EncMapUint8IntV(v, e)
789 fastpathTV.EncMapUint8IntV(*v, e)
791 fastpathTV.EncMapUint8Int8V(v, e)
792 case *map[uint8]int8:
793 fastpathTV.EncMapUint8Int8V(*v, e)
794 case map[uint8]int16:
795 fastpathTV.EncMapUint8Int16V(v, e)
796 case *map[uint8]int16:
797 fastpathTV.EncMapUint8Int16V(*v, e)
798 case map[uint8]int32:
799 fastpathTV.EncMapUint8Int32V(v, e)
800 case *map[uint8]int32:
801 fastpathTV.EncMapUint8Int32V(*v, e)
802 case map[uint8]int64:
803 fastpathTV.EncMapUint8Int64V(v, e)
804 case *map[uint8]int64:
805 fastpathTV.EncMapUint8Int64V(*v, e)
806 case map[uint8]float32:
807 fastpathTV.EncMapUint8Float32V(v, e)
808 case *map[uint8]float32:
809 fastpathTV.EncMapUint8Float32V(*v, e)
810 case map[uint8]float64:
811 fastpathTV.EncMapUint8Float64V(v, e)
812 case *map[uint8]float64:
813 fastpathTV.EncMapUint8Float64V(*v, e)
815 fastpathTV.EncMapUint8BoolV(v, e)
816 case *map[uint8]bool:
817 fastpathTV.EncMapUint8BoolV(*v, e)
818 case map[uint16]interface{}:
819 fastpathTV.EncMapUint16IntfV(v, e)
820 case *map[uint16]interface{}:
821 fastpathTV.EncMapUint16IntfV(*v, e)
822 case map[uint16]string:
823 fastpathTV.EncMapUint16StringV(v, e)
824 case *map[uint16]string:
825 fastpathTV.EncMapUint16StringV(*v, e)
826 case map[uint16]uint:
827 fastpathTV.EncMapUint16UintV(v, e)
828 case *map[uint16]uint:
829 fastpathTV.EncMapUint16UintV(*v, e)
830 case map[uint16]uint8:
831 fastpathTV.EncMapUint16Uint8V(v, e)
832 case *map[uint16]uint8:
833 fastpathTV.EncMapUint16Uint8V(*v, e)
834 case map[uint16]uint16:
835 fastpathTV.EncMapUint16Uint16V(v, e)
836 case *map[uint16]uint16:
837 fastpathTV.EncMapUint16Uint16V(*v, e)
838 case map[uint16]uint32:
839 fastpathTV.EncMapUint16Uint32V(v, e)
840 case *map[uint16]uint32:
841 fastpathTV.EncMapUint16Uint32V(*v, e)
842 case map[uint16]uint64:
843 fastpathTV.EncMapUint16Uint64V(v, e)
844 case *map[uint16]uint64:
845 fastpathTV.EncMapUint16Uint64V(*v, e)
846 case map[uint16]uintptr:
847 fastpathTV.EncMapUint16UintptrV(v, e)
848 case *map[uint16]uintptr:
849 fastpathTV.EncMapUint16UintptrV(*v, e)
851 fastpathTV.EncMapUint16IntV(v, e)
852 case *map[uint16]int:
853 fastpathTV.EncMapUint16IntV(*v, e)
854 case map[uint16]int8:
855 fastpathTV.EncMapUint16Int8V(v, e)
856 case *map[uint16]int8:
857 fastpathTV.EncMapUint16Int8V(*v, e)
858 case map[uint16]int16:
859 fastpathTV.EncMapUint16Int16V(v, e)
860 case *map[uint16]int16:
861 fastpathTV.EncMapUint16Int16V(*v, e)
862 case map[uint16]int32:
863 fastpathTV.EncMapUint16Int32V(v, e)
864 case *map[uint16]int32:
865 fastpathTV.EncMapUint16Int32V(*v, e)
866 case map[uint16]int64:
867 fastpathTV.EncMapUint16Int64V(v, e)
868 case *map[uint16]int64:
869 fastpathTV.EncMapUint16Int64V(*v, e)
870 case map[uint16]float32:
871 fastpathTV.EncMapUint16Float32V(v, e)
872 case *map[uint16]float32:
873 fastpathTV.EncMapUint16Float32V(*v, e)
874 case map[uint16]float64:
875 fastpathTV.EncMapUint16Float64V(v, e)
876 case *map[uint16]float64:
877 fastpathTV.EncMapUint16Float64V(*v, e)
878 case map[uint16]bool:
879 fastpathTV.EncMapUint16BoolV(v, e)
880 case *map[uint16]bool:
881 fastpathTV.EncMapUint16BoolV(*v, e)
882 case map[uint32]interface{}:
883 fastpathTV.EncMapUint32IntfV(v, e)
884 case *map[uint32]interface{}:
885 fastpathTV.EncMapUint32IntfV(*v, e)
886 case map[uint32]string:
887 fastpathTV.EncMapUint32StringV(v, e)
888 case *map[uint32]string:
889 fastpathTV.EncMapUint32StringV(*v, e)
890 case map[uint32]uint:
891 fastpathTV.EncMapUint32UintV(v, e)
892 case *map[uint32]uint:
893 fastpathTV.EncMapUint32UintV(*v, e)
894 case map[uint32]uint8:
895 fastpathTV.EncMapUint32Uint8V(v, e)
896 case *map[uint32]uint8:
897 fastpathTV.EncMapUint32Uint8V(*v, e)
898 case map[uint32]uint16:
899 fastpathTV.EncMapUint32Uint16V(v, e)
900 case *map[uint32]uint16:
901 fastpathTV.EncMapUint32Uint16V(*v, e)
902 case map[uint32]uint32:
903 fastpathTV.EncMapUint32Uint32V(v, e)
904 case *map[uint32]uint32:
905 fastpathTV.EncMapUint32Uint32V(*v, e)
906 case map[uint32]uint64:
907 fastpathTV.EncMapUint32Uint64V(v, e)
908 case *map[uint32]uint64:
909 fastpathTV.EncMapUint32Uint64V(*v, e)
910 case map[uint32]uintptr:
911 fastpathTV.EncMapUint32UintptrV(v, e)
912 case *map[uint32]uintptr:
913 fastpathTV.EncMapUint32UintptrV(*v, e)
915 fastpathTV.EncMapUint32IntV(v, e)
916 case *map[uint32]int:
917 fastpathTV.EncMapUint32IntV(*v, e)
918 case map[uint32]int8:
919 fastpathTV.EncMapUint32Int8V(v, e)
920 case *map[uint32]int8:
921 fastpathTV.EncMapUint32Int8V(*v, e)
922 case map[uint32]int16:
923 fastpathTV.EncMapUint32Int16V(v, e)
924 case *map[uint32]int16:
925 fastpathTV.EncMapUint32Int16V(*v, e)
926 case map[uint32]int32:
927 fastpathTV.EncMapUint32Int32V(v, e)
928 case *map[uint32]int32:
929 fastpathTV.EncMapUint32Int32V(*v, e)
930 case map[uint32]int64:
931 fastpathTV.EncMapUint32Int64V(v, e)
932 case *map[uint32]int64:
933 fastpathTV.EncMapUint32Int64V(*v, e)
934 case map[uint32]float32:
935 fastpathTV.EncMapUint32Float32V(v, e)
936 case *map[uint32]float32:
937 fastpathTV.EncMapUint32Float32V(*v, e)
938 case map[uint32]float64:
939 fastpathTV.EncMapUint32Float64V(v, e)
940 case *map[uint32]float64:
941 fastpathTV.EncMapUint32Float64V(*v, e)
942 case map[uint32]bool:
943 fastpathTV.EncMapUint32BoolV(v, e)
944 case *map[uint32]bool:
945 fastpathTV.EncMapUint32BoolV(*v, e)
946 case map[uint64]interface{}:
947 fastpathTV.EncMapUint64IntfV(v, e)
948 case *map[uint64]interface{}:
949 fastpathTV.EncMapUint64IntfV(*v, e)
950 case map[uint64]string:
951 fastpathTV.EncMapUint64StringV(v, e)
952 case *map[uint64]string:
953 fastpathTV.EncMapUint64StringV(*v, e)
954 case map[uint64]uint:
955 fastpathTV.EncMapUint64UintV(v, e)
956 case *map[uint64]uint:
957 fastpathTV.EncMapUint64UintV(*v, e)
958 case map[uint64]uint8:
959 fastpathTV.EncMapUint64Uint8V(v, e)
960 case *map[uint64]uint8:
961 fastpathTV.EncMapUint64Uint8V(*v, e)
962 case map[uint64]uint16:
963 fastpathTV.EncMapUint64Uint16V(v, e)
964 case *map[uint64]uint16:
965 fastpathTV.EncMapUint64Uint16V(*v, e)
966 case map[uint64]uint32:
967 fastpathTV.EncMapUint64Uint32V(v, e)
968 case *map[uint64]uint32:
969 fastpathTV.EncMapUint64Uint32V(*v, e)
970 case map[uint64]uint64:
971 fastpathTV.EncMapUint64Uint64V(v, e)
972 case *map[uint64]uint64:
973 fastpathTV.EncMapUint64Uint64V(*v, e)
974 case map[uint64]uintptr:
975 fastpathTV.EncMapUint64UintptrV(v, e)
976 case *map[uint64]uintptr:
977 fastpathTV.EncMapUint64UintptrV(*v, e)
979 fastpathTV.EncMapUint64IntV(v, e)
980 case *map[uint64]int:
981 fastpathTV.EncMapUint64IntV(*v, e)
982 case map[uint64]int8:
983 fastpathTV.EncMapUint64Int8V(v, e)
984 case *map[uint64]int8:
985 fastpathTV.EncMapUint64Int8V(*v, e)
986 case map[uint64]int16:
987 fastpathTV.EncMapUint64Int16V(v, e)
988 case *map[uint64]int16:
989 fastpathTV.EncMapUint64Int16V(*v, e)
990 case map[uint64]int32:
991 fastpathTV.EncMapUint64Int32V(v, e)
992 case *map[uint64]int32:
993 fastpathTV.EncMapUint64Int32V(*v, e)
994 case map[uint64]int64:
995 fastpathTV.EncMapUint64Int64V(v, e)
996 case *map[uint64]int64:
997 fastpathTV.EncMapUint64Int64V(*v, e)
998 case map[uint64]float32:
999 fastpathTV.EncMapUint64Float32V(v, e)
1000 case *map[uint64]float32:
1001 fastpathTV.EncMapUint64Float32V(*v, e)
1002 case map[uint64]float64:
1003 fastpathTV.EncMapUint64Float64V(v, e)
1004 case *map[uint64]float64:
1005 fastpathTV.EncMapUint64Float64V(*v, e)
1006 case map[uint64]bool:
1007 fastpathTV.EncMapUint64BoolV(v, e)
1008 case *map[uint64]bool:
1009 fastpathTV.EncMapUint64BoolV(*v, e)
1010 case map[uintptr]interface{}:
1011 fastpathTV.EncMapUintptrIntfV(v, e)
1012 case *map[uintptr]interface{}:
1013 fastpathTV.EncMapUintptrIntfV(*v, e)
1014 case map[uintptr]string:
1015 fastpathTV.EncMapUintptrStringV(v, e)
1016 case *map[uintptr]string:
1017 fastpathTV.EncMapUintptrStringV(*v, e)
1018 case map[uintptr]uint:
1019 fastpathTV.EncMapUintptrUintV(v, e)
1020 case *map[uintptr]uint:
1021 fastpathTV.EncMapUintptrUintV(*v, e)
1022 case map[uintptr]uint8:
1023 fastpathTV.EncMapUintptrUint8V(v, e)
1024 case *map[uintptr]uint8:
1025 fastpathTV.EncMapUintptrUint8V(*v, e)
1026 case map[uintptr]uint16:
1027 fastpathTV.EncMapUintptrUint16V(v, e)
1028 case *map[uintptr]uint16:
1029 fastpathTV.EncMapUintptrUint16V(*v, e)
1030 case map[uintptr]uint32:
1031 fastpathTV.EncMapUintptrUint32V(v, e)
1032 case *map[uintptr]uint32:
1033 fastpathTV.EncMapUintptrUint32V(*v, e)
1034 case map[uintptr]uint64:
1035 fastpathTV.EncMapUintptrUint64V(v, e)
1036 case *map[uintptr]uint64:
1037 fastpathTV.EncMapUintptrUint64V(*v, e)
1038 case map[uintptr]uintptr:
1039 fastpathTV.EncMapUintptrUintptrV(v, e)
1040 case *map[uintptr]uintptr:
1041 fastpathTV.EncMapUintptrUintptrV(*v, e)
1042 case map[uintptr]int:
1043 fastpathTV.EncMapUintptrIntV(v, e)
1044 case *map[uintptr]int:
1045 fastpathTV.EncMapUintptrIntV(*v, e)
1046 case map[uintptr]int8:
1047 fastpathTV.EncMapUintptrInt8V(v, e)
1048 case *map[uintptr]int8:
1049 fastpathTV.EncMapUintptrInt8V(*v, e)
1050 case map[uintptr]int16:
1051 fastpathTV.EncMapUintptrInt16V(v, e)
1052 case *map[uintptr]int16:
1053 fastpathTV.EncMapUintptrInt16V(*v, e)
1054 case map[uintptr]int32:
1055 fastpathTV.EncMapUintptrInt32V(v, e)
1056 case *map[uintptr]int32:
1057 fastpathTV.EncMapUintptrInt32V(*v, e)
1058 case map[uintptr]int64:
1059 fastpathTV.EncMapUintptrInt64V(v, e)
1060 case *map[uintptr]int64:
1061 fastpathTV.EncMapUintptrInt64V(*v, e)
1062 case map[uintptr]float32:
1063 fastpathTV.EncMapUintptrFloat32V(v, e)
1064 case *map[uintptr]float32:
1065 fastpathTV.EncMapUintptrFloat32V(*v, e)
1066 case map[uintptr]float64:
1067 fastpathTV.EncMapUintptrFloat64V(v, e)
1068 case *map[uintptr]float64:
1069 fastpathTV.EncMapUintptrFloat64V(*v, e)
1070 case map[uintptr]bool:
1071 fastpathTV.EncMapUintptrBoolV(v, e)
1072 case *map[uintptr]bool:
1073 fastpathTV.EncMapUintptrBoolV(*v, e)
1074 case map[int]interface{}:
1075 fastpathTV.EncMapIntIntfV(v, e)
1076 case *map[int]interface{}:
1077 fastpathTV.EncMapIntIntfV(*v, e)
1078 case map[int]string:
1079 fastpathTV.EncMapIntStringV(v, e)
1080 case *map[int]string:
1081 fastpathTV.EncMapIntStringV(*v, e)
1083 fastpathTV.EncMapIntUintV(v, e)
1085 fastpathTV.EncMapIntUintV(*v, e)
1087 fastpathTV.EncMapIntUint8V(v, e)
1088 case *map[int]uint8:
1089 fastpathTV.EncMapIntUint8V(*v, e)
1090 case map[int]uint16:
1091 fastpathTV.EncMapIntUint16V(v, e)
1092 case *map[int]uint16:
1093 fastpathTV.EncMapIntUint16V(*v, e)
1094 case map[int]uint32:
1095 fastpathTV.EncMapIntUint32V(v, e)
1096 case *map[int]uint32:
1097 fastpathTV.EncMapIntUint32V(*v, e)
1098 case map[int]uint64:
1099 fastpathTV.EncMapIntUint64V(v, e)
1100 case *map[int]uint64:
1101 fastpathTV.EncMapIntUint64V(*v, e)
1102 case map[int]uintptr:
1103 fastpathTV.EncMapIntUintptrV(v, e)
1104 case *map[int]uintptr:
1105 fastpathTV.EncMapIntUintptrV(*v, e)
1107 fastpathTV.EncMapIntIntV(v, e)
1109 fastpathTV.EncMapIntIntV(*v, e)
1111 fastpathTV.EncMapIntInt8V(v, e)
1113 fastpathTV.EncMapIntInt8V(*v, e)
1115 fastpathTV.EncMapIntInt16V(v, e)
1116 case *map[int]int16:
1117 fastpathTV.EncMapIntInt16V(*v, e)
1119 fastpathTV.EncMapIntInt32V(v, e)
1120 case *map[int]int32:
1121 fastpathTV.EncMapIntInt32V(*v, e)
1123 fastpathTV.EncMapIntInt64V(v, e)
1124 case *map[int]int64:
1125 fastpathTV.EncMapIntInt64V(*v, e)
1126 case map[int]float32:
1127 fastpathTV.EncMapIntFloat32V(v, e)
1128 case *map[int]float32:
1129 fastpathTV.EncMapIntFloat32V(*v, e)
1130 case map[int]float64:
1131 fastpathTV.EncMapIntFloat64V(v, e)
1132 case *map[int]float64:
1133 fastpathTV.EncMapIntFloat64V(*v, e)
1135 fastpathTV.EncMapIntBoolV(v, e)
1137 fastpathTV.EncMapIntBoolV(*v, e)
1138 case map[int8]interface{}:
1139 fastpathTV.EncMapInt8IntfV(v, e)
1140 case *map[int8]interface{}:
1141 fastpathTV.EncMapInt8IntfV(*v, e)
1142 case map[int8]string:
1143 fastpathTV.EncMapInt8StringV(v, e)
1144 case *map[int8]string:
1145 fastpathTV.EncMapInt8StringV(*v, e)
1147 fastpathTV.EncMapInt8UintV(v, e)
1148 case *map[int8]uint:
1149 fastpathTV.EncMapInt8UintV(*v, e)
1150 case map[int8]uint8:
1151 fastpathTV.EncMapInt8Uint8V(v, e)
1152 case *map[int8]uint8:
1153 fastpathTV.EncMapInt8Uint8V(*v, e)
1154 case map[int8]uint16:
1155 fastpathTV.EncMapInt8Uint16V(v, e)
1156 case *map[int8]uint16:
1157 fastpathTV.EncMapInt8Uint16V(*v, e)
1158 case map[int8]uint32:
1159 fastpathTV.EncMapInt8Uint32V(v, e)
1160 case *map[int8]uint32:
1161 fastpathTV.EncMapInt8Uint32V(*v, e)
1162 case map[int8]uint64:
1163 fastpathTV.EncMapInt8Uint64V(v, e)
1164 case *map[int8]uint64:
1165 fastpathTV.EncMapInt8Uint64V(*v, e)
1166 case map[int8]uintptr:
1167 fastpathTV.EncMapInt8UintptrV(v, e)
1168 case *map[int8]uintptr:
1169 fastpathTV.EncMapInt8UintptrV(*v, e)
1171 fastpathTV.EncMapInt8IntV(v, e)
1173 fastpathTV.EncMapInt8IntV(*v, e)
1175 fastpathTV.EncMapInt8Int8V(v, e)
1176 case *map[int8]int8:
1177 fastpathTV.EncMapInt8Int8V(*v, e)
1178 case map[int8]int16:
1179 fastpathTV.EncMapInt8Int16V(v, e)
1180 case *map[int8]int16:
1181 fastpathTV.EncMapInt8Int16V(*v, e)
1182 case map[int8]int32:
1183 fastpathTV.EncMapInt8Int32V(v, e)
1184 case *map[int8]int32:
1185 fastpathTV.EncMapInt8Int32V(*v, e)
1186 case map[int8]int64:
1187 fastpathTV.EncMapInt8Int64V(v, e)
1188 case *map[int8]int64:
1189 fastpathTV.EncMapInt8Int64V(*v, e)
1190 case map[int8]float32:
1191 fastpathTV.EncMapInt8Float32V(v, e)
1192 case *map[int8]float32:
1193 fastpathTV.EncMapInt8Float32V(*v, e)
1194 case map[int8]float64:
1195 fastpathTV.EncMapInt8Float64V(v, e)
1196 case *map[int8]float64:
1197 fastpathTV.EncMapInt8Float64V(*v, e)
1199 fastpathTV.EncMapInt8BoolV(v, e)
1200 case *map[int8]bool:
1201 fastpathTV.EncMapInt8BoolV(*v, e)
1202 case map[int16]interface{}:
1203 fastpathTV.EncMapInt16IntfV(v, e)
1204 case *map[int16]interface{}:
1205 fastpathTV.EncMapInt16IntfV(*v, e)
1206 case map[int16]string:
1207 fastpathTV.EncMapInt16StringV(v, e)
1208 case *map[int16]string:
1209 fastpathTV.EncMapInt16StringV(*v, e)
1210 case map[int16]uint:
1211 fastpathTV.EncMapInt16UintV(v, e)
1212 case *map[int16]uint:
1213 fastpathTV.EncMapInt16UintV(*v, e)
1214 case map[int16]uint8:
1215 fastpathTV.EncMapInt16Uint8V(v, e)
1216 case *map[int16]uint8:
1217 fastpathTV.EncMapInt16Uint8V(*v, e)
1218 case map[int16]uint16:
1219 fastpathTV.EncMapInt16Uint16V(v, e)
1220 case *map[int16]uint16:
1221 fastpathTV.EncMapInt16Uint16V(*v, e)
1222 case map[int16]uint32:
1223 fastpathTV.EncMapInt16Uint32V(v, e)
1224 case *map[int16]uint32:
1225 fastpathTV.EncMapInt16Uint32V(*v, e)
1226 case map[int16]uint64:
1227 fastpathTV.EncMapInt16Uint64V(v, e)
1228 case *map[int16]uint64:
1229 fastpathTV.EncMapInt16Uint64V(*v, e)
1230 case map[int16]uintptr:
1231 fastpathTV.EncMapInt16UintptrV(v, e)
1232 case *map[int16]uintptr:
1233 fastpathTV.EncMapInt16UintptrV(*v, e)
1235 fastpathTV.EncMapInt16IntV(v, e)
1236 case *map[int16]int:
1237 fastpathTV.EncMapInt16IntV(*v, e)
1238 case map[int16]int8:
1239 fastpathTV.EncMapInt16Int8V(v, e)
1240 case *map[int16]int8:
1241 fastpathTV.EncMapInt16Int8V(*v, e)
1242 case map[int16]int16:
1243 fastpathTV.EncMapInt16Int16V(v, e)
1244 case *map[int16]int16:
1245 fastpathTV.EncMapInt16Int16V(*v, e)
1246 case map[int16]int32:
1247 fastpathTV.EncMapInt16Int32V(v, e)
1248 case *map[int16]int32:
1249 fastpathTV.EncMapInt16Int32V(*v, e)
1250 case map[int16]int64:
1251 fastpathTV.EncMapInt16Int64V(v, e)
1252 case *map[int16]int64:
1253 fastpathTV.EncMapInt16Int64V(*v, e)
1254 case map[int16]float32:
1255 fastpathTV.EncMapInt16Float32V(v, e)
1256 case *map[int16]float32:
1257 fastpathTV.EncMapInt16Float32V(*v, e)
1258 case map[int16]float64:
1259 fastpathTV.EncMapInt16Float64V(v, e)
1260 case *map[int16]float64:
1261 fastpathTV.EncMapInt16Float64V(*v, e)
1262 case map[int16]bool:
1263 fastpathTV.EncMapInt16BoolV(v, e)
1264 case *map[int16]bool:
1265 fastpathTV.EncMapInt16BoolV(*v, e)
1266 case map[int32]interface{}:
1267 fastpathTV.EncMapInt32IntfV(v, e)
1268 case *map[int32]interface{}:
1269 fastpathTV.EncMapInt32IntfV(*v, e)
1270 case map[int32]string:
1271 fastpathTV.EncMapInt32StringV(v, e)
1272 case *map[int32]string:
1273 fastpathTV.EncMapInt32StringV(*v, e)
1274 case map[int32]uint:
1275 fastpathTV.EncMapInt32UintV(v, e)
1276 case *map[int32]uint:
1277 fastpathTV.EncMapInt32UintV(*v, e)
1278 case map[int32]uint8:
1279 fastpathTV.EncMapInt32Uint8V(v, e)
1280 case *map[int32]uint8:
1281 fastpathTV.EncMapInt32Uint8V(*v, e)
1282 case map[int32]uint16:
1283 fastpathTV.EncMapInt32Uint16V(v, e)
1284 case *map[int32]uint16:
1285 fastpathTV.EncMapInt32Uint16V(*v, e)
1286 case map[int32]uint32:
1287 fastpathTV.EncMapInt32Uint32V(v, e)
1288 case *map[int32]uint32:
1289 fastpathTV.EncMapInt32Uint32V(*v, e)
1290 case map[int32]uint64:
1291 fastpathTV.EncMapInt32Uint64V(v, e)
1292 case *map[int32]uint64:
1293 fastpathTV.EncMapInt32Uint64V(*v, e)
1294 case map[int32]uintptr:
1295 fastpathTV.EncMapInt32UintptrV(v, e)
1296 case *map[int32]uintptr:
1297 fastpathTV.EncMapInt32UintptrV(*v, e)
1299 fastpathTV.EncMapInt32IntV(v, e)
1300 case *map[int32]int:
1301 fastpathTV.EncMapInt32IntV(*v, e)
1302 case map[int32]int8:
1303 fastpathTV.EncMapInt32Int8V(v, e)
1304 case *map[int32]int8:
1305 fastpathTV.EncMapInt32Int8V(*v, e)
1306 case map[int32]int16:
1307 fastpathTV.EncMapInt32Int16V(v, e)
1308 case *map[int32]int16:
1309 fastpathTV.EncMapInt32Int16V(*v, e)
1310 case map[int32]int32:
1311 fastpathTV.EncMapInt32Int32V(v, e)
1312 case *map[int32]int32:
1313 fastpathTV.EncMapInt32Int32V(*v, e)
1314 case map[int32]int64:
1315 fastpathTV.EncMapInt32Int64V(v, e)
1316 case *map[int32]int64:
1317 fastpathTV.EncMapInt32Int64V(*v, e)
1318 case map[int32]float32:
1319 fastpathTV.EncMapInt32Float32V(v, e)
1320 case *map[int32]float32:
1321 fastpathTV.EncMapInt32Float32V(*v, e)
1322 case map[int32]float64:
1323 fastpathTV.EncMapInt32Float64V(v, e)
1324 case *map[int32]float64:
1325 fastpathTV.EncMapInt32Float64V(*v, e)
1326 case map[int32]bool:
1327 fastpathTV.EncMapInt32BoolV(v, e)
1328 case *map[int32]bool:
1329 fastpathTV.EncMapInt32BoolV(*v, e)
1330 case map[int64]interface{}:
1331 fastpathTV.EncMapInt64IntfV(v, e)
1332 case *map[int64]interface{}:
1333 fastpathTV.EncMapInt64IntfV(*v, e)
1334 case map[int64]string:
1335 fastpathTV.EncMapInt64StringV(v, e)
1336 case *map[int64]string:
1337 fastpathTV.EncMapInt64StringV(*v, e)
1338 case map[int64]uint:
1339 fastpathTV.EncMapInt64UintV(v, e)
1340 case *map[int64]uint:
1341 fastpathTV.EncMapInt64UintV(*v, e)
1342 case map[int64]uint8:
1343 fastpathTV.EncMapInt64Uint8V(v, e)
1344 case *map[int64]uint8:
1345 fastpathTV.EncMapInt64Uint8V(*v, e)
1346 case map[int64]uint16:
1347 fastpathTV.EncMapInt64Uint16V(v, e)
1348 case *map[int64]uint16:
1349 fastpathTV.EncMapInt64Uint16V(*v, e)
1350 case map[int64]uint32:
1351 fastpathTV.EncMapInt64Uint32V(v, e)
1352 case *map[int64]uint32:
1353 fastpathTV.EncMapInt64Uint32V(*v, e)
1354 case map[int64]uint64:
1355 fastpathTV.EncMapInt64Uint64V(v, e)
1356 case *map[int64]uint64:
1357 fastpathTV.EncMapInt64Uint64V(*v, e)
1358 case map[int64]uintptr:
1359 fastpathTV.EncMapInt64UintptrV(v, e)
1360 case *map[int64]uintptr:
1361 fastpathTV.EncMapInt64UintptrV(*v, e)
1363 fastpathTV.EncMapInt64IntV(v, e)
1364 case *map[int64]int:
1365 fastpathTV.EncMapInt64IntV(*v, e)
1366 case map[int64]int8:
1367 fastpathTV.EncMapInt64Int8V(v, e)
1368 case *map[int64]int8:
1369 fastpathTV.EncMapInt64Int8V(*v, e)
1370 case map[int64]int16:
1371 fastpathTV.EncMapInt64Int16V(v, e)
1372 case *map[int64]int16:
1373 fastpathTV.EncMapInt64Int16V(*v, e)
1374 case map[int64]int32:
1375 fastpathTV.EncMapInt64Int32V(v, e)
1376 case *map[int64]int32:
1377 fastpathTV.EncMapInt64Int32V(*v, e)
1378 case map[int64]int64:
1379 fastpathTV.EncMapInt64Int64V(v, e)
1380 case *map[int64]int64:
1381 fastpathTV.EncMapInt64Int64V(*v, e)
1382 case map[int64]float32:
1383 fastpathTV.EncMapInt64Float32V(v, e)
1384 case *map[int64]float32:
1385 fastpathTV.EncMapInt64Float32V(*v, e)
1386 case map[int64]float64:
1387 fastpathTV.EncMapInt64Float64V(v, e)
1388 case *map[int64]float64:
1389 fastpathTV.EncMapInt64Float64V(*v, e)
1390 case map[int64]bool:
1391 fastpathTV.EncMapInt64BoolV(v, e)
1392 case *map[int64]bool:
1393 fastpathTV.EncMapInt64BoolV(*v, e)
1394 case map[bool]interface{}:
1395 fastpathTV.EncMapBoolIntfV(v, e)
1396 case *map[bool]interface{}:
1397 fastpathTV.EncMapBoolIntfV(*v, e)
1398 case map[bool]string:
1399 fastpathTV.EncMapBoolStringV(v, e)
1400 case *map[bool]string:
1401 fastpathTV.EncMapBoolStringV(*v, e)
1403 fastpathTV.EncMapBoolUintV(v, e)
1404 case *map[bool]uint:
1405 fastpathTV.EncMapBoolUintV(*v, e)
1406 case map[bool]uint8:
1407 fastpathTV.EncMapBoolUint8V(v, e)
1408 case *map[bool]uint8:
1409 fastpathTV.EncMapBoolUint8V(*v, e)
1410 case map[bool]uint16:
1411 fastpathTV.EncMapBoolUint16V(v, e)
1412 case *map[bool]uint16:
1413 fastpathTV.EncMapBoolUint16V(*v, e)
1414 case map[bool]uint32:
1415 fastpathTV.EncMapBoolUint32V(v, e)
1416 case *map[bool]uint32:
1417 fastpathTV.EncMapBoolUint32V(*v, e)
1418 case map[bool]uint64:
1419 fastpathTV.EncMapBoolUint64V(v, e)
1420 case *map[bool]uint64:
1421 fastpathTV.EncMapBoolUint64V(*v, e)
1422 case map[bool]uintptr:
1423 fastpathTV.EncMapBoolUintptrV(v, e)
1424 case *map[bool]uintptr:
1425 fastpathTV.EncMapBoolUintptrV(*v, e)
1427 fastpathTV.EncMapBoolIntV(v, e)
1429 fastpathTV.EncMapBoolIntV(*v, e)
1431 fastpathTV.EncMapBoolInt8V(v, e)
1432 case *map[bool]int8:
1433 fastpathTV.EncMapBoolInt8V(*v, e)
1434 case map[bool]int16:
1435 fastpathTV.EncMapBoolInt16V(v, e)
1436 case *map[bool]int16:
1437 fastpathTV.EncMapBoolInt16V(*v, e)
1438 case map[bool]int32:
1439 fastpathTV.EncMapBoolInt32V(v, e)
1440 case *map[bool]int32:
1441 fastpathTV.EncMapBoolInt32V(*v, e)
1442 case map[bool]int64:
1443 fastpathTV.EncMapBoolInt64V(v, e)
1444 case *map[bool]int64:
1445 fastpathTV.EncMapBoolInt64V(*v, e)
1446 case map[bool]float32:
1447 fastpathTV.EncMapBoolFloat32V(v, e)
1448 case *map[bool]float32:
1449 fastpathTV.EncMapBoolFloat32V(*v, e)
1450 case map[bool]float64:
1451 fastpathTV.EncMapBoolFloat64V(v, e)
1452 case *map[bool]float64:
1453 fastpathTV.EncMapBoolFloat64V(*v, e)
1455 fastpathTV.EncMapBoolBoolV(v, e)
1456 case *map[bool]bool:
1457 fastpathTV.EncMapBoolBoolV(*v, e)
1460 _ = v // workaround https://github.com/golang/go/issues/12927 seen in go1.4
1466 // -- -- fast path functions
1468 func (e *Encoder) fastpathEncSliceIntfR(f *codecFnInfo, rv reflect.Value) {
1470 fastpathTV.EncAsMapSliceIntfV(rv2i(rv).([]interface{}), e)
1472 fastpathTV.EncSliceIntfV(rv2i(rv).([]interface{}), e)
1475 func (_ fastpathT) EncSliceIntfV(v []interface{}, e *Encoder) {
1480 ee, esep := e.e, e.hh.hasElemSeparators()
1481 ee.WriteArrayStart(len(v))
1483 for _, v2 := range v {
1488 for _, v2 := range v {
1494 func (_ fastpathT) EncAsMapSliceIntfV(v []interface{}, e *Encoder) {
1495 ee, esep := e.e, e.hh.hasElemSeparators()
1497 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
1500 ee.WriteMapStart(len(v) / 2)
1502 for j, v2 := range v {
1504 ee.WriteMapElemKey()
1506 ee.WriteMapElemValue()
1511 for _, v2 := range v {
1518 func (e *Encoder) fastpathEncSliceStringR(f *codecFnInfo, rv reflect.Value) {
1520 fastpathTV.EncAsMapSliceStringV(rv2i(rv).([]string), e)
1522 fastpathTV.EncSliceStringV(rv2i(rv).([]string), e)
1525 func (_ fastpathT) EncSliceStringV(v []string, e *Encoder) {
1530 ee, esep := e.e, e.hh.hasElemSeparators()
1531 ee.WriteArrayStart(len(v))
1533 for _, v2 := range v {
1535 ee.EncodeString(cUTF8, v2)
1538 for _, v2 := range v {
1539 ee.EncodeString(cUTF8, v2)
1544 func (_ fastpathT) EncAsMapSliceStringV(v []string, e *Encoder) {
1545 ee, esep := e.e, e.hh.hasElemSeparators()
1547 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
1550 ee.WriteMapStart(len(v) / 2)
1552 for j, v2 := range v {
1554 ee.WriteMapElemKey()
1556 ee.WriteMapElemValue()
1558 ee.EncodeString(cUTF8, v2)
1561 for _, v2 := range v {
1562 ee.EncodeString(cUTF8, v2)
1568 func (e *Encoder) fastpathEncSliceFloat32R(f *codecFnInfo, rv reflect.Value) {
1570 fastpathTV.EncAsMapSliceFloat32V(rv2i(rv).([]float32), e)
1572 fastpathTV.EncSliceFloat32V(rv2i(rv).([]float32), e)
1575 func (_ fastpathT) EncSliceFloat32V(v []float32, e *Encoder) {
1580 ee, esep := e.e, e.hh.hasElemSeparators()
1581 ee.WriteArrayStart(len(v))
1583 for _, v2 := range v {
1585 ee.EncodeFloat32(v2)
1588 for _, v2 := range v {
1589 ee.EncodeFloat32(v2)
1594 func (_ fastpathT) EncAsMapSliceFloat32V(v []float32, e *Encoder) {
1595 ee, esep := e.e, e.hh.hasElemSeparators()
1597 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
1600 ee.WriteMapStart(len(v) / 2)
1602 for j, v2 := range v {
1604 ee.WriteMapElemKey()
1606 ee.WriteMapElemValue()
1608 ee.EncodeFloat32(v2)
1611 for _, v2 := range v {
1612 ee.EncodeFloat32(v2)
1618 func (e *Encoder) fastpathEncSliceFloat64R(f *codecFnInfo, rv reflect.Value) {
1620 fastpathTV.EncAsMapSliceFloat64V(rv2i(rv).([]float64), e)
1622 fastpathTV.EncSliceFloat64V(rv2i(rv).([]float64), e)
1625 func (_ fastpathT) EncSliceFloat64V(v []float64, e *Encoder) {
1630 ee, esep := e.e, e.hh.hasElemSeparators()
1631 ee.WriteArrayStart(len(v))
1633 for _, v2 := range v {
1635 ee.EncodeFloat64(v2)
1638 for _, v2 := range v {
1639 ee.EncodeFloat64(v2)
1644 func (_ fastpathT) EncAsMapSliceFloat64V(v []float64, e *Encoder) {
1645 ee, esep := e.e, e.hh.hasElemSeparators()
1647 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
1650 ee.WriteMapStart(len(v) / 2)
1652 for j, v2 := range v {
1654 ee.WriteMapElemKey()
1656 ee.WriteMapElemValue()
1658 ee.EncodeFloat64(v2)
1661 for _, v2 := range v {
1662 ee.EncodeFloat64(v2)
1668 func (e *Encoder) fastpathEncSliceUintR(f *codecFnInfo, rv reflect.Value) {
1670 fastpathTV.EncAsMapSliceUintV(rv2i(rv).([]uint), e)
1672 fastpathTV.EncSliceUintV(rv2i(rv).([]uint), e)
1675 func (_ fastpathT) EncSliceUintV(v []uint, e *Encoder) {
1680 ee, esep := e.e, e.hh.hasElemSeparators()
1681 ee.WriteArrayStart(len(v))
1683 for _, v2 := range v {
1685 ee.EncodeUint(uint64(v2))
1688 for _, v2 := range v {
1689 ee.EncodeUint(uint64(v2))
1694 func (_ fastpathT) EncAsMapSliceUintV(v []uint, e *Encoder) {
1695 ee, esep := e.e, e.hh.hasElemSeparators()
1697 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
1700 ee.WriteMapStart(len(v) / 2)
1702 for j, v2 := range v {
1704 ee.WriteMapElemKey()
1706 ee.WriteMapElemValue()
1708 ee.EncodeUint(uint64(v2))
1711 for _, v2 := range v {
1712 ee.EncodeUint(uint64(v2))
1718 func (e *Encoder) fastpathEncSliceUint8R(f *codecFnInfo, rv reflect.Value) {
1720 fastpathTV.EncAsMapSliceUint8V(rv2i(rv).([]uint8), e)
1722 fastpathTV.EncSliceUint8V(rv2i(rv).([]uint8), e)
1725 func (_ fastpathT) EncSliceUint8V(v []uint8, e *Encoder) {
1730 ee, esep := e.e, e.hh.hasElemSeparators()
1731 ee.WriteArrayStart(len(v))
1733 for _, v2 := range v {
1735 ee.EncodeUint(uint64(v2))
1738 for _, v2 := range v {
1739 ee.EncodeUint(uint64(v2))
1744 func (_ fastpathT) EncAsMapSliceUint8V(v []uint8, e *Encoder) {
1745 ee, esep := e.e, e.hh.hasElemSeparators()
1747 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
1750 ee.WriteMapStart(len(v) / 2)
1752 for j, v2 := range v {
1754 ee.WriteMapElemKey()
1756 ee.WriteMapElemValue()
1758 ee.EncodeUint(uint64(v2))
1761 for _, v2 := range v {
1762 ee.EncodeUint(uint64(v2))
1768 func (e *Encoder) fastpathEncSliceUint16R(f *codecFnInfo, rv reflect.Value) {
1770 fastpathTV.EncAsMapSliceUint16V(rv2i(rv).([]uint16), e)
1772 fastpathTV.EncSliceUint16V(rv2i(rv).([]uint16), e)
1775 func (_ fastpathT) EncSliceUint16V(v []uint16, e *Encoder) {
1780 ee, esep := e.e, e.hh.hasElemSeparators()
1781 ee.WriteArrayStart(len(v))
1783 for _, v2 := range v {
1785 ee.EncodeUint(uint64(v2))
1788 for _, v2 := range v {
1789 ee.EncodeUint(uint64(v2))
1794 func (_ fastpathT) EncAsMapSliceUint16V(v []uint16, e *Encoder) {
1795 ee, esep := e.e, e.hh.hasElemSeparators()
1797 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
1800 ee.WriteMapStart(len(v) / 2)
1802 for j, v2 := range v {
1804 ee.WriteMapElemKey()
1806 ee.WriteMapElemValue()
1808 ee.EncodeUint(uint64(v2))
1811 for _, v2 := range v {
1812 ee.EncodeUint(uint64(v2))
1818 func (e *Encoder) fastpathEncSliceUint32R(f *codecFnInfo, rv reflect.Value) {
1820 fastpathTV.EncAsMapSliceUint32V(rv2i(rv).([]uint32), e)
1822 fastpathTV.EncSliceUint32V(rv2i(rv).([]uint32), e)
1825 func (_ fastpathT) EncSliceUint32V(v []uint32, e *Encoder) {
1830 ee, esep := e.e, e.hh.hasElemSeparators()
1831 ee.WriteArrayStart(len(v))
1833 for _, v2 := range v {
1835 ee.EncodeUint(uint64(v2))
1838 for _, v2 := range v {
1839 ee.EncodeUint(uint64(v2))
1844 func (_ fastpathT) EncAsMapSliceUint32V(v []uint32, e *Encoder) {
1845 ee, esep := e.e, e.hh.hasElemSeparators()
1847 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
1850 ee.WriteMapStart(len(v) / 2)
1852 for j, v2 := range v {
1854 ee.WriteMapElemKey()
1856 ee.WriteMapElemValue()
1858 ee.EncodeUint(uint64(v2))
1861 for _, v2 := range v {
1862 ee.EncodeUint(uint64(v2))
1868 func (e *Encoder) fastpathEncSliceUint64R(f *codecFnInfo, rv reflect.Value) {
1870 fastpathTV.EncAsMapSliceUint64V(rv2i(rv).([]uint64), e)
1872 fastpathTV.EncSliceUint64V(rv2i(rv).([]uint64), e)
1875 func (_ fastpathT) EncSliceUint64V(v []uint64, e *Encoder) {
1880 ee, esep := e.e, e.hh.hasElemSeparators()
1881 ee.WriteArrayStart(len(v))
1883 for _, v2 := range v {
1885 ee.EncodeUint(uint64(v2))
1888 for _, v2 := range v {
1889 ee.EncodeUint(uint64(v2))
1894 func (_ fastpathT) EncAsMapSliceUint64V(v []uint64, e *Encoder) {
1895 ee, esep := e.e, e.hh.hasElemSeparators()
1897 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
1900 ee.WriteMapStart(len(v) / 2)
1902 for j, v2 := range v {
1904 ee.WriteMapElemKey()
1906 ee.WriteMapElemValue()
1908 ee.EncodeUint(uint64(v2))
1911 for _, v2 := range v {
1912 ee.EncodeUint(uint64(v2))
1918 func (e *Encoder) fastpathEncSliceUintptrR(f *codecFnInfo, rv reflect.Value) {
1920 fastpathTV.EncAsMapSliceUintptrV(rv2i(rv).([]uintptr), e)
1922 fastpathTV.EncSliceUintptrV(rv2i(rv).([]uintptr), e)
1925 func (_ fastpathT) EncSliceUintptrV(v []uintptr, e *Encoder) {
1930 ee, esep := e.e, e.hh.hasElemSeparators()
1931 ee.WriteArrayStart(len(v))
1933 for _, v2 := range v {
1938 for _, v2 := range v {
1944 func (_ fastpathT) EncAsMapSliceUintptrV(v []uintptr, e *Encoder) {
1945 ee, esep := e.e, e.hh.hasElemSeparators()
1947 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
1950 ee.WriteMapStart(len(v) / 2)
1952 for j, v2 := range v {
1954 ee.WriteMapElemKey()
1956 ee.WriteMapElemValue()
1961 for _, v2 := range v {
1968 func (e *Encoder) fastpathEncSliceIntR(f *codecFnInfo, rv reflect.Value) {
1970 fastpathTV.EncAsMapSliceIntV(rv2i(rv).([]int), e)
1972 fastpathTV.EncSliceIntV(rv2i(rv).([]int), e)
1975 func (_ fastpathT) EncSliceIntV(v []int, e *Encoder) {
1980 ee, esep := e.e, e.hh.hasElemSeparators()
1981 ee.WriteArrayStart(len(v))
1983 for _, v2 := range v {
1985 ee.EncodeInt(int64(v2))
1988 for _, v2 := range v {
1989 ee.EncodeInt(int64(v2))
1994 func (_ fastpathT) EncAsMapSliceIntV(v []int, e *Encoder) {
1995 ee, esep := e.e, e.hh.hasElemSeparators()
1997 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
2000 ee.WriteMapStart(len(v) / 2)
2002 for j, v2 := range v {
2004 ee.WriteMapElemKey()
2006 ee.WriteMapElemValue()
2008 ee.EncodeInt(int64(v2))
2011 for _, v2 := range v {
2012 ee.EncodeInt(int64(v2))
2018 func (e *Encoder) fastpathEncSliceInt8R(f *codecFnInfo, rv reflect.Value) {
2020 fastpathTV.EncAsMapSliceInt8V(rv2i(rv).([]int8), e)
2022 fastpathTV.EncSliceInt8V(rv2i(rv).([]int8), e)
2025 func (_ fastpathT) EncSliceInt8V(v []int8, e *Encoder) {
2030 ee, esep := e.e, e.hh.hasElemSeparators()
2031 ee.WriteArrayStart(len(v))
2033 for _, v2 := range v {
2035 ee.EncodeInt(int64(v2))
2038 for _, v2 := range v {
2039 ee.EncodeInt(int64(v2))
2044 func (_ fastpathT) EncAsMapSliceInt8V(v []int8, e *Encoder) {
2045 ee, esep := e.e, e.hh.hasElemSeparators()
2047 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
2050 ee.WriteMapStart(len(v) / 2)
2052 for j, v2 := range v {
2054 ee.WriteMapElemKey()
2056 ee.WriteMapElemValue()
2058 ee.EncodeInt(int64(v2))
2061 for _, v2 := range v {
2062 ee.EncodeInt(int64(v2))
2068 func (e *Encoder) fastpathEncSliceInt16R(f *codecFnInfo, rv reflect.Value) {
2070 fastpathTV.EncAsMapSliceInt16V(rv2i(rv).([]int16), e)
2072 fastpathTV.EncSliceInt16V(rv2i(rv).([]int16), e)
2075 func (_ fastpathT) EncSliceInt16V(v []int16, e *Encoder) {
2080 ee, esep := e.e, e.hh.hasElemSeparators()
2081 ee.WriteArrayStart(len(v))
2083 for _, v2 := range v {
2085 ee.EncodeInt(int64(v2))
2088 for _, v2 := range v {
2089 ee.EncodeInt(int64(v2))
2094 func (_ fastpathT) EncAsMapSliceInt16V(v []int16, e *Encoder) {
2095 ee, esep := e.e, e.hh.hasElemSeparators()
2097 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
2100 ee.WriteMapStart(len(v) / 2)
2102 for j, v2 := range v {
2104 ee.WriteMapElemKey()
2106 ee.WriteMapElemValue()
2108 ee.EncodeInt(int64(v2))
2111 for _, v2 := range v {
2112 ee.EncodeInt(int64(v2))
2118 func (e *Encoder) fastpathEncSliceInt32R(f *codecFnInfo, rv reflect.Value) {
2120 fastpathTV.EncAsMapSliceInt32V(rv2i(rv).([]int32), e)
2122 fastpathTV.EncSliceInt32V(rv2i(rv).([]int32), e)
2125 func (_ fastpathT) EncSliceInt32V(v []int32, e *Encoder) {
2130 ee, esep := e.e, e.hh.hasElemSeparators()
2131 ee.WriteArrayStart(len(v))
2133 for _, v2 := range v {
2135 ee.EncodeInt(int64(v2))
2138 for _, v2 := range v {
2139 ee.EncodeInt(int64(v2))
2144 func (_ fastpathT) EncAsMapSliceInt32V(v []int32, e *Encoder) {
2145 ee, esep := e.e, e.hh.hasElemSeparators()
2147 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
2150 ee.WriteMapStart(len(v) / 2)
2152 for j, v2 := range v {
2154 ee.WriteMapElemKey()
2156 ee.WriteMapElemValue()
2158 ee.EncodeInt(int64(v2))
2161 for _, v2 := range v {
2162 ee.EncodeInt(int64(v2))
2168 func (e *Encoder) fastpathEncSliceInt64R(f *codecFnInfo, rv reflect.Value) {
2170 fastpathTV.EncAsMapSliceInt64V(rv2i(rv).([]int64), e)
2172 fastpathTV.EncSliceInt64V(rv2i(rv).([]int64), e)
2175 func (_ fastpathT) EncSliceInt64V(v []int64, e *Encoder) {
2180 ee, esep := e.e, e.hh.hasElemSeparators()
2181 ee.WriteArrayStart(len(v))
2183 for _, v2 := range v {
2185 ee.EncodeInt(int64(v2))
2188 for _, v2 := range v {
2189 ee.EncodeInt(int64(v2))
2194 func (_ fastpathT) EncAsMapSliceInt64V(v []int64, e *Encoder) {
2195 ee, esep := e.e, e.hh.hasElemSeparators()
2197 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
2200 ee.WriteMapStart(len(v) / 2)
2202 for j, v2 := range v {
2204 ee.WriteMapElemKey()
2206 ee.WriteMapElemValue()
2208 ee.EncodeInt(int64(v2))
2211 for _, v2 := range v {
2212 ee.EncodeInt(int64(v2))
2218 func (e *Encoder) fastpathEncSliceBoolR(f *codecFnInfo, rv reflect.Value) {
2220 fastpathTV.EncAsMapSliceBoolV(rv2i(rv).([]bool), e)
2222 fastpathTV.EncSliceBoolV(rv2i(rv).([]bool), e)
2225 func (_ fastpathT) EncSliceBoolV(v []bool, e *Encoder) {
2230 ee, esep := e.e, e.hh.hasElemSeparators()
2231 ee.WriteArrayStart(len(v))
2233 for _, v2 := range v {
2238 for _, v2 := range v {
2244 func (_ fastpathT) EncAsMapSliceBoolV(v []bool, e *Encoder) {
2245 ee, esep := e.e, e.hh.hasElemSeparators()
2247 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
2250 ee.WriteMapStart(len(v) / 2)
2252 for j, v2 := range v {
2254 ee.WriteMapElemKey()
2256 ee.WriteMapElemValue()
2261 for _, v2 := range v {
2268 func (e *Encoder) fastpathEncMapIntfIntfR(f *codecFnInfo, rv reflect.Value) {
2269 fastpathTV.EncMapIntfIntfV(rv2i(rv).(map[interface{}]interface{}), e)
2271 func (_ fastpathT) EncMapIntfIntfV(v map[interface{}]interface{}, e *Encoder) {
2276 ee, esep := e.e, e.hh.hasElemSeparators()
2277 ee.WriteMapStart(len(v))
2279 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2280 e2 := NewEncoderBytes(&mksv, e.hh)
2281 v2 := make([]bytesI, len(v))
2284 for k2, _ := range v {
2292 sort.Sort(bytesISlice(v2))
2295 ee.WriteMapElemKey()
2297 ee.WriteMapElemValue()
2298 e.encode(v[v2[j].i])
2303 e.encode(v[v2[j].i])
2308 for k2, v2 := range v {
2309 ee.WriteMapElemKey()
2311 ee.WriteMapElemValue()
2315 for k2, v2 := range v {
2324 func (e *Encoder) fastpathEncMapIntfStringR(f *codecFnInfo, rv reflect.Value) {
2325 fastpathTV.EncMapIntfStringV(rv2i(rv).(map[interface{}]string), e)
2327 func (_ fastpathT) EncMapIntfStringV(v map[interface{}]string, e *Encoder) {
2332 ee, esep := e.e, e.hh.hasElemSeparators()
2333 ee.WriteMapStart(len(v))
2335 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2336 e2 := NewEncoderBytes(&mksv, e.hh)
2337 v2 := make([]bytesI, len(v))
2340 for k2, _ := range v {
2348 sort.Sort(bytesISlice(v2))
2351 ee.WriteMapElemKey()
2353 ee.WriteMapElemValue()
2354 e.encode(v[v2[j].i])
2359 e.encode(v[v2[j].i])
2364 for k2, v2 := range v {
2365 ee.WriteMapElemKey()
2367 ee.WriteMapElemValue()
2368 ee.EncodeString(cUTF8, v2)
2371 for k2, v2 := range v {
2373 ee.EncodeString(cUTF8, v2)
2380 func (e *Encoder) fastpathEncMapIntfUintR(f *codecFnInfo, rv reflect.Value) {
2381 fastpathTV.EncMapIntfUintV(rv2i(rv).(map[interface{}]uint), e)
2383 func (_ fastpathT) EncMapIntfUintV(v map[interface{}]uint, e *Encoder) {
2388 ee, esep := e.e, e.hh.hasElemSeparators()
2389 ee.WriteMapStart(len(v))
2391 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2392 e2 := NewEncoderBytes(&mksv, e.hh)
2393 v2 := make([]bytesI, len(v))
2396 for k2, _ := range v {
2404 sort.Sort(bytesISlice(v2))
2407 ee.WriteMapElemKey()
2409 ee.WriteMapElemValue()
2410 e.encode(v[v2[j].i])
2415 e.encode(v[v2[j].i])
2420 for k2, v2 := range v {
2421 ee.WriteMapElemKey()
2423 ee.WriteMapElemValue()
2424 ee.EncodeUint(uint64(v2))
2427 for k2, v2 := range v {
2429 ee.EncodeUint(uint64(v2))
2436 func (e *Encoder) fastpathEncMapIntfUint8R(f *codecFnInfo, rv reflect.Value) {
2437 fastpathTV.EncMapIntfUint8V(rv2i(rv).(map[interface{}]uint8), e)
2439 func (_ fastpathT) EncMapIntfUint8V(v map[interface{}]uint8, e *Encoder) {
2444 ee, esep := e.e, e.hh.hasElemSeparators()
2445 ee.WriteMapStart(len(v))
2447 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2448 e2 := NewEncoderBytes(&mksv, e.hh)
2449 v2 := make([]bytesI, len(v))
2452 for k2, _ := range v {
2460 sort.Sort(bytesISlice(v2))
2463 ee.WriteMapElemKey()
2465 ee.WriteMapElemValue()
2466 e.encode(v[v2[j].i])
2471 e.encode(v[v2[j].i])
2476 for k2, v2 := range v {
2477 ee.WriteMapElemKey()
2479 ee.WriteMapElemValue()
2480 ee.EncodeUint(uint64(v2))
2483 for k2, v2 := range v {
2485 ee.EncodeUint(uint64(v2))
2492 func (e *Encoder) fastpathEncMapIntfUint16R(f *codecFnInfo, rv reflect.Value) {
2493 fastpathTV.EncMapIntfUint16V(rv2i(rv).(map[interface{}]uint16), e)
2495 func (_ fastpathT) EncMapIntfUint16V(v map[interface{}]uint16, e *Encoder) {
2500 ee, esep := e.e, e.hh.hasElemSeparators()
2501 ee.WriteMapStart(len(v))
2503 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2504 e2 := NewEncoderBytes(&mksv, e.hh)
2505 v2 := make([]bytesI, len(v))
2508 for k2, _ := range v {
2516 sort.Sort(bytesISlice(v2))
2519 ee.WriteMapElemKey()
2521 ee.WriteMapElemValue()
2522 e.encode(v[v2[j].i])
2527 e.encode(v[v2[j].i])
2532 for k2, v2 := range v {
2533 ee.WriteMapElemKey()
2535 ee.WriteMapElemValue()
2536 ee.EncodeUint(uint64(v2))
2539 for k2, v2 := range v {
2541 ee.EncodeUint(uint64(v2))
2548 func (e *Encoder) fastpathEncMapIntfUint32R(f *codecFnInfo, rv reflect.Value) {
2549 fastpathTV.EncMapIntfUint32V(rv2i(rv).(map[interface{}]uint32), e)
2551 func (_ fastpathT) EncMapIntfUint32V(v map[interface{}]uint32, e *Encoder) {
2556 ee, esep := e.e, e.hh.hasElemSeparators()
2557 ee.WriteMapStart(len(v))
2559 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2560 e2 := NewEncoderBytes(&mksv, e.hh)
2561 v2 := make([]bytesI, len(v))
2564 for k2, _ := range v {
2572 sort.Sort(bytesISlice(v2))
2575 ee.WriteMapElemKey()
2577 ee.WriteMapElemValue()
2578 e.encode(v[v2[j].i])
2583 e.encode(v[v2[j].i])
2588 for k2, v2 := range v {
2589 ee.WriteMapElemKey()
2591 ee.WriteMapElemValue()
2592 ee.EncodeUint(uint64(v2))
2595 for k2, v2 := range v {
2597 ee.EncodeUint(uint64(v2))
2604 func (e *Encoder) fastpathEncMapIntfUint64R(f *codecFnInfo, rv reflect.Value) {
2605 fastpathTV.EncMapIntfUint64V(rv2i(rv).(map[interface{}]uint64), e)
2607 func (_ fastpathT) EncMapIntfUint64V(v map[interface{}]uint64, e *Encoder) {
2612 ee, esep := e.e, e.hh.hasElemSeparators()
2613 ee.WriteMapStart(len(v))
2615 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2616 e2 := NewEncoderBytes(&mksv, e.hh)
2617 v2 := make([]bytesI, len(v))
2620 for k2, _ := range v {
2628 sort.Sort(bytesISlice(v2))
2631 ee.WriteMapElemKey()
2633 ee.WriteMapElemValue()
2634 e.encode(v[v2[j].i])
2639 e.encode(v[v2[j].i])
2644 for k2, v2 := range v {
2645 ee.WriteMapElemKey()
2647 ee.WriteMapElemValue()
2648 ee.EncodeUint(uint64(v2))
2651 for k2, v2 := range v {
2653 ee.EncodeUint(uint64(v2))
2660 func (e *Encoder) fastpathEncMapIntfUintptrR(f *codecFnInfo, rv reflect.Value) {
2661 fastpathTV.EncMapIntfUintptrV(rv2i(rv).(map[interface{}]uintptr), e)
2663 func (_ fastpathT) EncMapIntfUintptrV(v map[interface{}]uintptr, e *Encoder) {
2668 ee, esep := e.e, e.hh.hasElemSeparators()
2669 ee.WriteMapStart(len(v))
2671 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2672 e2 := NewEncoderBytes(&mksv, e.hh)
2673 v2 := make([]bytesI, len(v))
2676 for k2, _ := range v {
2684 sort.Sort(bytesISlice(v2))
2687 ee.WriteMapElemKey()
2689 ee.WriteMapElemValue()
2690 e.encode(v[v2[j].i])
2695 e.encode(v[v2[j].i])
2700 for k2, v2 := range v {
2701 ee.WriteMapElemKey()
2703 ee.WriteMapElemValue()
2707 for k2, v2 := range v {
2716 func (e *Encoder) fastpathEncMapIntfIntR(f *codecFnInfo, rv reflect.Value) {
2717 fastpathTV.EncMapIntfIntV(rv2i(rv).(map[interface{}]int), e)
2719 func (_ fastpathT) EncMapIntfIntV(v map[interface{}]int, e *Encoder) {
2724 ee, esep := e.e, e.hh.hasElemSeparators()
2725 ee.WriteMapStart(len(v))
2727 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2728 e2 := NewEncoderBytes(&mksv, e.hh)
2729 v2 := make([]bytesI, len(v))
2732 for k2, _ := range v {
2740 sort.Sort(bytesISlice(v2))
2743 ee.WriteMapElemKey()
2745 ee.WriteMapElemValue()
2746 e.encode(v[v2[j].i])
2751 e.encode(v[v2[j].i])
2756 for k2, v2 := range v {
2757 ee.WriteMapElemKey()
2759 ee.WriteMapElemValue()
2760 ee.EncodeInt(int64(v2))
2763 for k2, v2 := range v {
2765 ee.EncodeInt(int64(v2))
2772 func (e *Encoder) fastpathEncMapIntfInt8R(f *codecFnInfo, rv reflect.Value) {
2773 fastpathTV.EncMapIntfInt8V(rv2i(rv).(map[interface{}]int8), e)
2775 func (_ fastpathT) EncMapIntfInt8V(v map[interface{}]int8, e *Encoder) {
2780 ee, esep := e.e, e.hh.hasElemSeparators()
2781 ee.WriteMapStart(len(v))
2783 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2784 e2 := NewEncoderBytes(&mksv, e.hh)
2785 v2 := make([]bytesI, len(v))
2788 for k2, _ := range v {
2796 sort.Sort(bytesISlice(v2))
2799 ee.WriteMapElemKey()
2801 ee.WriteMapElemValue()
2802 e.encode(v[v2[j].i])
2807 e.encode(v[v2[j].i])
2812 for k2, v2 := range v {
2813 ee.WriteMapElemKey()
2815 ee.WriteMapElemValue()
2816 ee.EncodeInt(int64(v2))
2819 for k2, v2 := range v {
2821 ee.EncodeInt(int64(v2))
2828 func (e *Encoder) fastpathEncMapIntfInt16R(f *codecFnInfo, rv reflect.Value) {
2829 fastpathTV.EncMapIntfInt16V(rv2i(rv).(map[interface{}]int16), e)
2831 func (_ fastpathT) EncMapIntfInt16V(v map[interface{}]int16, e *Encoder) {
2836 ee, esep := e.e, e.hh.hasElemSeparators()
2837 ee.WriteMapStart(len(v))
2839 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2840 e2 := NewEncoderBytes(&mksv, e.hh)
2841 v2 := make([]bytesI, len(v))
2844 for k2, _ := range v {
2852 sort.Sort(bytesISlice(v2))
2855 ee.WriteMapElemKey()
2857 ee.WriteMapElemValue()
2858 e.encode(v[v2[j].i])
2863 e.encode(v[v2[j].i])
2868 for k2, v2 := range v {
2869 ee.WriteMapElemKey()
2871 ee.WriteMapElemValue()
2872 ee.EncodeInt(int64(v2))
2875 for k2, v2 := range v {
2877 ee.EncodeInt(int64(v2))
2884 func (e *Encoder) fastpathEncMapIntfInt32R(f *codecFnInfo, rv reflect.Value) {
2885 fastpathTV.EncMapIntfInt32V(rv2i(rv).(map[interface{}]int32), e)
2887 func (_ fastpathT) EncMapIntfInt32V(v map[interface{}]int32, e *Encoder) {
2892 ee, esep := e.e, e.hh.hasElemSeparators()
2893 ee.WriteMapStart(len(v))
2895 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2896 e2 := NewEncoderBytes(&mksv, e.hh)
2897 v2 := make([]bytesI, len(v))
2900 for k2, _ := range v {
2908 sort.Sort(bytesISlice(v2))
2911 ee.WriteMapElemKey()
2913 ee.WriteMapElemValue()
2914 e.encode(v[v2[j].i])
2919 e.encode(v[v2[j].i])
2924 for k2, v2 := range v {
2925 ee.WriteMapElemKey()
2927 ee.WriteMapElemValue()
2928 ee.EncodeInt(int64(v2))
2931 for k2, v2 := range v {
2933 ee.EncodeInt(int64(v2))
2940 func (e *Encoder) fastpathEncMapIntfInt64R(f *codecFnInfo, rv reflect.Value) {
2941 fastpathTV.EncMapIntfInt64V(rv2i(rv).(map[interface{}]int64), e)
2943 func (_ fastpathT) EncMapIntfInt64V(v map[interface{}]int64, e *Encoder) {
2948 ee, esep := e.e, e.hh.hasElemSeparators()
2949 ee.WriteMapStart(len(v))
2951 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2952 e2 := NewEncoderBytes(&mksv, e.hh)
2953 v2 := make([]bytesI, len(v))
2956 for k2, _ := range v {
2964 sort.Sort(bytesISlice(v2))
2967 ee.WriteMapElemKey()
2969 ee.WriteMapElemValue()
2970 e.encode(v[v2[j].i])
2975 e.encode(v[v2[j].i])
2980 for k2, v2 := range v {
2981 ee.WriteMapElemKey()
2983 ee.WriteMapElemValue()
2984 ee.EncodeInt(int64(v2))
2987 for k2, v2 := range v {
2989 ee.EncodeInt(int64(v2))
2996 func (e *Encoder) fastpathEncMapIntfFloat32R(f *codecFnInfo, rv reflect.Value) {
2997 fastpathTV.EncMapIntfFloat32V(rv2i(rv).(map[interface{}]float32), e)
2999 func (_ fastpathT) EncMapIntfFloat32V(v map[interface{}]float32, e *Encoder) {
3004 ee, esep := e.e, e.hh.hasElemSeparators()
3005 ee.WriteMapStart(len(v))
3007 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
3008 e2 := NewEncoderBytes(&mksv, e.hh)
3009 v2 := make([]bytesI, len(v))
3012 for k2, _ := range v {
3020 sort.Sort(bytesISlice(v2))
3023 ee.WriteMapElemKey()
3025 ee.WriteMapElemValue()
3026 e.encode(v[v2[j].i])
3031 e.encode(v[v2[j].i])
3036 for k2, v2 := range v {
3037 ee.WriteMapElemKey()
3039 ee.WriteMapElemValue()
3040 ee.EncodeFloat32(v2)
3043 for k2, v2 := range v {
3045 ee.EncodeFloat32(v2)
3052 func (e *Encoder) fastpathEncMapIntfFloat64R(f *codecFnInfo, rv reflect.Value) {
3053 fastpathTV.EncMapIntfFloat64V(rv2i(rv).(map[interface{}]float64), e)
3055 func (_ fastpathT) EncMapIntfFloat64V(v map[interface{}]float64, e *Encoder) {
3060 ee, esep := e.e, e.hh.hasElemSeparators()
3061 ee.WriteMapStart(len(v))
3063 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
3064 e2 := NewEncoderBytes(&mksv, e.hh)
3065 v2 := make([]bytesI, len(v))
3068 for k2, _ := range v {
3076 sort.Sort(bytesISlice(v2))
3079 ee.WriteMapElemKey()
3081 ee.WriteMapElemValue()
3082 e.encode(v[v2[j].i])
3087 e.encode(v[v2[j].i])
3092 for k2, v2 := range v {
3093 ee.WriteMapElemKey()
3095 ee.WriteMapElemValue()
3096 ee.EncodeFloat64(v2)
3099 for k2, v2 := range v {
3101 ee.EncodeFloat64(v2)
3108 func (e *Encoder) fastpathEncMapIntfBoolR(f *codecFnInfo, rv reflect.Value) {
3109 fastpathTV.EncMapIntfBoolV(rv2i(rv).(map[interface{}]bool), e)
3111 func (_ fastpathT) EncMapIntfBoolV(v map[interface{}]bool, e *Encoder) {
3116 ee, esep := e.e, e.hh.hasElemSeparators()
3117 ee.WriteMapStart(len(v))
3119 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
3120 e2 := NewEncoderBytes(&mksv, e.hh)
3121 v2 := make([]bytesI, len(v))
3124 for k2, _ := range v {
3132 sort.Sort(bytesISlice(v2))
3135 ee.WriteMapElemKey()
3137 ee.WriteMapElemValue()
3138 e.encode(v[v2[j].i])
3143 e.encode(v[v2[j].i])
3148 for k2, v2 := range v {
3149 ee.WriteMapElemKey()
3151 ee.WriteMapElemValue()
3155 for k2, v2 := range v {
3164 func (e *Encoder) fastpathEncMapStringIntfR(f *codecFnInfo, rv reflect.Value) {
3165 fastpathTV.EncMapStringIntfV(rv2i(rv).(map[string]interface{}), e)
3167 func (_ fastpathT) EncMapStringIntfV(v map[string]interface{}, e *Encoder) {
3172 ee, esep := e.e, e.hh.hasElemSeparators()
3173 ee.WriteMapStart(len(v))
3175 v2 := make([]string, len(v))
3177 for k, _ := range v {
3181 sort.Sort(stringSlice(v2))
3183 for _, k2 := range v2 {
3184 ee.WriteMapElemKey()
3185 ee.EncodeString(cUTF8, k2)
3186 ee.WriteMapElemValue()
3187 e.encode(v[string(k2)])
3190 for _, k2 := range v2 {
3191 ee.EncodeString(cUTF8, k2)
3192 e.encode(v[string(k2)])
3197 for k2, v2 := range v {
3198 ee.WriteMapElemKey()
3199 ee.EncodeString(cUTF8, k2)
3200 ee.WriteMapElemValue()
3204 for k2, v2 := range v {
3205 ee.EncodeString(cUTF8, k2)
3213 func (e *Encoder) fastpathEncMapStringStringR(f *codecFnInfo, rv reflect.Value) {
3214 fastpathTV.EncMapStringStringV(rv2i(rv).(map[string]string), e)
3216 func (_ fastpathT) EncMapStringStringV(v map[string]string, e *Encoder) {
3221 ee, esep := e.e, e.hh.hasElemSeparators()
3222 ee.WriteMapStart(len(v))
3224 v2 := make([]string, len(v))
3226 for k, _ := range v {
3230 sort.Sort(stringSlice(v2))
3232 for _, k2 := range v2 {
3233 ee.WriteMapElemKey()
3234 ee.EncodeString(cUTF8, k2)
3235 ee.WriteMapElemValue()
3236 ee.EncodeString(cUTF8, v[string(k2)])
3239 for _, k2 := range v2 {
3240 ee.EncodeString(cUTF8, k2)
3241 ee.EncodeString(cUTF8, v[string(k2)])
3246 for k2, v2 := range v {
3247 ee.WriteMapElemKey()
3248 ee.EncodeString(cUTF8, k2)
3249 ee.WriteMapElemValue()
3250 ee.EncodeString(cUTF8, v2)
3253 for k2, v2 := range v {
3254 ee.EncodeString(cUTF8, k2)
3255 ee.EncodeString(cUTF8, v2)
3262 func (e *Encoder) fastpathEncMapStringUintR(f *codecFnInfo, rv reflect.Value) {
3263 fastpathTV.EncMapStringUintV(rv2i(rv).(map[string]uint), e)
3265 func (_ fastpathT) EncMapStringUintV(v map[string]uint, e *Encoder) {
3270 ee, esep := e.e, e.hh.hasElemSeparators()
3271 ee.WriteMapStart(len(v))
3273 v2 := make([]string, len(v))
3275 for k, _ := range v {
3279 sort.Sort(stringSlice(v2))
3281 for _, k2 := range v2 {
3282 ee.WriteMapElemKey()
3283 ee.EncodeString(cUTF8, k2)
3284 ee.WriteMapElemValue()
3285 ee.EncodeUint(uint64(v[string(k2)]))
3288 for _, k2 := range v2 {
3289 ee.EncodeString(cUTF8, k2)
3290 ee.EncodeUint(uint64(v[string(k2)]))
3295 for k2, v2 := range v {
3296 ee.WriteMapElemKey()
3297 ee.EncodeString(cUTF8, k2)
3298 ee.WriteMapElemValue()
3299 ee.EncodeUint(uint64(v2))
3302 for k2, v2 := range v {
3303 ee.EncodeString(cUTF8, k2)
3304 ee.EncodeUint(uint64(v2))
3311 func (e *Encoder) fastpathEncMapStringUint8R(f *codecFnInfo, rv reflect.Value) {
3312 fastpathTV.EncMapStringUint8V(rv2i(rv).(map[string]uint8), e)
3314 func (_ fastpathT) EncMapStringUint8V(v map[string]uint8, e *Encoder) {
3319 ee, esep := e.e, e.hh.hasElemSeparators()
3320 ee.WriteMapStart(len(v))
3322 v2 := make([]string, len(v))
3324 for k, _ := range v {
3328 sort.Sort(stringSlice(v2))
3330 for _, k2 := range v2 {
3331 ee.WriteMapElemKey()
3332 ee.EncodeString(cUTF8, k2)
3333 ee.WriteMapElemValue()
3334 ee.EncodeUint(uint64(v[string(k2)]))
3337 for _, k2 := range v2 {
3338 ee.EncodeString(cUTF8, k2)
3339 ee.EncodeUint(uint64(v[string(k2)]))
3344 for k2, v2 := range v {
3345 ee.WriteMapElemKey()
3346 ee.EncodeString(cUTF8, k2)
3347 ee.WriteMapElemValue()
3348 ee.EncodeUint(uint64(v2))
3351 for k2, v2 := range v {
3352 ee.EncodeString(cUTF8, k2)
3353 ee.EncodeUint(uint64(v2))
3360 func (e *Encoder) fastpathEncMapStringUint16R(f *codecFnInfo, rv reflect.Value) {
3361 fastpathTV.EncMapStringUint16V(rv2i(rv).(map[string]uint16), e)
3363 func (_ fastpathT) EncMapStringUint16V(v map[string]uint16, e *Encoder) {
3368 ee, esep := e.e, e.hh.hasElemSeparators()
3369 ee.WriteMapStart(len(v))
3371 v2 := make([]string, len(v))
3373 for k, _ := range v {
3377 sort.Sort(stringSlice(v2))
3379 for _, k2 := range v2 {
3380 ee.WriteMapElemKey()
3381 ee.EncodeString(cUTF8, k2)
3382 ee.WriteMapElemValue()
3383 ee.EncodeUint(uint64(v[string(k2)]))
3386 for _, k2 := range v2 {
3387 ee.EncodeString(cUTF8, k2)
3388 ee.EncodeUint(uint64(v[string(k2)]))
3393 for k2, v2 := range v {
3394 ee.WriteMapElemKey()
3395 ee.EncodeString(cUTF8, k2)
3396 ee.WriteMapElemValue()
3397 ee.EncodeUint(uint64(v2))
3400 for k2, v2 := range v {
3401 ee.EncodeString(cUTF8, k2)
3402 ee.EncodeUint(uint64(v2))
3409 func (e *Encoder) fastpathEncMapStringUint32R(f *codecFnInfo, rv reflect.Value) {
3410 fastpathTV.EncMapStringUint32V(rv2i(rv).(map[string]uint32), e)
3412 func (_ fastpathT) EncMapStringUint32V(v map[string]uint32, e *Encoder) {
3417 ee, esep := e.e, e.hh.hasElemSeparators()
3418 ee.WriteMapStart(len(v))
3420 v2 := make([]string, len(v))
3422 for k, _ := range v {
3426 sort.Sort(stringSlice(v2))
3428 for _, k2 := range v2 {
3429 ee.WriteMapElemKey()
3430 ee.EncodeString(cUTF8, k2)
3431 ee.WriteMapElemValue()
3432 ee.EncodeUint(uint64(v[string(k2)]))
3435 for _, k2 := range v2 {
3436 ee.EncodeString(cUTF8, k2)
3437 ee.EncodeUint(uint64(v[string(k2)]))
3442 for k2, v2 := range v {
3443 ee.WriteMapElemKey()
3444 ee.EncodeString(cUTF8, k2)
3445 ee.WriteMapElemValue()
3446 ee.EncodeUint(uint64(v2))
3449 for k2, v2 := range v {
3450 ee.EncodeString(cUTF8, k2)
3451 ee.EncodeUint(uint64(v2))
3458 func (e *Encoder) fastpathEncMapStringUint64R(f *codecFnInfo, rv reflect.Value) {
3459 fastpathTV.EncMapStringUint64V(rv2i(rv).(map[string]uint64), e)
3461 func (_ fastpathT) EncMapStringUint64V(v map[string]uint64, e *Encoder) {
3466 ee, esep := e.e, e.hh.hasElemSeparators()
3467 ee.WriteMapStart(len(v))
3469 v2 := make([]string, len(v))
3471 for k, _ := range v {
3475 sort.Sort(stringSlice(v2))
3477 for _, k2 := range v2 {
3478 ee.WriteMapElemKey()
3479 ee.EncodeString(cUTF8, k2)
3480 ee.WriteMapElemValue()
3481 ee.EncodeUint(uint64(v[string(k2)]))
3484 for _, k2 := range v2 {
3485 ee.EncodeString(cUTF8, k2)
3486 ee.EncodeUint(uint64(v[string(k2)]))
3491 for k2, v2 := range v {
3492 ee.WriteMapElemKey()
3493 ee.EncodeString(cUTF8, k2)
3494 ee.WriteMapElemValue()
3495 ee.EncodeUint(uint64(v2))
3498 for k2, v2 := range v {
3499 ee.EncodeString(cUTF8, k2)
3500 ee.EncodeUint(uint64(v2))
3507 func (e *Encoder) fastpathEncMapStringUintptrR(f *codecFnInfo, rv reflect.Value) {
3508 fastpathTV.EncMapStringUintptrV(rv2i(rv).(map[string]uintptr), e)
3510 func (_ fastpathT) EncMapStringUintptrV(v map[string]uintptr, e *Encoder) {
3515 ee, esep := e.e, e.hh.hasElemSeparators()
3516 ee.WriteMapStart(len(v))
3518 v2 := make([]string, len(v))
3520 for k, _ := range v {
3524 sort.Sort(stringSlice(v2))
3526 for _, k2 := range v2 {
3527 ee.WriteMapElemKey()
3528 ee.EncodeString(cUTF8, k2)
3529 ee.WriteMapElemValue()
3530 e.encode(v[string(k2)])
3533 for _, k2 := range v2 {
3534 ee.EncodeString(cUTF8, k2)
3535 e.encode(v[string(k2)])
3540 for k2, v2 := range v {
3541 ee.WriteMapElemKey()
3542 ee.EncodeString(cUTF8, k2)
3543 ee.WriteMapElemValue()
3547 for k2, v2 := range v {
3548 ee.EncodeString(cUTF8, k2)
3556 func (e *Encoder) fastpathEncMapStringIntR(f *codecFnInfo, rv reflect.Value) {
3557 fastpathTV.EncMapStringIntV(rv2i(rv).(map[string]int), e)
3559 func (_ fastpathT) EncMapStringIntV(v map[string]int, e *Encoder) {
3564 ee, esep := e.e, e.hh.hasElemSeparators()
3565 ee.WriteMapStart(len(v))
3567 v2 := make([]string, len(v))
3569 for k, _ := range v {
3573 sort.Sort(stringSlice(v2))
3575 for _, k2 := range v2 {
3576 ee.WriteMapElemKey()
3577 ee.EncodeString(cUTF8, k2)
3578 ee.WriteMapElemValue()
3579 ee.EncodeInt(int64(v[string(k2)]))
3582 for _, k2 := range v2 {
3583 ee.EncodeString(cUTF8, k2)
3584 ee.EncodeInt(int64(v[string(k2)]))
3589 for k2, v2 := range v {
3590 ee.WriteMapElemKey()
3591 ee.EncodeString(cUTF8, k2)
3592 ee.WriteMapElemValue()
3593 ee.EncodeInt(int64(v2))
3596 for k2, v2 := range v {
3597 ee.EncodeString(cUTF8, k2)
3598 ee.EncodeInt(int64(v2))
3605 func (e *Encoder) fastpathEncMapStringInt8R(f *codecFnInfo, rv reflect.Value) {
3606 fastpathTV.EncMapStringInt8V(rv2i(rv).(map[string]int8), e)
3608 func (_ fastpathT) EncMapStringInt8V(v map[string]int8, e *Encoder) {
3613 ee, esep := e.e, e.hh.hasElemSeparators()
3614 ee.WriteMapStart(len(v))
3616 v2 := make([]string, len(v))
3618 for k, _ := range v {
3622 sort.Sort(stringSlice(v2))
3624 for _, k2 := range v2 {
3625 ee.WriteMapElemKey()
3626 ee.EncodeString(cUTF8, k2)
3627 ee.WriteMapElemValue()
3628 ee.EncodeInt(int64(v[string(k2)]))
3631 for _, k2 := range v2 {
3632 ee.EncodeString(cUTF8, k2)
3633 ee.EncodeInt(int64(v[string(k2)]))
3638 for k2, v2 := range v {
3639 ee.WriteMapElemKey()
3640 ee.EncodeString(cUTF8, k2)
3641 ee.WriteMapElemValue()
3642 ee.EncodeInt(int64(v2))
3645 for k2, v2 := range v {
3646 ee.EncodeString(cUTF8, k2)
3647 ee.EncodeInt(int64(v2))
3654 func (e *Encoder) fastpathEncMapStringInt16R(f *codecFnInfo, rv reflect.Value) {
3655 fastpathTV.EncMapStringInt16V(rv2i(rv).(map[string]int16), e)
3657 func (_ fastpathT) EncMapStringInt16V(v map[string]int16, e *Encoder) {
3662 ee, esep := e.e, e.hh.hasElemSeparators()
3663 ee.WriteMapStart(len(v))
3665 v2 := make([]string, len(v))
3667 for k, _ := range v {
3671 sort.Sort(stringSlice(v2))
3673 for _, k2 := range v2 {
3674 ee.WriteMapElemKey()
3675 ee.EncodeString(cUTF8, k2)
3676 ee.WriteMapElemValue()
3677 ee.EncodeInt(int64(v[string(k2)]))
3680 for _, k2 := range v2 {
3681 ee.EncodeString(cUTF8, k2)
3682 ee.EncodeInt(int64(v[string(k2)]))
3687 for k2, v2 := range v {
3688 ee.WriteMapElemKey()
3689 ee.EncodeString(cUTF8, k2)
3690 ee.WriteMapElemValue()
3691 ee.EncodeInt(int64(v2))
3694 for k2, v2 := range v {
3695 ee.EncodeString(cUTF8, k2)
3696 ee.EncodeInt(int64(v2))
3703 func (e *Encoder) fastpathEncMapStringInt32R(f *codecFnInfo, rv reflect.Value) {
3704 fastpathTV.EncMapStringInt32V(rv2i(rv).(map[string]int32), e)
3706 func (_ fastpathT) EncMapStringInt32V(v map[string]int32, e *Encoder) {
3711 ee, esep := e.e, e.hh.hasElemSeparators()
3712 ee.WriteMapStart(len(v))
3714 v2 := make([]string, len(v))
3716 for k, _ := range v {
3720 sort.Sort(stringSlice(v2))
3722 for _, k2 := range v2 {
3723 ee.WriteMapElemKey()
3724 ee.EncodeString(cUTF8, k2)
3725 ee.WriteMapElemValue()
3726 ee.EncodeInt(int64(v[string(k2)]))
3729 for _, k2 := range v2 {
3730 ee.EncodeString(cUTF8, k2)
3731 ee.EncodeInt(int64(v[string(k2)]))
3736 for k2, v2 := range v {
3737 ee.WriteMapElemKey()
3738 ee.EncodeString(cUTF8, k2)
3739 ee.WriteMapElemValue()
3740 ee.EncodeInt(int64(v2))
3743 for k2, v2 := range v {
3744 ee.EncodeString(cUTF8, k2)
3745 ee.EncodeInt(int64(v2))
3752 func (e *Encoder) fastpathEncMapStringInt64R(f *codecFnInfo, rv reflect.Value) {
3753 fastpathTV.EncMapStringInt64V(rv2i(rv).(map[string]int64), e)
3755 func (_ fastpathT) EncMapStringInt64V(v map[string]int64, e *Encoder) {
3760 ee, esep := e.e, e.hh.hasElemSeparators()
3761 ee.WriteMapStart(len(v))
3763 v2 := make([]string, len(v))
3765 for k, _ := range v {
3769 sort.Sort(stringSlice(v2))
3771 for _, k2 := range v2 {
3772 ee.WriteMapElemKey()
3773 ee.EncodeString(cUTF8, k2)
3774 ee.WriteMapElemValue()
3775 ee.EncodeInt(int64(v[string(k2)]))
3778 for _, k2 := range v2 {
3779 ee.EncodeString(cUTF8, k2)
3780 ee.EncodeInt(int64(v[string(k2)]))
3785 for k2, v2 := range v {
3786 ee.WriteMapElemKey()
3787 ee.EncodeString(cUTF8, k2)
3788 ee.WriteMapElemValue()
3789 ee.EncodeInt(int64(v2))
3792 for k2, v2 := range v {
3793 ee.EncodeString(cUTF8, k2)
3794 ee.EncodeInt(int64(v2))
3801 func (e *Encoder) fastpathEncMapStringFloat32R(f *codecFnInfo, rv reflect.Value) {
3802 fastpathTV.EncMapStringFloat32V(rv2i(rv).(map[string]float32), e)
3804 func (_ fastpathT) EncMapStringFloat32V(v map[string]float32, e *Encoder) {
3809 ee, esep := e.e, e.hh.hasElemSeparators()
3810 ee.WriteMapStart(len(v))
3812 v2 := make([]string, len(v))
3814 for k, _ := range v {
3818 sort.Sort(stringSlice(v2))
3820 for _, k2 := range v2 {
3821 ee.WriteMapElemKey()
3822 ee.EncodeString(cUTF8, k2)
3823 ee.WriteMapElemValue()
3824 ee.EncodeFloat32(v[string(k2)])
3827 for _, k2 := range v2 {
3828 ee.EncodeString(cUTF8, k2)
3829 ee.EncodeFloat32(v[string(k2)])
3834 for k2, v2 := range v {
3835 ee.WriteMapElemKey()
3836 ee.EncodeString(cUTF8, k2)
3837 ee.WriteMapElemValue()
3838 ee.EncodeFloat32(v2)
3841 for k2, v2 := range v {
3842 ee.EncodeString(cUTF8, k2)
3843 ee.EncodeFloat32(v2)
3850 func (e *Encoder) fastpathEncMapStringFloat64R(f *codecFnInfo, rv reflect.Value) {
3851 fastpathTV.EncMapStringFloat64V(rv2i(rv).(map[string]float64), e)
3853 func (_ fastpathT) EncMapStringFloat64V(v map[string]float64, e *Encoder) {
3858 ee, esep := e.e, e.hh.hasElemSeparators()
3859 ee.WriteMapStart(len(v))
3861 v2 := make([]string, len(v))
3863 for k, _ := range v {
3867 sort.Sort(stringSlice(v2))
3869 for _, k2 := range v2 {
3870 ee.WriteMapElemKey()
3871 ee.EncodeString(cUTF8, k2)
3872 ee.WriteMapElemValue()
3873 ee.EncodeFloat64(v[string(k2)])
3876 for _, k2 := range v2 {
3877 ee.EncodeString(cUTF8, k2)
3878 ee.EncodeFloat64(v[string(k2)])
3883 for k2, v2 := range v {
3884 ee.WriteMapElemKey()
3885 ee.EncodeString(cUTF8, k2)
3886 ee.WriteMapElemValue()
3887 ee.EncodeFloat64(v2)
3890 for k2, v2 := range v {
3891 ee.EncodeString(cUTF8, k2)
3892 ee.EncodeFloat64(v2)
3899 func (e *Encoder) fastpathEncMapStringBoolR(f *codecFnInfo, rv reflect.Value) {
3900 fastpathTV.EncMapStringBoolV(rv2i(rv).(map[string]bool), e)
3902 func (_ fastpathT) EncMapStringBoolV(v map[string]bool, e *Encoder) {
3907 ee, esep := e.e, e.hh.hasElemSeparators()
3908 ee.WriteMapStart(len(v))
3910 v2 := make([]string, len(v))
3912 for k, _ := range v {
3916 sort.Sort(stringSlice(v2))
3918 for _, k2 := range v2 {
3919 ee.WriteMapElemKey()
3920 ee.EncodeString(cUTF8, k2)
3921 ee.WriteMapElemValue()
3922 ee.EncodeBool(v[string(k2)])
3925 for _, k2 := range v2 {
3926 ee.EncodeString(cUTF8, k2)
3927 ee.EncodeBool(v[string(k2)])
3932 for k2, v2 := range v {
3933 ee.WriteMapElemKey()
3934 ee.EncodeString(cUTF8, k2)
3935 ee.WriteMapElemValue()
3939 for k2, v2 := range v {
3940 ee.EncodeString(cUTF8, k2)
3948 func (e *Encoder) fastpathEncMapFloat32IntfR(f *codecFnInfo, rv reflect.Value) {
3949 fastpathTV.EncMapFloat32IntfV(rv2i(rv).(map[float32]interface{}), e)
3951 func (_ fastpathT) EncMapFloat32IntfV(v map[float32]interface{}, e *Encoder) {
3956 ee, esep := e.e, e.hh.hasElemSeparators()
3957 ee.WriteMapStart(len(v))
3959 v2 := make([]float64, len(v))
3961 for k, _ := range v {
3965 sort.Sort(floatSlice(v2))
3967 for _, k2 := range v2 {
3968 ee.WriteMapElemKey()
3969 ee.EncodeFloat32(float32(k2))
3970 ee.WriteMapElemValue()
3971 e.encode(v[float32(k2)])
3974 for _, k2 := range v2 {
3975 ee.EncodeFloat32(float32(k2))
3976 e.encode(v[float32(k2)])
3981 for k2, v2 := range v {
3982 ee.WriteMapElemKey()
3983 ee.EncodeFloat32(k2)
3984 ee.WriteMapElemValue()
3988 for k2, v2 := range v {
3989 ee.EncodeFloat32(k2)
3997 func (e *Encoder) fastpathEncMapFloat32StringR(f *codecFnInfo, rv reflect.Value) {
3998 fastpathTV.EncMapFloat32StringV(rv2i(rv).(map[float32]string), e)
4000 func (_ fastpathT) EncMapFloat32StringV(v map[float32]string, e *Encoder) {
4005 ee, esep := e.e, e.hh.hasElemSeparators()
4006 ee.WriteMapStart(len(v))
4008 v2 := make([]float64, len(v))
4010 for k, _ := range v {
4014 sort.Sort(floatSlice(v2))
4016 for _, k2 := range v2 {
4017 ee.WriteMapElemKey()
4018 ee.EncodeFloat32(float32(k2))
4019 ee.WriteMapElemValue()
4020 ee.EncodeString(cUTF8, v[float32(k2)])
4023 for _, k2 := range v2 {
4024 ee.EncodeFloat32(float32(k2))
4025 ee.EncodeString(cUTF8, v[float32(k2)])
4030 for k2, v2 := range v {
4031 ee.WriteMapElemKey()
4032 ee.EncodeFloat32(k2)
4033 ee.WriteMapElemValue()
4034 ee.EncodeString(cUTF8, v2)
4037 for k2, v2 := range v {
4038 ee.EncodeFloat32(k2)
4039 ee.EncodeString(cUTF8, v2)
4046 func (e *Encoder) fastpathEncMapFloat32UintR(f *codecFnInfo, rv reflect.Value) {
4047 fastpathTV.EncMapFloat32UintV(rv2i(rv).(map[float32]uint), e)
4049 func (_ fastpathT) EncMapFloat32UintV(v map[float32]uint, e *Encoder) {
4054 ee, esep := e.e, e.hh.hasElemSeparators()
4055 ee.WriteMapStart(len(v))
4057 v2 := make([]float64, len(v))
4059 for k, _ := range v {
4063 sort.Sort(floatSlice(v2))
4065 for _, k2 := range v2 {
4066 ee.WriteMapElemKey()
4067 ee.EncodeFloat32(float32(k2))
4068 ee.WriteMapElemValue()
4069 ee.EncodeUint(uint64(v[float32(k2)]))
4072 for _, k2 := range v2 {
4073 ee.EncodeFloat32(float32(k2))
4074 ee.EncodeUint(uint64(v[float32(k2)]))
4079 for k2, v2 := range v {
4080 ee.WriteMapElemKey()
4081 ee.EncodeFloat32(k2)
4082 ee.WriteMapElemValue()
4083 ee.EncodeUint(uint64(v2))
4086 for k2, v2 := range v {
4087 ee.EncodeFloat32(k2)
4088 ee.EncodeUint(uint64(v2))
4095 func (e *Encoder) fastpathEncMapFloat32Uint8R(f *codecFnInfo, rv reflect.Value) {
4096 fastpathTV.EncMapFloat32Uint8V(rv2i(rv).(map[float32]uint8), e)
4098 func (_ fastpathT) EncMapFloat32Uint8V(v map[float32]uint8, e *Encoder) {
4103 ee, esep := e.e, e.hh.hasElemSeparators()
4104 ee.WriteMapStart(len(v))
4106 v2 := make([]float64, len(v))
4108 for k, _ := range v {
4112 sort.Sort(floatSlice(v2))
4114 for _, k2 := range v2 {
4115 ee.WriteMapElemKey()
4116 ee.EncodeFloat32(float32(k2))
4117 ee.WriteMapElemValue()
4118 ee.EncodeUint(uint64(v[float32(k2)]))
4121 for _, k2 := range v2 {
4122 ee.EncodeFloat32(float32(k2))
4123 ee.EncodeUint(uint64(v[float32(k2)]))
4128 for k2, v2 := range v {
4129 ee.WriteMapElemKey()
4130 ee.EncodeFloat32(k2)
4131 ee.WriteMapElemValue()
4132 ee.EncodeUint(uint64(v2))
4135 for k2, v2 := range v {
4136 ee.EncodeFloat32(k2)
4137 ee.EncodeUint(uint64(v2))
4144 func (e *Encoder) fastpathEncMapFloat32Uint16R(f *codecFnInfo, rv reflect.Value) {
4145 fastpathTV.EncMapFloat32Uint16V(rv2i(rv).(map[float32]uint16), e)
4147 func (_ fastpathT) EncMapFloat32Uint16V(v map[float32]uint16, e *Encoder) {
4152 ee, esep := e.e, e.hh.hasElemSeparators()
4153 ee.WriteMapStart(len(v))
4155 v2 := make([]float64, len(v))
4157 for k, _ := range v {
4161 sort.Sort(floatSlice(v2))
4163 for _, k2 := range v2 {
4164 ee.WriteMapElemKey()
4165 ee.EncodeFloat32(float32(k2))
4166 ee.WriteMapElemValue()
4167 ee.EncodeUint(uint64(v[float32(k2)]))
4170 for _, k2 := range v2 {
4171 ee.EncodeFloat32(float32(k2))
4172 ee.EncodeUint(uint64(v[float32(k2)]))
4177 for k2, v2 := range v {
4178 ee.WriteMapElemKey()
4179 ee.EncodeFloat32(k2)
4180 ee.WriteMapElemValue()
4181 ee.EncodeUint(uint64(v2))
4184 for k2, v2 := range v {
4185 ee.EncodeFloat32(k2)
4186 ee.EncodeUint(uint64(v2))
4193 func (e *Encoder) fastpathEncMapFloat32Uint32R(f *codecFnInfo, rv reflect.Value) {
4194 fastpathTV.EncMapFloat32Uint32V(rv2i(rv).(map[float32]uint32), e)
4196 func (_ fastpathT) EncMapFloat32Uint32V(v map[float32]uint32, e *Encoder) {
4201 ee, esep := e.e, e.hh.hasElemSeparators()
4202 ee.WriteMapStart(len(v))
4204 v2 := make([]float64, len(v))
4206 for k, _ := range v {
4210 sort.Sort(floatSlice(v2))
4212 for _, k2 := range v2 {
4213 ee.WriteMapElemKey()
4214 ee.EncodeFloat32(float32(k2))
4215 ee.WriteMapElemValue()
4216 ee.EncodeUint(uint64(v[float32(k2)]))
4219 for _, k2 := range v2 {
4220 ee.EncodeFloat32(float32(k2))
4221 ee.EncodeUint(uint64(v[float32(k2)]))
4226 for k2, v2 := range v {
4227 ee.WriteMapElemKey()
4228 ee.EncodeFloat32(k2)
4229 ee.WriteMapElemValue()
4230 ee.EncodeUint(uint64(v2))
4233 for k2, v2 := range v {
4234 ee.EncodeFloat32(k2)
4235 ee.EncodeUint(uint64(v2))
4242 func (e *Encoder) fastpathEncMapFloat32Uint64R(f *codecFnInfo, rv reflect.Value) {
4243 fastpathTV.EncMapFloat32Uint64V(rv2i(rv).(map[float32]uint64), e)
4245 func (_ fastpathT) EncMapFloat32Uint64V(v map[float32]uint64, e *Encoder) {
4250 ee, esep := e.e, e.hh.hasElemSeparators()
4251 ee.WriteMapStart(len(v))
4253 v2 := make([]float64, len(v))
4255 for k, _ := range v {
4259 sort.Sort(floatSlice(v2))
4261 for _, k2 := range v2 {
4262 ee.WriteMapElemKey()
4263 ee.EncodeFloat32(float32(k2))
4264 ee.WriteMapElemValue()
4265 ee.EncodeUint(uint64(v[float32(k2)]))
4268 for _, k2 := range v2 {
4269 ee.EncodeFloat32(float32(k2))
4270 ee.EncodeUint(uint64(v[float32(k2)]))
4275 for k2, v2 := range v {
4276 ee.WriteMapElemKey()
4277 ee.EncodeFloat32(k2)
4278 ee.WriteMapElemValue()
4279 ee.EncodeUint(uint64(v2))
4282 for k2, v2 := range v {
4283 ee.EncodeFloat32(k2)
4284 ee.EncodeUint(uint64(v2))
4291 func (e *Encoder) fastpathEncMapFloat32UintptrR(f *codecFnInfo, rv reflect.Value) {
4292 fastpathTV.EncMapFloat32UintptrV(rv2i(rv).(map[float32]uintptr), e)
4294 func (_ fastpathT) EncMapFloat32UintptrV(v map[float32]uintptr, e *Encoder) {
4299 ee, esep := e.e, e.hh.hasElemSeparators()
4300 ee.WriteMapStart(len(v))
4302 v2 := make([]float64, len(v))
4304 for k, _ := range v {
4308 sort.Sort(floatSlice(v2))
4310 for _, k2 := range v2 {
4311 ee.WriteMapElemKey()
4312 ee.EncodeFloat32(float32(k2))
4313 ee.WriteMapElemValue()
4314 e.encode(v[float32(k2)])
4317 for _, k2 := range v2 {
4318 ee.EncodeFloat32(float32(k2))
4319 e.encode(v[float32(k2)])
4324 for k2, v2 := range v {
4325 ee.WriteMapElemKey()
4326 ee.EncodeFloat32(k2)
4327 ee.WriteMapElemValue()
4331 for k2, v2 := range v {
4332 ee.EncodeFloat32(k2)
4340 func (e *Encoder) fastpathEncMapFloat32IntR(f *codecFnInfo, rv reflect.Value) {
4341 fastpathTV.EncMapFloat32IntV(rv2i(rv).(map[float32]int), e)
4343 func (_ fastpathT) EncMapFloat32IntV(v map[float32]int, e *Encoder) {
4348 ee, esep := e.e, e.hh.hasElemSeparators()
4349 ee.WriteMapStart(len(v))
4351 v2 := make([]float64, len(v))
4353 for k, _ := range v {
4357 sort.Sort(floatSlice(v2))
4359 for _, k2 := range v2 {
4360 ee.WriteMapElemKey()
4361 ee.EncodeFloat32(float32(k2))
4362 ee.WriteMapElemValue()
4363 ee.EncodeInt(int64(v[float32(k2)]))
4366 for _, k2 := range v2 {
4367 ee.EncodeFloat32(float32(k2))
4368 ee.EncodeInt(int64(v[float32(k2)]))
4373 for k2, v2 := range v {
4374 ee.WriteMapElemKey()
4375 ee.EncodeFloat32(k2)
4376 ee.WriteMapElemValue()
4377 ee.EncodeInt(int64(v2))
4380 for k2, v2 := range v {
4381 ee.EncodeFloat32(k2)
4382 ee.EncodeInt(int64(v2))
4389 func (e *Encoder) fastpathEncMapFloat32Int8R(f *codecFnInfo, rv reflect.Value) {
4390 fastpathTV.EncMapFloat32Int8V(rv2i(rv).(map[float32]int8), e)
4392 func (_ fastpathT) EncMapFloat32Int8V(v map[float32]int8, e *Encoder) {
4397 ee, esep := e.e, e.hh.hasElemSeparators()
4398 ee.WriteMapStart(len(v))
4400 v2 := make([]float64, len(v))
4402 for k, _ := range v {
4406 sort.Sort(floatSlice(v2))
4408 for _, k2 := range v2 {
4409 ee.WriteMapElemKey()
4410 ee.EncodeFloat32(float32(k2))
4411 ee.WriteMapElemValue()
4412 ee.EncodeInt(int64(v[float32(k2)]))
4415 for _, k2 := range v2 {
4416 ee.EncodeFloat32(float32(k2))
4417 ee.EncodeInt(int64(v[float32(k2)]))
4422 for k2, v2 := range v {
4423 ee.WriteMapElemKey()
4424 ee.EncodeFloat32(k2)
4425 ee.WriteMapElemValue()
4426 ee.EncodeInt(int64(v2))
4429 for k2, v2 := range v {
4430 ee.EncodeFloat32(k2)
4431 ee.EncodeInt(int64(v2))
4438 func (e *Encoder) fastpathEncMapFloat32Int16R(f *codecFnInfo, rv reflect.Value) {
4439 fastpathTV.EncMapFloat32Int16V(rv2i(rv).(map[float32]int16), e)
4441 func (_ fastpathT) EncMapFloat32Int16V(v map[float32]int16, e *Encoder) {
4446 ee, esep := e.e, e.hh.hasElemSeparators()
4447 ee.WriteMapStart(len(v))
4449 v2 := make([]float64, len(v))
4451 for k, _ := range v {
4455 sort.Sort(floatSlice(v2))
4457 for _, k2 := range v2 {
4458 ee.WriteMapElemKey()
4459 ee.EncodeFloat32(float32(k2))
4460 ee.WriteMapElemValue()
4461 ee.EncodeInt(int64(v[float32(k2)]))
4464 for _, k2 := range v2 {
4465 ee.EncodeFloat32(float32(k2))
4466 ee.EncodeInt(int64(v[float32(k2)]))
4471 for k2, v2 := range v {
4472 ee.WriteMapElemKey()
4473 ee.EncodeFloat32(k2)
4474 ee.WriteMapElemValue()
4475 ee.EncodeInt(int64(v2))
4478 for k2, v2 := range v {
4479 ee.EncodeFloat32(k2)
4480 ee.EncodeInt(int64(v2))
4487 func (e *Encoder) fastpathEncMapFloat32Int32R(f *codecFnInfo, rv reflect.Value) {
4488 fastpathTV.EncMapFloat32Int32V(rv2i(rv).(map[float32]int32), e)
4490 func (_ fastpathT) EncMapFloat32Int32V(v map[float32]int32, e *Encoder) {
4495 ee, esep := e.e, e.hh.hasElemSeparators()
4496 ee.WriteMapStart(len(v))
4498 v2 := make([]float64, len(v))
4500 for k, _ := range v {
4504 sort.Sort(floatSlice(v2))
4506 for _, k2 := range v2 {
4507 ee.WriteMapElemKey()
4508 ee.EncodeFloat32(float32(k2))
4509 ee.WriteMapElemValue()
4510 ee.EncodeInt(int64(v[float32(k2)]))
4513 for _, k2 := range v2 {
4514 ee.EncodeFloat32(float32(k2))
4515 ee.EncodeInt(int64(v[float32(k2)]))
4520 for k2, v2 := range v {
4521 ee.WriteMapElemKey()
4522 ee.EncodeFloat32(k2)
4523 ee.WriteMapElemValue()
4524 ee.EncodeInt(int64(v2))
4527 for k2, v2 := range v {
4528 ee.EncodeFloat32(k2)
4529 ee.EncodeInt(int64(v2))
4536 func (e *Encoder) fastpathEncMapFloat32Int64R(f *codecFnInfo, rv reflect.Value) {
4537 fastpathTV.EncMapFloat32Int64V(rv2i(rv).(map[float32]int64), e)
4539 func (_ fastpathT) EncMapFloat32Int64V(v map[float32]int64, e *Encoder) {
4544 ee, esep := e.e, e.hh.hasElemSeparators()
4545 ee.WriteMapStart(len(v))
4547 v2 := make([]float64, len(v))
4549 for k, _ := range v {
4553 sort.Sort(floatSlice(v2))
4555 for _, k2 := range v2 {
4556 ee.WriteMapElemKey()
4557 ee.EncodeFloat32(float32(k2))
4558 ee.WriteMapElemValue()
4559 ee.EncodeInt(int64(v[float32(k2)]))
4562 for _, k2 := range v2 {
4563 ee.EncodeFloat32(float32(k2))
4564 ee.EncodeInt(int64(v[float32(k2)]))
4569 for k2, v2 := range v {
4570 ee.WriteMapElemKey()
4571 ee.EncodeFloat32(k2)
4572 ee.WriteMapElemValue()
4573 ee.EncodeInt(int64(v2))
4576 for k2, v2 := range v {
4577 ee.EncodeFloat32(k2)
4578 ee.EncodeInt(int64(v2))
4585 func (e *Encoder) fastpathEncMapFloat32Float32R(f *codecFnInfo, rv reflect.Value) {
4586 fastpathTV.EncMapFloat32Float32V(rv2i(rv).(map[float32]float32), e)
4588 func (_ fastpathT) EncMapFloat32Float32V(v map[float32]float32, e *Encoder) {
4593 ee, esep := e.e, e.hh.hasElemSeparators()
4594 ee.WriteMapStart(len(v))
4596 v2 := make([]float64, len(v))
4598 for k, _ := range v {
4602 sort.Sort(floatSlice(v2))
4604 for _, k2 := range v2 {
4605 ee.WriteMapElemKey()
4606 ee.EncodeFloat32(float32(k2))
4607 ee.WriteMapElemValue()
4608 ee.EncodeFloat32(v[float32(k2)])
4611 for _, k2 := range v2 {
4612 ee.EncodeFloat32(float32(k2))
4613 ee.EncodeFloat32(v[float32(k2)])
4618 for k2, v2 := range v {
4619 ee.WriteMapElemKey()
4620 ee.EncodeFloat32(k2)
4621 ee.WriteMapElemValue()
4622 ee.EncodeFloat32(v2)
4625 for k2, v2 := range v {
4626 ee.EncodeFloat32(k2)
4627 ee.EncodeFloat32(v2)
4634 func (e *Encoder) fastpathEncMapFloat32Float64R(f *codecFnInfo, rv reflect.Value) {
4635 fastpathTV.EncMapFloat32Float64V(rv2i(rv).(map[float32]float64), e)
4637 func (_ fastpathT) EncMapFloat32Float64V(v map[float32]float64, e *Encoder) {
4642 ee, esep := e.e, e.hh.hasElemSeparators()
4643 ee.WriteMapStart(len(v))
4645 v2 := make([]float64, len(v))
4647 for k, _ := range v {
4651 sort.Sort(floatSlice(v2))
4653 for _, k2 := range v2 {
4654 ee.WriteMapElemKey()
4655 ee.EncodeFloat32(float32(k2))
4656 ee.WriteMapElemValue()
4657 ee.EncodeFloat64(v[float32(k2)])
4660 for _, k2 := range v2 {
4661 ee.EncodeFloat32(float32(k2))
4662 ee.EncodeFloat64(v[float32(k2)])
4667 for k2, v2 := range v {
4668 ee.WriteMapElemKey()
4669 ee.EncodeFloat32(k2)
4670 ee.WriteMapElemValue()
4671 ee.EncodeFloat64(v2)
4674 for k2, v2 := range v {
4675 ee.EncodeFloat32(k2)
4676 ee.EncodeFloat64(v2)
4683 func (e *Encoder) fastpathEncMapFloat32BoolR(f *codecFnInfo, rv reflect.Value) {
4684 fastpathTV.EncMapFloat32BoolV(rv2i(rv).(map[float32]bool), e)
4686 func (_ fastpathT) EncMapFloat32BoolV(v map[float32]bool, e *Encoder) {
4691 ee, esep := e.e, e.hh.hasElemSeparators()
4692 ee.WriteMapStart(len(v))
4694 v2 := make([]float64, len(v))
4696 for k, _ := range v {
4700 sort.Sort(floatSlice(v2))
4702 for _, k2 := range v2 {
4703 ee.WriteMapElemKey()
4704 ee.EncodeFloat32(float32(k2))
4705 ee.WriteMapElemValue()
4706 ee.EncodeBool(v[float32(k2)])
4709 for _, k2 := range v2 {
4710 ee.EncodeFloat32(float32(k2))
4711 ee.EncodeBool(v[float32(k2)])
4716 for k2, v2 := range v {
4717 ee.WriteMapElemKey()
4718 ee.EncodeFloat32(k2)
4719 ee.WriteMapElemValue()
4723 for k2, v2 := range v {
4724 ee.EncodeFloat32(k2)
4732 func (e *Encoder) fastpathEncMapFloat64IntfR(f *codecFnInfo, rv reflect.Value) {
4733 fastpathTV.EncMapFloat64IntfV(rv2i(rv).(map[float64]interface{}), e)
4735 func (_ fastpathT) EncMapFloat64IntfV(v map[float64]interface{}, e *Encoder) {
4740 ee, esep := e.e, e.hh.hasElemSeparators()
4741 ee.WriteMapStart(len(v))
4743 v2 := make([]float64, len(v))
4745 for k, _ := range v {
4749 sort.Sort(floatSlice(v2))
4751 for _, k2 := range v2 {
4752 ee.WriteMapElemKey()
4753 ee.EncodeFloat64(float64(k2))
4754 ee.WriteMapElemValue()
4755 e.encode(v[float64(k2)])
4758 for _, k2 := range v2 {
4759 ee.EncodeFloat64(float64(k2))
4760 e.encode(v[float64(k2)])
4765 for k2, v2 := range v {
4766 ee.WriteMapElemKey()
4767 ee.EncodeFloat64(k2)
4768 ee.WriteMapElemValue()
4772 for k2, v2 := range v {
4773 ee.EncodeFloat64(k2)
4781 func (e *Encoder) fastpathEncMapFloat64StringR(f *codecFnInfo, rv reflect.Value) {
4782 fastpathTV.EncMapFloat64StringV(rv2i(rv).(map[float64]string), e)
4784 func (_ fastpathT) EncMapFloat64StringV(v map[float64]string, e *Encoder) {
4789 ee, esep := e.e, e.hh.hasElemSeparators()
4790 ee.WriteMapStart(len(v))
4792 v2 := make([]float64, len(v))
4794 for k, _ := range v {
4798 sort.Sort(floatSlice(v2))
4800 for _, k2 := range v2 {
4801 ee.WriteMapElemKey()
4802 ee.EncodeFloat64(float64(k2))
4803 ee.WriteMapElemValue()
4804 ee.EncodeString(cUTF8, v[float64(k2)])
4807 for _, k2 := range v2 {
4808 ee.EncodeFloat64(float64(k2))
4809 ee.EncodeString(cUTF8, v[float64(k2)])
4814 for k2, v2 := range v {
4815 ee.WriteMapElemKey()
4816 ee.EncodeFloat64(k2)
4817 ee.WriteMapElemValue()
4818 ee.EncodeString(cUTF8, v2)
4821 for k2, v2 := range v {
4822 ee.EncodeFloat64(k2)
4823 ee.EncodeString(cUTF8, v2)
4830 func (e *Encoder) fastpathEncMapFloat64UintR(f *codecFnInfo, rv reflect.Value) {
4831 fastpathTV.EncMapFloat64UintV(rv2i(rv).(map[float64]uint), e)
4833 func (_ fastpathT) EncMapFloat64UintV(v map[float64]uint, e *Encoder) {
4838 ee, esep := e.e, e.hh.hasElemSeparators()
4839 ee.WriteMapStart(len(v))
4841 v2 := make([]float64, len(v))
4843 for k, _ := range v {
4847 sort.Sort(floatSlice(v2))
4849 for _, k2 := range v2 {
4850 ee.WriteMapElemKey()
4851 ee.EncodeFloat64(float64(k2))
4852 ee.WriteMapElemValue()
4853 ee.EncodeUint(uint64(v[float64(k2)]))
4856 for _, k2 := range v2 {
4857 ee.EncodeFloat64(float64(k2))
4858 ee.EncodeUint(uint64(v[float64(k2)]))
4863 for k2, v2 := range v {
4864 ee.WriteMapElemKey()
4865 ee.EncodeFloat64(k2)
4866 ee.WriteMapElemValue()
4867 ee.EncodeUint(uint64(v2))
4870 for k2, v2 := range v {
4871 ee.EncodeFloat64(k2)
4872 ee.EncodeUint(uint64(v2))
4879 func (e *Encoder) fastpathEncMapFloat64Uint8R(f *codecFnInfo, rv reflect.Value) {
4880 fastpathTV.EncMapFloat64Uint8V(rv2i(rv).(map[float64]uint8), e)
4882 func (_ fastpathT) EncMapFloat64Uint8V(v map[float64]uint8, e *Encoder) {
4887 ee, esep := e.e, e.hh.hasElemSeparators()
4888 ee.WriteMapStart(len(v))
4890 v2 := make([]float64, len(v))
4892 for k, _ := range v {
4896 sort.Sort(floatSlice(v2))
4898 for _, k2 := range v2 {
4899 ee.WriteMapElemKey()
4900 ee.EncodeFloat64(float64(k2))
4901 ee.WriteMapElemValue()
4902 ee.EncodeUint(uint64(v[float64(k2)]))
4905 for _, k2 := range v2 {
4906 ee.EncodeFloat64(float64(k2))
4907 ee.EncodeUint(uint64(v[float64(k2)]))
4912 for k2, v2 := range v {
4913 ee.WriteMapElemKey()
4914 ee.EncodeFloat64(k2)
4915 ee.WriteMapElemValue()
4916 ee.EncodeUint(uint64(v2))
4919 for k2, v2 := range v {
4920 ee.EncodeFloat64(k2)
4921 ee.EncodeUint(uint64(v2))
4928 func (e *Encoder) fastpathEncMapFloat64Uint16R(f *codecFnInfo, rv reflect.Value) {
4929 fastpathTV.EncMapFloat64Uint16V(rv2i(rv).(map[float64]uint16), e)
4931 func (_ fastpathT) EncMapFloat64Uint16V(v map[float64]uint16, e *Encoder) {
4936 ee, esep := e.e, e.hh.hasElemSeparators()
4937 ee.WriteMapStart(len(v))
4939 v2 := make([]float64, len(v))
4941 for k, _ := range v {
4945 sort.Sort(floatSlice(v2))
4947 for _, k2 := range v2 {
4948 ee.WriteMapElemKey()
4949 ee.EncodeFloat64(float64(k2))
4950 ee.WriteMapElemValue()
4951 ee.EncodeUint(uint64(v[float64(k2)]))
4954 for _, k2 := range v2 {
4955 ee.EncodeFloat64(float64(k2))
4956 ee.EncodeUint(uint64(v[float64(k2)]))
4961 for k2, v2 := range v {
4962 ee.WriteMapElemKey()
4963 ee.EncodeFloat64(k2)
4964 ee.WriteMapElemValue()
4965 ee.EncodeUint(uint64(v2))
4968 for k2, v2 := range v {
4969 ee.EncodeFloat64(k2)
4970 ee.EncodeUint(uint64(v2))
4977 func (e *Encoder) fastpathEncMapFloat64Uint32R(f *codecFnInfo, rv reflect.Value) {
4978 fastpathTV.EncMapFloat64Uint32V(rv2i(rv).(map[float64]uint32), e)
4980 func (_ fastpathT) EncMapFloat64Uint32V(v map[float64]uint32, e *Encoder) {
4985 ee, esep := e.e, e.hh.hasElemSeparators()
4986 ee.WriteMapStart(len(v))
4988 v2 := make([]float64, len(v))
4990 for k, _ := range v {
4994 sort.Sort(floatSlice(v2))
4996 for _, k2 := range v2 {
4997 ee.WriteMapElemKey()
4998 ee.EncodeFloat64(float64(k2))
4999 ee.WriteMapElemValue()
5000 ee.EncodeUint(uint64(v[float64(k2)]))
5003 for _, k2 := range v2 {
5004 ee.EncodeFloat64(float64(k2))
5005 ee.EncodeUint(uint64(v[float64(k2)]))
5010 for k2, v2 := range v {
5011 ee.WriteMapElemKey()
5012 ee.EncodeFloat64(k2)
5013 ee.WriteMapElemValue()
5014 ee.EncodeUint(uint64(v2))
5017 for k2, v2 := range v {
5018 ee.EncodeFloat64(k2)
5019 ee.EncodeUint(uint64(v2))
5026 func (e *Encoder) fastpathEncMapFloat64Uint64R(f *codecFnInfo, rv reflect.Value) {
5027 fastpathTV.EncMapFloat64Uint64V(rv2i(rv).(map[float64]uint64), e)
5029 func (_ fastpathT) EncMapFloat64Uint64V(v map[float64]uint64, e *Encoder) {
5034 ee, esep := e.e, e.hh.hasElemSeparators()
5035 ee.WriteMapStart(len(v))
5037 v2 := make([]float64, len(v))
5039 for k, _ := range v {
5043 sort.Sort(floatSlice(v2))
5045 for _, k2 := range v2 {
5046 ee.WriteMapElemKey()
5047 ee.EncodeFloat64(float64(k2))
5048 ee.WriteMapElemValue()
5049 ee.EncodeUint(uint64(v[float64(k2)]))
5052 for _, k2 := range v2 {
5053 ee.EncodeFloat64(float64(k2))
5054 ee.EncodeUint(uint64(v[float64(k2)]))
5059 for k2, v2 := range v {
5060 ee.WriteMapElemKey()
5061 ee.EncodeFloat64(k2)
5062 ee.WriteMapElemValue()
5063 ee.EncodeUint(uint64(v2))
5066 for k2, v2 := range v {
5067 ee.EncodeFloat64(k2)
5068 ee.EncodeUint(uint64(v2))
5075 func (e *Encoder) fastpathEncMapFloat64UintptrR(f *codecFnInfo, rv reflect.Value) {
5076 fastpathTV.EncMapFloat64UintptrV(rv2i(rv).(map[float64]uintptr), e)
5078 func (_ fastpathT) EncMapFloat64UintptrV(v map[float64]uintptr, e *Encoder) {
5083 ee, esep := e.e, e.hh.hasElemSeparators()
5084 ee.WriteMapStart(len(v))
5086 v2 := make([]float64, len(v))
5088 for k, _ := range v {
5092 sort.Sort(floatSlice(v2))
5094 for _, k2 := range v2 {
5095 ee.WriteMapElemKey()
5096 ee.EncodeFloat64(float64(k2))
5097 ee.WriteMapElemValue()
5098 e.encode(v[float64(k2)])
5101 for _, k2 := range v2 {
5102 ee.EncodeFloat64(float64(k2))
5103 e.encode(v[float64(k2)])
5108 for k2, v2 := range v {
5109 ee.WriteMapElemKey()
5110 ee.EncodeFloat64(k2)
5111 ee.WriteMapElemValue()
5115 for k2, v2 := range v {
5116 ee.EncodeFloat64(k2)
5124 func (e *Encoder) fastpathEncMapFloat64IntR(f *codecFnInfo, rv reflect.Value) {
5125 fastpathTV.EncMapFloat64IntV(rv2i(rv).(map[float64]int), e)
5127 func (_ fastpathT) EncMapFloat64IntV(v map[float64]int, e *Encoder) {
5132 ee, esep := e.e, e.hh.hasElemSeparators()
5133 ee.WriteMapStart(len(v))
5135 v2 := make([]float64, len(v))
5137 for k, _ := range v {
5141 sort.Sort(floatSlice(v2))
5143 for _, k2 := range v2 {
5144 ee.WriteMapElemKey()
5145 ee.EncodeFloat64(float64(k2))
5146 ee.WriteMapElemValue()
5147 ee.EncodeInt(int64(v[float64(k2)]))
5150 for _, k2 := range v2 {
5151 ee.EncodeFloat64(float64(k2))
5152 ee.EncodeInt(int64(v[float64(k2)]))
5157 for k2, v2 := range v {
5158 ee.WriteMapElemKey()
5159 ee.EncodeFloat64(k2)
5160 ee.WriteMapElemValue()
5161 ee.EncodeInt(int64(v2))
5164 for k2, v2 := range v {
5165 ee.EncodeFloat64(k2)
5166 ee.EncodeInt(int64(v2))
5173 func (e *Encoder) fastpathEncMapFloat64Int8R(f *codecFnInfo, rv reflect.Value) {
5174 fastpathTV.EncMapFloat64Int8V(rv2i(rv).(map[float64]int8), e)
5176 func (_ fastpathT) EncMapFloat64Int8V(v map[float64]int8, e *Encoder) {
5181 ee, esep := e.e, e.hh.hasElemSeparators()
5182 ee.WriteMapStart(len(v))
5184 v2 := make([]float64, len(v))
5186 for k, _ := range v {
5190 sort.Sort(floatSlice(v2))
5192 for _, k2 := range v2 {
5193 ee.WriteMapElemKey()
5194 ee.EncodeFloat64(float64(k2))
5195 ee.WriteMapElemValue()
5196 ee.EncodeInt(int64(v[float64(k2)]))
5199 for _, k2 := range v2 {
5200 ee.EncodeFloat64(float64(k2))
5201 ee.EncodeInt(int64(v[float64(k2)]))
5206 for k2, v2 := range v {
5207 ee.WriteMapElemKey()
5208 ee.EncodeFloat64(k2)
5209 ee.WriteMapElemValue()
5210 ee.EncodeInt(int64(v2))
5213 for k2, v2 := range v {
5214 ee.EncodeFloat64(k2)
5215 ee.EncodeInt(int64(v2))
5222 func (e *Encoder) fastpathEncMapFloat64Int16R(f *codecFnInfo, rv reflect.Value) {
5223 fastpathTV.EncMapFloat64Int16V(rv2i(rv).(map[float64]int16), e)
5225 func (_ fastpathT) EncMapFloat64Int16V(v map[float64]int16, e *Encoder) {
5230 ee, esep := e.e, e.hh.hasElemSeparators()
5231 ee.WriteMapStart(len(v))
5233 v2 := make([]float64, len(v))
5235 for k, _ := range v {
5239 sort.Sort(floatSlice(v2))
5241 for _, k2 := range v2 {
5242 ee.WriteMapElemKey()
5243 ee.EncodeFloat64(float64(k2))
5244 ee.WriteMapElemValue()
5245 ee.EncodeInt(int64(v[float64(k2)]))
5248 for _, k2 := range v2 {
5249 ee.EncodeFloat64(float64(k2))
5250 ee.EncodeInt(int64(v[float64(k2)]))
5255 for k2, v2 := range v {
5256 ee.WriteMapElemKey()
5257 ee.EncodeFloat64(k2)
5258 ee.WriteMapElemValue()
5259 ee.EncodeInt(int64(v2))
5262 for k2, v2 := range v {
5263 ee.EncodeFloat64(k2)
5264 ee.EncodeInt(int64(v2))
5271 func (e *Encoder) fastpathEncMapFloat64Int32R(f *codecFnInfo, rv reflect.Value) {
5272 fastpathTV.EncMapFloat64Int32V(rv2i(rv).(map[float64]int32), e)
5274 func (_ fastpathT) EncMapFloat64Int32V(v map[float64]int32, e *Encoder) {
5279 ee, esep := e.e, e.hh.hasElemSeparators()
5280 ee.WriteMapStart(len(v))
5282 v2 := make([]float64, len(v))
5284 for k, _ := range v {
5288 sort.Sort(floatSlice(v2))
5290 for _, k2 := range v2 {
5291 ee.WriteMapElemKey()
5292 ee.EncodeFloat64(float64(k2))
5293 ee.WriteMapElemValue()
5294 ee.EncodeInt(int64(v[float64(k2)]))
5297 for _, k2 := range v2 {
5298 ee.EncodeFloat64(float64(k2))
5299 ee.EncodeInt(int64(v[float64(k2)]))
5304 for k2, v2 := range v {
5305 ee.WriteMapElemKey()
5306 ee.EncodeFloat64(k2)
5307 ee.WriteMapElemValue()
5308 ee.EncodeInt(int64(v2))
5311 for k2, v2 := range v {
5312 ee.EncodeFloat64(k2)
5313 ee.EncodeInt(int64(v2))
5320 func (e *Encoder) fastpathEncMapFloat64Int64R(f *codecFnInfo, rv reflect.Value) {
5321 fastpathTV.EncMapFloat64Int64V(rv2i(rv).(map[float64]int64), e)
5323 func (_ fastpathT) EncMapFloat64Int64V(v map[float64]int64, e *Encoder) {
5328 ee, esep := e.e, e.hh.hasElemSeparators()
5329 ee.WriteMapStart(len(v))
5331 v2 := make([]float64, len(v))
5333 for k, _ := range v {
5337 sort.Sort(floatSlice(v2))
5339 for _, k2 := range v2 {
5340 ee.WriteMapElemKey()
5341 ee.EncodeFloat64(float64(k2))
5342 ee.WriteMapElemValue()
5343 ee.EncodeInt(int64(v[float64(k2)]))
5346 for _, k2 := range v2 {
5347 ee.EncodeFloat64(float64(k2))
5348 ee.EncodeInt(int64(v[float64(k2)]))
5353 for k2, v2 := range v {
5354 ee.WriteMapElemKey()
5355 ee.EncodeFloat64(k2)
5356 ee.WriteMapElemValue()
5357 ee.EncodeInt(int64(v2))
5360 for k2, v2 := range v {
5361 ee.EncodeFloat64(k2)
5362 ee.EncodeInt(int64(v2))
5369 func (e *Encoder) fastpathEncMapFloat64Float32R(f *codecFnInfo, rv reflect.Value) {
5370 fastpathTV.EncMapFloat64Float32V(rv2i(rv).(map[float64]float32), e)
5372 func (_ fastpathT) EncMapFloat64Float32V(v map[float64]float32, e *Encoder) {
5377 ee, esep := e.e, e.hh.hasElemSeparators()
5378 ee.WriteMapStart(len(v))
5380 v2 := make([]float64, len(v))
5382 for k, _ := range v {
5386 sort.Sort(floatSlice(v2))
5388 for _, k2 := range v2 {
5389 ee.WriteMapElemKey()
5390 ee.EncodeFloat64(float64(k2))
5391 ee.WriteMapElemValue()
5392 ee.EncodeFloat32(v[float64(k2)])
5395 for _, k2 := range v2 {
5396 ee.EncodeFloat64(float64(k2))
5397 ee.EncodeFloat32(v[float64(k2)])
5402 for k2, v2 := range v {
5403 ee.WriteMapElemKey()
5404 ee.EncodeFloat64(k2)
5405 ee.WriteMapElemValue()
5406 ee.EncodeFloat32(v2)
5409 for k2, v2 := range v {
5410 ee.EncodeFloat64(k2)
5411 ee.EncodeFloat32(v2)
5418 func (e *Encoder) fastpathEncMapFloat64Float64R(f *codecFnInfo, rv reflect.Value) {
5419 fastpathTV.EncMapFloat64Float64V(rv2i(rv).(map[float64]float64), e)
5421 func (_ fastpathT) EncMapFloat64Float64V(v map[float64]float64, e *Encoder) {
5426 ee, esep := e.e, e.hh.hasElemSeparators()
5427 ee.WriteMapStart(len(v))
5429 v2 := make([]float64, len(v))
5431 for k, _ := range v {
5435 sort.Sort(floatSlice(v2))
5437 for _, k2 := range v2 {
5438 ee.WriteMapElemKey()
5439 ee.EncodeFloat64(float64(k2))
5440 ee.WriteMapElemValue()
5441 ee.EncodeFloat64(v[float64(k2)])
5444 for _, k2 := range v2 {
5445 ee.EncodeFloat64(float64(k2))
5446 ee.EncodeFloat64(v[float64(k2)])
5451 for k2, v2 := range v {
5452 ee.WriteMapElemKey()
5453 ee.EncodeFloat64(k2)
5454 ee.WriteMapElemValue()
5455 ee.EncodeFloat64(v2)
5458 for k2, v2 := range v {
5459 ee.EncodeFloat64(k2)
5460 ee.EncodeFloat64(v2)
5467 func (e *Encoder) fastpathEncMapFloat64BoolR(f *codecFnInfo, rv reflect.Value) {
5468 fastpathTV.EncMapFloat64BoolV(rv2i(rv).(map[float64]bool), e)
5470 func (_ fastpathT) EncMapFloat64BoolV(v map[float64]bool, e *Encoder) {
5475 ee, esep := e.e, e.hh.hasElemSeparators()
5476 ee.WriteMapStart(len(v))
5478 v2 := make([]float64, len(v))
5480 for k, _ := range v {
5484 sort.Sort(floatSlice(v2))
5486 for _, k2 := range v2 {
5487 ee.WriteMapElemKey()
5488 ee.EncodeFloat64(float64(k2))
5489 ee.WriteMapElemValue()
5490 ee.EncodeBool(v[float64(k2)])
5493 for _, k2 := range v2 {
5494 ee.EncodeFloat64(float64(k2))
5495 ee.EncodeBool(v[float64(k2)])
5500 for k2, v2 := range v {
5501 ee.WriteMapElemKey()
5502 ee.EncodeFloat64(k2)
5503 ee.WriteMapElemValue()
5507 for k2, v2 := range v {
5508 ee.EncodeFloat64(k2)
5516 func (e *Encoder) fastpathEncMapUintIntfR(f *codecFnInfo, rv reflect.Value) {
5517 fastpathTV.EncMapUintIntfV(rv2i(rv).(map[uint]interface{}), e)
5519 func (_ fastpathT) EncMapUintIntfV(v map[uint]interface{}, e *Encoder) {
5524 ee, esep := e.e, e.hh.hasElemSeparators()
5525 ee.WriteMapStart(len(v))
5527 v2 := make([]uint64, len(v))
5529 for k, _ := range v {
5533 sort.Sort(uintSlice(v2))
5535 for _, k2 := range v2 {
5536 ee.WriteMapElemKey()
5537 ee.EncodeUint(uint64(uint(k2)))
5538 ee.WriteMapElemValue()
5539 e.encode(v[uint(k2)])
5542 for _, k2 := range v2 {
5543 ee.EncodeUint(uint64(uint(k2)))
5544 e.encode(v[uint(k2)])
5549 for k2, v2 := range v {
5550 ee.WriteMapElemKey()
5551 ee.EncodeUint(uint64(k2))
5552 ee.WriteMapElemValue()
5556 for k2, v2 := range v {
5557 ee.EncodeUint(uint64(k2))
5565 func (e *Encoder) fastpathEncMapUintStringR(f *codecFnInfo, rv reflect.Value) {
5566 fastpathTV.EncMapUintStringV(rv2i(rv).(map[uint]string), e)
5568 func (_ fastpathT) EncMapUintStringV(v map[uint]string, e *Encoder) {
5573 ee, esep := e.e, e.hh.hasElemSeparators()
5574 ee.WriteMapStart(len(v))
5576 v2 := make([]uint64, len(v))
5578 for k, _ := range v {
5582 sort.Sort(uintSlice(v2))
5584 for _, k2 := range v2 {
5585 ee.WriteMapElemKey()
5586 ee.EncodeUint(uint64(uint(k2)))
5587 ee.WriteMapElemValue()
5588 ee.EncodeString(cUTF8, v[uint(k2)])
5591 for _, k2 := range v2 {
5592 ee.EncodeUint(uint64(uint(k2)))
5593 ee.EncodeString(cUTF8, v[uint(k2)])
5598 for k2, v2 := range v {
5599 ee.WriteMapElemKey()
5600 ee.EncodeUint(uint64(k2))
5601 ee.WriteMapElemValue()
5602 ee.EncodeString(cUTF8, v2)
5605 for k2, v2 := range v {
5606 ee.EncodeUint(uint64(k2))
5607 ee.EncodeString(cUTF8, v2)
5614 func (e *Encoder) fastpathEncMapUintUintR(f *codecFnInfo, rv reflect.Value) {
5615 fastpathTV.EncMapUintUintV(rv2i(rv).(map[uint]uint), e)
5617 func (_ fastpathT) EncMapUintUintV(v map[uint]uint, e *Encoder) {
5622 ee, esep := e.e, e.hh.hasElemSeparators()
5623 ee.WriteMapStart(len(v))
5625 v2 := make([]uint64, len(v))
5627 for k, _ := range v {
5631 sort.Sort(uintSlice(v2))
5633 for _, k2 := range v2 {
5634 ee.WriteMapElemKey()
5635 ee.EncodeUint(uint64(uint(k2)))
5636 ee.WriteMapElemValue()
5637 ee.EncodeUint(uint64(v[uint(k2)]))
5640 for _, k2 := range v2 {
5641 ee.EncodeUint(uint64(uint(k2)))
5642 ee.EncodeUint(uint64(v[uint(k2)]))
5647 for k2, v2 := range v {
5648 ee.WriteMapElemKey()
5649 ee.EncodeUint(uint64(k2))
5650 ee.WriteMapElemValue()
5651 ee.EncodeUint(uint64(v2))
5654 for k2, v2 := range v {
5655 ee.EncodeUint(uint64(k2))
5656 ee.EncodeUint(uint64(v2))
5663 func (e *Encoder) fastpathEncMapUintUint8R(f *codecFnInfo, rv reflect.Value) {
5664 fastpathTV.EncMapUintUint8V(rv2i(rv).(map[uint]uint8), e)
5666 func (_ fastpathT) EncMapUintUint8V(v map[uint]uint8, e *Encoder) {
5671 ee, esep := e.e, e.hh.hasElemSeparators()
5672 ee.WriteMapStart(len(v))
5674 v2 := make([]uint64, len(v))
5676 for k, _ := range v {
5680 sort.Sort(uintSlice(v2))
5682 for _, k2 := range v2 {
5683 ee.WriteMapElemKey()
5684 ee.EncodeUint(uint64(uint(k2)))
5685 ee.WriteMapElemValue()
5686 ee.EncodeUint(uint64(v[uint(k2)]))
5689 for _, k2 := range v2 {
5690 ee.EncodeUint(uint64(uint(k2)))
5691 ee.EncodeUint(uint64(v[uint(k2)]))
5696 for k2, v2 := range v {
5697 ee.WriteMapElemKey()
5698 ee.EncodeUint(uint64(k2))
5699 ee.WriteMapElemValue()
5700 ee.EncodeUint(uint64(v2))
5703 for k2, v2 := range v {
5704 ee.EncodeUint(uint64(k2))
5705 ee.EncodeUint(uint64(v2))
5712 func (e *Encoder) fastpathEncMapUintUint16R(f *codecFnInfo, rv reflect.Value) {
5713 fastpathTV.EncMapUintUint16V(rv2i(rv).(map[uint]uint16), e)
5715 func (_ fastpathT) EncMapUintUint16V(v map[uint]uint16, e *Encoder) {
5720 ee, esep := e.e, e.hh.hasElemSeparators()
5721 ee.WriteMapStart(len(v))
5723 v2 := make([]uint64, len(v))
5725 for k, _ := range v {
5729 sort.Sort(uintSlice(v2))
5731 for _, k2 := range v2 {
5732 ee.WriteMapElemKey()
5733 ee.EncodeUint(uint64(uint(k2)))
5734 ee.WriteMapElemValue()
5735 ee.EncodeUint(uint64(v[uint(k2)]))
5738 for _, k2 := range v2 {
5739 ee.EncodeUint(uint64(uint(k2)))
5740 ee.EncodeUint(uint64(v[uint(k2)]))
5745 for k2, v2 := range v {
5746 ee.WriteMapElemKey()
5747 ee.EncodeUint(uint64(k2))
5748 ee.WriteMapElemValue()
5749 ee.EncodeUint(uint64(v2))
5752 for k2, v2 := range v {
5753 ee.EncodeUint(uint64(k2))
5754 ee.EncodeUint(uint64(v2))
5761 func (e *Encoder) fastpathEncMapUintUint32R(f *codecFnInfo, rv reflect.Value) {
5762 fastpathTV.EncMapUintUint32V(rv2i(rv).(map[uint]uint32), e)
5764 func (_ fastpathT) EncMapUintUint32V(v map[uint]uint32, e *Encoder) {
5769 ee, esep := e.e, e.hh.hasElemSeparators()
5770 ee.WriteMapStart(len(v))
5772 v2 := make([]uint64, len(v))
5774 for k, _ := range v {
5778 sort.Sort(uintSlice(v2))
5780 for _, k2 := range v2 {
5781 ee.WriteMapElemKey()
5782 ee.EncodeUint(uint64(uint(k2)))
5783 ee.WriteMapElemValue()
5784 ee.EncodeUint(uint64(v[uint(k2)]))
5787 for _, k2 := range v2 {
5788 ee.EncodeUint(uint64(uint(k2)))
5789 ee.EncodeUint(uint64(v[uint(k2)]))
5794 for k2, v2 := range v {
5795 ee.WriteMapElemKey()
5796 ee.EncodeUint(uint64(k2))
5797 ee.WriteMapElemValue()
5798 ee.EncodeUint(uint64(v2))
5801 for k2, v2 := range v {
5802 ee.EncodeUint(uint64(k2))
5803 ee.EncodeUint(uint64(v2))
5810 func (e *Encoder) fastpathEncMapUintUint64R(f *codecFnInfo, rv reflect.Value) {
5811 fastpathTV.EncMapUintUint64V(rv2i(rv).(map[uint]uint64), e)
5813 func (_ fastpathT) EncMapUintUint64V(v map[uint]uint64, e *Encoder) {
5818 ee, esep := e.e, e.hh.hasElemSeparators()
5819 ee.WriteMapStart(len(v))
5821 v2 := make([]uint64, len(v))
5823 for k, _ := range v {
5827 sort.Sort(uintSlice(v2))
5829 for _, k2 := range v2 {
5830 ee.WriteMapElemKey()
5831 ee.EncodeUint(uint64(uint(k2)))
5832 ee.WriteMapElemValue()
5833 ee.EncodeUint(uint64(v[uint(k2)]))
5836 for _, k2 := range v2 {
5837 ee.EncodeUint(uint64(uint(k2)))
5838 ee.EncodeUint(uint64(v[uint(k2)]))
5843 for k2, v2 := range v {
5844 ee.WriteMapElemKey()
5845 ee.EncodeUint(uint64(k2))
5846 ee.WriteMapElemValue()
5847 ee.EncodeUint(uint64(v2))
5850 for k2, v2 := range v {
5851 ee.EncodeUint(uint64(k2))
5852 ee.EncodeUint(uint64(v2))
5859 func (e *Encoder) fastpathEncMapUintUintptrR(f *codecFnInfo, rv reflect.Value) {
5860 fastpathTV.EncMapUintUintptrV(rv2i(rv).(map[uint]uintptr), e)
5862 func (_ fastpathT) EncMapUintUintptrV(v map[uint]uintptr, e *Encoder) {
5867 ee, esep := e.e, e.hh.hasElemSeparators()
5868 ee.WriteMapStart(len(v))
5870 v2 := make([]uint64, len(v))
5872 for k, _ := range v {
5876 sort.Sort(uintSlice(v2))
5878 for _, k2 := range v2 {
5879 ee.WriteMapElemKey()
5880 ee.EncodeUint(uint64(uint(k2)))
5881 ee.WriteMapElemValue()
5882 e.encode(v[uint(k2)])
5885 for _, k2 := range v2 {
5886 ee.EncodeUint(uint64(uint(k2)))
5887 e.encode(v[uint(k2)])
5892 for k2, v2 := range v {
5893 ee.WriteMapElemKey()
5894 ee.EncodeUint(uint64(k2))
5895 ee.WriteMapElemValue()
5899 for k2, v2 := range v {
5900 ee.EncodeUint(uint64(k2))
5908 func (e *Encoder) fastpathEncMapUintIntR(f *codecFnInfo, rv reflect.Value) {
5909 fastpathTV.EncMapUintIntV(rv2i(rv).(map[uint]int), e)
5911 func (_ fastpathT) EncMapUintIntV(v map[uint]int, e *Encoder) {
5916 ee, esep := e.e, e.hh.hasElemSeparators()
5917 ee.WriteMapStart(len(v))
5919 v2 := make([]uint64, len(v))
5921 for k, _ := range v {
5925 sort.Sort(uintSlice(v2))
5927 for _, k2 := range v2 {
5928 ee.WriteMapElemKey()
5929 ee.EncodeUint(uint64(uint(k2)))
5930 ee.WriteMapElemValue()
5931 ee.EncodeInt(int64(v[uint(k2)]))
5934 for _, k2 := range v2 {
5935 ee.EncodeUint(uint64(uint(k2)))
5936 ee.EncodeInt(int64(v[uint(k2)]))
5941 for k2, v2 := range v {
5942 ee.WriteMapElemKey()
5943 ee.EncodeUint(uint64(k2))
5944 ee.WriteMapElemValue()
5945 ee.EncodeInt(int64(v2))
5948 for k2, v2 := range v {
5949 ee.EncodeUint(uint64(k2))
5950 ee.EncodeInt(int64(v2))
5957 func (e *Encoder) fastpathEncMapUintInt8R(f *codecFnInfo, rv reflect.Value) {
5958 fastpathTV.EncMapUintInt8V(rv2i(rv).(map[uint]int8), e)
5960 func (_ fastpathT) EncMapUintInt8V(v map[uint]int8, e *Encoder) {
5965 ee, esep := e.e, e.hh.hasElemSeparators()
5966 ee.WriteMapStart(len(v))
5968 v2 := make([]uint64, len(v))
5970 for k, _ := range v {
5974 sort.Sort(uintSlice(v2))
5976 for _, k2 := range v2 {
5977 ee.WriteMapElemKey()
5978 ee.EncodeUint(uint64(uint(k2)))
5979 ee.WriteMapElemValue()
5980 ee.EncodeInt(int64(v[uint(k2)]))
5983 for _, k2 := range v2 {
5984 ee.EncodeUint(uint64(uint(k2)))
5985 ee.EncodeInt(int64(v[uint(k2)]))
5990 for k2, v2 := range v {
5991 ee.WriteMapElemKey()
5992 ee.EncodeUint(uint64(k2))
5993 ee.WriteMapElemValue()
5994 ee.EncodeInt(int64(v2))
5997 for k2, v2 := range v {
5998 ee.EncodeUint(uint64(k2))
5999 ee.EncodeInt(int64(v2))
6006 func (e *Encoder) fastpathEncMapUintInt16R(f *codecFnInfo, rv reflect.Value) {
6007 fastpathTV.EncMapUintInt16V(rv2i(rv).(map[uint]int16), e)
6009 func (_ fastpathT) EncMapUintInt16V(v map[uint]int16, e *Encoder) {
6014 ee, esep := e.e, e.hh.hasElemSeparators()
6015 ee.WriteMapStart(len(v))
6017 v2 := make([]uint64, len(v))
6019 for k, _ := range v {
6023 sort.Sort(uintSlice(v2))
6025 for _, k2 := range v2 {
6026 ee.WriteMapElemKey()
6027 ee.EncodeUint(uint64(uint(k2)))
6028 ee.WriteMapElemValue()
6029 ee.EncodeInt(int64(v[uint(k2)]))
6032 for _, k2 := range v2 {
6033 ee.EncodeUint(uint64(uint(k2)))
6034 ee.EncodeInt(int64(v[uint(k2)]))
6039 for k2, v2 := range v {
6040 ee.WriteMapElemKey()
6041 ee.EncodeUint(uint64(k2))
6042 ee.WriteMapElemValue()
6043 ee.EncodeInt(int64(v2))
6046 for k2, v2 := range v {
6047 ee.EncodeUint(uint64(k2))
6048 ee.EncodeInt(int64(v2))
6055 func (e *Encoder) fastpathEncMapUintInt32R(f *codecFnInfo, rv reflect.Value) {
6056 fastpathTV.EncMapUintInt32V(rv2i(rv).(map[uint]int32), e)
6058 func (_ fastpathT) EncMapUintInt32V(v map[uint]int32, e *Encoder) {
6063 ee, esep := e.e, e.hh.hasElemSeparators()
6064 ee.WriteMapStart(len(v))
6066 v2 := make([]uint64, len(v))
6068 for k, _ := range v {
6072 sort.Sort(uintSlice(v2))
6074 for _, k2 := range v2 {
6075 ee.WriteMapElemKey()
6076 ee.EncodeUint(uint64(uint(k2)))
6077 ee.WriteMapElemValue()
6078 ee.EncodeInt(int64(v[uint(k2)]))
6081 for _, k2 := range v2 {
6082 ee.EncodeUint(uint64(uint(k2)))
6083 ee.EncodeInt(int64(v[uint(k2)]))
6088 for k2, v2 := range v {
6089 ee.WriteMapElemKey()
6090 ee.EncodeUint(uint64(k2))
6091 ee.WriteMapElemValue()
6092 ee.EncodeInt(int64(v2))
6095 for k2, v2 := range v {
6096 ee.EncodeUint(uint64(k2))
6097 ee.EncodeInt(int64(v2))
6104 func (e *Encoder) fastpathEncMapUintInt64R(f *codecFnInfo, rv reflect.Value) {
6105 fastpathTV.EncMapUintInt64V(rv2i(rv).(map[uint]int64), e)
6107 func (_ fastpathT) EncMapUintInt64V(v map[uint]int64, e *Encoder) {
6112 ee, esep := e.e, e.hh.hasElemSeparators()
6113 ee.WriteMapStart(len(v))
6115 v2 := make([]uint64, len(v))
6117 for k, _ := range v {
6121 sort.Sort(uintSlice(v2))
6123 for _, k2 := range v2 {
6124 ee.WriteMapElemKey()
6125 ee.EncodeUint(uint64(uint(k2)))
6126 ee.WriteMapElemValue()
6127 ee.EncodeInt(int64(v[uint(k2)]))
6130 for _, k2 := range v2 {
6131 ee.EncodeUint(uint64(uint(k2)))
6132 ee.EncodeInt(int64(v[uint(k2)]))
6137 for k2, v2 := range v {
6138 ee.WriteMapElemKey()
6139 ee.EncodeUint(uint64(k2))
6140 ee.WriteMapElemValue()
6141 ee.EncodeInt(int64(v2))
6144 for k2, v2 := range v {
6145 ee.EncodeUint(uint64(k2))
6146 ee.EncodeInt(int64(v2))
6153 func (e *Encoder) fastpathEncMapUintFloat32R(f *codecFnInfo, rv reflect.Value) {
6154 fastpathTV.EncMapUintFloat32V(rv2i(rv).(map[uint]float32), e)
6156 func (_ fastpathT) EncMapUintFloat32V(v map[uint]float32, e *Encoder) {
6161 ee, esep := e.e, e.hh.hasElemSeparators()
6162 ee.WriteMapStart(len(v))
6164 v2 := make([]uint64, len(v))
6166 for k, _ := range v {
6170 sort.Sort(uintSlice(v2))
6172 for _, k2 := range v2 {
6173 ee.WriteMapElemKey()
6174 ee.EncodeUint(uint64(uint(k2)))
6175 ee.WriteMapElemValue()
6176 ee.EncodeFloat32(v[uint(k2)])
6179 for _, k2 := range v2 {
6180 ee.EncodeUint(uint64(uint(k2)))
6181 ee.EncodeFloat32(v[uint(k2)])
6186 for k2, v2 := range v {
6187 ee.WriteMapElemKey()
6188 ee.EncodeUint(uint64(k2))
6189 ee.WriteMapElemValue()
6190 ee.EncodeFloat32(v2)
6193 for k2, v2 := range v {
6194 ee.EncodeUint(uint64(k2))
6195 ee.EncodeFloat32(v2)
6202 func (e *Encoder) fastpathEncMapUintFloat64R(f *codecFnInfo, rv reflect.Value) {
6203 fastpathTV.EncMapUintFloat64V(rv2i(rv).(map[uint]float64), e)
6205 func (_ fastpathT) EncMapUintFloat64V(v map[uint]float64, e *Encoder) {
6210 ee, esep := e.e, e.hh.hasElemSeparators()
6211 ee.WriteMapStart(len(v))
6213 v2 := make([]uint64, len(v))
6215 for k, _ := range v {
6219 sort.Sort(uintSlice(v2))
6221 for _, k2 := range v2 {
6222 ee.WriteMapElemKey()
6223 ee.EncodeUint(uint64(uint(k2)))
6224 ee.WriteMapElemValue()
6225 ee.EncodeFloat64(v[uint(k2)])
6228 for _, k2 := range v2 {
6229 ee.EncodeUint(uint64(uint(k2)))
6230 ee.EncodeFloat64(v[uint(k2)])
6235 for k2, v2 := range v {
6236 ee.WriteMapElemKey()
6237 ee.EncodeUint(uint64(k2))
6238 ee.WriteMapElemValue()
6239 ee.EncodeFloat64(v2)
6242 for k2, v2 := range v {
6243 ee.EncodeUint(uint64(k2))
6244 ee.EncodeFloat64(v2)
6251 func (e *Encoder) fastpathEncMapUintBoolR(f *codecFnInfo, rv reflect.Value) {
6252 fastpathTV.EncMapUintBoolV(rv2i(rv).(map[uint]bool), e)
6254 func (_ fastpathT) EncMapUintBoolV(v map[uint]bool, e *Encoder) {
6259 ee, esep := e.e, e.hh.hasElemSeparators()
6260 ee.WriteMapStart(len(v))
6262 v2 := make([]uint64, len(v))
6264 for k, _ := range v {
6268 sort.Sort(uintSlice(v2))
6270 for _, k2 := range v2 {
6271 ee.WriteMapElemKey()
6272 ee.EncodeUint(uint64(uint(k2)))
6273 ee.WriteMapElemValue()
6274 ee.EncodeBool(v[uint(k2)])
6277 for _, k2 := range v2 {
6278 ee.EncodeUint(uint64(uint(k2)))
6279 ee.EncodeBool(v[uint(k2)])
6284 for k2, v2 := range v {
6285 ee.WriteMapElemKey()
6286 ee.EncodeUint(uint64(k2))
6287 ee.WriteMapElemValue()
6291 for k2, v2 := range v {
6292 ee.EncodeUint(uint64(k2))
6300 func (e *Encoder) fastpathEncMapUint8IntfR(f *codecFnInfo, rv reflect.Value) {
6301 fastpathTV.EncMapUint8IntfV(rv2i(rv).(map[uint8]interface{}), e)
6303 func (_ fastpathT) EncMapUint8IntfV(v map[uint8]interface{}, e *Encoder) {
6308 ee, esep := e.e, e.hh.hasElemSeparators()
6309 ee.WriteMapStart(len(v))
6311 v2 := make([]uint64, len(v))
6313 for k, _ := range v {
6317 sort.Sort(uintSlice(v2))
6319 for _, k2 := range v2 {
6320 ee.WriteMapElemKey()
6321 ee.EncodeUint(uint64(uint8(k2)))
6322 ee.WriteMapElemValue()
6323 e.encode(v[uint8(k2)])
6326 for _, k2 := range v2 {
6327 ee.EncodeUint(uint64(uint8(k2)))
6328 e.encode(v[uint8(k2)])
6333 for k2, v2 := range v {
6334 ee.WriteMapElemKey()
6335 ee.EncodeUint(uint64(k2))
6336 ee.WriteMapElemValue()
6340 for k2, v2 := range v {
6341 ee.EncodeUint(uint64(k2))
6349 func (e *Encoder) fastpathEncMapUint8StringR(f *codecFnInfo, rv reflect.Value) {
6350 fastpathTV.EncMapUint8StringV(rv2i(rv).(map[uint8]string), e)
6352 func (_ fastpathT) EncMapUint8StringV(v map[uint8]string, e *Encoder) {
6357 ee, esep := e.e, e.hh.hasElemSeparators()
6358 ee.WriteMapStart(len(v))
6360 v2 := make([]uint64, len(v))
6362 for k, _ := range v {
6366 sort.Sort(uintSlice(v2))
6368 for _, k2 := range v2 {
6369 ee.WriteMapElemKey()
6370 ee.EncodeUint(uint64(uint8(k2)))
6371 ee.WriteMapElemValue()
6372 ee.EncodeString(cUTF8, v[uint8(k2)])
6375 for _, k2 := range v2 {
6376 ee.EncodeUint(uint64(uint8(k2)))
6377 ee.EncodeString(cUTF8, v[uint8(k2)])
6382 for k2, v2 := range v {
6383 ee.WriteMapElemKey()
6384 ee.EncodeUint(uint64(k2))
6385 ee.WriteMapElemValue()
6386 ee.EncodeString(cUTF8, v2)
6389 for k2, v2 := range v {
6390 ee.EncodeUint(uint64(k2))
6391 ee.EncodeString(cUTF8, v2)
6398 func (e *Encoder) fastpathEncMapUint8UintR(f *codecFnInfo, rv reflect.Value) {
6399 fastpathTV.EncMapUint8UintV(rv2i(rv).(map[uint8]uint), e)
6401 func (_ fastpathT) EncMapUint8UintV(v map[uint8]uint, e *Encoder) {
6406 ee, esep := e.e, e.hh.hasElemSeparators()
6407 ee.WriteMapStart(len(v))
6409 v2 := make([]uint64, len(v))
6411 for k, _ := range v {
6415 sort.Sort(uintSlice(v2))
6417 for _, k2 := range v2 {
6418 ee.WriteMapElemKey()
6419 ee.EncodeUint(uint64(uint8(k2)))
6420 ee.WriteMapElemValue()
6421 ee.EncodeUint(uint64(v[uint8(k2)]))
6424 for _, k2 := range v2 {
6425 ee.EncodeUint(uint64(uint8(k2)))
6426 ee.EncodeUint(uint64(v[uint8(k2)]))
6431 for k2, v2 := range v {
6432 ee.WriteMapElemKey()
6433 ee.EncodeUint(uint64(k2))
6434 ee.WriteMapElemValue()
6435 ee.EncodeUint(uint64(v2))
6438 for k2, v2 := range v {
6439 ee.EncodeUint(uint64(k2))
6440 ee.EncodeUint(uint64(v2))
6447 func (e *Encoder) fastpathEncMapUint8Uint8R(f *codecFnInfo, rv reflect.Value) {
6448 fastpathTV.EncMapUint8Uint8V(rv2i(rv).(map[uint8]uint8), e)
6450 func (_ fastpathT) EncMapUint8Uint8V(v map[uint8]uint8, e *Encoder) {
6455 ee, esep := e.e, e.hh.hasElemSeparators()
6456 ee.WriteMapStart(len(v))
6458 v2 := make([]uint64, len(v))
6460 for k, _ := range v {
6464 sort.Sort(uintSlice(v2))
6466 for _, k2 := range v2 {
6467 ee.WriteMapElemKey()
6468 ee.EncodeUint(uint64(uint8(k2)))
6469 ee.WriteMapElemValue()
6470 ee.EncodeUint(uint64(v[uint8(k2)]))
6473 for _, k2 := range v2 {
6474 ee.EncodeUint(uint64(uint8(k2)))
6475 ee.EncodeUint(uint64(v[uint8(k2)]))
6480 for k2, v2 := range v {
6481 ee.WriteMapElemKey()
6482 ee.EncodeUint(uint64(k2))
6483 ee.WriteMapElemValue()
6484 ee.EncodeUint(uint64(v2))
6487 for k2, v2 := range v {
6488 ee.EncodeUint(uint64(k2))
6489 ee.EncodeUint(uint64(v2))
6496 func (e *Encoder) fastpathEncMapUint8Uint16R(f *codecFnInfo, rv reflect.Value) {
6497 fastpathTV.EncMapUint8Uint16V(rv2i(rv).(map[uint8]uint16), e)
6499 func (_ fastpathT) EncMapUint8Uint16V(v map[uint8]uint16, e *Encoder) {
6504 ee, esep := e.e, e.hh.hasElemSeparators()
6505 ee.WriteMapStart(len(v))
6507 v2 := make([]uint64, len(v))
6509 for k, _ := range v {
6513 sort.Sort(uintSlice(v2))
6515 for _, k2 := range v2 {
6516 ee.WriteMapElemKey()
6517 ee.EncodeUint(uint64(uint8(k2)))
6518 ee.WriteMapElemValue()
6519 ee.EncodeUint(uint64(v[uint8(k2)]))
6522 for _, k2 := range v2 {
6523 ee.EncodeUint(uint64(uint8(k2)))
6524 ee.EncodeUint(uint64(v[uint8(k2)]))
6529 for k2, v2 := range v {
6530 ee.WriteMapElemKey()
6531 ee.EncodeUint(uint64(k2))
6532 ee.WriteMapElemValue()
6533 ee.EncodeUint(uint64(v2))
6536 for k2, v2 := range v {
6537 ee.EncodeUint(uint64(k2))
6538 ee.EncodeUint(uint64(v2))
6545 func (e *Encoder) fastpathEncMapUint8Uint32R(f *codecFnInfo, rv reflect.Value) {
6546 fastpathTV.EncMapUint8Uint32V(rv2i(rv).(map[uint8]uint32), e)
6548 func (_ fastpathT) EncMapUint8Uint32V(v map[uint8]uint32, e *Encoder) {
6553 ee, esep := e.e, e.hh.hasElemSeparators()
6554 ee.WriteMapStart(len(v))
6556 v2 := make([]uint64, len(v))
6558 for k, _ := range v {
6562 sort.Sort(uintSlice(v2))
6564 for _, k2 := range v2 {
6565 ee.WriteMapElemKey()
6566 ee.EncodeUint(uint64(uint8(k2)))
6567 ee.WriteMapElemValue()
6568 ee.EncodeUint(uint64(v[uint8(k2)]))
6571 for _, k2 := range v2 {
6572 ee.EncodeUint(uint64(uint8(k2)))
6573 ee.EncodeUint(uint64(v[uint8(k2)]))
6578 for k2, v2 := range v {
6579 ee.WriteMapElemKey()
6580 ee.EncodeUint(uint64(k2))
6581 ee.WriteMapElemValue()
6582 ee.EncodeUint(uint64(v2))
6585 for k2, v2 := range v {
6586 ee.EncodeUint(uint64(k2))
6587 ee.EncodeUint(uint64(v2))
6594 func (e *Encoder) fastpathEncMapUint8Uint64R(f *codecFnInfo, rv reflect.Value) {
6595 fastpathTV.EncMapUint8Uint64V(rv2i(rv).(map[uint8]uint64), e)
6597 func (_ fastpathT) EncMapUint8Uint64V(v map[uint8]uint64, e *Encoder) {
6602 ee, esep := e.e, e.hh.hasElemSeparators()
6603 ee.WriteMapStart(len(v))
6605 v2 := make([]uint64, len(v))
6607 for k, _ := range v {
6611 sort.Sort(uintSlice(v2))
6613 for _, k2 := range v2 {
6614 ee.WriteMapElemKey()
6615 ee.EncodeUint(uint64(uint8(k2)))
6616 ee.WriteMapElemValue()
6617 ee.EncodeUint(uint64(v[uint8(k2)]))
6620 for _, k2 := range v2 {
6621 ee.EncodeUint(uint64(uint8(k2)))
6622 ee.EncodeUint(uint64(v[uint8(k2)]))
6627 for k2, v2 := range v {
6628 ee.WriteMapElemKey()
6629 ee.EncodeUint(uint64(k2))
6630 ee.WriteMapElemValue()
6631 ee.EncodeUint(uint64(v2))
6634 for k2, v2 := range v {
6635 ee.EncodeUint(uint64(k2))
6636 ee.EncodeUint(uint64(v2))
6643 func (e *Encoder) fastpathEncMapUint8UintptrR(f *codecFnInfo, rv reflect.Value) {
6644 fastpathTV.EncMapUint8UintptrV(rv2i(rv).(map[uint8]uintptr), e)
6646 func (_ fastpathT) EncMapUint8UintptrV(v map[uint8]uintptr, e *Encoder) {
6651 ee, esep := e.e, e.hh.hasElemSeparators()
6652 ee.WriteMapStart(len(v))
6654 v2 := make([]uint64, len(v))
6656 for k, _ := range v {
6660 sort.Sort(uintSlice(v2))
6662 for _, k2 := range v2 {
6663 ee.WriteMapElemKey()
6664 ee.EncodeUint(uint64(uint8(k2)))
6665 ee.WriteMapElemValue()
6666 e.encode(v[uint8(k2)])
6669 for _, k2 := range v2 {
6670 ee.EncodeUint(uint64(uint8(k2)))
6671 e.encode(v[uint8(k2)])
6676 for k2, v2 := range v {
6677 ee.WriteMapElemKey()
6678 ee.EncodeUint(uint64(k2))
6679 ee.WriteMapElemValue()
6683 for k2, v2 := range v {
6684 ee.EncodeUint(uint64(k2))
6692 func (e *Encoder) fastpathEncMapUint8IntR(f *codecFnInfo, rv reflect.Value) {
6693 fastpathTV.EncMapUint8IntV(rv2i(rv).(map[uint8]int), e)
6695 func (_ fastpathT) EncMapUint8IntV(v map[uint8]int, e *Encoder) {
6700 ee, esep := e.e, e.hh.hasElemSeparators()
6701 ee.WriteMapStart(len(v))
6703 v2 := make([]uint64, len(v))
6705 for k, _ := range v {
6709 sort.Sort(uintSlice(v2))
6711 for _, k2 := range v2 {
6712 ee.WriteMapElemKey()
6713 ee.EncodeUint(uint64(uint8(k2)))
6714 ee.WriteMapElemValue()
6715 ee.EncodeInt(int64(v[uint8(k2)]))
6718 for _, k2 := range v2 {
6719 ee.EncodeUint(uint64(uint8(k2)))
6720 ee.EncodeInt(int64(v[uint8(k2)]))
6725 for k2, v2 := range v {
6726 ee.WriteMapElemKey()
6727 ee.EncodeUint(uint64(k2))
6728 ee.WriteMapElemValue()
6729 ee.EncodeInt(int64(v2))
6732 for k2, v2 := range v {
6733 ee.EncodeUint(uint64(k2))
6734 ee.EncodeInt(int64(v2))
6741 func (e *Encoder) fastpathEncMapUint8Int8R(f *codecFnInfo, rv reflect.Value) {
6742 fastpathTV.EncMapUint8Int8V(rv2i(rv).(map[uint8]int8), e)
6744 func (_ fastpathT) EncMapUint8Int8V(v map[uint8]int8, e *Encoder) {
6749 ee, esep := e.e, e.hh.hasElemSeparators()
6750 ee.WriteMapStart(len(v))
6752 v2 := make([]uint64, len(v))
6754 for k, _ := range v {
6758 sort.Sort(uintSlice(v2))
6760 for _, k2 := range v2 {
6761 ee.WriteMapElemKey()
6762 ee.EncodeUint(uint64(uint8(k2)))
6763 ee.WriteMapElemValue()
6764 ee.EncodeInt(int64(v[uint8(k2)]))
6767 for _, k2 := range v2 {
6768 ee.EncodeUint(uint64(uint8(k2)))
6769 ee.EncodeInt(int64(v[uint8(k2)]))
6774 for k2, v2 := range v {
6775 ee.WriteMapElemKey()
6776 ee.EncodeUint(uint64(k2))
6777 ee.WriteMapElemValue()
6778 ee.EncodeInt(int64(v2))
6781 for k2, v2 := range v {
6782 ee.EncodeUint(uint64(k2))
6783 ee.EncodeInt(int64(v2))
6790 func (e *Encoder) fastpathEncMapUint8Int16R(f *codecFnInfo, rv reflect.Value) {
6791 fastpathTV.EncMapUint8Int16V(rv2i(rv).(map[uint8]int16), e)
6793 func (_ fastpathT) EncMapUint8Int16V(v map[uint8]int16, e *Encoder) {
6798 ee, esep := e.e, e.hh.hasElemSeparators()
6799 ee.WriteMapStart(len(v))
6801 v2 := make([]uint64, len(v))
6803 for k, _ := range v {
6807 sort.Sort(uintSlice(v2))
6809 for _, k2 := range v2 {
6810 ee.WriteMapElemKey()
6811 ee.EncodeUint(uint64(uint8(k2)))
6812 ee.WriteMapElemValue()
6813 ee.EncodeInt(int64(v[uint8(k2)]))
6816 for _, k2 := range v2 {
6817 ee.EncodeUint(uint64(uint8(k2)))
6818 ee.EncodeInt(int64(v[uint8(k2)]))
6823 for k2, v2 := range v {
6824 ee.WriteMapElemKey()
6825 ee.EncodeUint(uint64(k2))
6826 ee.WriteMapElemValue()
6827 ee.EncodeInt(int64(v2))
6830 for k2, v2 := range v {
6831 ee.EncodeUint(uint64(k2))
6832 ee.EncodeInt(int64(v2))
6839 func (e *Encoder) fastpathEncMapUint8Int32R(f *codecFnInfo, rv reflect.Value) {
6840 fastpathTV.EncMapUint8Int32V(rv2i(rv).(map[uint8]int32), e)
6842 func (_ fastpathT) EncMapUint8Int32V(v map[uint8]int32, e *Encoder) {
6847 ee, esep := e.e, e.hh.hasElemSeparators()
6848 ee.WriteMapStart(len(v))
6850 v2 := make([]uint64, len(v))
6852 for k, _ := range v {
6856 sort.Sort(uintSlice(v2))
6858 for _, k2 := range v2 {
6859 ee.WriteMapElemKey()
6860 ee.EncodeUint(uint64(uint8(k2)))
6861 ee.WriteMapElemValue()
6862 ee.EncodeInt(int64(v[uint8(k2)]))
6865 for _, k2 := range v2 {
6866 ee.EncodeUint(uint64(uint8(k2)))
6867 ee.EncodeInt(int64(v[uint8(k2)]))
6872 for k2, v2 := range v {
6873 ee.WriteMapElemKey()
6874 ee.EncodeUint(uint64(k2))
6875 ee.WriteMapElemValue()
6876 ee.EncodeInt(int64(v2))
6879 for k2, v2 := range v {
6880 ee.EncodeUint(uint64(k2))
6881 ee.EncodeInt(int64(v2))
6888 func (e *Encoder) fastpathEncMapUint8Int64R(f *codecFnInfo, rv reflect.Value) {
6889 fastpathTV.EncMapUint8Int64V(rv2i(rv).(map[uint8]int64), e)
6891 func (_ fastpathT) EncMapUint8Int64V(v map[uint8]int64, e *Encoder) {
6896 ee, esep := e.e, e.hh.hasElemSeparators()
6897 ee.WriteMapStart(len(v))
6899 v2 := make([]uint64, len(v))
6901 for k, _ := range v {
6905 sort.Sort(uintSlice(v2))
6907 for _, k2 := range v2 {
6908 ee.WriteMapElemKey()
6909 ee.EncodeUint(uint64(uint8(k2)))
6910 ee.WriteMapElemValue()
6911 ee.EncodeInt(int64(v[uint8(k2)]))
6914 for _, k2 := range v2 {
6915 ee.EncodeUint(uint64(uint8(k2)))
6916 ee.EncodeInt(int64(v[uint8(k2)]))
6921 for k2, v2 := range v {
6922 ee.WriteMapElemKey()
6923 ee.EncodeUint(uint64(k2))
6924 ee.WriteMapElemValue()
6925 ee.EncodeInt(int64(v2))
6928 for k2, v2 := range v {
6929 ee.EncodeUint(uint64(k2))
6930 ee.EncodeInt(int64(v2))
6937 func (e *Encoder) fastpathEncMapUint8Float32R(f *codecFnInfo, rv reflect.Value) {
6938 fastpathTV.EncMapUint8Float32V(rv2i(rv).(map[uint8]float32), e)
6940 func (_ fastpathT) EncMapUint8Float32V(v map[uint8]float32, e *Encoder) {
6945 ee, esep := e.e, e.hh.hasElemSeparators()
6946 ee.WriteMapStart(len(v))
6948 v2 := make([]uint64, len(v))
6950 for k, _ := range v {
6954 sort.Sort(uintSlice(v2))
6956 for _, k2 := range v2 {
6957 ee.WriteMapElemKey()
6958 ee.EncodeUint(uint64(uint8(k2)))
6959 ee.WriteMapElemValue()
6960 ee.EncodeFloat32(v[uint8(k2)])
6963 for _, k2 := range v2 {
6964 ee.EncodeUint(uint64(uint8(k2)))
6965 ee.EncodeFloat32(v[uint8(k2)])
6970 for k2, v2 := range v {
6971 ee.WriteMapElemKey()
6972 ee.EncodeUint(uint64(k2))
6973 ee.WriteMapElemValue()
6974 ee.EncodeFloat32(v2)
6977 for k2, v2 := range v {
6978 ee.EncodeUint(uint64(k2))
6979 ee.EncodeFloat32(v2)
6986 func (e *Encoder) fastpathEncMapUint8Float64R(f *codecFnInfo, rv reflect.Value) {
6987 fastpathTV.EncMapUint8Float64V(rv2i(rv).(map[uint8]float64), e)
6989 func (_ fastpathT) EncMapUint8Float64V(v map[uint8]float64, e *Encoder) {
6994 ee, esep := e.e, e.hh.hasElemSeparators()
6995 ee.WriteMapStart(len(v))
6997 v2 := make([]uint64, len(v))
6999 for k, _ := range v {
7003 sort.Sort(uintSlice(v2))
7005 for _, k2 := range v2 {
7006 ee.WriteMapElemKey()
7007 ee.EncodeUint(uint64(uint8(k2)))
7008 ee.WriteMapElemValue()
7009 ee.EncodeFloat64(v[uint8(k2)])
7012 for _, k2 := range v2 {
7013 ee.EncodeUint(uint64(uint8(k2)))
7014 ee.EncodeFloat64(v[uint8(k2)])
7019 for k2, v2 := range v {
7020 ee.WriteMapElemKey()
7021 ee.EncodeUint(uint64(k2))
7022 ee.WriteMapElemValue()
7023 ee.EncodeFloat64(v2)
7026 for k2, v2 := range v {
7027 ee.EncodeUint(uint64(k2))
7028 ee.EncodeFloat64(v2)
7035 func (e *Encoder) fastpathEncMapUint8BoolR(f *codecFnInfo, rv reflect.Value) {
7036 fastpathTV.EncMapUint8BoolV(rv2i(rv).(map[uint8]bool), e)
7038 func (_ fastpathT) EncMapUint8BoolV(v map[uint8]bool, e *Encoder) {
7043 ee, esep := e.e, e.hh.hasElemSeparators()
7044 ee.WriteMapStart(len(v))
7046 v2 := make([]uint64, len(v))
7048 for k, _ := range v {
7052 sort.Sort(uintSlice(v2))
7054 for _, k2 := range v2 {
7055 ee.WriteMapElemKey()
7056 ee.EncodeUint(uint64(uint8(k2)))
7057 ee.WriteMapElemValue()
7058 ee.EncodeBool(v[uint8(k2)])
7061 for _, k2 := range v2 {
7062 ee.EncodeUint(uint64(uint8(k2)))
7063 ee.EncodeBool(v[uint8(k2)])
7068 for k2, v2 := range v {
7069 ee.WriteMapElemKey()
7070 ee.EncodeUint(uint64(k2))
7071 ee.WriteMapElemValue()
7075 for k2, v2 := range v {
7076 ee.EncodeUint(uint64(k2))
7084 func (e *Encoder) fastpathEncMapUint16IntfR(f *codecFnInfo, rv reflect.Value) {
7085 fastpathTV.EncMapUint16IntfV(rv2i(rv).(map[uint16]interface{}), e)
7087 func (_ fastpathT) EncMapUint16IntfV(v map[uint16]interface{}, e *Encoder) {
7092 ee, esep := e.e, e.hh.hasElemSeparators()
7093 ee.WriteMapStart(len(v))
7095 v2 := make([]uint64, len(v))
7097 for k, _ := range v {
7101 sort.Sort(uintSlice(v2))
7103 for _, k2 := range v2 {
7104 ee.WriteMapElemKey()
7105 ee.EncodeUint(uint64(uint16(k2)))
7106 ee.WriteMapElemValue()
7107 e.encode(v[uint16(k2)])
7110 for _, k2 := range v2 {
7111 ee.EncodeUint(uint64(uint16(k2)))
7112 e.encode(v[uint16(k2)])
7117 for k2, v2 := range v {
7118 ee.WriteMapElemKey()
7119 ee.EncodeUint(uint64(k2))
7120 ee.WriteMapElemValue()
7124 for k2, v2 := range v {
7125 ee.EncodeUint(uint64(k2))
7133 func (e *Encoder) fastpathEncMapUint16StringR(f *codecFnInfo, rv reflect.Value) {
7134 fastpathTV.EncMapUint16StringV(rv2i(rv).(map[uint16]string), e)
7136 func (_ fastpathT) EncMapUint16StringV(v map[uint16]string, e *Encoder) {
7141 ee, esep := e.e, e.hh.hasElemSeparators()
7142 ee.WriteMapStart(len(v))
7144 v2 := make([]uint64, len(v))
7146 for k, _ := range v {
7150 sort.Sort(uintSlice(v2))
7152 for _, k2 := range v2 {
7153 ee.WriteMapElemKey()
7154 ee.EncodeUint(uint64(uint16(k2)))
7155 ee.WriteMapElemValue()
7156 ee.EncodeString(cUTF8, v[uint16(k2)])
7159 for _, k2 := range v2 {
7160 ee.EncodeUint(uint64(uint16(k2)))
7161 ee.EncodeString(cUTF8, v[uint16(k2)])
7166 for k2, v2 := range v {
7167 ee.WriteMapElemKey()
7168 ee.EncodeUint(uint64(k2))
7169 ee.WriteMapElemValue()
7170 ee.EncodeString(cUTF8, v2)
7173 for k2, v2 := range v {
7174 ee.EncodeUint(uint64(k2))
7175 ee.EncodeString(cUTF8, v2)
7182 func (e *Encoder) fastpathEncMapUint16UintR(f *codecFnInfo, rv reflect.Value) {
7183 fastpathTV.EncMapUint16UintV(rv2i(rv).(map[uint16]uint), e)
7185 func (_ fastpathT) EncMapUint16UintV(v map[uint16]uint, e *Encoder) {
7190 ee, esep := e.e, e.hh.hasElemSeparators()
7191 ee.WriteMapStart(len(v))
7193 v2 := make([]uint64, len(v))
7195 for k, _ := range v {
7199 sort.Sort(uintSlice(v2))
7201 for _, k2 := range v2 {
7202 ee.WriteMapElemKey()
7203 ee.EncodeUint(uint64(uint16(k2)))
7204 ee.WriteMapElemValue()
7205 ee.EncodeUint(uint64(v[uint16(k2)]))
7208 for _, k2 := range v2 {
7209 ee.EncodeUint(uint64(uint16(k2)))
7210 ee.EncodeUint(uint64(v[uint16(k2)]))
7215 for k2, v2 := range v {
7216 ee.WriteMapElemKey()
7217 ee.EncodeUint(uint64(k2))
7218 ee.WriteMapElemValue()
7219 ee.EncodeUint(uint64(v2))
7222 for k2, v2 := range v {
7223 ee.EncodeUint(uint64(k2))
7224 ee.EncodeUint(uint64(v2))
7231 func (e *Encoder) fastpathEncMapUint16Uint8R(f *codecFnInfo, rv reflect.Value) {
7232 fastpathTV.EncMapUint16Uint8V(rv2i(rv).(map[uint16]uint8), e)
7234 func (_ fastpathT) EncMapUint16Uint8V(v map[uint16]uint8, e *Encoder) {
7239 ee, esep := e.e, e.hh.hasElemSeparators()
7240 ee.WriteMapStart(len(v))
7242 v2 := make([]uint64, len(v))
7244 for k, _ := range v {
7248 sort.Sort(uintSlice(v2))
7250 for _, k2 := range v2 {
7251 ee.WriteMapElemKey()
7252 ee.EncodeUint(uint64(uint16(k2)))
7253 ee.WriteMapElemValue()
7254 ee.EncodeUint(uint64(v[uint16(k2)]))
7257 for _, k2 := range v2 {
7258 ee.EncodeUint(uint64(uint16(k2)))
7259 ee.EncodeUint(uint64(v[uint16(k2)]))
7264 for k2, v2 := range v {
7265 ee.WriteMapElemKey()
7266 ee.EncodeUint(uint64(k2))
7267 ee.WriteMapElemValue()
7268 ee.EncodeUint(uint64(v2))
7271 for k2, v2 := range v {
7272 ee.EncodeUint(uint64(k2))
7273 ee.EncodeUint(uint64(v2))
7280 func (e *Encoder) fastpathEncMapUint16Uint16R(f *codecFnInfo, rv reflect.Value) {
7281 fastpathTV.EncMapUint16Uint16V(rv2i(rv).(map[uint16]uint16), e)
7283 func (_ fastpathT) EncMapUint16Uint16V(v map[uint16]uint16, e *Encoder) {
7288 ee, esep := e.e, e.hh.hasElemSeparators()
7289 ee.WriteMapStart(len(v))
7291 v2 := make([]uint64, len(v))
7293 for k, _ := range v {
7297 sort.Sort(uintSlice(v2))
7299 for _, k2 := range v2 {
7300 ee.WriteMapElemKey()
7301 ee.EncodeUint(uint64(uint16(k2)))
7302 ee.WriteMapElemValue()
7303 ee.EncodeUint(uint64(v[uint16(k2)]))
7306 for _, k2 := range v2 {
7307 ee.EncodeUint(uint64(uint16(k2)))
7308 ee.EncodeUint(uint64(v[uint16(k2)]))
7313 for k2, v2 := range v {
7314 ee.WriteMapElemKey()
7315 ee.EncodeUint(uint64(k2))
7316 ee.WriteMapElemValue()
7317 ee.EncodeUint(uint64(v2))
7320 for k2, v2 := range v {
7321 ee.EncodeUint(uint64(k2))
7322 ee.EncodeUint(uint64(v2))
7329 func (e *Encoder) fastpathEncMapUint16Uint32R(f *codecFnInfo, rv reflect.Value) {
7330 fastpathTV.EncMapUint16Uint32V(rv2i(rv).(map[uint16]uint32), e)
7332 func (_ fastpathT) EncMapUint16Uint32V(v map[uint16]uint32, e *Encoder) {
7337 ee, esep := e.e, e.hh.hasElemSeparators()
7338 ee.WriteMapStart(len(v))
7340 v2 := make([]uint64, len(v))
7342 for k, _ := range v {
7346 sort.Sort(uintSlice(v2))
7348 for _, k2 := range v2 {
7349 ee.WriteMapElemKey()
7350 ee.EncodeUint(uint64(uint16(k2)))
7351 ee.WriteMapElemValue()
7352 ee.EncodeUint(uint64(v[uint16(k2)]))
7355 for _, k2 := range v2 {
7356 ee.EncodeUint(uint64(uint16(k2)))
7357 ee.EncodeUint(uint64(v[uint16(k2)]))
7362 for k2, v2 := range v {
7363 ee.WriteMapElemKey()
7364 ee.EncodeUint(uint64(k2))
7365 ee.WriteMapElemValue()
7366 ee.EncodeUint(uint64(v2))
7369 for k2, v2 := range v {
7370 ee.EncodeUint(uint64(k2))
7371 ee.EncodeUint(uint64(v2))
7378 func (e *Encoder) fastpathEncMapUint16Uint64R(f *codecFnInfo, rv reflect.Value) {
7379 fastpathTV.EncMapUint16Uint64V(rv2i(rv).(map[uint16]uint64), e)
7381 func (_ fastpathT) EncMapUint16Uint64V(v map[uint16]uint64, e *Encoder) {
7386 ee, esep := e.e, e.hh.hasElemSeparators()
7387 ee.WriteMapStart(len(v))
7389 v2 := make([]uint64, len(v))
7391 for k, _ := range v {
7395 sort.Sort(uintSlice(v2))
7397 for _, k2 := range v2 {
7398 ee.WriteMapElemKey()
7399 ee.EncodeUint(uint64(uint16(k2)))
7400 ee.WriteMapElemValue()
7401 ee.EncodeUint(uint64(v[uint16(k2)]))
7404 for _, k2 := range v2 {
7405 ee.EncodeUint(uint64(uint16(k2)))
7406 ee.EncodeUint(uint64(v[uint16(k2)]))
7411 for k2, v2 := range v {
7412 ee.WriteMapElemKey()
7413 ee.EncodeUint(uint64(k2))
7414 ee.WriteMapElemValue()
7415 ee.EncodeUint(uint64(v2))
7418 for k2, v2 := range v {
7419 ee.EncodeUint(uint64(k2))
7420 ee.EncodeUint(uint64(v2))
7427 func (e *Encoder) fastpathEncMapUint16UintptrR(f *codecFnInfo, rv reflect.Value) {
7428 fastpathTV.EncMapUint16UintptrV(rv2i(rv).(map[uint16]uintptr), e)
7430 func (_ fastpathT) EncMapUint16UintptrV(v map[uint16]uintptr, e *Encoder) {
7435 ee, esep := e.e, e.hh.hasElemSeparators()
7436 ee.WriteMapStart(len(v))
7438 v2 := make([]uint64, len(v))
7440 for k, _ := range v {
7444 sort.Sort(uintSlice(v2))
7446 for _, k2 := range v2 {
7447 ee.WriteMapElemKey()
7448 ee.EncodeUint(uint64(uint16(k2)))
7449 ee.WriteMapElemValue()
7450 e.encode(v[uint16(k2)])
7453 for _, k2 := range v2 {
7454 ee.EncodeUint(uint64(uint16(k2)))
7455 e.encode(v[uint16(k2)])
7460 for k2, v2 := range v {
7461 ee.WriteMapElemKey()
7462 ee.EncodeUint(uint64(k2))
7463 ee.WriteMapElemValue()
7467 for k2, v2 := range v {
7468 ee.EncodeUint(uint64(k2))
7476 func (e *Encoder) fastpathEncMapUint16IntR(f *codecFnInfo, rv reflect.Value) {
7477 fastpathTV.EncMapUint16IntV(rv2i(rv).(map[uint16]int), e)
7479 func (_ fastpathT) EncMapUint16IntV(v map[uint16]int, e *Encoder) {
7484 ee, esep := e.e, e.hh.hasElemSeparators()
7485 ee.WriteMapStart(len(v))
7487 v2 := make([]uint64, len(v))
7489 for k, _ := range v {
7493 sort.Sort(uintSlice(v2))
7495 for _, k2 := range v2 {
7496 ee.WriteMapElemKey()
7497 ee.EncodeUint(uint64(uint16(k2)))
7498 ee.WriteMapElemValue()
7499 ee.EncodeInt(int64(v[uint16(k2)]))
7502 for _, k2 := range v2 {
7503 ee.EncodeUint(uint64(uint16(k2)))
7504 ee.EncodeInt(int64(v[uint16(k2)]))
7509 for k2, v2 := range v {
7510 ee.WriteMapElemKey()
7511 ee.EncodeUint(uint64(k2))
7512 ee.WriteMapElemValue()
7513 ee.EncodeInt(int64(v2))
7516 for k2, v2 := range v {
7517 ee.EncodeUint(uint64(k2))
7518 ee.EncodeInt(int64(v2))
7525 func (e *Encoder) fastpathEncMapUint16Int8R(f *codecFnInfo, rv reflect.Value) {
7526 fastpathTV.EncMapUint16Int8V(rv2i(rv).(map[uint16]int8), e)
7528 func (_ fastpathT) EncMapUint16Int8V(v map[uint16]int8, e *Encoder) {
7533 ee, esep := e.e, e.hh.hasElemSeparators()
7534 ee.WriteMapStart(len(v))
7536 v2 := make([]uint64, len(v))
7538 for k, _ := range v {
7542 sort.Sort(uintSlice(v2))
7544 for _, k2 := range v2 {
7545 ee.WriteMapElemKey()
7546 ee.EncodeUint(uint64(uint16(k2)))
7547 ee.WriteMapElemValue()
7548 ee.EncodeInt(int64(v[uint16(k2)]))
7551 for _, k2 := range v2 {
7552 ee.EncodeUint(uint64(uint16(k2)))
7553 ee.EncodeInt(int64(v[uint16(k2)]))
7558 for k2, v2 := range v {
7559 ee.WriteMapElemKey()
7560 ee.EncodeUint(uint64(k2))
7561 ee.WriteMapElemValue()
7562 ee.EncodeInt(int64(v2))
7565 for k2, v2 := range v {
7566 ee.EncodeUint(uint64(k2))
7567 ee.EncodeInt(int64(v2))
7574 func (e *Encoder) fastpathEncMapUint16Int16R(f *codecFnInfo, rv reflect.Value) {
7575 fastpathTV.EncMapUint16Int16V(rv2i(rv).(map[uint16]int16), e)
7577 func (_ fastpathT) EncMapUint16Int16V(v map[uint16]int16, e *Encoder) {
7582 ee, esep := e.e, e.hh.hasElemSeparators()
7583 ee.WriteMapStart(len(v))
7585 v2 := make([]uint64, len(v))
7587 for k, _ := range v {
7591 sort.Sort(uintSlice(v2))
7593 for _, k2 := range v2 {
7594 ee.WriteMapElemKey()
7595 ee.EncodeUint(uint64(uint16(k2)))
7596 ee.WriteMapElemValue()
7597 ee.EncodeInt(int64(v[uint16(k2)]))
7600 for _, k2 := range v2 {
7601 ee.EncodeUint(uint64(uint16(k2)))
7602 ee.EncodeInt(int64(v[uint16(k2)]))
7607 for k2, v2 := range v {
7608 ee.WriteMapElemKey()
7609 ee.EncodeUint(uint64(k2))
7610 ee.WriteMapElemValue()
7611 ee.EncodeInt(int64(v2))
7614 for k2, v2 := range v {
7615 ee.EncodeUint(uint64(k2))
7616 ee.EncodeInt(int64(v2))
7623 func (e *Encoder) fastpathEncMapUint16Int32R(f *codecFnInfo, rv reflect.Value) {
7624 fastpathTV.EncMapUint16Int32V(rv2i(rv).(map[uint16]int32), e)
7626 func (_ fastpathT) EncMapUint16Int32V(v map[uint16]int32, e *Encoder) {
7631 ee, esep := e.e, e.hh.hasElemSeparators()
7632 ee.WriteMapStart(len(v))
7634 v2 := make([]uint64, len(v))
7636 for k, _ := range v {
7640 sort.Sort(uintSlice(v2))
7642 for _, k2 := range v2 {
7643 ee.WriteMapElemKey()
7644 ee.EncodeUint(uint64(uint16(k2)))
7645 ee.WriteMapElemValue()
7646 ee.EncodeInt(int64(v[uint16(k2)]))
7649 for _, k2 := range v2 {
7650 ee.EncodeUint(uint64(uint16(k2)))
7651 ee.EncodeInt(int64(v[uint16(k2)]))
7656 for k2, v2 := range v {
7657 ee.WriteMapElemKey()
7658 ee.EncodeUint(uint64(k2))
7659 ee.WriteMapElemValue()
7660 ee.EncodeInt(int64(v2))
7663 for k2, v2 := range v {
7664 ee.EncodeUint(uint64(k2))
7665 ee.EncodeInt(int64(v2))
7672 func (e *Encoder) fastpathEncMapUint16Int64R(f *codecFnInfo, rv reflect.Value) {
7673 fastpathTV.EncMapUint16Int64V(rv2i(rv).(map[uint16]int64), e)
7675 func (_ fastpathT) EncMapUint16Int64V(v map[uint16]int64, e *Encoder) {
7680 ee, esep := e.e, e.hh.hasElemSeparators()
7681 ee.WriteMapStart(len(v))
7683 v2 := make([]uint64, len(v))
7685 for k, _ := range v {
7689 sort.Sort(uintSlice(v2))
7691 for _, k2 := range v2 {
7692 ee.WriteMapElemKey()
7693 ee.EncodeUint(uint64(uint16(k2)))
7694 ee.WriteMapElemValue()
7695 ee.EncodeInt(int64(v[uint16(k2)]))
7698 for _, k2 := range v2 {
7699 ee.EncodeUint(uint64(uint16(k2)))
7700 ee.EncodeInt(int64(v[uint16(k2)]))
7705 for k2, v2 := range v {
7706 ee.WriteMapElemKey()
7707 ee.EncodeUint(uint64(k2))
7708 ee.WriteMapElemValue()
7709 ee.EncodeInt(int64(v2))
7712 for k2, v2 := range v {
7713 ee.EncodeUint(uint64(k2))
7714 ee.EncodeInt(int64(v2))
7721 func (e *Encoder) fastpathEncMapUint16Float32R(f *codecFnInfo, rv reflect.Value) {
7722 fastpathTV.EncMapUint16Float32V(rv2i(rv).(map[uint16]float32), e)
7724 func (_ fastpathT) EncMapUint16Float32V(v map[uint16]float32, e *Encoder) {
7729 ee, esep := e.e, e.hh.hasElemSeparators()
7730 ee.WriteMapStart(len(v))
7732 v2 := make([]uint64, len(v))
7734 for k, _ := range v {
7738 sort.Sort(uintSlice(v2))
7740 for _, k2 := range v2 {
7741 ee.WriteMapElemKey()
7742 ee.EncodeUint(uint64(uint16(k2)))
7743 ee.WriteMapElemValue()
7744 ee.EncodeFloat32(v[uint16(k2)])
7747 for _, k2 := range v2 {
7748 ee.EncodeUint(uint64(uint16(k2)))
7749 ee.EncodeFloat32(v[uint16(k2)])
7754 for k2, v2 := range v {
7755 ee.WriteMapElemKey()
7756 ee.EncodeUint(uint64(k2))
7757 ee.WriteMapElemValue()
7758 ee.EncodeFloat32(v2)
7761 for k2, v2 := range v {
7762 ee.EncodeUint(uint64(k2))
7763 ee.EncodeFloat32(v2)
7770 func (e *Encoder) fastpathEncMapUint16Float64R(f *codecFnInfo, rv reflect.Value) {
7771 fastpathTV.EncMapUint16Float64V(rv2i(rv).(map[uint16]float64), e)
7773 func (_ fastpathT) EncMapUint16Float64V(v map[uint16]float64, e *Encoder) {
7778 ee, esep := e.e, e.hh.hasElemSeparators()
7779 ee.WriteMapStart(len(v))
7781 v2 := make([]uint64, len(v))
7783 for k, _ := range v {
7787 sort.Sort(uintSlice(v2))
7789 for _, k2 := range v2 {
7790 ee.WriteMapElemKey()
7791 ee.EncodeUint(uint64(uint16(k2)))
7792 ee.WriteMapElemValue()
7793 ee.EncodeFloat64(v[uint16(k2)])
7796 for _, k2 := range v2 {
7797 ee.EncodeUint(uint64(uint16(k2)))
7798 ee.EncodeFloat64(v[uint16(k2)])
7803 for k2, v2 := range v {
7804 ee.WriteMapElemKey()
7805 ee.EncodeUint(uint64(k2))
7806 ee.WriteMapElemValue()
7807 ee.EncodeFloat64(v2)
7810 for k2, v2 := range v {
7811 ee.EncodeUint(uint64(k2))
7812 ee.EncodeFloat64(v2)
7819 func (e *Encoder) fastpathEncMapUint16BoolR(f *codecFnInfo, rv reflect.Value) {
7820 fastpathTV.EncMapUint16BoolV(rv2i(rv).(map[uint16]bool), e)
7822 func (_ fastpathT) EncMapUint16BoolV(v map[uint16]bool, e *Encoder) {
7827 ee, esep := e.e, e.hh.hasElemSeparators()
7828 ee.WriteMapStart(len(v))
7830 v2 := make([]uint64, len(v))
7832 for k, _ := range v {
7836 sort.Sort(uintSlice(v2))
7838 for _, k2 := range v2 {
7839 ee.WriteMapElemKey()
7840 ee.EncodeUint(uint64(uint16(k2)))
7841 ee.WriteMapElemValue()
7842 ee.EncodeBool(v[uint16(k2)])
7845 for _, k2 := range v2 {
7846 ee.EncodeUint(uint64(uint16(k2)))
7847 ee.EncodeBool(v[uint16(k2)])
7852 for k2, v2 := range v {
7853 ee.WriteMapElemKey()
7854 ee.EncodeUint(uint64(k2))
7855 ee.WriteMapElemValue()
7859 for k2, v2 := range v {
7860 ee.EncodeUint(uint64(k2))
7868 func (e *Encoder) fastpathEncMapUint32IntfR(f *codecFnInfo, rv reflect.Value) {
7869 fastpathTV.EncMapUint32IntfV(rv2i(rv).(map[uint32]interface{}), e)
7871 func (_ fastpathT) EncMapUint32IntfV(v map[uint32]interface{}, e *Encoder) {
7876 ee, esep := e.e, e.hh.hasElemSeparators()
7877 ee.WriteMapStart(len(v))
7879 v2 := make([]uint64, len(v))
7881 for k, _ := range v {
7885 sort.Sort(uintSlice(v2))
7887 for _, k2 := range v2 {
7888 ee.WriteMapElemKey()
7889 ee.EncodeUint(uint64(uint32(k2)))
7890 ee.WriteMapElemValue()
7891 e.encode(v[uint32(k2)])
7894 for _, k2 := range v2 {
7895 ee.EncodeUint(uint64(uint32(k2)))
7896 e.encode(v[uint32(k2)])
7901 for k2, v2 := range v {
7902 ee.WriteMapElemKey()
7903 ee.EncodeUint(uint64(k2))
7904 ee.WriteMapElemValue()
7908 for k2, v2 := range v {
7909 ee.EncodeUint(uint64(k2))
7917 func (e *Encoder) fastpathEncMapUint32StringR(f *codecFnInfo, rv reflect.Value) {
7918 fastpathTV.EncMapUint32StringV(rv2i(rv).(map[uint32]string), e)
7920 func (_ fastpathT) EncMapUint32StringV(v map[uint32]string, e *Encoder) {
7925 ee, esep := e.e, e.hh.hasElemSeparators()
7926 ee.WriteMapStart(len(v))
7928 v2 := make([]uint64, len(v))
7930 for k, _ := range v {
7934 sort.Sort(uintSlice(v2))
7936 for _, k2 := range v2 {
7937 ee.WriteMapElemKey()
7938 ee.EncodeUint(uint64(uint32(k2)))
7939 ee.WriteMapElemValue()
7940 ee.EncodeString(cUTF8, v[uint32(k2)])
7943 for _, k2 := range v2 {
7944 ee.EncodeUint(uint64(uint32(k2)))
7945 ee.EncodeString(cUTF8, v[uint32(k2)])
7950 for k2, v2 := range v {
7951 ee.WriteMapElemKey()
7952 ee.EncodeUint(uint64(k2))
7953 ee.WriteMapElemValue()
7954 ee.EncodeString(cUTF8, v2)
7957 for k2, v2 := range v {
7958 ee.EncodeUint(uint64(k2))
7959 ee.EncodeString(cUTF8, v2)
7966 func (e *Encoder) fastpathEncMapUint32UintR(f *codecFnInfo, rv reflect.Value) {
7967 fastpathTV.EncMapUint32UintV(rv2i(rv).(map[uint32]uint), e)
7969 func (_ fastpathT) EncMapUint32UintV(v map[uint32]uint, e *Encoder) {
7974 ee, esep := e.e, e.hh.hasElemSeparators()
7975 ee.WriteMapStart(len(v))
7977 v2 := make([]uint64, len(v))
7979 for k, _ := range v {
7983 sort.Sort(uintSlice(v2))
7985 for _, k2 := range v2 {
7986 ee.WriteMapElemKey()
7987 ee.EncodeUint(uint64(uint32(k2)))
7988 ee.WriteMapElemValue()
7989 ee.EncodeUint(uint64(v[uint32(k2)]))
7992 for _, k2 := range v2 {
7993 ee.EncodeUint(uint64(uint32(k2)))
7994 ee.EncodeUint(uint64(v[uint32(k2)]))
7999 for k2, v2 := range v {
8000 ee.WriteMapElemKey()
8001 ee.EncodeUint(uint64(k2))
8002 ee.WriteMapElemValue()
8003 ee.EncodeUint(uint64(v2))
8006 for k2, v2 := range v {
8007 ee.EncodeUint(uint64(k2))
8008 ee.EncodeUint(uint64(v2))
8015 func (e *Encoder) fastpathEncMapUint32Uint8R(f *codecFnInfo, rv reflect.Value) {
8016 fastpathTV.EncMapUint32Uint8V(rv2i(rv).(map[uint32]uint8), e)
8018 func (_ fastpathT) EncMapUint32Uint8V(v map[uint32]uint8, e *Encoder) {
8023 ee, esep := e.e, e.hh.hasElemSeparators()
8024 ee.WriteMapStart(len(v))
8026 v2 := make([]uint64, len(v))
8028 for k, _ := range v {
8032 sort.Sort(uintSlice(v2))
8034 for _, k2 := range v2 {
8035 ee.WriteMapElemKey()
8036 ee.EncodeUint(uint64(uint32(k2)))
8037 ee.WriteMapElemValue()
8038 ee.EncodeUint(uint64(v[uint32(k2)]))
8041 for _, k2 := range v2 {
8042 ee.EncodeUint(uint64(uint32(k2)))
8043 ee.EncodeUint(uint64(v[uint32(k2)]))
8048 for k2, v2 := range v {
8049 ee.WriteMapElemKey()
8050 ee.EncodeUint(uint64(k2))
8051 ee.WriteMapElemValue()
8052 ee.EncodeUint(uint64(v2))
8055 for k2, v2 := range v {
8056 ee.EncodeUint(uint64(k2))
8057 ee.EncodeUint(uint64(v2))
8064 func (e *Encoder) fastpathEncMapUint32Uint16R(f *codecFnInfo, rv reflect.Value) {
8065 fastpathTV.EncMapUint32Uint16V(rv2i(rv).(map[uint32]uint16), e)
8067 func (_ fastpathT) EncMapUint32Uint16V(v map[uint32]uint16, e *Encoder) {
8072 ee, esep := e.e, e.hh.hasElemSeparators()
8073 ee.WriteMapStart(len(v))
8075 v2 := make([]uint64, len(v))
8077 for k, _ := range v {
8081 sort.Sort(uintSlice(v2))
8083 for _, k2 := range v2 {
8084 ee.WriteMapElemKey()
8085 ee.EncodeUint(uint64(uint32(k2)))
8086 ee.WriteMapElemValue()
8087 ee.EncodeUint(uint64(v[uint32(k2)]))
8090 for _, k2 := range v2 {
8091 ee.EncodeUint(uint64(uint32(k2)))
8092 ee.EncodeUint(uint64(v[uint32(k2)]))
8097 for k2, v2 := range v {
8098 ee.WriteMapElemKey()
8099 ee.EncodeUint(uint64(k2))
8100 ee.WriteMapElemValue()
8101 ee.EncodeUint(uint64(v2))
8104 for k2, v2 := range v {
8105 ee.EncodeUint(uint64(k2))
8106 ee.EncodeUint(uint64(v2))
8113 func (e *Encoder) fastpathEncMapUint32Uint32R(f *codecFnInfo, rv reflect.Value) {
8114 fastpathTV.EncMapUint32Uint32V(rv2i(rv).(map[uint32]uint32), e)
8116 func (_ fastpathT) EncMapUint32Uint32V(v map[uint32]uint32, e *Encoder) {
8121 ee, esep := e.e, e.hh.hasElemSeparators()
8122 ee.WriteMapStart(len(v))
8124 v2 := make([]uint64, len(v))
8126 for k, _ := range v {
8130 sort.Sort(uintSlice(v2))
8132 for _, k2 := range v2 {
8133 ee.WriteMapElemKey()
8134 ee.EncodeUint(uint64(uint32(k2)))
8135 ee.WriteMapElemValue()
8136 ee.EncodeUint(uint64(v[uint32(k2)]))
8139 for _, k2 := range v2 {
8140 ee.EncodeUint(uint64(uint32(k2)))
8141 ee.EncodeUint(uint64(v[uint32(k2)]))
8146 for k2, v2 := range v {
8147 ee.WriteMapElemKey()
8148 ee.EncodeUint(uint64(k2))
8149 ee.WriteMapElemValue()
8150 ee.EncodeUint(uint64(v2))
8153 for k2, v2 := range v {
8154 ee.EncodeUint(uint64(k2))
8155 ee.EncodeUint(uint64(v2))
8162 func (e *Encoder) fastpathEncMapUint32Uint64R(f *codecFnInfo, rv reflect.Value) {
8163 fastpathTV.EncMapUint32Uint64V(rv2i(rv).(map[uint32]uint64), e)
8165 func (_ fastpathT) EncMapUint32Uint64V(v map[uint32]uint64, e *Encoder) {
8170 ee, esep := e.e, e.hh.hasElemSeparators()
8171 ee.WriteMapStart(len(v))
8173 v2 := make([]uint64, len(v))
8175 for k, _ := range v {
8179 sort.Sort(uintSlice(v2))
8181 for _, k2 := range v2 {
8182 ee.WriteMapElemKey()
8183 ee.EncodeUint(uint64(uint32(k2)))
8184 ee.WriteMapElemValue()
8185 ee.EncodeUint(uint64(v[uint32(k2)]))
8188 for _, k2 := range v2 {
8189 ee.EncodeUint(uint64(uint32(k2)))
8190 ee.EncodeUint(uint64(v[uint32(k2)]))
8195 for k2, v2 := range v {
8196 ee.WriteMapElemKey()
8197 ee.EncodeUint(uint64(k2))
8198 ee.WriteMapElemValue()
8199 ee.EncodeUint(uint64(v2))
8202 for k2, v2 := range v {
8203 ee.EncodeUint(uint64(k2))
8204 ee.EncodeUint(uint64(v2))
8211 func (e *Encoder) fastpathEncMapUint32UintptrR(f *codecFnInfo, rv reflect.Value) {
8212 fastpathTV.EncMapUint32UintptrV(rv2i(rv).(map[uint32]uintptr), e)
8214 func (_ fastpathT) EncMapUint32UintptrV(v map[uint32]uintptr, e *Encoder) {
8219 ee, esep := e.e, e.hh.hasElemSeparators()
8220 ee.WriteMapStart(len(v))
8222 v2 := make([]uint64, len(v))
8224 for k, _ := range v {
8228 sort.Sort(uintSlice(v2))
8230 for _, k2 := range v2 {
8231 ee.WriteMapElemKey()
8232 ee.EncodeUint(uint64(uint32(k2)))
8233 ee.WriteMapElemValue()
8234 e.encode(v[uint32(k2)])
8237 for _, k2 := range v2 {
8238 ee.EncodeUint(uint64(uint32(k2)))
8239 e.encode(v[uint32(k2)])
8244 for k2, v2 := range v {
8245 ee.WriteMapElemKey()
8246 ee.EncodeUint(uint64(k2))
8247 ee.WriteMapElemValue()
8251 for k2, v2 := range v {
8252 ee.EncodeUint(uint64(k2))
8260 func (e *Encoder) fastpathEncMapUint32IntR(f *codecFnInfo, rv reflect.Value) {
8261 fastpathTV.EncMapUint32IntV(rv2i(rv).(map[uint32]int), e)
8263 func (_ fastpathT) EncMapUint32IntV(v map[uint32]int, e *Encoder) {
8268 ee, esep := e.e, e.hh.hasElemSeparators()
8269 ee.WriteMapStart(len(v))
8271 v2 := make([]uint64, len(v))
8273 for k, _ := range v {
8277 sort.Sort(uintSlice(v2))
8279 for _, k2 := range v2 {
8280 ee.WriteMapElemKey()
8281 ee.EncodeUint(uint64(uint32(k2)))
8282 ee.WriteMapElemValue()
8283 ee.EncodeInt(int64(v[uint32(k2)]))
8286 for _, k2 := range v2 {
8287 ee.EncodeUint(uint64(uint32(k2)))
8288 ee.EncodeInt(int64(v[uint32(k2)]))
8293 for k2, v2 := range v {
8294 ee.WriteMapElemKey()
8295 ee.EncodeUint(uint64(k2))
8296 ee.WriteMapElemValue()
8297 ee.EncodeInt(int64(v2))
8300 for k2, v2 := range v {
8301 ee.EncodeUint(uint64(k2))
8302 ee.EncodeInt(int64(v2))
8309 func (e *Encoder) fastpathEncMapUint32Int8R(f *codecFnInfo, rv reflect.Value) {
8310 fastpathTV.EncMapUint32Int8V(rv2i(rv).(map[uint32]int8), e)
8312 func (_ fastpathT) EncMapUint32Int8V(v map[uint32]int8, e *Encoder) {
8317 ee, esep := e.e, e.hh.hasElemSeparators()
8318 ee.WriteMapStart(len(v))
8320 v2 := make([]uint64, len(v))
8322 for k, _ := range v {
8326 sort.Sort(uintSlice(v2))
8328 for _, k2 := range v2 {
8329 ee.WriteMapElemKey()
8330 ee.EncodeUint(uint64(uint32(k2)))
8331 ee.WriteMapElemValue()
8332 ee.EncodeInt(int64(v[uint32(k2)]))
8335 for _, k2 := range v2 {
8336 ee.EncodeUint(uint64(uint32(k2)))
8337 ee.EncodeInt(int64(v[uint32(k2)]))
8342 for k2, v2 := range v {
8343 ee.WriteMapElemKey()
8344 ee.EncodeUint(uint64(k2))
8345 ee.WriteMapElemValue()
8346 ee.EncodeInt(int64(v2))
8349 for k2, v2 := range v {
8350 ee.EncodeUint(uint64(k2))
8351 ee.EncodeInt(int64(v2))
8358 func (e *Encoder) fastpathEncMapUint32Int16R(f *codecFnInfo, rv reflect.Value) {
8359 fastpathTV.EncMapUint32Int16V(rv2i(rv).(map[uint32]int16), e)
8361 func (_ fastpathT) EncMapUint32Int16V(v map[uint32]int16, e *Encoder) {
8366 ee, esep := e.e, e.hh.hasElemSeparators()
8367 ee.WriteMapStart(len(v))
8369 v2 := make([]uint64, len(v))
8371 for k, _ := range v {
8375 sort.Sort(uintSlice(v2))
8377 for _, k2 := range v2 {
8378 ee.WriteMapElemKey()
8379 ee.EncodeUint(uint64(uint32(k2)))
8380 ee.WriteMapElemValue()
8381 ee.EncodeInt(int64(v[uint32(k2)]))
8384 for _, k2 := range v2 {
8385 ee.EncodeUint(uint64(uint32(k2)))
8386 ee.EncodeInt(int64(v[uint32(k2)]))
8391 for k2, v2 := range v {
8392 ee.WriteMapElemKey()
8393 ee.EncodeUint(uint64(k2))
8394 ee.WriteMapElemValue()
8395 ee.EncodeInt(int64(v2))
8398 for k2, v2 := range v {
8399 ee.EncodeUint(uint64(k2))
8400 ee.EncodeInt(int64(v2))
8407 func (e *Encoder) fastpathEncMapUint32Int32R(f *codecFnInfo, rv reflect.Value) {
8408 fastpathTV.EncMapUint32Int32V(rv2i(rv).(map[uint32]int32), e)
8410 func (_ fastpathT) EncMapUint32Int32V(v map[uint32]int32, e *Encoder) {
8415 ee, esep := e.e, e.hh.hasElemSeparators()
8416 ee.WriteMapStart(len(v))
8418 v2 := make([]uint64, len(v))
8420 for k, _ := range v {
8424 sort.Sort(uintSlice(v2))
8426 for _, k2 := range v2 {
8427 ee.WriteMapElemKey()
8428 ee.EncodeUint(uint64(uint32(k2)))
8429 ee.WriteMapElemValue()
8430 ee.EncodeInt(int64(v[uint32(k2)]))
8433 for _, k2 := range v2 {
8434 ee.EncodeUint(uint64(uint32(k2)))
8435 ee.EncodeInt(int64(v[uint32(k2)]))
8440 for k2, v2 := range v {
8441 ee.WriteMapElemKey()
8442 ee.EncodeUint(uint64(k2))
8443 ee.WriteMapElemValue()
8444 ee.EncodeInt(int64(v2))
8447 for k2, v2 := range v {
8448 ee.EncodeUint(uint64(k2))
8449 ee.EncodeInt(int64(v2))
8456 func (e *Encoder) fastpathEncMapUint32Int64R(f *codecFnInfo, rv reflect.Value) {
8457 fastpathTV.EncMapUint32Int64V(rv2i(rv).(map[uint32]int64), e)
8459 func (_ fastpathT) EncMapUint32Int64V(v map[uint32]int64, e *Encoder) {
8464 ee, esep := e.e, e.hh.hasElemSeparators()
8465 ee.WriteMapStart(len(v))
8467 v2 := make([]uint64, len(v))
8469 for k, _ := range v {
8473 sort.Sort(uintSlice(v2))
8475 for _, k2 := range v2 {
8476 ee.WriteMapElemKey()
8477 ee.EncodeUint(uint64(uint32(k2)))
8478 ee.WriteMapElemValue()
8479 ee.EncodeInt(int64(v[uint32(k2)]))
8482 for _, k2 := range v2 {
8483 ee.EncodeUint(uint64(uint32(k2)))
8484 ee.EncodeInt(int64(v[uint32(k2)]))
8489 for k2, v2 := range v {
8490 ee.WriteMapElemKey()
8491 ee.EncodeUint(uint64(k2))
8492 ee.WriteMapElemValue()
8493 ee.EncodeInt(int64(v2))
8496 for k2, v2 := range v {
8497 ee.EncodeUint(uint64(k2))
8498 ee.EncodeInt(int64(v2))
8505 func (e *Encoder) fastpathEncMapUint32Float32R(f *codecFnInfo, rv reflect.Value) {
8506 fastpathTV.EncMapUint32Float32V(rv2i(rv).(map[uint32]float32), e)
8508 func (_ fastpathT) EncMapUint32Float32V(v map[uint32]float32, e *Encoder) {
8513 ee, esep := e.e, e.hh.hasElemSeparators()
8514 ee.WriteMapStart(len(v))
8516 v2 := make([]uint64, len(v))
8518 for k, _ := range v {
8522 sort.Sort(uintSlice(v2))
8524 for _, k2 := range v2 {
8525 ee.WriteMapElemKey()
8526 ee.EncodeUint(uint64(uint32(k2)))
8527 ee.WriteMapElemValue()
8528 ee.EncodeFloat32(v[uint32(k2)])
8531 for _, k2 := range v2 {
8532 ee.EncodeUint(uint64(uint32(k2)))
8533 ee.EncodeFloat32(v[uint32(k2)])
8538 for k2, v2 := range v {
8539 ee.WriteMapElemKey()
8540 ee.EncodeUint(uint64(k2))
8541 ee.WriteMapElemValue()
8542 ee.EncodeFloat32(v2)
8545 for k2, v2 := range v {
8546 ee.EncodeUint(uint64(k2))
8547 ee.EncodeFloat32(v2)
8554 func (e *Encoder) fastpathEncMapUint32Float64R(f *codecFnInfo, rv reflect.Value) {
8555 fastpathTV.EncMapUint32Float64V(rv2i(rv).(map[uint32]float64), e)
8557 func (_ fastpathT) EncMapUint32Float64V(v map[uint32]float64, e *Encoder) {
8562 ee, esep := e.e, e.hh.hasElemSeparators()
8563 ee.WriteMapStart(len(v))
8565 v2 := make([]uint64, len(v))
8567 for k, _ := range v {
8571 sort.Sort(uintSlice(v2))
8573 for _, k2 := range v2 {
8574 ee.WriteMapElemKey()
8575 ee.EncodeUint(uint64(uint32(k2)))
8576 ee.WriteMapElemValue()
8577 ee.EncodeFloat64(v[uint32(k2)])
8580 for _, k2 := range v2 {
8581 ee.EncodeUint(uint64(uint32(k2)))
8582 ee.EncodeFloat64(v[uint32(k2)])
8587 for k2, v2 := range v {
8588 ee.WriteMapElemKey()
8589 ee.EncodeUint(uint64(k2))
8590 ee.WriteMapElemValue()
8591 ee.EncodeFloat64(v2)
8594 for k2, v2 := range v {
8595 ee.EncodeUint(uint64(k2))
8596 ee.EncodeFloat64(v2)
8603 func (e *Encoder) fastpathEncMapUint32BoolR(f *codecFnInfo, rv reflect.Value) {
8604 fastpathTV.EncMapUint32BoolV(rv2i(rv).(map[uint32]bool), e)
8606 func (_ fastpathT) EncMapUint32BoolV(v map[uint32]bool, e *Encoder) {
8611 ee, esep := e.e, e.hh.hasElemSeparators()
8612 ee.WriteMapStart(len(v))
8614 v2 := make([]uint64, len(v))
8616 for k, _ := range v {
8620 sort.Sort(uintSlice(v2))
8622 for _, k2 := range v2 {
8623 ee.WriteMapElemKey()
8624 ee.EncodeUint(uint64(uint32(k2)))
8625 ee.WriteMapElemValue()
8626 ee.EncodeBool(v[uint32(k2)])
8629 for _, k2 := range v2 {
8630 ee.EncodeUint(uint64(uint32(k2)))
8631 ee.EncodeBool(v[uint32(k2)])
8636 for k2, v2 := range v {
8637 ee.WriteMapElemKey()
8638 ee.EncodeUint(uint64(k2))
8639 ee.WriteMapElemValue()
8643 for k2, v2 := range v {
8644 ee.EncodeUint(uint64(k2))
8652 func (e *Encoder) fastpathEncMapUint64IntfR(f *codecFnInfo, rv reflect.Value) {
8653 fastpathTV.EncMapUint64IntfV(rv2i(rv).(map[uint64]interface{}), e)
8655 func (_ fastpathT) EncMapUint64IntfV(v map[uint64]interface{}, e *Encoder) {
8660 ee, esep := e.e, e.hh.hasElemSeparators()
8661 ee.WriteMapStart(len(v))
8663 v2 := make([]uint64, len(v))
8665 for k, _ := range v {
8669 sort.Sort(uintSlice(v2))
8671 for _, k2 := range v2 {
8672 ee.WriteMapElemKey()
8673 ee.EncodeUint(uint64(uint64(k2)))
8674 ee.WriteMapElemValue()
8675 e.encode(v[uint64(k2)])
8678 for _, k2 := range v2 {
8679 ee.EncodeUint(uint64(uint64(k2)))
8680 e.encode(v[uint64(k2)])
8685 for k2, v2 := range v {
8686 ee.WriteMapElemKey()
8687 ee.EncodeUint(uint64(k2))
8688 ee.WriteMapElemValue()
8692 for k2, v2 := range v {
8693 ee.EncodeUint(uint64(k2))
8701 func (e *Encoder) fastpathEncMapUint64StringR(f *codecFnInfo, rv reflect.Value) {
8702 fastpathTV.EncMapUint64StringV(rv2i(rv).(map[uint64]string), e)
8704 func (_ fastpathT) EncMapUint64StringV(v map[uint64]string, e *Encoder) {
8709 ee, esep := e.e, e.hh.hasElemSeparators()
8710 ee.WriteMapStart(len(v))
8712 v2 := make([]uint64, len(v))
8714 for k, _ := range v {
8718 sort.Sort(uintSlice(v2))
8720 for _, k2 := range v2 {
8721 ee.WriteMapElemKey()
8722 ee.EncodeUint(uint64(uint64(k2)))
8723 ee.WriteMapElemValue()
8724 ee.EncodeString(cUTF8, v[uint64(k2)])
8727 for _, k2 := range v2 {
8728 ee.EncodeUint(uint64(uint64(k2)))
8729 ee.EncodeString(cUTF8, v[uint64(k2)])
8734 for k2, v2 := range v {
8735 ee.WriteMapElemKey()
8736 ee.EncodeUint(uint64(k2))
8737 ee.WriteMapElemValue()
8738 ee.EncodeString(cUTF8, v2)
8741 for k2, v2 := range v {
8742 ee.EncodeUint(uint64(k2))
8743 ee.EncodeString(cUTF8, v2)
8750 func (e *Encoder) fastpathEncMapUint64UintR(f *codecFnInfo, rv reflect.Value) {
8751 fastpathTV.EncMapUint64UintV(rv2i(rv).(map[uint64]uint), e)
8753 func (_ fastpathT) EncMapUint64UintV(v map[uint64]uint, e *Encoder) {
8758 ee, esep := e.e, e.hh.hasElemSeparators()
8759 ee.WriteMapStart(len(v))
8761 v2 := make([]uint64, len(v))
8763 for k, _ := range v {
8767 sort.Sort(uintSlice(v2))
8769 for _, k2 := range v2 {
8770 ee.WriteMapElemKey()
8771 ee.EncodeUint(uint64(uint64(k2)))
8772 ee.WriteMapElemValue()
8773 ee.EncodeUint(uint64(v[uint64(k2)]))
8776 for _, k2 := range v2 {
8777 ee.EncodeUint(uint64(uint64(k2)))
8778 ee.EncodeUint(uint64(v[uint64(k2)]))
8783 for k2, v2 := range v {
8784 ee.WriteMapElemKey()
8785 ee.EncodeUint(uint64(k2))
8786 ee.WriteMapElemValue()
8787 ee.EncodeUint(uint64(v2))
8790 for k2, v2 := range v {
8791 ee.EncodeUint(uint64(k2))
8792 ee.EncodeUint(uint64(v2))
8799 func (e *Encoder) fastpathEncMapUint64Uint8R(f *codecFnInfo, rv reflect.Value) {
8800 fastpathTV.EncMapUint64Uint8V(rv2i(rv).(map[uint64]uint8), e)
8802 func (_ fastpathT) EncMapUint64Uint8V(v map[uint64]uint8, e *Encoder) {
8807 ee, esep := e.e, e.hh.hasElemSeparators()
8808 ee.WriteMapStart(len(v))
8810 v2 := make([]uint64, len(v))
8812 for k, _ := range v {
8816 sort.Sort(uintSlice(v2))
8818 for _, k2 := range v2 {
8819 ee.WriteMapElemKey()
8820 ee.EncodeUint(uint64(uint64(k2)))
8821 ee.WriteMapElemValue()
8822 ee.EncodeUint(uint64(v[uint64(k2)]))
8825 for _, k2 := range v2 {
8826 ee.EncodeUint(uint64(uint64(k2)))
8827 ee.EncodeUint(uint64(v[uint64(k2)]))
8832 for k2, v2 := range v {
8833 ee.WriteMapElemKey()
8834 ee.EncodeUint(uint64(k2))
8835 ee.WriteMapElemValue()
8836 ee.EncodeUint(uint64(v2))
8839 for k2, v2 := range v {
8840 ee.EncodeUint(uint64(k2))
8841 ee.EncodeUint(uint64(v2))
8848 func (e *Encoder) fastpathEncMapUint64Uint16R(f *codecFnInfo, rv reflect.Value) {
8849 fastpathTV.EncMapUint64Uint16V(rv2i(rv).(map[uint64]uint16), e)
8851 func (_ fastpathT) EncMapUint64Uint16V(v map[uint64]uint16, e *Encoder) {
8856 ee, esep := e.e, e.hh.hasElemSeparators()
8857 ee.WriteMapStart(len(v))
8859 v2 := make([]uint64, len(v))
8861 for k, _ := range v {
8865 sort.Sort(uintSlice(v2))
8867 for _, k2 := range v2 {
8868 ee.WriteMapElemKey()
8869 ee.EncodeUint(uint64(uint64(k2)))
8870 ee.WriteMapElemValue()
8871 ee.EncodeUint(uint64(v[uint64(k2)]))
8874 for _, k2 := range v2 {
8875 ee.EncodeUint(uint64(uint64(k2)))
8876 ee.EncodeUint(uint64(v[uint64(k2)]))
8881 for k2, v2 := range v {
8882 ee.WriteMapElemKey()
8883 ee.EncodeUint(uint64(k2))
8884 ee.WriteMapElemValue()
8885 ee.EncodeUint(uint64(v2))
8888 for k2, v2 := range v {
8889 ee.EncodeUint(uint64(k2))
8890 ee.EncodeUint(uint64(v2))
8897 func (e *Encoder) fastpathEncMapUint64Uint32R(f *codecFnInfo, rv reflect.Value) {
8898 fastpathTV.EncMapUint64Uint32V(rv2i(rv).(map[uint64]uint32), e)
8900 func (_ fastpathT) EncMapUint64Uint32V(v map[uint64]uint32, e *Encoder) {
8905 ee, esep := e.e, e.hh.hasElemSeparators()
8906 ee.WriteMapStart(len(v))
8908 v2 := make([]uint64, len(v))
8910 for k, _ := range v {
8914 sort.Sort(uintSlice(v2))
8916 for _, k2 := range v2 {
8917 ee.WriteMapElemKey()
8918 ee.EncodeUint(uint64(uint64(k2)))
8919 ee.WriteMapElemValue()
8920 ee.EncodeUint(uint64(v[uint64(k2)]))
8923 for _, k2 := range v2 {
8924 ee.EncodeUint(uint64(uint64(k2)))
8925 ee.EncodeUint(uint64(v[uint64(k2)]))
8930 for k2, v2 := range v {
8931 ee.WriteMapElemKey()
8932 ee.EncodeUint(uint64(k2))
8933 ee.WriteMapElemValue()
8934 ee.EncodeUint(uint64(v2))
8937 for k2, v2 := range v {
8938 ee.EncodeUint(uint64(k2))
8939 ee.EncodeUint(uint64(v2))
8946 func (e *Encoder) fastpathEncMapUint64Uint64R(f *codecFnInfo, rv reflect.Value) {
8947 fastpathTV.EncMapUint64Uint64V(rv2i(rv).(map[uint64]uint64), e)
8949 func (_ fastpathT) EncMapUint64Uint64V(v map[uint64]uint64, e *Encoder) {
8954 ee, esep := e.e, e.hh.hasElemSeparators()
8955 ee.WriteMapStart(len(v))
8957 v2 := make([]uint64, len(v))
8959 for k, _ := range v {
8963 sort.Sort(uintSlice(v2))
8965 for _, k2 := range v2 {
8966 ee.WriteMapElemKey()
8967 ee.EncodeUint(uint64(uint64(k2)))
8968 ee.WriteMapElemValue()
8969 ee.EncodeUint(uint64(v[uint64(k2)]))
8972 for _, k2 := range v2 {
8973 ee.EncodeUint(uint64(uint64(k2)))
8974 ee.EncodeUint(uint64(v[uint64(k2)]))
8979 for k2, v2 := range v {
8980 ee.WriteMapElemKey()
8981 ee.EncodeUint(uint64(k2))
8982 ee.WriteMapElemValue()
8983 ee.EncodeUint(uint64(v2))
8986 for k2, v2 := range v {
8987 ee.EncodeUint(uint64(k2))
8988 ee.EncodeUint(uint64(v2))
8995 func (e *Encoder) fastpathEncMapUint64UintptrR(f *codecFnInfo, rv reflect.Value) {
8996 fastpathTV.EncMapUint64UintptrV(rv2i(rv).(map[uint64]uintptr), e)
8998 func (_ fastpathT) EncMapUint64UintptrV(v map[uint64]uintptr, e *Encoder) {
9003 ee, esep := e.e, e.hh.hasElemSeparators()
9004 ee.WriteMapStart(len(v))
9006 v2 := make([]uint64, len(v))
9008 for k, _ := range v {
9012 sort.Sort(uintSlice(v2))
9014 for _, k2 := range v2 {
9015 ee.WriteMapElemKey()
9016 ee.EncodeUint(uint64(uint64(k2)))
9017 ee.WriteMapElemValue()
9018 e.encode(v[uint64(k2)])
9021 for _, k2 := range v2 {
9022 ee.EncodeUint(uint64(uint64(k2)))
9023 e.encode(v[uint64(k2)])
9028 for k2, v2 := range v {
9029 ee.WriteMapElemKey()
9030 ee.EncodeUint(uint64(k2))
9031 ee.WriteMapElemValue()
9035 for k2, v2 := range v {
9036 ee.EncodeUint(uint64(k2))
9044 func (e *Encoder) fastpathEncMapUint64IntR(f *codecFnInfo, rv reflect.Value) {
9045 fastpathTV.EncMapUint64IntV(rv2i(rv).(map[uint64]int), e)
9047 func (_ fastpathT) EncMapUint64IntV(v map[uint64]int, e *Encoder) {
9052 ee, esep := e.e, e.hh.hasElemSeparators()
9053 ee.WriteMapStart(len(v))
9055 v2 := make([]uint64, len(v))
9057 for k, _ := range v {
9061 sort.Sort(uintSlice(v2))
9063 for _, k2 := range v2 {
9064 ee.WriteMapElemKey()
9065 ee.EncodeUint(uint64(uint64(k2)))
9066 ee.WriteMapElemValue()
9067 ee.EncodeInt(int64(v[uint64(k2)]))
9070 for _, k2 := range v2 {
9071 ee.EncodeUint(uint64(uint64(k2)))
9072 ee.EncodeInt(int64(v[uint64(k2)]))
9077 for k2, v2 := range v {
9078 ee.WriteMapElemKey()
9079 ee.EncodeUint(uint64(k2))
9080 ee.WriteMapElemValue()
9081 ee.EncodeInt(int64(v2))
9084 for k2, v2 := range v {
9085 ee.EncodeUint(uint64(k2))
9086 ee.EncodeInt(int64(v2))
9093 func (e *Encoder) fastpathEncMapUint64Int8R(f *codecFnInfo, rv reflect.Value) {
9094 fastpathTV.EncMapUint64Int8V(rv2i(rv).(map[uint64]int8), e)
9096 func (_ fastpathT) EncMapUint64Int8V(v map[uint64]int8, e *Encoder) {
9101 ee, esep := e.e, e.hh.hasElemSeparators()
9102 ee.WriteMapStart(len(v))
9104 v2 := make([]uint64, len(v))
9106 for k, _ := range v {
9110 sort.Sort(uintSlice(v2))
9112 for _, k2 := range v2 {
9113 ee.WriteMapElemKey()
9114 ee.EncodeUint(uint64(uint64(k2)))
9115 ee.WriteMapElemValue()
9116 ee.EncodeInt(int64(v[uint64(k2)]))
9119 for _, k2 := range v2 {
9120 ee.EncodeUint(uint64(uint64(k2)))
9121 ee.EncodeInt(int64(v[uint64(k2)]))
9126 for k2, v2 := range v {
9127 ee.WriteMapElemKey()
9128 ee.EncodeUint(uint64(k2))
9129 ee.WriteMapElemValue()
9130 ee.EncodeInt(int64(v2))
9133 for k2, v2 := range v {
9134 ee.EncodeUint(uint64(k2))
9135 ee.EncodeInt(int64(v2))
9142 func (e *Encoder) fastpathEncMapUint64Int16R(f *codecFnInfo, rv reflect.Value) {
9143 fastpathTV.EncMapUint64Int16V(rv2i(rv).(map[uint64]int16), e)
9145 func (_ fastpathT) EncMapUint64Int16V(v map[uint64]int16, e *Encoder) {
9150 ee, esep := e.e, e.hh.hasElemSeparators()
9151 ee.WriteMapStart(len(v))
9153 v2 := make([]uint64, len(v))
9155 for k, _ := range v {
9159 sort.Sort(uintSlice(v2))
9161 for _, k2 := range v2 {
9162 ee.WriteMapElemKey()
9163 ee.EncodeUint(uint64(uint64(k2)))
9164 ee.WriteMapElemValue()
9165 ee.EncodeInt(int64(v[uint64(k2)]))
9168 for _, k2 := range v2 {
9169 ee.EncodeUint(uint64(uint64(k2)))
9170 ee.EncodeInt(int64(v[uint64(k2)]))
9175 for k2, v2 := range v {
9176 ee.WriteMapElemKey()
9177 ee.EncodeUint(uint64(k2))
9178 ee.WriteMapElemValue()
9179 ee.EncodeInt(int64(v2))
9182 for k2, v2 := range v {
9183 ee.EncodeUint(uint64(k2))
9184 ee.EncodeInt(int64(v2))
9191 func (e *Encoder) fastpathEncMapUint64Int32R(f *codecFnInfo, rv reflect.Value) {
9192 fastpathTV.EncMapUint64Int32V(rv2i(rv).(map[uint64]int32), e)
9194 func (_ fastpathT) EncMapUint64Int32V(v map[uint64]int32, e *Encoder) {
9199 ee, esep := e.e, e.hh.hasElemSeparators()
9200 ee.WriteMapStart(len(v))
9202 v2 := make([]uint64, len(v))
9204 for k, _ := range v {
9208 sort.Sort(uintSlice(v2))
9210 for _, k2 := range v2 {
9211 ee.WriteMapElemKey()
9212 ee.EncodeUint(uint64(uint64(k2)))
9213 ee.WriteMapElemValue()
9214 ee.EncodeInt(int64(v[uint64(k2)]))
9217 for _, k2 := range v2 {
9218 ee.EncodeUint(uint64(uint64(k2)))
9219 ee.EncodeInt(int64(v[uint64(k2)]))
9224 for k2, v2 := range v {
9225 ee.WriteMapElemKey()
9226 ee.EncodeUint(uint64(k2))
9227 ee.WriteMapElemValue()
9228 ee.EncodeInt(int64(v2))
9231 for k2, v2 := range v {
9232 ee.EncodeUint(uint64(k2))
9233 ee.EncodeInt(int64(v2))
9240 func (e *Encoder) fastpathEncMapUint64Int64R(f *codecFnInfo, rv reflect.Value) {
9241 fastpathTV.EncMapUint64Int64V(rv2i(rv).(map[uint64]int64), e)
9243 func (_ fastpathT) EncMapUint64Int64V(v map[uint64]int64, e *Encoder) {
9248 ee, esep := e.e, e.hh.hasElemSeparators()
9249 ee.WriteMapStart(len(v))
9251 v2 := make([]uint64, len(v))
9253 for k, _ := range v {
9257 sort.Sort(uintSlice(v2))
9259 for _, k2 := range v2 {
9260 ee.WriteMapElemKey()
9261 ee.EncodeUint(uint64(uint64(k2)))
9262 ee.WriteMapElemValue()
9263 ee.EncodeInt(int64(v[uint64(k2)]))
9266 for _, k2 := range v2 {
9267 ee.EncodeUint(uint64(uint64(k2)))
9268 ee.EncodeInt(int64(v[uint64(k2)]))
9273 for k2, v2 := range v {
9274 ee.WriteMapElemKey()
9275 ee.EncodeUint(uint64(k2))
9276 ee.WriteMapElemValue()
9277 ee.EncodeInt(int64(v2))
9280 for k2, v2 := range v {
9281 ee.EncodeUint(uint64(k2))
9282 ee.EncodeInt(int64(v2))
9289 func (e *Encoder) fastpathEncMapUint64Float32R(f *codecFnInfo, rv reflect.Value) {
9290 fastpathTV.EncMapUint64Float32V(rv2i(rv).(map[uint64]float32), e)
9292 func (_ fastpathT) EncMapUint64Float32V(v map[uint64]float32, e *Encoder) {
9297 ee, esep := e.e, e.hh.hasElemSeparators()
9298 ee.WriteMapStart(len(v))
9300 v2 := make([]uint64, len(v))
9302 for k, _ := range v {
9306 sort.Sort(uintSlice(v2))
9308 for _, k2 := range v2 {
9309 ee.WriteMapElemKey()
9310 ee.EncodeUint(uint64(uint64(k2)))
9311 ee.WriteMapElemValue()
9312 ee.EncodeFloat32(v[uint64(k2)])
9315 for _, k2 := range v2 {
9316 ee.EncodeUint(uint64(uint64(k2)))
9317 ee.EncodeFloat32(v[uint64(k2)])
9322 for k2, v2 := range v {
9323 ee.WriteMapElemKey()
9324 ee.EncodeUint(uint64(k2))
9325 ee.WriteMapElemValue()
9326 ee.EncodeFloat32(v2)
9329 for k2, v2 := range v {
9330 ee.EncodeUint(uint64(k2))
9331 ee.EncodeFloat32(v2)
9338 func (e *Encoder) fastpathEncMapUint64Float64R(f *codecFnInfo, rv reflect.Value) {
9339 fastpathTV.EncMapUint64Float64V(rv2i(rv).(map[uint64]float64), e)
9341 func (_ fastpathT) EncMapUint64Float64V(v map[uint64]float64, e *Encoder) {
9346 ee, esep := e.e, e.hh.hasElemSeparators()
9347 ee.WriteMapStart(len(v))
9349 v2 := make([]uint64, len(v))
9351 for k, _ := range v {
9355 sort.Sort(uintSlice(v2))
9357 for _, k2 := range v2 {
9358 ee.WriteMapElemKey()
9359 ee.EncodeUint(uint64(uint64(k2)))
9360 ee.WriteMapElemValue()
9361 ee.EncodeFloat64(v[uint64(k2)])
9364 for _, k2 := range v2 {
9365 ee.EncodeUint(uint64(uint64(k2)))
9366 ee.EncodeFloat64(v[uint64(k2)])
9371 for k2, v2 := range v {
9372 ee.WriteMapElemKey()
9373 ee.EncodeUint(uint64(k2))
9374 ee.WriteMapElemValue()
9375 ee.EncodeFloat64(v2)
9378 for k2, v2 := range v {
9379 ee.EncodeUint(uint64(k2))
9380 ee.EncodeFloat64(v2)
9387 func (e *Encoder) fastpathEncMapUint64BoolR(f *codecFnInfo, rv reflect.Value) {
9388 fastpathTV.EncMapUint64BoolV(rv2i(rv).(map[uint64]bool), e)
9390 func (_ fastpathT) EncMapUint64BoolV(v map[uint64]bool, e *Encoder) {
9395 ee, esep := e.e, e.hh.hasElemSeparators()
9396 ee.WriteMapStart(len(v))
9398 v2 := make([]uint64, len(v))
9400 for k, _ := range v {
9404 sort.Sort(uintSlice(v2))
9406 for _, k2 := range v2 {
9407 ee.WriteMapElemKey()
9408 ee.EncodeUint(uint64(uint64(k2)))
9409 ee.WriteMapElemValue()
9410 ee.EncodeBool(v[uint64(k2)])
9413 for _, k2 := range v2 {
9414 ee.EncodeUint(uint64(uint64(k2)))
9415 ee.EncodeBool(v[uint64(k2)])
9420 for k2, v2 := range v {
9421 ee.WriteMapElemKey()
9422 ee.EncodeUint(uint64(k2))
9423 ee.WriteMapElemValue()
9427 for k2, v2 := range v {
9428 ee.EncodeUint(uint64(k2))
9436 func (e *Encoder) fastpathEncMapUintptrIntfR(f *codecFnInfo, rv reflect.Value) {
9437 fastpathTV.EncMapUintptrIntfV(rv2i(rv).(map[uintptr]interface{}), e)
9439 func (_ fastpathT) EncMapUintptrIntfV(v map[uintptr]interface{}, e *Encoder) {
9444 ee, esep := e.e, e.hh.hasElemSeparators()
9445 ee.WriteMapStart(len(v))
9447 v2 := make([]uint64, len(v))
9449 for k, _ := range v {
9453 sort.Sort(uintSlice(v2))
9455 for _, k2 := range v2 {
9456 ee.WriteMapElemKey()
9457 e.encode(uintptr(k2))
9458 ee.WriteMapElemValue()
9459 e.encode(v[uintptr(k2)])
9462 for _, k2 := range v2 {
9463 e.encode(uintptr(k2))
9464 e.encode(v[uintptr(k2)])
9469 for k2, v2 := range v {
9470 ee.WriteMapElemKey()
9472 ee.WriteMapElemValue()
9476 for k2, v2 := range v {
9485 func (e *Encoder) fastpathEncMapUintptrStringR(f *codecFnInfo, rv reflect.Value) {
9486 fastpathTV.EncMapUintptrStringV(rv2i(rv).(map[uintptr]string), e)
9488 func (_ fastpathT) EncMapUintptrStringV(v map[uintptr]string, e *Encoder) {
9493 ee, esep := e.e, e.hh.hasElemSeparators()
9494 ee.WriteMapStart(len(v))
9496 v2 := make([]uint64, len(v))
9498 for k, _ := range v {
9502 sort.Sort(uintSlice(v2))
9504 for _, k2 := range v2 {
9505 ee.WriteMapElemKey()
9506 e.encode(uintptr(k2))
9507 ee.WriteMapElemValue()
9508 ee.EncodeString(cUTF8, v[uintptr(k2)])
9511 for _, k2 := range v2 {
9512 e.encode(uintptr(k2))
9513 ee.EncodeString(cUTF8, v[uintptr(k2)])
9518 for k2, v2 := range v {
9519 ee.WriteMapElemKey()
9521 ee.WriteMapElemValue()
9522 ee.EncodeString(cUTF8, v2)
9525 for k2, v2 := range v {
9527 ee.EncodeString(cUTF8, v2)
9534 func (e *Encoder) fastpathEncMapUintptrUintR(f *codecFnInfo, rv reflect.Value) {
9535 fastpathTV.EncMapUintptrUintV(rv2i(rv).(map[uintptr]uint), e)
9537 func (_ fastpathT) EncMapUintptrUintV(v map[uintptr]uint, e *Encoder) {
9542 ee, esep := e.e, e.hh.hasElemSeparators()
9543 ee.WriteMapStart(len(v))
9545 v2 := make([]uint64, len(v))
9547 for k, _ := range v {
9551 sort.Sort(uintSlice(v2))
9553 for _, k2 := range v2 {
9554 ee.WriteMapElemKey()
9555 e.encode(uintptr(k2))
9556 ee.WriteMapElemValue()
9557 ee.EncodeUint(uint64(v[uintptr(k2)]))
9560 for _, k2 := range v2 {
9561 e.encode(uintptr(k2))
9562 ee.EncodeUint(uint64(v[uintptr(k2)]))
9567 for k2, v2 := range v {
9568 ee.WriteMapElemKey()
9570 ee.WriteMapElemValue()
9571 ee.EncodeUint(uint64(v2))
9574 for k2, v2 := range v {
9576 ee.EncodeUint(uint64(v2))
9583 func (e *Encoder) fastpathEncMapUintptrUint8R(f *codecFnInfo, rv reflect.Value) {
9584 fastpathTV.EncMapUintptrUint8V(rv2i(rv).(map[uintptr]uint8), e)
9586 func (_ fastpathT) EncMapUintptrUint8V(v map[uintptr]uint8, e *Encoder) {
9591 ee, esep := e.e, e.hh.hasElemSeparators()
9592 ee.WriteMapStart(len(v))
9594 v2 := make([]uint64, len(v))
9596 for k, _ := range v {
9600 sort.Sort(uintSlice(v2))
9602 for _, k2 := range v2 {
9603 ee.WriteMapElemKey()
9604 e.encode(uintptr(k2))
9605 ee.WriteMapElemValue()
9606 ee.EncodeUint(uint64(v[uintptr(k2)]))
9609 for _, k2 := range v2 {
9610 e.encode(uintptr(k2))
9611 ee.EncodeUint(uint64(v[uintptr(k2)]))
9616 for k2, v2 := range v {
9617 ee.WriteMapElemKey()
9619 ee.WriteMapElemValue()
9620 ee.EncodeUint(uint64(v2))
9623 for k2, v2 := range v {
9625 ee.EncodeUint(uint64(v2))
9632 func (e *Encoder) fastpathEncMapUintptrUint16R(f *codecFnInfo, rv reflect.Value) {
9633 fastpathTV.EncMapUintptrUint16V(rv2i(rv).(map[uintptr]uint16), e)
9635 func (_ fastpathT) EncMapUintptrUint16V(v map[uintptr]uint16, e *Encoder) {
9640 ee, esep := e.e, e.hh.hasElemSeparators()
9641 ee.WriteMapStart(len(v))
9643 v2 := make([]uint64, len(v))
9645 for k, _ := range v {
9649 sort.Sort(uintSlice(v2))
9651 for _, k2 := range v2 {
9652 ee.WriteMapElemKey()
9653 e.encode(uintptr(k2))
9654 ee.WriteMapElemValue()
9655 ee.EncodeUint(uint64(v[uintptr(k2)]))
9658 for _, k2 := range v2 {
9659 e.encode(uintptr(k2))
9660 ee.EncodeUint(uint64(v[uintptr(k2)]))
9665 for k2, v2 := range v {
9666 ee.WriteMapElemKey()
9668 ee.WriteMapElemValue()
9669 ee.EncodeUint(uint64(v2))
9672 for k2, v2 := range v {
9674 ee.EncodeUint(uint64(v2))
9681 func (e *Encoder) fastpathEncMapUintptrUint32R(f *codecFnInfo, rv reflect.Value) {
9682 fastpathTV.EncMapUintptrUint32V(rv2i(rv).(map[uintptr]uint32), e)
9684 func (_ fastpathT) EncMapUintptrUint32V(v map[uintptr]uint32, e *Encoder) {
9689 ee, esep := e.e, e.hh.hasElemSeparators()
9690 ee.WriteMapStart(len(v))
9692 v2 := make([]uint64, len(v))
9694 for k, _ := range v {
9698 sort.Sort(uintSlice(v2))
9700 for _, k2 := range v2 {
9701 ee.WriteMapElemKey()
9702 e.encode(uintptr(k2))
9703 ee.WriteMapElemValue()
9704 ee.EncodeUint(uint64(v[uintptr(k2)]))
9707 for _, k2 := range v2 {
9708 e.encode(uintptr(k2))
9709 ee.EncodeUint(uint64(v[uintptr(k2)]))
9714 for k2, v2 := range v {
9715 ee.WriteMapElemKey()
9717 ee.WriteMapElemValue()
9718 ee.EncodeUint(uint64(v2))
9721 for k2, v2 := range v {
9723 ee.EncodeUint(uint64(v2))
9730 func (e *Encoder) fastpathEncMapUintptrUint64R(f *codecFnInfo, rv reflect.Value) {
9731 fastpathTV.EncMapUintptrUint64V(rv2i(rv).(map[uintptr]uint64), e)
9733 func (_ fastpathT) EncMapUintptrUint64V(v map[uintptr]uint64, e *Encoder) {
9738 ee, esep := e.e, e.hh.hasElemSeparators()
9739 ee.WriteMapStart(len(v))
9741 v2 := make([]uint64, len(v))
9743 for k, _ := range v {
9747 sort.Sort(uintSlice(v2))
9749 for _, k2 := range v2 {
9750 ee.WriteMapElemKey()
9751 e.encode(uintptr(k2))
9752 ee.WriteMapElemValue()
9753 ee.EncodeUint(uint64(v[uintptr(k2)]))
9756 for _, k2 := range v2 {
9757 e.encode(uintptr(k2))
9758 ee.EncodeUint(uint64(v[uintptr(k2)]))
9763 for k2, v2 := range v {
9764 ee.WriteMapElemKey()
9766 ee.WriteMapElemValue()
9767 ee.EncodeUint(uint64(v2))
9770 for k2, v2 := range v {
9772 ee.EncodeUint(uint64(v2))
9779 func (e *Encoder) fastpathEncMapUintptrUintptrR(f *codecFnInfo, rv reflect.Value) {
9780 fastpathTV.EncMapUintptrUintptrV(rv2i(rv).(map[uintptr]uintptr), e)
9782 func (_ fastpathT) EncMapUintptrUintptrV(v map[uintptr]uintptr, e *Encoder) {
9787 ee, esep := e.e, e.hh.hasElemSeparators()
9788 ee.WriteMapStart(len(v))
9790 v2 := make([]uint64, len(v))
9792 for k, _ := range v {
9796 sort.Sort(uintSlice(v2))
9798 for _, k2 := range v2 {
9799 ee.WriteMapElemKey()
9800 e.encode(uintptr(k2))
9801 ee.WriteMapElemValue()
9802 e.encode(v[uintptr(k2)])
9805 for _, k2 := range v2 {
9806 e.encode(uintptr(k2))
9807 e.encode(v[uintptr(k2)])
9812 for k2, v2 := range v {
9813 ee.WriteMapElemKey()
9815 ee.WriteMapElemValue()
9819 for k2, v2 := range v {
9828 func (e *Encoder) fastpathEncMapUintptrIntR(f *codecFnInfo, rv reflect.Value) {
9829 fastpathTV.EncMapUintptrIntV(rv2i(rv).(map[uintptr]int), e)
9831 func (_ fastpathT) EncMapUintptrIntV(v map[uintptr]int, e *Encoder) {
9836 ee, esep := e.e, e.hh.hasElemSeparators()
9837 ee.WriteMapStart(len(v))
9839 v2 := make([]uint64, len(v))
9841 for k, _ := range v {
9845 sort.Sort(uintSlice(v2))
9847 for _, k2 := range v2 {
9848 ee.WriteMapElemKey()
9849 e.encode(uintptr(k2))
9850 ee.WriteMapElemValue()
9851 ee.EncodeInt(int64(v[uintptr(k2)]))
9854 for _, k2 := range v2 {
9855 e.encode(uintptr(k2))
9856 ee.EncodeInt(int64(v[uintptr(k2)]))
9861 for k2, v2 := range v {
9862 ee.WriteMapElemKey()
9864 ee.WriteMapElemValue()
9865 ee.EncodeInt(int64(v2))
9868 for k2, v2 := range v {
9870 ee.EncodeInt(int64(v2))
9877 func (e *Encoder) fastpathEncMapUintptrInt8R(f *codecFnInfo, rv reflect.Value) {
9878 fastpathTV.EncMapUintptrInt8V(rv2i(rv).(map[uintptr]int8), e)
9880 func (_ fastpathT) EncMapUintptrInt8V(v map[uintptr]int8, e *Encoder) {
9885 ee, esep := e.e, e.hh.hasElemSeparators()
9886 ee.WriteMapStart(len(v))
9888 v2 := make([]uint64, len(v))
9890 for k, _ := range v {
9894 sort.Sort(uintSlice(v2))
9896 for _, k2 := range v2 {
9897 ee.WriteMapElemKey()
9898 e.encode(uintptr(k2))
9899 ee.WriteMapElemValue()
9900 ee.EncodeInt(int64(v[uintptr(k2)]))
9903 for _, k2 := range v2 {
9904 e.encode(uintptr(k2))
9905 ee.EncodeInt(int64(v[uintptr(k2)]))
9910 for k2, v2 := range v {
9911 ee.WriteMapElemKey()
9913 ee.WriteMapElemValue()
9914 ee.EncodeInt(int64(v2))
9917 for k2, v2 := range v {
9919 ee.EncodeInt(int64(v2))
9926 func (e *Encoder) fastpathEncMapUintptrInt16R(f *codecFnInfo, rv reflect.Value) {
9927 fastpathTV.EncMapUintptrInt16V(rv2i(rv).(map[uintptr]int16), e)
9929 func (_ fastpathT) EncMapUintptrInt16V(v map[uintptr]int16, e *Encoder) {
9934 ee, esep := e.e, e.hh.hasElemSeparators()
9935 ee.WriteMapStart(len(v))
9937 v2 := make([]uint64, len(v))
9939 for k, _ := range v {
9943 sort.Sort(uintSlice(v2))
9945 for _, k2 := range v2 {
9946 ee.WriteMapElemKey()
9947 e.encode(uintptr(k2))
9948 ee.WriteMapElemValue()
9949 ee.EncodeInt(int64(v[uintptr(k2)]))
9952 for _, k2 := range v2 {
9953 e.encode(uintptr(k2))
9954 ee.EncodeInt(int64(v[uintptr(k2)]))
9959 for k2, v2 := range v {
9960 ee.WriteMapElemKey()
9962 ee.WriteMapElemValue()
9963 ee.EncodeInt(int64(v2))
9966 for k2, v2 := range v {
9968 ee.EncodeInt(int64(v2))
9975 func (e *Encoder) fastpathEncMapUintptrInt32R(f *codecFnInfo, rv reflect.Value) {
9976 fastpathTV.EncMapUintptrInt32V(rv2i(rv).(map[uintptr]int32), e)
9978 func (_ fastpathT) EncMapUintptrInt32V(v map[uintptr]int32, e *Encoder) {
9983 ee, esep := e.e, e.hh.hasElemSeparators()
9984 ee.WriteMapStart(len(v))
9986 v2 := make([]uint64, len(v))
9988 for k, _ := range v {
9992 sort.Sort(uintSlice(v2))
9994 for _, k2 := range v2 {
9995 ee.WriteMapElemKey()
9996 e.encode(uintptr(k2))
9997 ee.WriteMapElemValue()
9998 ee.EncodeInt(int64(v[uintptr(k2)]))
10001 for _, k2 := range v2 {
10002 e.encode(uintptr(k2))
10003 ee.EncodeInt(int64(v[uintptr(k2)]))
10008 for k2, v2 := range v {
10009 ee.WriteMapElemKey()
10011 ee.WriteMapElemValue()
10012 ee.EncodeInt(int64(v2))
10015 for k2, v2 := range v {
10017 ee.EncodeInt(int64(v2))
10024 func (e *Encoder) fastpathEncMapUintptrInt64R(f *codecFnInfo, rv reflect.Value) {
10025 fastpathTV.EncMapUintptrInt64V(rv2i(rv).(map[uintptr]int64), e)
10027 func (_ fastpathT) EncMapUintptrInt64V(v map[uintptr]int64, e *Encoder) {
10032 ee, esep := e.e, e.hh.hasElemSeparators()
10033 ee.WriteMapStart(len(v))
10035 v2 := make([]uint64, len(v))
10037 for k, _ := range v {
10041 sort.Sort(uintSlice(v2))
10043 for _, k2 := range v2 {
10044 ee.WriteMapElemKey()
10045 e.encode(uintptr(k2))
10046 ee.WriteMapElemValue()
10047 ee.EncodeInt(int64(v[uintptr(k2)]))
10050 for _, k2 := range v2 {
10051 e.encode(uintptr(k2))
10052 ee.EncodeInt(int64(v[uintptr(k2)]))
10057 for k2, v2 := range v {
10058 ee.WriteMapElemKey()
10060 ee.WriteMapElemValue()
10061 ee.EncodeInt(int64(v2))
10064 for k2, v2 := range v {
10066 ee.EncodeInt(int64(v2))
10073 func (e *Encoder) fastpathEncMapUintptrFloat32R(f *codecFnInfo, rv reflect.Value) {
10074 fastpathTV.EncMapUintptrFloat32V(rv2i(rv).(map[uintptr]float32), e)
10076 func (_ fastpathT) EncMapUintptrFloat32V(v map[uintptr]float32, e *Encoder) {
10081 ee, esep := e.e, e.hh.hasElemSeparators()
10082 ee.WriteMapStart(len(v))
10084 v2 := make([]uint64, len(v))
10086 for k, _ := range v {
10090 sort.Sort(uintSlice(v2))
10092 for _, k2 := range v2 {
10093 ee.WriteMapElemKey()
10094 e.encode(uintptr(k2))
10095 ee.WriteMapElemValue()
10096 ee.EncodeFloat32(v[uintptr(k2)])
10099 for _, k2 := range v2 {
10100 e.encode(uintptr(k2))
10101 ee.EncodeFloat32(v[uintptr(k2)])
10106 for k2, v2 := range v {
10107 ee.WriteMapElemKey()
10109 ee.WriteMapElemValue()
10110 ee.EncodeFloat32(v2)
10113 for k2, v2 := range v {
10115 ee.EncodeFloat32(v2)
10122 func (e *Encoder) fastpathEncMapUintptrFloat64R(f *codecFnInfo, rv reflect.Value) {
10123 fastpathTV.EncMapUintptrFloat64V(rv2i(rv).(map[uintptr]float64), e)
10125 func (_ fastpathT) EncMapUintptrFloat64V(v map[uintptr]float64, e *Encoder) {
10130 ee, esep := e.e, e.hh.hasElemSeparators()
10131 ee.WriteMapStart(len(v))
10133 v2 := make([]uint64, len(v))
10135 for k, _ := range v {
10139 sort.Sort(uintSlice(v2))
10141 for _, k2 := range v2 {
10142 ee.WriteMapElemKey()
10143 e.encode(uintptr(k2))
10144 ee.WriteMapElemValue()
10145 ee.EncodeFloat64(v[uintptr(k2)])
10148 for _, k2 := range v2 {
10149 e.encode(uintptr(k2))
10150 ee.EncodeFloat64(v[uintptr(k2)])
10155 for k2, v2 := range v {
10156 ee.WriteMapElemKey()
10158 ee.WriteMapElemValue()
10159 ee.EncodeFloat64(v2)
10162 for k2, v2 := range v {
10164 ee.EncodeFloat64(v2)
10171 func (e *Encoder) fastpathEncMapUintptrBoolR(f *codecFnInfo, rv reflect.Value) {
10172 fastpathTV.EncMapUintptrBoolV(rv2i(rv).(map[uintptr]bool), e)
10174 func (_ fastpathT) EncMapUintptrBoolV(v map[uintptr]bool, e *Encoder) {
10179 ee, esep := e.e, e.hh.hasElemSeparators()
10180 ee.WriteMapStart(len(v))
10182 v2 := make([]uint64, len(v))
10184 for k, _ := range v {
10188 sort.Sort(uintSlice(v2))
10190 for _, k2 := range v2 {
10191 ee.WriteMapElemKey()
10192 e.encode(uintptr(k2))
10193 ee.WriteMapElemValue()
10194 ee.EncodeBool(v[uintptr(k2)])
10197 for _, k2 := range v2 {
10198 e.encode(uintptr(k2))
10199 ee.EncodeBool(v[uintptr(k2)])
10204 for k2, v2 := range v {
10205 ee.WriteMapElemKey()
10207 ee.WriteMapElemValue()
10211 for k2, v2 := range v {
10220 func (e *Encoder) fastpathEncMapIntIntfR(f *codecFnInfo, rv reflect.Value) {
10221 fastpathTV.EncMapIntIntfV(rv2i(rv).(map[int]interface{}), e)
10223 func (_ fastpathT) EncMapIntIntfV(v map[int]interface{}, e *Encoder) {
10228 ee, esep := e.e, e.hh.hasElemSeparators()
10229 ee.WriteMapStart(len(v))
10231 v2 := make([]int64, len(v))
10233 for k, _ := range v {
10237 sort.Sort(intSlice(v2))
10239 for _, k2 := range v2 {
10240 ee.WriteMapElemKey()
10241 ee.EncodeInt(int64(int(k2)))
10242 ee.WriteMapElemValue()
10243 e.encode(v[int(k2)])
10246 for _, k2 := range v2 {
10247 ee.EncodeInt(int64(int(k2)))
10248 e.encode(v[int(k2)])
10253 for k2, v2 := range v {
10254 ee.WriteMapElemKey()
10255 ee.EncodeInt(int64(k2))
10256 ee.WriteMapElemValue()
10260 for k2, v2 := range v {
10261 ee.EncodeInt(int64(k2))
10269 func (e *Encoder) fastpathEncMapIntStringR(f *codecFnInfo, rv reflect.Value) {
10270 fastpathTV.EncMapIntStringV(rv2i(rv).(map[int]string), e)
10272 func (_ fastpathT) EncMapIntStringV(v map[int]string, e *Encoder) {
10277 ee, esep := e.e, e.hh.hasElemSeparators()
10278 ee.WriteMapStart(len(v))
10280 v2 := make([]int64, len(v))
10282 for k, _ := range v {
10286 sort.Sort(intSlice(v2))
10288 for _, k2 := range v2 {
10289 ee.WriteMapElemKey()
10290 ee.EncodeInt(int64(int(k2)))
10291 ee.WriteMapElemValue()
10292 ee.EncodeString(cUTF8, v[int(k2)])
10295 for _, k2 := range v2 {
10296 ee.EncodeInt(int64(int(k2)))
10297 ee.EncodeString(cUTF8, v[int(k2)])
10302 for k2, v2 := range v {
10303 ee.WriteMapElemKey()
10304 ee.EncodeInt(int64(k2))
10305 ee.WriteMapElemValue()
10306 ee.EncodeString(cUTF8, v2)
10309 for k2, v2 := range v {
10310 ee.EncodeInt(int64(k2))
10311 ee.EncodeString(cUTF8, v2)
10318 func (e *Encoder) fastpathEncMapIntUintR(f *codecFnInfo, rv reflect.Value) {
10319 fastpathTV.EncMapIntUintV(rv2i(rv).(map[int]uint), e)
10321 func (_ fastpathT) EncMapIntUintV(v map[int]uint, e *Encoder) {
10326 ee, esep := e.e, e.hh.hasElemSeparators()
10327 ee.WriteMapStart(len(v))
10329 v2 := make([]int64, len(v))
10331 for k, _ := range v {
10335 sort.Sort(intSlice(v2))
10337 for _, k2 := range v2 {
10338 ee.WriteMapElemKey()
10339 ee.EncodeInt(int64(int(k2)))
10340 ee.WriteMapElemValue()
10341 ee.EncodeUint(uint64(v[int(k2)]))
10344 for _, k2 := range v2 {
10345 ee.EncodeInt(int64(int(k2)))
10346 ee.EncodeUint(uint64(v[int(k2)]))
10351 for k2, v2 := range v {
10352 ee.WriteMapElemKey()
10353 ee.EncodeInt(int64(k2))
10354 ee.WriteMapElemValue()
10355 ee.EncodeUint(uint64(v2))
10358 for k2, v2 := range v {
10359 ee.EncodeInt(int64(k2))
10360 ee.EncodeUint(uint64(v2))
10367 func (e *Encoder) fastpathEncMapIntUint8R(f *codecFnInfo, rv reflect.Value) {
10368 fastpathTV.EncMapIntUint8V(rv2i(rv).(map[int]uint8), e)
10370 func (_ fastpathT) EncMapIntUint8V(v map[int]uint8, e *Encoder) {
10375 ee, esep := e.e, e.hh.hasElemSeparators()
10376 ee.WriteMapStart(len(v))
10378 v2 := make([]int64, len(v))
10380 for k, _ := range v {
10384 sort.Sort(intSlice(v2))
10386 for _, k2 := range v2 {
10387 ee.WriteMapElemKey()
10388 ee.EncodeInt(int64(int(k2)))
10389 ee.WriteMapElemValue()
10390 ee.EncodeUint(uint64(v[int(k2)]))
10393 for _, k2 := range v2 {
10394 ee.EncodeInt(int64(int(k2)))
10395 ee.EncodeUint(uint64(v[int(k2)]))
10400 for k2, v2 := range v {
10401 ee.WriteMapElemKey()
10402 ee.EncodeInt(int64(k2))
10403 ee.WriteMapElemValue()
10404 ee.EncodeUint(uint64(v2))
10407 for k2, v2 := range v {
10408 ee.EncodeInt(int64(k2))
10409 ee.EncodeUint(uint64(v2))
10416 func (e *Encoder) fastpathEncMapIntUint16R(f *codecFnInfo, rv reflect.Value) {
10417 fastpathTV.EncMapIntUint16V(rv2i(rv).(map[int]uint16), e)
10419 func (_ fastpathT) EncMapIntUint16V(v map[int]uint16, e *Encoder) {
10424 ee, esep := e.e, e.hh.hasElemSeparators()
10425 ee.WriteMapStart(len(v))
10427 v2 := make([]int64, len(v))
10429 for k, _ := range v {
10433 sort.Sort(intSlice(v2))
10435 for _, k2 := range v2 {
10436 ee.WriteMapElemKey()
10437 ee.EncodeInt(int64(int(k2)))
10438 ee.WriteMapElemValue()
10439 ee.EncodeUint(uint64(v[int(k2)]))
10442 for _, k2 := range v2 {
10443 ee.EncodeInt(int64(int(k2)))
10444 ee.EncodeUint(uint64(v[int(k2)]))
10449 for k2, v2 := range v {
10450 ee.WriteMapElemKey()
10451 ee.EncodeInt(int64(k2))
10452 ee.WriteMapElemValue()
10453 ee.EncodeUint(uint64(v2))
10456 for k2, v2 := range v {
10457 ee.EncodeInt(int64(k2))
10458 ee.EncodeUint(uint64(v2))
10465 func (e *Encoder) fastpathEncMapIntUint32R(f *codecFnInfo, rv reflect.Value) {
10466 fastpathTV.EncMapIntUint32V(rv2i(rv).(map[int]uint32), e)
10468 func (_ fastpathT) EncMapIntUint32V(v map[int]uint32, e *Encoder) {
10473 ee, esep := e.e, e.hh.hasElemSeparators()
10474 ee.WriteMapStart(len(v))
10476 v2 := make([]int64, len(v))
10478 for k, _ := range v {
10482 sort.Sort(intSlice(v2))
10484 for _, k2 := range v2 {
10485 ee.WriteMapElemKey()
10486 ee.EncodeInt(int64(int(k2)))
10487 ee.WriteMapElemValue()
10488 ee.EncodeUint(uint64(v[int(k2)]))
10491 for _, k2 := range v2 {
10492 ee.EncodeInt(int64(int(k2)))
10493 ee.EncodeUint(uint64(v[int(k2)]))
10498 for k2, v2 := range v {
10499 ee.WriteMapElemKey()
10500 ee.EncodeInt(int64(k2))
10501 ee.WriteMapElemValue()
10502 ee.EncodeUint(uint64(v2))
10505 for k2, v2 := range v {
10506 ee.EncodeInt(int64(k2))
10507 ee.EncodeUint(uint64(v2))
10514 func (e *Encoder) fastpathEncMapIntUint64R(f *codecFnInfo, rv reflect.Value) {
10515 fastpathTV.EncMapIntUint64V(rv2i(rv).(map[int]uint64), e)
10517 func (_ fastpathT) EncMapIntUint64V(v map[int]uint64, e *Encoder) {
10522 ee, esep := e.e, e.hh.hasElemSeparators()
10523 ee.WriteMapStart(len(v))
10525 v2 := make([]int64, len(v))
10527 for k, _ := range v {
10531 sort.Sort(intSlice(v2))
10533 for _, k2 := range v2 {
10534 ee.WriteMapElemKey()
10535 ee.EncodeInt(int64(int(k2)))
10536 ee.WriteMapElemValue()
10537 ee.EncodeUint(uint64(v[int(k2)]))
10540 for _, k2 := range v2 {
10541 ee.EncodeInt(int64(int(k2)))
10542 ee.EncodeUint(uint64(v[int(k2)]))
10547 for k2, v2 := range v {
10548 ee.WriteMapElemKey()
10549 ee.EncodeInt(int64(k2))
10550 ee.WriteMapElemValue()
10551 ee.EncodeUint(uint64(v2))
10554 for k2, v2 := range v {
10555 ee.EncodeInt(int64(k2))
10556 ee.EncodeUint(uint64(v2))
10563 func (e *Encoder) fastpathEncMapIntUintptrR(f *codecFnInfo, rv reflect.Value) {
10564 fastpathTV.EncMapIntUintptrV(rv2i(rv).(map[int]uintptr), e)
10566 func (_ fastpathT) EncMapIntUintptrV(v map[int]uintptr, e *Encoder) {
10571 ee, esep := e.e, e.hh.hasElemSeparators()
10572 ee.WriteMapStart(len(v))
10574 v2 := make([]int64, len(v))
10576 for k, _ := range v {
10580 sort.Sort(intSlice(v2))
10582 for _, k2 := range v2 {
10583 ee.WriteMapElemKey()
10584 ee.EncodeInt(int64(int(k2)))
10585 ee.WriteMapElemValue()
10586 e.encode(v[int(k2)])
10589 for _, k2 := range v2 {
10590 ee.EncodeInt(int64(int(k2)))
10591 e.encode(v[int(k2)])
10596 for k2, v2 := range v {
10597 ee.WriteMapElemKey()
10598 ee.EncodeInt(int64(k2))
10599 ee.WriteMapElemValue()
10603 for k2, v2 := range v {
10604 ee.EncodeInt(int64(k2))
10612 func (e *Encoder) fastpathEncMapIntIntR(f *codecFnInfo, rv reflect.Value) {
10613 fastpathTV.EncMapIntIntV(rv2i(rv).(map[int]int), e)
10615 func (_ fastpathT) EncMapIntIntV(v map[int]int, e *Encoder) {
10620 ee, esep := e.e, e.hh.hasElemSeparators()
10621 ee.WriteMapStart(len(v))
10623 v2 := make([]int64, len(v))
10625 for k, _ := range v {
10629 sort.Sort(intSlice(v2))
10631 for _, k2 := range v2 {
10632 ee.WriteMapElemKey()
10633 ee.EncodeInt(int64(int(k2)))
10634 ee.WriteMapElemValue()
10635 ee.EncodeInt(int64(v[int(k2)]))
10638 for _, k2 := range v2 {
10639 ee.EncodeInt(int64(int(k2)))
10640 ee.EncodeInt(int64(v[int(k2)]))
10645 for k2, v2 := range v {
10646 ee.WriteMapElemKey()
10647 ee.EncodeInt(int64(k2))
10648 ee.WriteMapElemValue()
10649 ee.EncodeInt(int64(v2))
10652 for k2, v2 := range v {
10653 ee.EncodeInt(int64(k2))
10654 ee.EncodeInt(int64(v2))
10661 func (e *Encoder) fastpathEncMapIntInt8R(f *codecFnInfo, rv reflect.Value) {
10662 fastpathTV.EncMapIntInt8V(rv2i(rv).(map[int]int8), e)
10664 func (_ fastpathT) EncMapIntInt8V(v map[int]int8, e *Encoder) {
10669 ee, esep := e.e, e.hh.hasElemSeparators()
10670 ee.WriteMapStart(len(v))
10672 v2 := make([]int64, len(v))
10674 for k, _ := range v {
10678 sort.Sort(intSlice(v2))
10680 for _, k2 := range v2 {
10681 ee.WriteMapElemKey()
10682 ee.EncodeInt(int64(int(k2)))
10683 ee.WriteMapElemValue()
10684 ee.EncodeInt(int64(v[int(k2)]))
10687 for _, k2 := range v2 {
10688 ee.EncodeInt(int64(int(k2)))
10689 ee.EncodeInt(int64(v[int(k2)]))
10694 for k2, v2 := range v {
10695 ee.WriteMapElemKey()
10696 ee.EncodeInt(int64(k2))
10697 ee.WriteMapElemValue()
10698 ee.EncodeInt(int64(v2))
10701 for k2, v2 := range v {
10702 ee.EncodeInt(int64(k2))
10703 ee.EncodeInt(int64(v2))
10710 func (e *Encoder) fastpathEncMapIntInt16R(f *codecFnInfo, rv reflect.Value) {
10711 fastpathTV.EncMapIntInt16V(rv2i(rv).(map[int]int16), e)
10713 func (_ fastpathT) EncMapIntInt16V(v map[int]int16, e *Encoder) {
10718 ee, esep := e.e, e.hh.hasElemSeparators()
10719 ee.WriteMapStart(len(v))
10721 v2 := make([]int64, len(v))
10723 for k, _ := range v {
10727 sort.Sort(intSlice(v2))
10729 for _, k2 := range v2 {
10730 ee.WriteMapElemKey()
10731 ee.EncodeInt(int64(int(k2)))
10732 ee.WriteMapElemValue()
10733 ee.EncodeInt(int64(v[int(k2)]))
10736 for _, k2 := range v2 {
10737 ee.EncodeInt(int64(int(k2)))
10738 ee.EncodeInt(int64(v[int(k2)]))
10743 for k2, v2 := range v {
10744 ee.WriteMapElemKey()
10745 ee.EncodeInt(int64(k2))
10746 ee.WriteMapElemValue()
10747 ee.EncodeInt(int64(v2))
10750 for k2, v2 := range v {
10751 ee.EncodeInt(int64(k2))
10752 ee.EncodeInt(int64(v2))
10759 func (e *Encoder) fastpathEncMapIntInt32R(f *codecFnInfo, rv reflect.Value) {
10760 fastpathTV.EncMapIntInt32V(rv2i(rv).(map[int]int32), e)
10762 func (_ fastpathT) EncMapIntInt32V(v map[int]int32, e *Encoder) {
10767 ee, esep := e.e, e.hh.hasElemSeparators()
10768 ee.WriteMapStart(len(v))
10770 v2 := make([]int64, len(v))
10772 for k, _ := range v {
10776 sort.Sort(intSlice(v2))
10778 for _, k2 := range v2 {
10779 ee.WriteMapElemKey()
10780 ee.EncodeInt(int64(int(k2)))
10781 ee.WriteMapElemValue()
10782 ee.EncodeInt(int64(v[int(k2)]))
10785 for _, k2 := range v2 {
10786 ee.EncodeInt(int64(int(k2)))
10787 ee.EncodeInt(int64(v[int(k2)]))
10792 for k2, v2 := range v {
10793 ee.WriteMapElemKey()
10794 ee.EncodeInt(int64(k2))
10795 ee.WriteMapElemValue()
10796 ee.EncodeInt(int64(v2))
10799 for k2, v2 := range v {
10800 ee.EncodeInt(int64(k2))
10801 ee.EncodeInt(int64(v2))
10808 func (e *Encoder) fastpathEncMapIntInt64R(f *codecFnInfo, rv reflect.Value) {
10809 fastpathTV.EncMapIntInt64V(rv2i(rv).(map[int]int64), e)
10811 func (_ fastpathT) EncMapIntInt64V(v map[int]int64, e *Encoder) {
10816 ee, esep := e.e, e.hh.hasElemSeparators()
10817 ee.WriteMapStart(len(v))
10819 v2 := make([]int64, len(v))
10821 for k, _ := range v {
10825 sort.Sort(intSlice(v2))
10827 for _, k2 := range v2 {
10828 ee.WriteMapElemKey()
10829 ee.EncodeInt(int64(int(k2)))
10830 ee.WriteMapElemValue()
10831 ee.EncodeInt(int64(v[int(k2)]))
10834 for _, k2 := range v2 {
10835 ee.EncodeInt(int64(int(k2)))
10836 ee.EncodeInt(int64(v[int(k2)]))
10841 for k2, v2 := range v {
10842 ee.WriteMapElemKey()
10843 ee.EncodeInt(int64(k2))
10844 ee.WriteMapElemValue()
10845 ee.EncodeInt(int64(v2))
10848 for k2, v2 := range v {
10849 ee.EncodeInt(int64(k2))
10850 ee.EncodeInt(int64(v2))
10857 func (e *Encoder) fastpathEncMapIntFloat32R(f *codecFnInfo, rv reflect.Value) {
10858 fastpathTV.EncMapIntFloat32V(rv2i(rv).(map[int]float32), e)
10860 func (_ fastpathT) EncMapIntFloat32V(v map[int]float32, e *Encoder) {
10865 ee, esep := e.e, e.hh.hasElemSeparators()
10866 ee.WriteMapStart(len(v))
10868 v2 := make([]int64, len(v))
10870 for k, _ := range v {
10874 sort.Sort(intSlice(v2))
10876 for _, k2 := range v2 {
10877 ee.WriteMapElemKey()
10878 ee.EncodeInt(int64(int(k2)))
10879 ee.WriteMapElemValue()
10880 ee.EncodeFloat32(v[int(k2)])
10883 for _, k2 := range v2 {
10884 ee.EncodeInt(int64(int(k2)))
10885 ee.EncodeFloat32(v[int(k2)])
10890 for k2, v2 := range v {
10891 ee.WriteMapElemKey()
10892 ee.EncodeInt(int64(k2))
10893 ee.WriteMapElemValue()
10894 ee.EncodeFloat32(v2)
10897 for k2, v2 := range v {
10898 ee.EncodeInt(int64(k2))
10899 ee.EncodeFloat32(v2)
10906 func (e *Encoder) fastpathEncMapIntFloat64R(f *codecFnInfo, rv reflect.Value) {
10907 fastpathTV.EncMapIntFloat64V(rv2i(rv).(map[int]float64), e)
10909 func (_ fastpathT) EncMapIntFloat64V(v map[int]float64, e *Encoder) {
10914 ee, esep := e.e, e.hh.hasElemSeparators()
10915 ee.WriteMapStart(len(v))
10917 v2 := make([]int64, len(v))
10919 for k, _ := range v {
10923 sort.Sort(intSlice(v2))
10925 for _, k2 := range v2 {
10926 ee.WriteMapElemKey()
10927 ee.EncodeInt(int64(int(k2)))
10928 ee.WriteMapElemValue()
10929 ee.EncodeFloat64(v[int(k2)])
10932 for _, k2 := range v2 {
10933 ee.EncodeInt(int64(int(k2)))
10934 ee.EncodeFloat64(v[int(k2)])
10939 for k2, v2 := range v {
10940 ee.WriteMapElemKey()
10941 ee.EncodeInt(int64(k2))
10942 ee.WriteMapElemValue()
10943 ee.EncodeFloat64(v2)
10946 for k2, v2 := range v {
10947 ee.EncodeInt(int64(k2))
10948 ee.EncodeFloat64(v2)
10955 func (e *Encoder) fastpathEncMapIntBoolR(f *codecFnInfo, rv reflect.Value) {
10956 fastpathTV.EncMapIntBoolV(rv2i(rv).(map[int]bool), e)
10958 func (_ fastpathT) EncMapIntBoolV(v map[int]bool, e *Encoder) {
10963 ee, esep := e.e, e.hh.hasElemSeparators()
10964 ee.WriteMapStart(len(v))
10966 v2 := make([]int64, len(v))
10968 for k, _ := range v {
10972 sort.Sort(intSlice(v2))
10974 for _, k2 := range v2 {
10975 ee.WriteMapElemKey()
10976 ee.EncodeInt(int64(int(k2)))
10977 ee.WriteMapElemValue()
10978 ee.EncodeBool(v[int(k2)])
10981 for _, k2 := range v2 {
10982 ee.EncodeInt(int64(int(k2)))
10983 ee.EncodeBool(v[int(k2)])
10988 for k2, v2 := range v {
10989 ee.WriteMapElemKey()
10990 ee.EncodeInt(int64(k2))
10991 ee.WriteMapElemValue()
10995 for k2, v2 := range v {
10996 ee.EncodeInt(int64(k2))
11004 func (e *Encoder) fastpathEncMapInt8IntfR(f *codecFnInfo, rv reflect.Value) {
11005 fastpathTV.EncMapInt8IntfV(rv2i(rv).(map[int8]interface{}), e)
11007 func (_ fastpathT) EncMapInt8IntfV(v map[int8]interface{}, e *Encoder) {
11012 ee, esep := e.e, e.hh.hasElemSeparators()
11013 ee.WriteMapStart(len(v))
11015 v2 := make([]int64, len(v))
11017 for k, _ := range v {
11021 sort.Sort(intSlice(v2))
11023 for _, k2 := range v2 {
11024 ee.WriteMapElemKey()
11025 ee.EncodeInt(int64(int8(k2)))
11026 ee.WriteMapElemValue()
11027 e.encode(v[int8(k2)])
11030 for _, k2 := range v2 {
11031 ee.EncodeInt(int64(int8(k2)))
11032 e.encode(v[int8(k2)])
11037 for k2, v2 := range v {
11038 ee.WriteMapElemKey()
11039 ee.EncodeInt(int64(k2))
11040 ee.WriteMapElemValue()
11044 for k2, v2 := range v {
11045 ee.EncodeInt(int64(k2))
11053 func (e *Encoder) fastpathEncMapInt8StringR(f *codecFnInfo, rv reflect.Value) {
11054 fastpathTV.EncMapInt8StringV(rv2i(rv).(map[int8]string), e)
11056 func (_ fastpathT) EncMapInt8StringV(v map[int8]string, e *Encoder) {
11061 ee, esep := e.e, e.hh.hasElemSeparators()
11062 ee.WriteMapStart(len(v))
11064 v2 := make([]int64, len(v))
11066 for k, _ := range v {
11070 sort.Sort(intSlice(v2))
11072 for _, k2 := range v2 {
11073 ee.WriteMapElemKey()
11074 ee.EncodeInt(int64(int8(k2)))
11075 ee.WriteMapElemValue()
11076 ee.EncodeString(cUTF8, v[int8(k2)])
11079 for _, k2 := range v2 {
11080 ee.EncodeInt(int64(int8(k2)))
11081 ee.EncodeString(cUTF8, v[int8(k2)])
11086 for k2, v2 := range v {
11087 ee.WriteMapElemKey()
11088 ee.EncodeInt(int64(k2))
11089 ee.WriteMapElemValue()
11090 ee.EncodeString(cUTF8, v2)
11093 for k2, v2 := range v {
11094 ee.EncodeInt(int64(k2))
11095 ee.EncodeString(cUTF8, v2)
11102 func (e *Encoder) fastpathEncMapInt8UintR(f *codecFnInfo, rv reflect.Value) {
11103 fastpathTV.EncMapInt8UintV(rv2i(rv).(map[int8]uint), e)
11105 func (_ fastpathT) EncMapInt8UintV(v map[int8]uint, e *Encoder) {
11110 ee, esep := e.e, e.hh.hasElemSeparators()
11111 ee.WriteMapStart(len(v))
11113 v2 := make([]int64, len(v))
11115 for k, _ := range v {
11119 sort.Sort(intSlice(v2))
11121 for _, k2 := range v2 {
11122 ee.WriteMapElemKey()
11123 ee.EncodeInt(int64(int8(k2)))
11124 ee.WriteMapElemValue()
11125 ee.EncodeUint(uint64(v[int8(k2)]))
11128 for _, k2 := range v2 {
11129 ee.EncodeInt(int64(int8(k2)))
11130 ee.EncodeUint(uint64(v[int8(k2)]))
11135 for k2, v2 := range v {
11136 ee.WriteMapElemKey()
11137 ee.EncodeInt(int64(k2))
11138 ee.WriteMapElemValue()
11139 ee.EncodeUint(uint64(v2))
11142 for k2, v2 := range v {
11143 ee.EncodeInt(int64(k2))
11144 ee.EncodeUint(uint64(v2))
11151 func (e *Encoder) fastpathEncMapInt8Uint8R(f *codecFnInfo, rv reflect.Value) {
11152 fastpathTV.EncMapInt8Uint8V(rv2i(rv).(map[int8]uint8), e)
11154 func (_ fastpathT) EncMapInt8Uint8V(v map[int8]uint8, e *Encoder) {
11159 ee, esep := e.e, e.hh.hasElemSeparators()
11160 ee.WriteMapStart(len(v))
11162 v2 := make([]int64, len(v))
11164 for k, _ := range v {
11168 sort.Sort(intSlice(v2))
11170 for _, k2 := range v2 {
11171 ee.WriteMapElemKey()
11172 ee.EncodeInt(int64(int8(k2)))
11173 ee.WriteMapElemValue()
11174 ee.EncodeUint(uint64(v[int8(k2)]))
11177 for _, k2 := range v2 {
11178 ee.EncodeInt(int64(int8(k2)))
11179 ee.EncodeUint(uint64(v[int8(k2)]))
11184 for k2, v2 := range v {
11185 ee.WriteMapElemKey()
11186 ee.EncodeInt(int64(k2))
11187 ee.WriteMapElemValue()
11188 ee.EncodeUint(uint64(v2))
11191 for k2, v2 := range v {
11192 ee.EncodeInt(int64(k2))
11193 ee.EncodeUint(uint64(v2))
11200 func (e *Encoder) fastpathEncMapInt8Uint16R(f *codecFnInfo, rv reflect.Value) {
11201 fastpathTV.EncMapInt8Uint16V(rv2i(rv).(map[int8]uint16), e)
11203 func (_ fastpathT) EncMapInt8Uint16V(v map[int8]uint16, e *Encoder) {
11208 ee, esep := e.e, e.hh.hasElemSeparators()
11209 ee.WriteMapStart(len(v))
11211 v2 := make([]int64, len(v))
11213 for k, _ := range v {
11217 sort.Sort(intSlice(v2))
11219 for _, k2 := range v2 {
11220 ee.WriteMapElemKey()
11221 ee.EncodeInt(int64(int8(k2)))
11222 ee.WriteMapElemValue()
11223 ee.EncodeUint(uint64(v[int8(k2)]))
11226 for _, k2 := range v2 {
11227 ee.EncodeInt(int64(int8(k2)))
11228 ee.EncodeUint(uint64(v[int8(k2)]))
11233 for k2, v2 := range v {
11234 ee.WriteMapElemKey()
11235 ee.EncodeInt(int64(k2))
11236 ee.WriteMapElemValue()
11237 ee.EncodeUint(uint64(v2))
11240 for k2, v2 := range v {
11241 ee.EncodeInt(int64(k2))
11242 ee.EncodeUint(uint64(v2))
11249 func (e *Encoder) fastpathEncMapInt8Uint32R(f *codecFnInfo, rv reflect.Value) {
11250 fastpathTV.EncMapInt8Uint32V(rv2i(rv).(map[int8]uint32), e)
11252 func (_ fastpathT) EncMapInt8Uint32V(v map[int8]uint32, e *Encoder) {
11257 ee, esep := e.e, e.hh.hasElemSeparators()
11258 ee.WriteMapStart(len(v))
11260 v2 := make([]int64, len(v))
11262 for k, _ := range v {
11266 sort.Sort(intSlice(v2))
11268 for _, k2 := range v2 {
11269 ee.WriteMapElemKey()
11270 ee.EncodeInt(int64(int8(k2)))
11271 ee.WriteMapElemValue()
11272 ee.EncodeUint(uint64(v[int8(k2)]))
11275 for _, k2 := range v2 {
11276 ee.EncodeInt(int64(int8(k2)))
11277 ee.EncodeUint(uint64(v[int8(k2)]))
11282 for k2, v2 := range v {
11283 ee.WriteMapElemKey()
11284 ee.EncodeInt(int64(k2))
11285 ee.WriteMapElemValue()
11286 ee.EncodeUint(uint64(v2))
11289 for k2, v2 := range v {
11290 ee.EncodeInt(int64(k2))
11291 ee.EncodeUint(uint64(v2))
11298 func (e *Encoder) fastpathEncMapInt8Uint64R(f *codecFnInfo, rv reflect.Value) {
11299 fastpathTV.EncMapInt8Uint64V(rv2i(rv).(map[int8]uint64), e)
11301 func (_ fastpathT) EncMapInt8Uint64V(v map[int8]uint64, e *Encoder) {
11306 ee, esep := e.e, e.hh.hasElemSeparators()
11307 ee.WriteMapStart(len(v))
11309 v2 := make([]int64, len(v))
11311 for k, _ := range v {
11315 sort.Sort(intSlice(v2))
11317 for _, k2 := range v2 {
11318 ee.WriteMapElemKey()
11319 ee.EncodeInt(int64(int8(k2)))
11320 ee.WriteMapElemValue()
11321 ee.EncodeUint(uint64(v[int8(k2)]))
11324 for _, k2 := range v2 {
11325 ee.EncodeInt(int64(int8(k2)))
11326 ee.EncodeUint(uint64(v[int8(k2)]))
11331 for k2, v2 := range v {
11332 ee.WriteMapElemKey()
11333 ee.EncodeInt(int64(k2))
11334 ee.WriteMapElemValue()
11335 ee.EncodeUint(uint64(v2))
11338 for k2, v2 := range v {
11339 ee.EncodeInt(int64(k2))
11340 ee.EncodeUint(uint64(v2))
11347 func (e *Encoder) fastpathEncMapInt8UintptrR(f *codecFnInfo, rv reflect.Value) {
11348 fastpathTV.EncMapInt8UintptrV(rv2i(rv).(map[int8]uintptr), e)
11350 func (_ fastpathT) EncMapInt8UintptrV(v map[int8]uintptr, e *Encoder) {
11355 ee, esep := e.e, e.hh.hasElemSeparators()
11356 ee.WriteMapStart(len(v))
11358 v2 := make([]int64, len(v))
11360 for k, _ := range v {
11364 sort.Sort(intSlice(v2))
11366 for _, k2 := range v2 {
11367 ee.WriteMapElemKey()
11368 ee.EncodeInt(int64(int8(k2)))
11369 ee.WriteMapElemValue()
11370 e.encode(v[int8(k2)])
11373 for _, k2 := range v2 {
11374 ee.EncodeInt(int64(int8(k2)))
11375 e.encode(v[int8(k2)])
11380 for k2, v2 := range v {
11381 ee.WriteMapElemKey()
11382 ee.EncodeInt(int64(k2))
11383 ee.WriteMapElemValue()
11387 for k2, v2 := range v {
11388 ee.EncodeInt(int64(k2))
11396 func (e *Encoder) fastpathEncMapInt8IntR(f *codecFnInfo, rv reflect.Value) {
11397 fastpathTV.EncMapInt8IntV(rv2i(rv).(map[int8]int), e)
11399 func (_ fastpathT) EncMapInt8IntV(v map[int8]int, e *Encoder) {
11404 ee, esep := e.e, e.hh.hasElemSeparators()
11405 ee.WriteMapStart(len(v))
11407 v2 := make([]int64, len(v))
11409 for k, _ := range v {
11413 sort.Sort(intSlice(v2))
11415 for _, k2 := range v2 {
11416 ee.WriteMapElemKey()
11417 ee.EncodeInt(int64(int8(k2)))
11418 ee.WriteMapElemValue()
11419 ee.EncodeInt(int64(v[int8(k2)]))
11422 for _, k2 := range v2 {
11423 ee.EncodeInt(int64(int8(k2)))
11424 ee.EncodeInt(int64(v[int8(k2)]))
11429 for k2, v2 := range v {
11430 ee.WriteMapElemKey()
11431 ee.EncodeInt(int64(k2))
11432 ee.WriteMapElemValue()
11433 ee.EncodeInt(int64(v2))
11436 for k2, v2 := range v {
11437 ee.EncodeInt(int64(k2))
11438 ee.EncodeInt(int64(v2))
11445 func (e *Encoder) fastpathEncMapInt8Int8R(f *codecFnInfo, rv reflect.Value) {
11446 fastpathTV.EncMapInt8Int8V(rv2i(rv).(map[int8]int8), e)
11448 func (_ fastpathT) EncMapInt8Int8V(v map[int8]int8, e *Encoder) {
11453 ee, esep := e.e, e.hh.hasElemSeparators()
11454 ee.WriteMapStart(len(v))
11456 v2 := make([]int64, len(v))
11458 for k, _ := range v {
11462 sort.Sort(intSlice(v2))
11464 for _, k2 := range v2 {
11465 ee.WriteMapElemKey()
11466 ee.EncodeInt(int64(int8(k2)))
11467 ee.WriteMapElemValue()
11468 ee.EncodeInt(int64(v[int8(k2)]))
11471 for _, k2 := range v2 {
11472 ee.EncodeInt(int64(int8(k2)))
11473 ee.EncodeInt(int64(v[int8(k2)]))
11478 for k2, v2 := range v {
11479 ee.WriteMapElemKey()
11480 ee.EncodeInt(int64(k2))
11481 ee.WriteMapElemValue()
11482 ee.EncodeInt(int64(v2))
11485 for k2, v2 := range v {
11486 ee.EncodeInt(int64(k2))
11487 ee.EncodeInt(int64(v2))
11494 func (e *Encoder) fastpathEncMapInt8Int16R(f *codecFnInfo, rv reflect.Value) {
11495 fastpathTV.EncMapInt8Int16V(rv2i(rv).(map[int8]int16), e)
11497 func (_ fastpathT) EncMapInt8Int16V(v map[int8]int16, e *Encoder) {
11502 ee, esep := e.e, e.hh.hasElemSeparators()
11503 ee.WriteMapStart(len(v))
11505 v2 := make([]int64, len(v))
11507 for k, _ := range v {
11511 sort.Sort(intSlice(v2))
11513 for _, k2 := range v2 {
11514 ee.WriteMapElemKey()
11515 ee.EncodeInt(int64(int8(k2)))
11516 ee.WriteMapElemValue()
11517 ee.EncodeInt(int64(v[int8(k2)]))
11520 for _, k2 := range v2 {
11521 ee.EncodeInt(int64(int8(k2)))
11522 ee.EncodeInt(int64(v[int8(k2)]))
11527 for k2, v2 := range v {
11528 ee.WriteMapElemKey()
11529 ee.EncodeInt(int64(k2))
11530 ee.WriteMapElemValue()
11531 ee.EncodeInt(int64(v2))
11534 for k2, v2 := range v {
11535 ee.EncodeInt(int64(k2))
11536 ee.EncodeInt(int64(v2))
11543 func (e *Encoder) fastpathEncMapInt8Int32R(f *codecFnInfo, rv reflect.Value) {
11544 fastpathTV.EncMapInt8Int32V(rv2i(rv).(map[int8]int32), e)
11546 func (_ fastpathT) EncMapInt8Int32V(v map[int8]int32, e *Encoder) {
11551 ee, esep := e.e, e.hh.hasElemSeparators()
11552 ee.WriteMapStart(len(v))
11554 v2 := make([]int64, len(v))
11556 for k, _ := range v {
11560 sort.Sort(intSlice(v2))
11562 for _, k2 := range v2 {
11563 ee.WriteMapElemKey()
11564 ee.EncodeInt(int64(int8(k2)))
11565 ee.WriteMapElemValue()
11566 ee.EncodeInt(int64(v[int8(k2)]))
11569 for _, k2 := range v2 {
11570 ee.EncodeInt(int64(int8(k2)))
11571 ee.EncodeInt(int64(v[int8(k2)]))
11576 for k2, v2 := range v {
11577 ee.WriteMapElemKey()
11578 ee.EncodeInt(int64(k2))
11579 ee.WriteMapElemValue()
11580 ee.EncodeInt(int64(v2))
11583 for k2, v2 := range v {
11584 ee.EncodeInt(int64(k2))
11585 ee.EncodeInt(int64(v2))
11592 func (e *Encoder) fastpathEncMapInt8Int64R(f *codecFnInfo, rv reflect.Value) {
11593 fastpathTV.EncMapInt8Int64V(rv2i(rv).(map[int8]int64), e)
11595 func (_ fastpathT) EncMapInt8Int64V(v map[int8]int64, e *Encoder) {
11600 ee, esep := e.e, e.hh.hasElemSeparators()
11601 ee.WriteMapStart(len(v))
11603 v2 := make([]int64, len(v))
11605 for k, _ := range v {
11609 sort.Sort(intSlice(v2))
11611 for _, k2 := range v2 {
11612 ee.WriteMapElemKey()
11613 ee.EncodeInt(int64(int8(k2)))
11614 ee.WriteMapElemValue()
11615 ee.EncodeInt(int64(v[int8(k2)]))
11618 for _, k2 := range v2 {
11619 ee.EncodeInt(int64(int8(k2)))
11620 ee.EncodeInt(int64(v[int8(k2)]))
11625 for k2, v2 := range v {
11626 ee.WriteMapElemKey()
11627 ee.EncodeInt(int64(k2))
11628 ee.WriteMapElemValue()
11629 ee.EncodeInt(int64(v2))
11632 for k2, v2 := range v {
11633 ee.EncodeInt(int64(k2))
11634 ee.EncodeInt(int64(v2))
11641 func (e *Encoder) fastpathEncMapInt8Float32R(f *codecFnInfo, rv reflect.Value) {
11642 fastpathTV.EncMapInt8Float32V(rv2i(rv).(map[int8]float32), e)
11644 func (_ fastpathT) EncMapInt8Float32V(v map[int8]float32, e *Encoder) {
11649 ee, esep := e.e, e.hh.hasElemSeparators()
11650 ee.WriteMapStart(len(v))
11652 v2 := make([]int64, len(v))
11654 for k, _ := range v {
11658 sort.Sort(intSlice(v2))
11660 for _, k2 := range v2 {
11661 ee.WriteMapElemKey()
11662 ee.EncodeInt(int64(int8(k2)))
11663 ee.WriteMapElemValue()
11664 ee.EncodeFloat32(v[int8(k2)])
11667 for _, k2 := range v2 {
11668 ee.EncodeInt(int64(int8(k2)))
11669 ee.EncodeFloat32(v[int8(k2)])
11674 for k2, v2 := range v {
11675 ee.WriteMapElemKey()
11676 ee.EncodeInt(int64(k2))
11677 ee.WriteMapElemValue()
11678 ee.EncodeFloat32(v2)
11681 for k2, v2 := range v {
11682 ee.EncodeInt(int64(k2))
11683 ee.EncodeFloat32(v2)
11690 func (e *Encoder) fastpathEncMapInt8Float64R(f *codecFnInfo, rv reflect.Value) {
11691 fastpathTV.EncMapInt8Float64V(rv2i(rv).(map[int8]float64), e)
11693 func (_ fastpathT) EncMapInt8Float64V(v map[int8]float64, e *Encoder) {
11698 ee, esep := e.e, e.hh.hasElemSeparators()
11699 ee.WriteMapStart(len(v))
11701 v2 := make([]int64, len(v))
11703 for k, _ := range v {
11707 sort.Sort(intSlice(v2))
11709 for _, k2 := range v2 {
11710 ee.WriteMapElemKey()
11711 ee.EncodeInt(int64(int8(k2)))
11712 ee.WriteMapElemValue()
11713 ee.EncodeFloat64(v[int8(k2)])
11716 for _, k2 := range v2 {
11717 ee.EncodeInt(int64(int8(k2)))
11718 ee.EncodeFloat64(v[int8(k2)])
11723 for k2, v2 := range v {
11724 ee.WriteMapElemKey()
11725 ee.EncodeInt(int64(k2))
11726 ee.WriteMapElemValue()
11727 ee.EncodeFloat64(v2)
11730 for k2, v2 := range v {
11731 ee.EncodeInt(int64(k2))
11732 ee.EncodeFloat64(v2)
11739 func (e *Encoder) fastpathEncMapInt8BoolR(f *codecFnInfo, rv reflect.Value) {
11740 fastpathTV.EncMapInt8BoolV(rv2i(rv).(map[int8]bool), e)
11742 func (_ fastpathT) EncMapInt8BoolV(v map[int8]bool, e *Encoder) {
11747 ee, esep := e.e, e.hh.hasElemSeparators()
11748 ee.WriteMapStart(len(v))
11750 v2 := make([]int64, len(v))
11752 for k, _ := range v {
11756 sort.Sort(intSlice(v2))
11758 for _, k2 := range v2 {
11759 ee.WriteMapElemKey()
11760 ee.EncodeInt(int64(int8(k2)))
11761 ee.WriteMapElemValue()
11762 ee.EncodeBool(v[int8(k2)])
11765 for _, k2 := range v2 {
11766 ee.EncodeInt(int64(int8(k2)))
11767 ee.EncodeBool(v[int8(k2)])
11772 for k2, v2 := range v {
11773 ee.WriteMapElemKey()
11774 ee.EncodeInt(int64(k2))
11775 ee.WriteMapElemValue()
11779 for k2, v2 := range v {
11780 ee.EncodeInt(int64(k2))
11788 func (e *Encoder) fastpathEncMapInt16IntfR(f *codecFnInfo, rv reflect.Value) {
11789 fastpathTV.EncMapInt16IntfV(rv2i(rv).(map[int16]interface{}), e)
11791 func (_ fastpathT) EncMapInt16IntfV(v map[int16]interface{}, e *Encoder) {
11796 ee, esep := e.e, e.hh.hasElemSeparators()
11797 ee.WriteMapStart(len(v))
11799 v2 := make([]int64, len(v))
11801 for k, _ := range v {
11805 sort.Sort(intSlice(v2))
11807 for _, k2 := range v2 {
11808 ee.WriteMapElemKey()
11809 ee.EncodeInt(int64(int16(k2)))
11810 ee.WriteMapElemValue()
11811 e.encode(v[int16(k2)])
11814 for _, k2 := range v2 {
11815 ee.EncodeInt(int64(int16(k2)))
11816 e.encode(v[int16(k2)])
11821 for k2, v2 := range v {
11822 ee.WriteMapElemKey()
11823 ee.EncodeInt(int64(k2))
11824 ee.WriteMapElemValue()
11828 for k2, v2 := range v {
11829 ee.EncodeInt(int64(k2))
11837 func (e *Encoder) fastpathEncMapInt16StringR(f *codecFnInfo, rv reflect.Value) {
11838 fastpathTV.EncMapInt16StringV(rv2i(rv).(map[int16]string), e)
11840 func (_ fastpathT) EncMapInt16StringV(v map[int16]string, e *Encoder) {
11845 ee, esep := e.e, e.hh.hasElemSeparators()
11846 ee.WriteMapStart(len(v))
11848 v2 := make([]int64, len(v))
11850 for k, _ := range v {
11854 sort.Sort(intSlice(v2))
11856 for _, k2 := range v2 {
11857 ee.WriteMapElemKey()
11858 ee.EncodeInt(int64(int16(k2)))
11859 ee.WriteMapElemValue()
11860 ee.EncodeString(cUTF8, v[int16(k2)])
11863 for _, k2 := range v2 {
11864 ee.EncodeInt(int64(int16(k2)))
11865 ee.EncodeString(cUTF8, v[int16(k2)])
11870 for k2, v2 := range v {
11871 ee.WriteMapElemKey()
11872 ee.EncodeInt(int64(k2))
11873 ee.WriteMapElemValue()
11874 ee.EncodeString(cUTF8, v2)
11877 for k2, v2 := range v {
11878 ee.EncodeInt(int64(k2))
11879 ee.EncodeString(cUTF8, v2)
11886 func (e *Encoder) fastpathEncMapInt16UintR(f *codecFnInfo, rv reflect.Value) {
11887 fastpathTV.EncMapInt16UintV(rv2i(rv).(map[int16]uint), e)
11889 func (_ fastpathT) EncMapInt16UintV(v map[int16]uint, e *Encoder) {
11894 ee, esep := e.e, e.hh.hasElemSeparators()
11895 ee.WriteMapStart(len(v))
11897 v2 := make([]int64, len(v))
11899 for k, _ := range v {
11903 sort.Sort(intSlice(v2))
11905 for _, k2 := range v2 {
11906 ee.WriteMapElemKey()
11907 ee.EncodeInt(int64(int16(k2)))
11908 ee.WriteMapElemValue()
11909 ee.EncodeUint(uint64(v[int16(k2)]))
11912 for _, k2 := range v2 {
11913 ee.EncodeInt(int64(int16(k2)))
11914 ee.EncodeUint(uint64(v[int16(k2)]))
11919 for k2, v2 := range v {
11920 ee.WriteMapElemKey()
11921 ee.EncodeInt(int64(k2))
11922 ee.WriteMapElemValue()
11923 ee.EncodeUint(uint64(v2))
11926 for k2, v2 := range v {
11927 ee.EncodeInt(int64(k2))
11928 ee.EncodeUint(uint64(v2))
11935 func (e *Encoder) fastpathEncMapInt16Uint8R(f *codecFnInfo, rv reflect.Value) {
11936 fastpathTV.EncMapInt16Uint8V(rv2i(rv).(map[int16]uint8), e)
11938 func (_ fastpathT) EncMapInt16Uint8V(v map[int16]uint8, e *Encoder) {
11943 ee, esep := e.e, e.hh.hasElemSeparators()
11944 ee.WriteMapStart(len(v))
11946 v2 := make([]int64, len(v))
11948 for k, _ := range v {
11952 sort.Sort(intSlice(v2))
11954 for _, k2 := range v2 {
11955 ee.WriteMapElemKey()
11956 ee.EncodeInt(int64(int16(k2)))
11957 ee.WriteMapElemValue()
11958 ee.EncodeUint(uint64(v[int16(k2)]))
11961 for _, k2 := range v2 {
11962 ee.EncodeInt(int64(int16(k2)))
11963 ee.EncodeUint(uint64(v[int16(k2)]))
11968 for k2, v2 := range v {
11969 ee.WriteMapElemKey()
11970 ee.EncodeInt(int64(k2))
11971 ee.WriteMapElemValue()
11972 ee.EncodeUint(uint64(v2))
11975 for k2, v2 := range v {
11976 ee.EncodeInt(int64(k2))
11977 ee.EncodeUint(uint64(v2))
11984 func (e *Encoder) fastpathEncMapInt16Uint16R(f *codecFnInfo, rv reflect.Value) {
11985 fastpathTV.EncMapInt16Uint16V(rv2i(rv).(map[int16]uint16), e)
11987 func (_ fastpathT) EncMapInt16Uint16V(v map[int16]uint16, e *Encoder) {
11992 ee, esep := e.e, e.hh.hasElemSeparators()
11993 ee.WriteMapStart(len(v))
11995 v2 := make([]int64, len(v))
11997 for k, _ := range v {
12001 sort.Sort(intSlice(v2))
12003 for _, k2 := range v2 {
12004 ee.WriteMapElemKey()
12005 ee.EncodeInt(int64(int16(k2)))
12006 ee.WriteMapElemValue()
12007 ee.EncodeUint(uint64(v[int16(k2)]))
12010 for _, k2 := range v2 {
12011 ee.EncodeInt(int64(int16(k2)))
12012 ee.EncodeUint(uint64(v[int16(k2)]))
12017 for k2, v2 := range v {
12018 ee.WriteMapElemKey()
12019 ee.EncodeInt(int64(k2))
12020 ee.WriteMapElemValue()
12021 ee.EncodeUint(uint64(v2))
12024 for k2, v2 := range v {
12025 ee.EncodeInt(int64(k2))
12026 ee.EncodeUint(uint64(v2))
12033 func (e *Encoder) fastpathEncMapInt16Uint32R(f *codecFnInfo, rv reflect.Value) {
12034 fastpathTV.EncMapInt16Uint32V(rv2i(rv).(map[int16]uint32), e)
12036 func (_ fastpathT) EncMapInt16Uint32V(v map[int16]uint32, e *Encoder) {
12041 ee, esep := e.e, e.hh.hasElemSeparators()
12042 ee.WriteMapStart(len(v))
12044 v2 := make([]int64, len(v))
12046 for k, _ := range v {
12050 sort.Sort(intSlice(v2))
12052 for _, k2 := range v2 {
12053 ee.WriteMapElemKey()
12054 ee.EncodeInt(int64(int16(k2)))
12055 ee.WriteMapElemValue()
12056 ee.EncodeUint(uint64(v[int16(k2)]))
12059 for _, k2 := range v2 {
12060 ee.EncodeInt(int64(int16(k2)))
12061 ee.EncodeUint(uint64(v[int16(k2)]))
12066 for k2, v2 := range v {
12067 ee.WriteMapElemKey()
12068 ee.EncodeInt(int64(k2))
12069 ee.WriteMapElemValue()
12070 ee.EncodeUint(uint64(v2))
12073 for k2, v2 := range v {
12074 ee.EncodeInt(int64(k2))
12075 ee.EncodeUint(uint64(v2))
12082 func (e *Encoder) fastpathEncMapInt16Uint64R(f *codecFnInfo, rv reflect.Value) {
12083 fastpathTV.EncMapInt16Uint64V(rv2i(rv).(map[int16]uint64), e)
12085 func (_ fastpathT) EncMapInt16Uint64V(v map[int16]uint64, e *Encoder) {
12090 ee, esep := e.e, e.hh.hasElemSeparators()
12091 ee.WriteMapStart(len(v))
12093 v2 := make([]int64, len(v))
12095 for k, _ := range v {
12099 sort.Sort(intSlice(v2))
12101 for _, k2 := range v2 {
12102 ee.WriteMapElemKey()
12103 ee.EncodeInt(int64(int16(k2)))
12104 ee.WriteMapElemValue()
12105 ee.EncodeUint(uint64(v[int16(k2)]))
12108 for _, k2 := range v2 {
12109 ee.EncodeInt(int64(int16(k2)))
12110 ee.EncodeUint(uint64(v[int16(k2)]))
12115 for k2, v2 := range v {
12116 ee.WriteMapElemKey()
12117 ee.EncodeInt(int64(k2))
12118 ee.WriteMapElemValue()
12119 ee.EncodeUint(uint64(v2))
12122 for k2, v2 := range v {
12123 ee.EncodeInt(int64(k2))
12124 ee.EncodeUint(uint64(v2))
12131 func (e *Encoder) fastpathEncMapInt16UintptrR(f *codecFnInfo, rv reflect.Value) {
12132 fastpathTV.EncMapInt16UintptrV(rv2i(rv).(map[int16]uintptr), e)
12134 func (_ fastpathT) EncMapInt16UintptrV(v map[int16]uintptr, e *Encoder) {
12139 ee, esep := e.e, e.hh.hasElemSeparators()
12140 ee.WriteMapStart(len(v))
12142 v2 := make([]int64, len(v))
12144 for k, _ := range v {
12148 sort.Sort(intSlice(v2))
12150 for _, k2 := range v2 {
12151 ee.WriteMapElemKey()
12152 ee.EncodeInt(int64(int16(k2)))
12153 ee.WriteMapElemValue()
12154 e.encode(v[int16(k2)])
12157 for _, k2 := range v2 {
12158 ee.EncodeInt(int64(int16(k2)))
12159 e.encode(v[int16(k2)])
12164 for k2, v2 := range v {
12165 ee.WriteMapElemKey()
12166 ee.EncodeInt(int64(k2))
12167 ee.WriteMapElemValue()
12171 for k2, v2 := range v {
12172 ee.EncodeInt(int64(k2))
12180 func (e *Encoder) fastpathEncMapInt16IntR(f *codecFnInfo, rv reflect.Value) {
12181 fastpathTV.EncMapInt16IntV(rv2i(rv).(map[int16]int), e)
12183 func (_ fastpathT) EncMapInt16IntV(v map[int16]int, e *Encoder) {
12188 ee, esep := e.e, e.hh.hasElemSeparators()
12189 ee.WriteMapStart(len(v))
12191 v2 := make([]int64, len(v))
12193 for k, _ := range v {
12197 sort.Sort(intSlice(v2))
12199 for _, k2 := range v2 {
12200 ee.WriteMapElemKey()
12201 ee.EncodeInt(int64(int16(k2)))
12202 ee.WriteMapElemValue()
12203 ee.EncodeInt(int64(v[int16(k2)]))
12206 for _, k2 := range v2 {
12207 ee.EncodeInt(int64(int16(k2)))
12208 ee.EncodeInt(int64(v[int16(k2)]))
12213 for k2, v2 := range v {
12214 ee.WriteMapElemKey()
12215 ee.EncodeInt(int64(k2))
12216 ee.WriteMapElemValue()
12217 ee.EncodeInt(int64(v2))
12220 for k2, v2 := range v {
12221 ee.EncodeInt(int64(k2))
12222 ee.EncodeInt(int64(v2))
12229 func (e *Encoder) fastpathEncMapInt16Int8R(f *codecFnInfo, rv reflect.Value) {
12230 fastpathTV.EncMapInt16Int8V(rv2i(rv).(map[int16]int8), e)
12232 func (_ fastpathT) EncMapInt16Int8V(v map[int16]int8, e *Encoder) {
12237 ee, esep := e.e, e.hh.hasElemSeparators()
12238 ee.WriteMapStart(len(v))
12240 v2 := make([]int64, len(v))
12242 for k, _ := range v {
12246 sort.Sort(intSlice(v2))
12248 for _, k2 := range v2 {
12249 ee.WriteMapElemKey()
12250 ee.EncodeInt(int64(int16(k2)))
12251 ee.WriteMapElemValue()
12252 ee.EncodeInt(int64(v[int16(k2)]))
12255 for _, k2 := range v2 {
12256 ee.EncodeInt(int64(int16(k2)))
12257 ee.EncodeInt(int64(v[int16(k2)]))
12262 for k2, v2 := range v {
12263 ee.WriteMapElemKey()
12264 ee.EncodeInt(int64(k2))
12265 ee.WriteMapElemValue()
12266 ee.EncodeInt(int64(v2))
12269 for k2, v2 := range v {
12270 ee.EncodeInt(int64(k2))
12271 ee.EncodeInt(int64(v2))
12278 func (e *Encoder) fastpathEncMapInt16Int16R(f *codecFnInfo, rv reflect.Value) {
12279 fastpathTV.EncMapInt16Int16V(rv2i(rv).(map[int16]int16), e)
12281 func (_ fastpathT) EncMapInt16Int16V(v map[int16]int16, e *Encoder) {
12286 ee, esep := e.e, e.hh.hasElemSeparators()
12287 ee.WriteMapStart(len(v))
12289 v2 := make([]int64, len(v))
12291 for k, _ := range v {
12295 sort.Sort(intSlice(v2))
12297 for _, k2 := range v2 {
12298 ee.WriteMapElemKey()
12299 ee.EncodeInt(int64(int16(k2)))
12300 ee.WriteMapElemValue()
12301 ee.EncodeInt(int64(v[int16(k2)]))
12304 for _, k2 := range v2 {
12305 ee.EncodeInt(int64(int16(k2)))
12306 ee.EncodeInt(int64(v[int16(k2)]))
12311 for k2, v2 := range v {
12312 ee.WriteMapElemKey()
12313 ee.EncodeInt(int64(k2))
12314 ee.WriteMapElemValue()
12315 ee.EncodeInt(int64(v2))
12318 for k2, v2 := range v {
12319 ee.EncodeInt(int64(k2))
12320 ee.EncodeInt(int64(v2))
12327 func (e *Encoder) fastpathEncMapInt16Int32R(f *codecFnInfo, rv reflect.Value) {
12328 fastpathTV.EncMapInt16Int32V(rv2i(rv).(map[int16]int32), e)
12330 func (_ fastpathT) EncMapInt16Int32V(v map[int16]int32, e *Encoder) {
12335 ee, esep := e.e, e.hh.hasElemSeparators()
12336 ee.WriteMapStart(len(v))
12338 v2 := make([]int64, len(v))
12340 for k, _ := range v {
12344 sort.Sort(intSlice(v2))
12346 for _, k2 := range v2 {
12347 ee.WriteMapElemKey()
12348 ee.EncodeInt(int64(int16(k2)))
12349 ee.WriteMapElemValue()
12350 ee.EncodeInt(int64(v[int16(k2)]))
12353 for _, k2 := range v2 {
12354 ee.EncodeInt(int64(int16(k2)))
12355 ee.EncodeInt(int64(v[int16(k2)]))
12360 for k2, v2 := range v {
12361 ee.WriteMapElemKey()
12362 ee.EncodeInt(int64(k2))
12363 ee.WriteMapElemValue()
12364 ee.EncodeInt(int64(v2))
12367 for k2, v2 := range v {
12368 ee.EncodeInt(int64(k2))
12369 ee.EncodeInt(int64(v2))
12376 func (e *Encoder) fastpathEncMapInt16Int64R(f *codecFnInfo, rv reflect.Value) {
12377 fastpathTV.EncMapInt16Int64V(rv2i(rv).(map[int16]int64), e)
12379 func (_ fastpathT) EncMapInt16Int64V(v map[int16]int64, e *Encoder) {
12384 ee, esep := e.e, e.hh.hasElemSeparators()
12385 ee.WriteMapStart(len(v))
12387 v2 := make([]int64, len(v))
12389 for k, _ := range v {
12393 sort.Sort(intSlice(v2))
12395 for _, k2 := range v2 {
12396 ee.WriteMapElemKey()
12397 ee.EncodeInt(int64(int16(k2)))
12398 ee.WriteMapElemValue()
12399 ee.EncodeInt(int64(v[int16(k2)]))
12402 for _, k2 := range v2 {
12403 ee.EncodeInt(int64(int16(k2)))
12404 ee.EncodeInt(int64(v[int16(k2)]))
12409 for k2, v2 := range v {
12410 ee.WriteMapElemKey()
12411 ee.EncodeInt(int64(k2))
12412 ee.WriteMapElemValue()
12413 ee.EncodeInt(int64(v2))
12416 for k2, v2 := range v {
12417 ee.EncodeInt(int64(k2))
12418 ee.EncodeInt(int64(v2))
12425 func (e *Encoder) fastpathEncMapInt16Float32R(f *codecFnInfo, rv reflect.Value) {
12426 fastpathTV.EncMapInt16Float32V(rv2i(rv).(map[int16]float32), e)
12428 func (_ fastpathT) EncMapInt16Float32V(v map[int16]float32, e *Encoder) {
12433 ee, esep := e.e, e.hh.hasElemSeparators()
12434 ee.WriteMapStart(len(v))
12436 v2 := make([]int64, len(v))
12438 for k, _ := range v {
12442 sort.Sort(intSlice(v2))
12444 for _, k2 := range v2 {
12445 ee.WriteMapElemKey()
12446 ee.EncodeInt(int64(int16(k2)))
12447 ee.WriteMapElemValue()
12448 ee.EncodeFloat32(v[int16(k2)])
12451 for _, k2 := range v2 {
12452 ee.EncodeInt(int64(int16(k2)))
12453 ee.EncodeFloat32(v[int16(k2)])
12458 for k2, v2 := range v {
12459 ee.WriteMapElemKey()
12460 ee.EncodeInt(int64(k2))
12461 ee.WriteMapElemValue()
12462 ee.EncodeFloat32(v2)
12465 for k2, v2 := range v {
12466 ee.EncodeInt(int64(k2))
12467 ee.EncodeFloat32(v2)
12474 func (e *Encoder) fastpathEncMapInt16Float64R(f *codecFnInfo, rv reflect.Value) {
12475 fastpathTV.EncMapInt16Float64V(rv2i(rv).(map[int16]float64), e)
12477 func (_ fastpathT) EncMapInt16Float64V(v map[int16]float64, e *Encoder) {
12482 ee, esep := e.e, e.hh.hasElemSeparators()
12483 ee.WriteMapStart(len(v))
12485 v2 := make([]int64, len(v))
12487 for k, _ := range v {
12491 sort.Sort(intSlice(v2))
12493 for _, k2 := range v2 {
12494 ee.WriteMapElemKey()
12495 ee.EncodeInt(int64(int16(k2)))
12496 ee.WriteMapElemValue()
12497 ee.EncodeFloat64(v[int16(k2)])
12500 for _, k2 := range v2 {
12501 ee.EncodeInt(int64(int16(k2)))
12502 ee.EncodeFloat64(v[int16(k2)])
12507 for k2, v2 := range v {
12508 ee.WriteMapElemKey()
12509 ee.EncodeInt(int64(k2))
12510 ee.WriteMapElemValue()
12511 ee.EncodeFloat64(v2)
12514 for k2, v2 := range v {
12515 ee.EncodeInt(int64(k2))
12516 ee.EncodeFloat64(v2)
12523 func (e *Encoder) fastpathEncMapInt16BoolR(f *codecFnInfo, rv reflect.Value) {
12524 fastpathTV.EncMapInt16BoolV(rv2i(rv).(map[int16]bool), e)
12526 func (_ fastpathT) EncMapInt16BoolV(v map[int16]bool, e *Encoder) {
12531 ee, esep := e.e, e.hh.hasElemSeparators()
12532 ee.WriteMapStart(len(v))
12534 v2 := make([]int64, len(v))
12536 for k, _ := range v {
12540 sort.Sort(intSlice(v2))
12542 for _, k2 := range v2 {
12543 ee.WriteMapElemKey()
12544 ee.EncodeInt(int64(int16(k2)))
12545 ee.WriteMapElemValue()
12546 ee.EncodeBool(v[int16(k2)])
12549 for _, k2 := range v2 {
12550 ee.EncodeInt(int64(int16(k2)))
12551 ee.EncodeBool(v[int16(k2)])
12556 for k2, v2 := range v {
12557 ee.WriteMapElemKey()
12558 ee.EncodeInt(int64(k2))
12559 ee.WriteMapElemValue()
12563 for k2, v2 := range v {
12564 ee.EncodeInt(int64(k2))
12572 func (e *Encoder) fastpathEncMapInt32IntfR(f *codecFnInfo, rv reflect.Value) {
12573 fastpathTV.EncMapInt32IntfV(rv2i(rv).(map[int32]interface{}), e)
12575 func (_ fastpathT) EncMapInt32IntfV(v map[int32]interface{}, e *Encoder) {
12580 ee, esep := e.e, e.hh.hasElemSeparators()
12581 ee.WriteMapStart(len(v))
12583 v2 := make([]int64, len(v))
12585 for k, _ := range v {
12589 sort.Sort(intSlice(v2))
12591 for _, k2 := range v2 {
12592 ee.WriteMapElemKey()
12593 ee.EncodeInt(int64(int32(k2)))
12594 ee.WriteMapElemValue()
12595 e.encode(v[int32(k2)])
12598 for _, k2 := range v2 {
12599 ee.EncodeInt(int64(int32(k2)))
12600 e.encode(v[int32(k2)])
12605 for k2, v2 := range v {
12606 ee.WriteMapElemKey()
12607 ee.EncodeInt(int64(k2))
12608 ee.WriteMapElemValue()
12612 for k2, v2 := range v {
12613 ee.EncodeInt(int64(k2))
12621 func (e *Encoder) fastpathEncMapInt32StringR(f *codecFnInfo, rv reflect.Value) {
12622 fastpathTV.EncMapInt32StringV(rv2i(rv).(map[int32]string), e)
12624 func (_ fastpathT) EncMapInt32StringV(v map[int32]string, e *Encoder) {
12629 ee, esep := e.e, e.hh.hasElemSeparators()
12630 ee.WriteMapStart(len(v))
12632 v2 := make([]int64, len(v))
12634 for k, _ := range v {
12638 sort.Sort(intSlice(v2))
12640 for _, k2 := range v2 {
12641 ee.WriteMapElemKey()
12642 ee.EncodeInt(int64(int32(k2)))
12643 ee.WriteMapElemValue()
12644 ee.EncodeString(cUTF8, v[int32(k2)])
12647 for _, k2 := range v2 {
12648 ee.EncodeInt(int64(int32(k2)))
12649 ee.EncodeString(cUTF8, v[int32(k2)])
12654 for k2, v2 := range v {
12655 ee.WriteMapElemKey()
12656 ee.EncodeInt(int64(k2))
12657 ee.WriteMapElemValue()
12658 ee.EncodeString(cUTF8, v2)
12661 for k2, v2 := range v {
12662 ee.EncodeInt(int64(k2))
12663 ee.EncodeString(cUTF8, v2)
12670 func (e *Encoder) fastpathEncMapInt32UintR(f *codecFnInfo, rv reflect.Value) {
12671 fastpathTV.EncMapInt32UintV(rv2i(rv).(map[int32]uint), e)
12673 func (_ fastpathT) EncMapInt32UintV(v map[int32]uint, e *Encoder) {
12678 ee, esep := e.e, e.hh.hasElemSeparators()
12679 ee.WriteMapStart(len(v))
12681 v2 := make([]int64, len(v))
12683 for k, _ := range v {
12687 sort.Sort(intSlice(v2))
12689 for _, k2 := range v2 {
12690 ee.WriteMapElemKey()
12691 ee.EncodeInt(int64(int32(k2)))
12692 ee.WriteMapElemValue()
12693 ee.EncodeUint(uint64(v[int32(k2)]))
12696 for _, k2 := range v2 {
12697 ee.EncodeInt(int64(int32(k2)))
12698 ee.EncodeUint(uint64(v[int32(k2)]))
12703 for k2, v2 := range v {
12704 ee.WriteMapElemKey()
12705 ee.EncodeInt(int64(k2))
12706 ee.WriteMapElemValue()
12707 ee.EncodeUint(uint64(v2))
12710 for k2, v2 := range v {
12711 ee.EncodeInt(int64(k2))
12712 ee.EncodeUint(uint64(v2))
12719 func (e *Encoder) fastpathEncMapInt32Uint8R(f *codecFnInfo, rv reflect.Value) {
12720 fastpathTV.EncMapInt32Uint8V(rv2i(rv).(map[int32]uint8), e)
12722 func (_ fastpathT) EncMapInt32Uint8V(v map[int32]uint8, e *Encoder) {
12727 ee, esep := e.e, e.hh.hasElemSeparators()
12728 ee.WriteMapStart(len(v))
12730 v2 := make([]int64, len(v))
12732 for k, _ := range v {
12736 sort.Sort(intSlice(v2))
12738 for _, k2 := range v2 {
12739 ee.WriteMapElemKey()
12740 ee.EncodeInt(int64(int32(k2)))
12741 ee.WriteMapElemValue()
12742 ee.EncodeUint(uint64(v[int32(k2)]))
12745 for _, k2 := range v2 {
12746 ee.EncodeInt(int64(int32(k2)))
12747 ee.EncodeUint(uint64(v[int32(k2)]))
12752 for k2, v2 := range v {
12753 ee.WriteMapElemKey()
12754 ee.EncodeInt(int64(k2))
12755 ee.WriteMapElemValue()
12756 ee.EncodeUint(uint64(v2))
12759 for k2, v2 := range v {
12760 ee.EncodeInt(int64(k2))
12761 ee.EncodeUint(uint64(v2))
12768 func (e *Encoder) fastpathEncMapInt32Uint16R(f *codecFnInfo, rv reflect.Value) {
12769 fastpathTV.EncMapInt32Uint16V(rv2i(rv).(map[int32]uint16), e)
12771 func (_ fastpathT) EncMapInt32Uint16V(v map[int32]uint16, e *Encoder) {
12776 ee, esep := e.e, e.hh.hasElemSeparators()
12777 ee.WriteMapStart(len(v))
12779 v2 := make([]int64, len(v))
12781 for k, _ := range v {
12785 sort.Sort(intSlice(v2))
12787 for _, k2 := range v2 {
12788 ee.WriteMapElemKey()
12789 ee.EncodeInt(int64(int32(k2)))
12790 ee.WriteMapElemValue()
12791 ee.EncodeUint(uint64(v[int32(k2)]))
12794 for _, k2 := range v2 {
12795 ee.EncodeInt(int64(int32(k2)))
12796 ee.EncodeUint(uint64(v[int32(k2)]))
12801 for k2, v2 := range v {
12802 ee.WriteMapElemKey()
12803 ee.EncodeInt(int64(k2))
12804 ee.WriteMapElemValue()
12805 ee.EncodeUint(uint64(v2))
12808 for k2, v2 := range v {
12809 ee.EncodeInt(int64(k2))
12810 ee.EncodeUint(uint64(v2))
12817 func (e *Encoder) fastpathEncMapInt32Uint32R(f *codecFnInfo, rv reflect.Value) {
12818 fastpathTV.EncMapInt32Uint32V(rv2i(rv).(map[int32]uint32), e)
12820 func (_ fastpathT) EncMapInt32Uint32V(v map[int32]uint32, e *Encoder) {
12825 ee, esep := e.e, e.hh.hasElemSeparators()
12826 ee.WriteMapStart(len(v))
12828 v2 := make([]int64, len(v))
12830 for k, _ := range v {
12834 sort.Sort(intSlice(v2))
12836 for _, k2 := range v2 {
12837 ee.WriteMapElemKey()
12838 ee.EncodeInt(int64(int32(k2)))
12839 ee.WriteMapElemValue()
12840 ee.EncodeUint(uint64(v[int32(k2)]))
12843 for _, k2 := range v2 {
12844 ee.EncodeInt(int64(int32(k2)))
12845 ee.EncodeUint(uint64(v[int32(k2)]))
12850 for k2, v2 := range v {
12851 ee.WriteMapElemKey()
12852 ee.EncodeInt(int64(k2))
12853 ee.WriteMapElemValue()
12854 ee.EncodeUint(uint64(v2))
12857 for k2, v2 := range v {
12858 ee.EncodeInt(int64(k2))
12859 ee.EncodeUint(uint64(v2))
12866 func (e *Encoder) fastpathEncMapInt32Uint64R(f *codecFnInfo, rv reflect.Value) {
12867 fastpathTV.EncMapInt32Uint64V(rv2i(rv).(map[int32]uint64), e)
12869 func (_ fastpathT) EncMapInt32Uint64V(v map[int32]uint64, e *Encoder) {
12874 ee, esep := e.e, e.hh.hasElemSeparators()
12875 ee.WriteMapStart(len(v))
12877 v2 := make([]int64, len(v))
12879 for k, _ := range v {
12883 sort.Sort(intSlice(v2))
12885 for _, k2 := range v2 {
12886 ee.WriteMapElemKey()
12887 ee.EncodeInt(int64(int32(k2)))
12888 ee.WriteMapElemValue()
12889 ee.EncodeUint(uint64(v[int32(k2)]))
12892 for _, k2 := range v2 {
12893 ee.EncodeInt(int64(int32(k2)))
12894 ee.EncodeUint(uint64(v[int32(k2)]))
12899 for k2, v2 := range v {
12900 ee.WriteMapElemKey()
12901 ee.EncodeInt(int64(k2))
12902 ee.WriteMapElemValue()
12903 ee.EncodeUint(uint64(v2))
12906 for k2, v2 := range v {
12907 ee.EncodeInt(int64(k2))
12908 ee.EncodeUint(uint64(v2))
12915 func (e *Encoder) fastpathEncMapInt32UintptrR(f *codecFnInfo, rv reflect.Value) {
12916 fastpathTV.EncMapInt32UintptrV(rv2i(rv).(map[int32]uintptr), e)
12918 func (_ fastpathT) EncMapInt32UintptrV(v map[int32]uintptr, e *Encoder) {
12923 ee, esep := e.e, e.hh.hasElemSeparators()
12924 ee.WriteMapStart(len(v))
12926 v2 := make([]int64, len(v))
12928 for k, _ := range v {
12932 sort.Sort(intSlice(v2))
12934 for _, k2 := range v2 {
12935 ee.WriteMapElemKey()
12936 ee.EncodeInt(int64(int32(k2)))
12937 ee.WriteMapElemValue()
12938 e.encode(v[int32(k2)])
12941 for _, k2 := range v2 {
12942 ee.EncodeInt(int64(int32(k2)))
12943 e.encode(v[int32(k2)])
12948 for k2, v2 := range v {
12949 ee.WriteMapElemKey()
12950 ee.EncodeInt(int64(k2))
12951 ee.WriteMapElemValue()
12955 for k2, v2 := range v {
12956 ee.EncodeInt(int64(k2))
12964 func (e *Encoder) fastpathEncMapInt32IntR(f *codecFnInfo, rv reflect.Value) {
12965 fastpathTV.EncMapInt32IntV(rv2i(rv).(map[int32]int), e)
12967 func (_ fastpathT) EncMapInt32IntV(v map[int32]int, e *Encoder) {
12972 ee, esep := e.e, e.hh.hasElemSeparators()
12973 ee.WriteMapStart(len(v))
12975 v2 := make([]int64, len(v))
12977 for k, _ := range v {
12981 sort.Sort(intSlice(v2))
12983 for _, k2 := range v2 {
12984 ee.WriteMapElemKey()
12985 ee.EncodeInt(int64(int32(k2)))
12986 ee.WriteMapElemValue()
12987 ee.EncodeInt(int64(v[int32(k2)]))
12990 for _, k2 := range v2 {
12991 ee.EncodeInt(int64(int32(k2)))
12992 ee.EncodeInt(int64(v[int32(k2)]))
12997 for k2, v2 := range v {
12998 ee.WriteMapElemKey()
12999 ee.EncodeInt(int64(k2))
13000 ee.WriteMapElemValue()
13001 ee.EncodeInt(int64(v2))
13004 for k2, v2 := range v {
13005 ee.EncodeInt(int64(k2))
13006 ee.EncodeInt(int64(v2))
13013 func (e *Encoder) fastpathEncMapInt32Int8R(f *codecFnInfo, rv reflect.Value) {
13014 fastpathTV.EncMapInt32Int8V(rv2i(rv).(map[int32]int8), e)
13016 func (_ fastpathT) EncMapInt32Int8V(v map[int32]int8, e *Encoder) {
13021 ee, esep := e.e, e.hh.hasElemSeparators()
13022 ee.WriteMapStart(len(v))
13024 v2 := make([]int64, len(v))
13026 for k, _ := range v {
13030 sort.Sort(intSlice(v2))
13032 for _, k2 := range v2 {
13033 ee.WriteMapElemKey()
13034 ee.EncodeInt(int64(int32(k2)))
13035 ee.WriteMapElemValue()
13036 ee.EncodeInt(int64(v[int32(k2)]))
13039 for _, k2 := range v2 {
13040 ee.EncodeInt(int64(int32(k2)))
13041 ee.EncodeInt(int64(v[int32(k2)]))
13046 for k2, v2 := range v {
13047 ee.WriteMapElemKey()
13048 ee.EncodeInt(int64(k2))
13049 ee.WriteMapElemValue()
13050 ee.EncodeInt(int64(v2))
13053 for k2, v2 := range v {
13054 ee.EncodeInt(int64(k2))
13055 ee.EncodeInt(int64(v2))
13062 func (e *Encoder) fastpathEncMapInt32Int16R(f *codecFnInfo, rv reflect.Value) {
13063 fastpathTV.EncMapInt32Int16V(rv2i(rv).(map[int32]int16), e)
13065 func (_ fastpathT) EncMapInt32Int16V(v map[int32]int16, e *Encoder) {
13070 ee, esep := e.e, e.hh.hasElemSeparators()
13071 ee.WriteMapStart(len(v))
13073 v2 := make([]int64, len(v))
13075 for k, _ := range v {
13079 sort.Sort(intSlice(v2))
13081 for _, k2 := range v2 {
13082 ee.WriteMapElemKey()
13083 ee.EncodeInt(int64(int32(k2)))
13084 ee.WriteMapElemValue()
13085 ee.EncodeInt(int64(v[int32(k2)]))
13088 for _, k2 := range v2 {
13089 ee.EncodeInt(int64(int32(k2)))
13090 ee.EncodeInt(int64(v[int32(k2)]))
13095 for k2, v2 := range v {
13096 ee.WriteMapElemKey()
13097 ee.EncodeInt(int64(k2))
13098 ee.WriteMapElemValue()
13099 ee.EncodeInt(int64(v2))
13102 for k2, v2 := range v {
13103 ee.EncodeInt(int64(k2))
13104 ee.EncodeInt(int64(v2))
13111 func (e *Encoder) fastpathEncMapInt32Int32R(f *codecFnInfo, rv reflect.Value) {
13112 fastpathTV.EncMapInt32Int32V(rv2i(rv).(map[int32]int32), e)
13114 func (_ fastpathT) EncMapInt32Int32V(v map[int32]int32, e *Encoder) {
13119 ee, esep := e.e, e.hh.hasElemSeparators()
13120 ee.WriteMapStart(len(v))
13122 v2 := make([]int64, len(v))
13124 for k, _ := range v {
13128 sort.Sort(intSlice(v2))
13130 for _, k2 := range v2 {
13131 ee.WriteMapElemKey()
13132 ee.EncodeInt(int64(int32(k2)))
13133 ee.WriteMapElemValue()
13134 ee.EncodeInt(int64(v[int32(k2)]))
13137 for _, k2 := range v2 {
13138 ee.EncodeInt(int64(int32(k2)))
13139 ee.EncodeInt(int64(v[int32(k2)]))
13144 for k2, v2 := range v {
13145 ee.WriteMapElemKey()
13146 ee.EncodeInt(int64(k2))
13147 ee.WriteMapElemValue()
13148 ee.EncodeInt(int64(v2))
13151 for k2, v2 := range v {
13152 ee.EncodeInt(int64(k2))
13153 ee.EncodeInt(int64(v2))
13160 func (e *Encoder) fastpathEncMapInt32Int64R(f *codecFnInfo, rv reflect.Value) {
13161 fastpathTV.EncMapInt32Int64V(rv2i(rv).(map[int32]int64), e)
13163 func (_ fastpathT) EncMapInt32Int64V(v map[int32]int64, e *Encoder) {
13168 ee, esep := e.e, e.hh.hasElemSeparators()
13169 ee.WriteMapStart(len(v))
13171 v2 := make([]int64, len(v))
13173 for k, _ := range v {
13177 sort.Sort(intSlice(v2))
13179 for _, k2 := range v2 {
13180 ee.WriteMapElemKey()
13181 ee.EncodeInt(int64(int32(k2)))
13182 ee.WriteMapElemValue()
13183 ee.EncodeInt(int64(v[int32(k2)]))
13186 for _, k2 := range v2 {
13187 ee.EncodeInt(int64(int32(k2)))
13188 ee.EncodeInt(int64(v[int32(k2)]))
13193 for k2, v2 := range v {
13194 ee.WriteMapElemKey()
13195 ee.EncodeInt(int64(k2))
13196 ee.WriteMapElemValue()
13197 ee.EncodeInt(int64(v2))
13200 for k2, v2 := range v {
13201 ee.EncodeInt(int64(k2))
13202 ee.EncodeInt(int64(v2))
13209 func (e *Encoder) fastpathEncMapInt32Float32R(f *codecFnInfo, rv reflect.Value) {
13210 fastpathTV.EncMapInt32Float32V(rv2i(rv).(map[int32]float32), e)
13212 func (_ fastpathT) EncMapInt32Float32V(v map[int32]float32, e *Encoder) {
13217 ee, esep := e.e, e.hh.hasElemSeparators()
13218 ee.WriteMapStart(len(v))
13220 v2 := make([]int64, len(v))
13222 for k, _ := range v {
13226 sort.Sort(intSlice(v2))
13228 for _, k2 := range v2 {
13229 ee.WriteMapElemKey()
13230 ee.EncodeInt(int64(int32(k2)))
13231 ee.WriteMapElemValue()
13232 ee.EncodeFloat32(v[int32(k2)])
13235 for _, k2 := range v2 {
13236 ee.EncodeInt(int64(int32(k2)))
13237 ee.EncodeFloat32(v[int32(k2)])
13242 for k2, v2 := range v {
13243 ee.WriteMapElemKey()
13244 ee.EncodeInt(int64(k2))
13245 ee.WriteMapElemValue()
13246 ee.EncodeFloat32(v2)
13249 for k2, v2 := range v {
13250 ee.EncodeInt(int64(k2))
13251 ee.EncodeFloat32(v2)
13258 func (e *Encoder) fastpathEncMapInt32Float64R(f *codecFnInfo, rv reflect.Value) {
13259 fastpathTV.EncMapInt32Float64V(rv2i(rv).(map[int32]float64), e)
13261 func (_ fastpathT) EncMapInt32Float64V(v map[int32]float64, e *Encoder) {
13266 ee, esep := e.e, e.hh.hasElemSeparators()
13267 ee.WriteMapStart(len(v))
13269 v2 := make([]int64, len(v))
13271 for k, _ := range v {
13275 sort.Sort(intSlice(v2))
13277 for _, k2 := range v2 {
13278 ee.WriteMapElemKey()
13279 ee.EncodeInt(int64(int32(k2)))
13280 ee.WriteMapElemValue()
13281 ee.EncodeFloat64(v[int32(k2)])
13284 for _, k2 := range v2 {
13285 ee.EncodeInt(int64(int32(k2)))
13286 ee.EncodeFloat64(v[int32(k2)])
13291 for k2, v2 := range v {
13292 ee.WriteMapElemKey()
13293 ee.EncodeInt(int64(k2))
13294 ee.WriteMapElemValue()
13295 ee.EncodeFloat64(v2)
13298 for k2, v2 := range v {
13299 ee.EncodeInt(int64(k2))
13300 ee.EncodeFloat64(v2)
13307 func (e *Encoder) fastpathEncMapInt32BoolR(f *codecFnInfo, rv reflect.Value) {
13308 fastpathTV.EncMapInt32BoolV(rv2i(rv).(map[int32]bool), e)
13310 func (_ fastpathT) EncMapInt32BoolV(v map[int32]bool, e *Encoder) {
13315 ee, esep := e.e, e.hh.hasElemSeparators()
13316 ee.WriteMapStart(len(v))
13318 v2 := make([]int64, len(v))
13320 for k, _ := range v {
13324 sort.Sort(intSlice(v2))
13326 for _, k2 := range v2 {
13327 ee.WriteMapElemKey()
13328 ee.EncodeInt(int64(int32(k2)))
13329 ee.WriteMapElemValue()
13330 ee.EncodeBool(v[int32(k2)])
13333 for _, k2 := range v2 {
13334 ee.EncodeInt(int64(int32(k2)))
13335 ee.EncodeBool(v[int32(k2)])
13340 for k2, v2 := range v {
13341 ee.WriteMapElemKey()
13342 ee.EncodeInt(int64(k2))
13343 ee.WriteMapElemValue()
13347 for k2, v2 := range v {
13348 ee.EncodeInt(int64(k2))
13356 func (e *Encoder) fastpathEncMapInt64IntfR(f *codecFnInfo, rv reflect.Value) {
13357 fastpathTV.EncMapInt64IntfV(rv2i(rv).(map[int64]interface{}), e)
13359 func (_ fastpathT) EncMapInt64IntfV(v map[int64]interface{}, e *Encoder) {
13364 ee, esep := e.e, e.hh.hasElemSeparators()
13365 ee.WriteMapStart(len(v))
13367 v2 := make([]int64, len(v))
13369 for k, _ := range v {
13373 sort.Sort(intSlice(v2))
13375 for _, k2 := range v2 {
13376 ee.WriteMapElemKey()
13377 ee.EncodeInt(int64(int64(k2)))
13378 ee.WriteMapElemValue()
13379 e.encode(v[int64(k2)])
13382 for _, k2 := range v2 {
13383 ee.EncodeInt(int64(int64(k2)))
13384 e.encode(v[int64(k2)])
13389 for k2, v2 := range v {
13390 ee.WriteMapElemKey()
13391 ee.EncodeInt(int64(k2))
13392 ee.WriteMapElemValue()
13396 for k2, v2 := range v {
13397 ee.EncodeInt(int64(k2))
13405 func (e *Encoder) fastpathEncMapInt64StringR(f *codecFnInfo, rv reflect.Value) {
13406 fastpathTV.EncMapInt64StringV(rv2i(rv).(map[int64]string), e)
13408 func (_ fastpathT) EncMapInt64StringV(v map[int64]string, e *Encoder) {
13413 ee, esep := e.e, e.hh.hasElemSeparators()
13414 ee.WriteMapStart(len(v))
13416 v2 := make([]int64, len(v))
13418 for k, _ := range v {
13422 sort.Sort(intSlice(v2))
13424 for _, k2 := range v2 {
13425 ee.WriteMapElemKey()
13426 ee.EncodeInt(int64(int64(k2)))
13427 ee.WriteMapElemValue()
13428 ee.EncodeString(cUTF8, v[int64(k2)])
13431 for _, k2 := range v2 {
13432 ee.EncodeInt(int64(int64(k2)))
13433 ee.EncodeString(cUTF8, v[int64(k2)])
13438 for k2, v2 := range v {
13439 ee.WriteMapElemKey()
13440 ee.EncodeInt(int64(k2))
13441 ee.WriteMapElemValue()
13442 ee.EncodeString(cUTF8, v2)
13445 for k2, v2 := range v {
13446 ee.EncodeInt(int64(k2))
13447 ee.EncodeString(cUTF8, v2)
13454 func (e *Encoder) fastpathEncMapInt64UintR(f *codecFnInfo, rv reflect.Value) {
13455 fastpathTV.EncMapInt64UintV(rv2i(rv).(map[int64]uint), e)
13457 func (_ fastpathT) EncMapInt64UintV(v map[int64]uint, e *Encoder) {
13462 ee, esep := e.e, e.hh.hasElemSeparators()
13463 ee.WriteMapStart(len(v))
13465 v2 := make([]int64, len(v))
13467 for k, _ := range v {
13471 sort.Sort(intSlice(v2))
13473 for _, k2 := range v2 {
13474 ee.WriteMapElemKey()
13475 ee.EncodeInt(int64(int64(k2)))
13476 ee.WriteMapElemValue()
13477 ee.EncodeUint(uint64(v[int64(k2)]))
13480 for _, k2 := range v2 {
13481 ee.EncodeInt(int64(int64(k2)))
13482 ee.EncodeUint(uint64(v[int64(k2)]))
13487 for k2, v2 := range v {
13488 ee.WriteMapElemKey()
13489 ee.EncodeInt(int64(k2))
13490 ee.WriteMapElemValue()
13491 ee.EncodeUint(uint64(v2))
13494 for k2, v2 := range v {
13495 ee.EncodeInt(int64(k2))
13496 ee.EncodeUint(uint64(v2))
13503 func (e *Encoder) fastpathEncMapInt64Uint8R(f *codecFnInfo, rv reflect.Value) {
13504 fastpathTV.EncMapInt64Uint8V(rv2i(rv).(map[int64]uint8), e)
13506 func (_ fastpathT) EncMapInt64Uint8V(v map[int64]uint8, e *Encoder) {
13511 ee, esep := e.e, e.hh.hasElemSeparators()
13512 ee.WriteMapStart(len(v))
13514 v2 := make([]int64, len(v))
13516 for k, _ := range v {
13520 sort.Sort(intSlice(v2))
13522 for _, k2 := range v2 {
13523 ee.WriteMapElemKey()
13524 ee.EncodeInt(int64(int64(k2)))
13525 ee.WriteMapElemValue()
13526 ee.EncodeUint(uint64(v[int64(k2)]))
13529 for _, k2 := range v2 {
13530 ee.EncodeInt(int64(int64(k2)))
13531 ee.EncodeUint(uint64(v[int64(k2)]))
13536 for k2, v2 := range v {
13537 ee.WriteMapElemKey()
13538 ee.EncodeInt(int64(k2))
13539 ee.WriteMapElemValue()
13540 ee.EncodeUint(uint64(v2))
13543 for k2, v2 := range v {
13544 ee.EncodeInt(int64(k2))
13545 ee.EncodeUint(uint64(v2))
13552 func (e *Encoder) fastpathEncMapInt64Uint16R(f *codecFnInfo, rv reflect.Value) {
13553 fastpathTV.EncMapInt64Uint16V(rv2i(rv).(map[int64]uint16), e)
13555 func (_ fastpathT) EncMapInt64Uint16V(v map[int64]uint16, e *Encoder) {
13560 ee, esep := e.e, e.hh.hasElemSeparators()
13561 ee.WriteMapStart(len(v))
13563 v2 := make([]int64, len(v))
13565 for k, _ := range v {
13569 sort.Sort(intSlice(v2))
13571 for _, k2 := range v2 {
13572 ee.WriteMapElemKey()
13573 ee.EncodeInt(int64(int64(k2)))
13574 ee.WriteMapElemValue()
13575 ee.EncodeUint(uint64(v[int64(k2)]))
13578 for _, k2 := range v2 {
13579 ee.EncodeInt(int64(int64(k2)))
13580 ee.EncodeUint(uint64(v[int64(k2)]))
13585 for k2, v2 := range v {
13586 ee.WriteMapElemKey()
13587 ee.EncodeInt(int64(k2))
13588 ee.WriteMapElemValue()
13589 ee.EncodeUint(uint64(v2))
13592 for k2, v2 := range v {
13593 ee.EncodeInt(int64(k2))
13594 ee.EncodeUint(uint64(v2))
13601 func (e *Encoder) fastpathEncMapInt64Uint32R(f *codecFnInfo, rv reflect.Value) {
13602 fastpathTV.EncMapInt64Uint32V(rv2i(rv).(map[int64]uint32), e)
13604 func (_ fastpathT) EncMapInt64Uint32V(v map[int64]uint32, e *Encoder) {
13609 ee, esep := e.e, e.hh.hasElemSeparators()
13610 ee.WriteMapStart(len(v))
13612 v2 := make([]int64, len(v))
13614 for k, _ := range v {
13618 sort.Sort(intSlice(v2))
13620 for _, k2 := range v2 {
13621 ee.WriteMapElemKey()
13622 ee.EncodeInt(int64(int64(k2)))
13623 ee.WriteMapElemValue()
13624 ee.EncodeUint(uint64(v[int64(k2)]))
13627 for _, k2 := range v2 {
13628 ee.EncodeInt(int64(int64(k2)))
13629 ee.EncodeUint(uint64(v[int64(k2)]))
13634 for k2, v2 := range v {
13635 ee.WriteMapElemKey()
13636 ee.EncodeInt(int64(k2))
13637 ee.WriteMapElemValue()
13638 ee.EncodeUint(uint64(v2))
13641 for k2, v2 := range v {
13642 ee.EncodeInt(int64(k2))
13643 ee.EncodeUint(uint64(v2))
13650 func (e *Encoder) fastpathEncMapInt64Uint64R(f *codecFnInfo, rv reflect.Value) {
13651 fastpathTV.EncMapInt64Uint64V(rv2i(rv).(map[int64]uint64), e)
13653 func (_ fastpathT) EncMapInt64Uint64V(v map[int64]uint64, e *Encoder) {
13658 ee, esep := e.e, e.hh.hasElemSeparators()
13659 ee.WriteMapStart(len(v))
13661 v2 := make([]int64, len(v))
13663 for k, _ := range v {
13667 sort.Sort(intSlice(v2))
13669 for _, k2 := range v2 {
13670 ee.WriteMapElemKey()
13671 ee.EncodeInt(int64(int64(k2)))
13672 ee.WriteMapElemValue()
13673 ee.EncodeUint(uint64(v[int64(k2)]))
13676 for _, k2 := range v2 {
13677 ee.EncodeInt(int64(int64(k2)))
13678 ee.EncodeUint(uint64(v[int64(k2)]))
13683 for k2, v2 := range v {
13684 ee.WriteMapElemKey()
13685 ee.EncodeInt(int64(k2))
13686 ee.WriteMapElemValue()
13687 ee.EncodeUint(uint64(v2))
13690 for k2, v2 := range v {
13691 ee.EncodeInt(int64(k2))
13692 ee.EncodeUint(uint64(v2))
13699 func (e *Encoder) fastpathEncMapInt64UintptrR(f *codecFnInfo, rv reflect.Value) {
13700 fastpathTV.EncMapInt64UintptrV(rv2i(rv).(map[int64]uintptr), e)
13702 func (_ fastpathT) EncMapInt64UintptrV(v map[int64]uintptr, e *Encoder) {
13707 ee, esep := e.e, e.hh.hasElemSeparators()
13708 ee.WriteMapStart(len(v))
13710 v2 := make([]int64, len(v))
13712 for k, _ := range v {
13716 sort.Sort(intSlice(v2))
13718 for _, k2 := range v2 {
13719 ee.WriteMapElemKey()
13720 ee.EncodeInt(int64(int64(k2)))
13721 ee.WriteMapElemValue()
13722 e.encode(v[int64(k2)])
13725 for _, k2 := range v2 {
13726 ee.EncodeInt(int64(int64(k2)))
13727 e.encode(v[int64(k2)])
13732 for k2, v2 := range v {
13733 ee.WriteMapElemKey()
13734 ee.EncodeInt(int64(k2))
13735 ee.WriteMapElemValue()
13739 for k2, v2 := range v {
13740 ee.EncodeInt(int64(k2))
13748 func (e *Encoder) fastpathEncMapInt64IntR(f *codecFnInfo, rv reflect.Value) {
13749 fastpathTV.EncMapInt64IntV(rv2i(rv).(map[int64]int), e)
13751 func (_ fastpathT) EncMapInt64IntV(v map[int64]int, e *Encoder) {
13756 ee, esep := e.e, e.hh.hasElemSeparators()
13757 ee.WriteMapStart(len(v))
13759 v2 := make([]int64, len(v))
13761 for k, _ := range v {
13765 sort.Sort(intSlice(v2))
13767 for _, k2 := range v2 {
13768 ee.WriteMapElemKey()
13769 ee.EncodeInt(int64(int64(k2)))
13770 ee.WriteMapElemValue()
13771 ee.EncodeInt(int64(v[int64(k2)]))
13774 for _, k2 := range v2 {
13775 ee.EncodeInt(int64(int64(k2)))
13776 ee.EncodeInt(int64(v[int64(k2)]))
13781 for k2, v2 := range v {
13782 ee.WriteMapElemKey()
13783 ee.EncodeInt(int64(k2))
13784 ee.WriteMapElemValue()
13785 ee.EncodeInt(int64(v2))
13788 for k2, v2 := range v {
13789 ee.EncodeInt(int64(k2))
13790 ee.EncodeInt(int64(v2))
13797 func (e *Encoder) fastpathEncMapInt64Int8R(f *codecFnInfo, rv reflect.Value) {
13798 fastpathTV.EncMapInt64Int8V(rv2i(rv).(map[int64]int8), e)
13800 func (_ fastpathT) EncMapInt64Int8V(v map[int64]int8, e *Encoder) {
13805 ee, esep := e.e, e.hh.hasElemSeparators()
13806 ee.WriteMapStart(len(v))
13808 v2 := make([]int64, len(v))
13810 for k, _ := range v {
13814 sort.Sort(intSlice(v2))
13816 for _, k2 := range v2 {
13817 ee.WriteMapElemKey()
13818 ee.EncodeInt(int64(int64(k2)))
13819 ee.WriteMapElemValue()
13820 ee.EncodeInt(int64(v[int64(k2)]))
13823 for _, k2 := range v2 {
13824 ee.EncodeInt(int64(int64(k2)))
13825 ee.EncodeInt(int64(v[int64(k2)]))
13830 for k2, v2 := range v {
13831 ee.WriteMapElemKey()
13832 ee.EncodeInt(int64(k2))
13833 ee.WriteMapElemValue()
13834 ee.EncodeInt(int64(v2))
13837 for k2, v2 := range v {
13838 ee.EncodeInt(int64(k2))
13839 ee.EncodeInt(int64(v2))
13846 func (e *Encoder) fastpathEncMapInt64Int16R(f *codecFnInfo, rv reflect.Value) {
13847 fastpathTV.EncMapInt64Int16V(rv2i(rv).(map[int64]int16), e)
13849 func (_ fastpathT) EncMapInt64Int16V(v map[int64]int16, e *Encoder) {
13854 ee, esep := e.e, e.hh.hasElemSeparators()
13855 ee.WriteMapStart(len(v))
13857 v2 := make([]int64, len(v))
13859 for k, _ := range v {
13863 sort.Sort(intSlice(v2))
13865 for _, k2 := range v2 {
13866 ee.WriteMapElemKey()
13867 ee.EncodeInt(int64(int64(k2)))
13868 ee.WriteMapElemValue()
13869 ee.EncodeInt(int64(v[int64(k2)]))
13872 for _, k2 := range v2 {
13873 ee.EncodeInt(int64(int64(k2)))
13874 ee.EncodeInt(int64(v[int64(k2)]))
13879 for k2, v2 := range v {
13880 ee.WriteMapElemKey()
13881 ee.EncodeInt(int64(k2))
13882 ee.WriteMapElemValue()
13883 ee.EncodeInt(int64(v2))
13886 for k2, v2 := range v {
13887 ee.EncodeInt(int64(k2))
13888 ee.EncodeInt(int64(v2))
13895 func (e *Encoder) fastpathEncMapInt64Int32R(f *codecFnInfo, rv reflect.Value) {
13896 fastpathTV.EncMapInt64Int32V(rv2i(rv).(map[int64]int32), e)
13898 func (_ fastpathT) EncMapInt64Int32V(v map[int64]int32, e *Encoder) {
13903 ee, esep := e.e, e.hh.hasElemSeparators()
13904 ee.WriteMapStart(len(v))
13906 v2 := make([]int64, len(v))
13908 for k, _ := range v {
13912 sort.Sort(intSlice(v2))
13914 for _, k2 := range v2 {
13915 ee.WriteMapElemKey()
13916 ee.EncodeInt(int64(int64(k2)))
13917 ee.WriteMapElemValue()
13918 ee.EncodeInt(int64(v[int64(k2)]))
13921 for _, k2 := range v2 {
13922 ee.EncodeInt(int64(int64(k2)))
13923 ee.EncodeInt(int64(v[int64(k2)]))
13928 for k2, v2 := range v {
13929 ee.WriteMapElemKey()
13930 ee.EncodeInt(int64(k2))
13931 ee.WriteMapElemValue()
13932 ee.EncodeInt(int64(v2))
13935 for k2, v2 := range v {
13936 ee.EncodeInt(int64(k2))
13937 ee.EncodeInt(int64(v2))
13944 func (e *Encoder) fastpathEncMapInt64Int64R(f *codecFnInfo, rv reflect.Value) {
13945 fastpathTV.EncMapInt64Int64V(rv2i(rv).(map[int64]int64), e)
13947 func (_ fastpathT) EncMapInt64Int64V(v map[int64]int64, e *Encoder) {
13952 ee, esep := e.e, e.hh.hasElemSeparators()
13953 ee.WriteMapStart(len(v))
13955 v2 := make([]int64, len(v))
13957 for k, _ := range v {
13961 sort.Sort(intSlice(v2))
13963 for _, k2 := range v2 {
13964 ee.WriteMapElemKey()
13965 ee.EncodeInt(int64(int64(k2)))
13966 ee.WriteMapElemValue()
13967 ee.EncodeInt(int64(v[int64(k2)]))
13970 for _, k2 := range v2 {
13971 ee.EncodeInt(int64(int64(k2)))
13972 ee.EncodeInt(int64(v[int64(k2)]))
13977 for k2, v2 := range v {
13978 ee.WriteMapElemKey()
13979 ee.EncodeInt(int64(k2))
13980 ee.WriteMapElemValue()
13981 ee.EncodeInt(int64(v2))
13984 for k2, v2 := range v {
13985 ee.EncodeInt(int64(k2))
13986 ee.EncodeInt(int64(v2))
13993 func (e *Encoder) fastpathEncMapInt64Float32R(f *codecFnInfo, rv reflect.Value) {
13994 fastpathTV.EncMapInt64Float32V(rv2i(rv).(map[int64]float32), e)
13996 func (_ fastpathT) EncMapInt64Float32V(v map[int64]float32, e *Encoder) {
14001 ee, esep := e.e, e.hh.hasElemSeparators()
14002 ee.WriteMapStart(len(v))
14004 v2 := make([]int64, len(v))
14006 for k, _ := range v {
14010 sort.Sort(intSlice(v2))
14012 for _, k2 := range v2 {
14013 ee.WriteMapElemKey()
14014 ee.EncodeInt(int64(int64(k2)))
14015 ee.WriteMapElemValue()
14016 ee.EncodeFloat32(v[int64(k2)])
14019 for _, k2 := range v2 {
14020 ee.EncodeInt(int64(int64(k2)))
14021 ee.EncodeFloat32(v[int64(k2)])
14026 for k2, v2 := range v {
14027 ee.WriteMapElemKey()
14028 ee.EncodeInt(int64(k2))
14029 ee.WriteMapElemValue()
14030 ee.EncodeFloat32(v2)
14033 for k2, v2 := range v {
14034 ee.EncodeInt(int64(k2))
14035 ee.EncodeFloat32(v2)
14042 func (e *Encoder) fastpathEncMapInt64Float64R(f *codecFnInfo, rv reflect.Value) {
14043 fastpathTV.EncMapInt64Float64V(rv2i(rv).(map[int64]float64), e)
14045 func (_ fastpathT) EncMapInt64Float64V(v map[int64]float64, e *Encoder) {
14050 ee, esep := e.e, e.hh.hasElemSeparators()
14051 ee.WriteMapStart(len(v))
14053 v2 := make([]int64, len(v))
14055 for k, _ := range v {
14059 sort.Sort(intSlice(v2))
14061 for _, k2 := range v2 {
14062 ee.WriteMapElemKey()
14063 ee.EncodeInt(int64(int64(k2)))
14064 ee.WriteMapElemValue()
14065 ee.EncodeFloat64(v[int64(k2)])
14068 for _, k2 := range v2 {
14069 ee.EncodeInt(int64(int64(k2)))
14070 ee.EncodeFloat64(v[int64(k2)])
14075 for k2, v2 := range v {
14076 ee.WriteMapElemKey()
14077 ee.EncodeInt(int64(k2))
14078 ee.WriteMapElemValue()
14079 ee.EncodeFloat64(v2)
14082 for k2, v2 := range v {
14083 ee.EncodeInt(int64(k2))
14084 ee.EncodeFloat64(v2)
14091 func (e *Encoder) fastpathEncMapInt64BoolR(f *codecFnInfo, rv reflect.Value) {
14092 fastpathTV.EncMapInt64BoolV(rv2i(rv).(map[int64]bool), e)
14094 func (_ fastpathT) EncMapInt64BoolV(v map[int64]bool, e *Encoder) {
14099 ee, esep := e.e, e.hh.hasElemSeparators()
14100 ee.WriteMapStart(len(v))
14102 v2 := make([]int64, len(v))
14104 for k, _ := range v {
14108 sort.Sort(intSlice(v2))
14110 for _, k2 := range v2 {
14111 ee.WriteMapElemKey()
14112 ee.EncodeInt(int64(int64(k2)))
14113 ee.WriteMapElemValue()
14114 ee.EncodeBool(v[int64(k2)])
14117 for _, k2 := range v2 {
14118 ee.EncodeInt(int64(int64(k2)))
14119 ee.EncodeBool(v[int64(k2)])
14124 for k2, v2 := range v {
14125 ee.WriteMapElemKey()
14126 ee.EncodeInt(int64(k2))
14127 ee.WriteMapElemValue()
14131 for k2, v2 := range v {
14132 ee.EncodeInt(int64(k2))
14140 func (e *Encoder) fastpathEncMapBoolIntfR(f *codecFnInfo, rv reflect.Value) {
14141 fastpathTV.EncMapBoolIntfV(rv2i(rv).(map[bool]interface{}), e)
14143 func (_ fastpathT) EncMapBoolIntfV(v map[bool]interface{}, e *Encoder) {
14148 ee, esep := e.e, e.hh.hasElemSeparators()
14149 ee.WriteMapStart(len(v))
14151 v2 := make([]bool, len(v))
14153 for k, _ := range v {
14157 sort.Sort(boolSlice(v2))
14159 for _, k2 := range v2 {
14160 ee.WriteMapElemKey()
14161 ee.EncodeBool(bool(k2))
14162 ee.WriteMapElemValue()
14163 e.encode(v[bool(k2)])
14166 for _, k2 := range v2 {
14167 ee.EncodeBool(bool(k2))
14168 e.encode(v[bool(k2)])
14173 for k2, v2 := range v {
14174 ee.WriteMapElemKey()
14176 ee.WriteMapElemValue()
14180 for k2, v2 := range v {
14189 func (e *Encoder) fastpathEncMapBoolStringR(f *codecFnInfo, rv reflect.Value) {
14190 fastpathTV.EncMapBoolStringV(rv2i(rv).(map[bool]string), e)
14192 func (_ fastpathT) EncMapBoolStringV(v map[bool]string, e *Encoder) {
14197 ee, esep := e.e, e.hh.hasElemSeparators()
14198 ee.WriteMapStart(len(v))
14200 v2 := make([]bool, len(v))
14202 for k, _ := range v {
14206 sort.Sort(boolSlice(v2))
14208 for _, k2 := range v2 {
14209 ee.WriteMapElemKey()
14210 ee.EncodeBool(bool(k2))
14211 ee.WriteMapElemValue()
14212 ee.EncodeString(cUTF8, v[bool(k2)])
14215 for _, k2 := range v2 {
14216 ee.EncodeBool(bool(k2))
14217 ee.EncodeString(cUTF8, v[bool(k2)])
14222 for k2, v2 := range v {
14223 ee.WriteMapElemKey()
14225 ee.WriteMapElemValue()
14226 ee.EncodeString(cUTF8, v2)
14229 for k2, v2 := range v {
14231 ee.EncodeString(cUTF8, v2)
14238 func (e *Encoder) fastpathEncMapBoolUintR(f *codecFnInfo, rv reflect.Value) {
14239 fastpathTV.EncMapBoolUintV(rv2i(rv).(map[bool]uint), e)
14241 func (_ fastpathT) EncMapBoolUintV(v map[bool]uint, e *Encoder) {
14246 ee, esep := e.e, e.hh.hasElemSeparators()
14247 ee.WriteMapStart(len(v))
14249 v2 := make([]bool, len(v))
14251 for k, _ := range v {
14255 sort.Sort(boolSlice(v2))
14257 for _, k2 := range v2 {
14258 ee.WriteMapElemKey()
14259 ee.EncodeBool(bool(k2))
14260 ee.WriteMapElemValue()
14261 ee.EncodeUint(uint64(v[bool(k2)]))
14264 for _, k2 := range v2 {
14265 ee.EncodeBool(bool(k2))
14266 ee.EncodeUint(uint64(v[bool(k2)]))
14271 for k2, v2 := range v {
14272 ee.WriteMapElemKey()
14274 ee.WriteMapElemValue()
14275 ee.EncodeUint(uint64(v2))
14278 for k2, v2 := range v {
14280 ee.EncodeUint(uint64(v2))
14287 func (e *Encoder) fastpathEncMapBoolUint8R(f *codecFnInfo, rv reflect.Value) {
14288 fastpathTV.EncMapBoolUint8V(rv2i(rv).(map[bool]uint8), e)
14290 func (_ fastpathT) EncMapBoolUint8V(v map[bool]uint8, e *Encoder) {
14295 ee, esep := e.e, e.hh.hasElemSeparators()
14296 ee.WriteMapStart(len(v))
14298 v2 := make([]bool, len(v))
14300 for k, _ := range v {
14304 sort.Sort(boolSlice(v2))
14306 for _, k2 := range v2 {
14307 ee.WriteMapElemKey()
14308 ee.EncodeBool(bool(k2))
14309 ee.WriteMapElemValue()
14310 ee.EncodeUint(uint64(v[bool(k2)]))
14313 for _, k2 := range v2 {
14314 ee.EncodeBool(bool(k2))
14315 ee.EncodeUint(uint64(v[bool(k2)]))
14320 for k2, v2 := range v {
14321 ee.WriteMapElemKey()
14323 ee.WriteMapElemValue()
14324 ee.EncodeUint(uint64(v2))
14327 for k2, v2 := range v {
14329 ee.EncodeUint(uint64(v2))
14336 func (e *Encoder) fastpathEncMapBoolUint16R(f *codecFnInfo, rv reflect.Value) {
14337 fastpathTV.EncMapBoolUint16V(rv2i(rv).(map[bool]uint16), e)
14339 func (_ fastpathT) EncMapBoolUint16V(v map[bool]uint16, e *Encoder) {
14344 ee, esep := e.e, e.hh.hasElemSeparators()
14345 ee.WriteMapStart(len(v))
14347 v2 := make([]bool, len(v))
14349 for k, _ := range v {
14353 sort.Sort(boolSlice(v2))
14355 for _, k2 := range v2 {
14356 ee.WriteMapElemKey()
14357 ee.EncodeBool(bool(k2))
14358 ee.WriteMapElemValue()
14359 ee.EncodeUint(uint64(v[bool(k2)]))
14362 for _, k2 := range v2 {
14363 ee.EncodeBool(bool(k2))
14364 ee.EncodeUint(uint64(v[bool(k2)]))
14369 for k2, v2 := range v {
14370 ee.WriteMapElemKey()
14372 ee.WriteMapElemValue()
14373 ee.EncodeUint(uint64(v2))
14376 for k2, v2 := range v {
14378 ee.EncodeUint(uint64(v2))
14385 func (e *Encoder) fastpathEncMapBoolUint32R(f *codecFnInfo, rv reflect.Value) {
14386 fastpathTV.EncMapBoolUint32V(rv2i(rv).(map[bool]uint32), e)
14388 func (_ fastpathT) EncMapBoolUint32V(v map[bool]uint32, e *Encoder) {
14393 ee, esep := e.e, e.hh.hasElemSeparators()
14394 ee.WriteMapStart(len(v))
14396 v2 := make([]bool, len(v))
14398 for k, _ := range v {
14402 sort.Sort(boolSlice(v2))
14404 for _, k2 := range v2 {
14405 ee.WriteMapElemKey()
14406 ee.EncodeBool(bool(k2))
14407 ee.WriteMapElemValue()
14408 ee.EncodeUint(uint64(v[bool(k2)]))
14411 for _, k2 := range v2 {
14412 ee.EncodeBool(bool(k2))
14413 ee.EncodeUint(uint64(v[bool(k2)]))
14418 for k2, v2 := range v {
14419 ee.WriteMapElemKey()
14421 ee.WriteMapElemValue()
14422 ee.EncodeUint(uint64(v2))
14425 for k2, v2 := range v {
14427 ee.EncodeUint(uint64(v2))
14434 func (e *Encoder) fastpathEncMapBoolUint64R(f *codecFnInfo, rv reflect.Value) {
14435 fastpathTV.EncMapBoolUint64V(rv2i(rv).(map[bool]uint64), e)
14437 func (_ fastpathT) EncMapBoolUint64V(v map[bool]uint64, e *Encoder) {
14442 ee, esep := e.e, e.hh.hasElemSeparators()
14443 ee.WriteMapStart(len(v))
14445 v2 := make([]bool, len(v))
14447 for k, _ := range v {
14451 sort.Sort(boolSlice(v2))
14453 for _, k2 := range v2 {
14454 ee.WriteMapElemKey()
14455 ee.EncodeBool(bool(k2))
14456 ee.WriteMapElemValue()
14457 ee.EncodeUint(uint64(v[bool(k2)]))
14460 for _, k2 := range v2 {
14461 ee.EncodeBool(bool(k2))
14462 ee.EncodeUint(uint64(v[bool(k2)]))
14467 for k2, v2 := range v {
14468 ee.WriteMapElemKey()
14470 ee.WriteMapElemValue()
14471 ee.EncodeUint(uint64(v2))
14474 for k2, v2 := range v {
14476 ee.EncodeUint(uint64(v2))
14483 func (e *Encoder) fastpathEncMapBoolUintptrR(f *codecFnInfo, rv reflect.Value) {
14484 fastpathTV.EncMapBoolUintptrV(rv2i(rv).(map[bool]uintptr), e)
14486 func (_ fastpathT) EncMapBoolUintptrV(v map[bool]uintptr, e *Encoder) {
14491 ee, esep := e.e, e.hh.hasElemSeparators()
14492 ee.WriteMapStart(len(v))
14494 v2 := make([]bool, len(v))
14496 for k, _ := range v {
14500 sort.Sort(boolSlice(v2))
14502 for _, k2 := range v2 {
14503 ee.WriteMapElemKey()
14504 ee.EncodeBool(bool(k2))
14505 ee.WriteMapElemValue()
14506 e.encode(v[bool(k2)])
14509 for _, k2 := range v2 {
14510 ee.EncodeBool(bool(k2))
14511 e.encode(v[bool(k2)])
14516 for k2, v2 := range v {
14517 ee.WriteMapElemKey()
14519 ee.WriteMapElemValue()
14523 for k2, v2 := range v {
14532 func (e *Encoder) fastpathEncMapBoolIntR(f *codecFnInfo, rv reflect.Value) {
14533 fastpathTV.EncMapBoolIntV(rv2i(rv).(map[bool]int), e)
14535 func (_ fastpathT) EncMapBoolIntV(v map[bool]int, e *Encoder) {
14540 ee, esep := e.e, e.hh.hasElemSeparators()
14541 ee.WriteMapStart(len(v))
14543 v2 := make([]bool, len(v))
14545 for k, _ := range v {
14549 sort.Sort(boolSlice(v2))
14551 for _, k2 := range v2 {
14552 ee.WriteMapElemKey()
14553 ee.EncodeBool(bool(k2))
14554 ee.WriteMapElemValue()
14555 ee.EncodeInt(int64(v[bool(k2)]))
14558 for _, k2 := range v2 {
14559 ee.EncodeBool(bool(k2))
14560 ee.EncodeInt(int64(v[bool(k2)]))
14565 for k2, v2 := range v {
14566 ee.WriteMapElemKey()
14568 ee.WriteMapElemValue()
14569 ee.EncodeInt(int64(v2))
14572 for k2, v2 := range v {
14574 ee.EncodeInt(int64(v2))
14581 func (e *Encoder) fastpathEncMapBoolInt8R(f *codecFnInfo, rv reflect.Value) {
14582 fastpathTV.EncMapBoolInt8V(rv2i(rv).(map[bool]int8), e)
14584 func (_ fastpathT) EncMapBoolInt8V(v map[bool]int8, e *Encoder) {
14589 ee, esep := e.e, e.hh.hasElemSeparators()
14590 ee.WriteMapStart(len(v))
14592 v2 := make([]bool, len(v))
14594 for k, _ := range v {
14598 sort.Sort(boolSlice(v2))
14600 for _, k2 := range v2 {
14601 ee.WriteMapElemKey()
14602 ee.EncodeBool(bool(k2))
14603 ee.WriteMapElemValue()
14604 ee.EncodeInt(int64(v[bool(k2)]))
14607 for _, k2 := range v2 {
14608 ee.EncodeBool(bool(k2))
14609 ee.EncodeInt(int64(v[bool(k2)]))
14614 for k2, v2 := range v {
14615 ee.WriteMapElemKey()
14617 ee.WriteMapElemValue()
14618 ee.EncodeInt(int64(v2))
14621 for k2, v2 := range v {
14623 ee.EncodeInt(int64(v2))
14630 func (e *Encoder) fastpathEncMapBoolInt16R(f *codecFnInfo, rv reflect.Value) {
14631 fastpathTV.EncMapBoolInt16V(rv2i(rv).(map[bool]int16), e)
14633 func (_ fastpathT) EncMapBoolInt16V(v map[bool]int16, e *Encoder) {
14638 ee, esep := e.e, e.hh.hasElemSeparators()
14639 ee.WriteMapStart(len(v))
14641 v2 := make([]bool, len(v))
14643 for k, _ := range v {
14647 sort.Sort(boolSlice(v2))
14649 for _, k2 := range v2 {
14650 ee.WriteMapElemKey()
14651 ee.EncodeBool(bool(k2))
14652 ee.WriteMapElemValue()
14653 ee.EncodeInt(int64(v[bool(k2)]))
14656 for _, k2 := range v2 {
14657 ee.EncodeBool(bool(k2))
14658 ee.EncodeInt(int64(v[bool(k2)]))
14663 for k2, v2 := range v {
14664 ee.WriteMapElemKey()
14666 ee.WriteMapElemValue()
14667 ee.EncodeInt(int64(v2))
14670 for k2, v2 := range v {
14672 ee.EncodeInt(int64(v2))
14679 func (e *Encoder) fastpathEncMapBoolInt32R(f *codecFnInfo, rv reflect.Value) {
14680 fastpathTV.EncMapBoolInt32V(rv2i(rv).(map[bool]int32), e)
14682 func (_ fastpathT) EncMapBoolInt32V(v map[bool]int32, e *Encoder) {
14687 ee, esep := e.e, e.hh.hasElemSeparators()
14688 ee.WriteMapStart(len(v))
14690 v2 := make([]bool, len(v))
14692 for k, _ := range v {
14696 sort.Sort(boolSlice(v2))
14698 for _, k2 := range v2 {
14699 ee.WriteMapElemKey()
14700 ee.EncodeBool(bool(k2))
14701 ee.WriteMapElemValue()
14702 ee.EncodeInt(int64(v[bool(k2)]))
14705 for _, k2 := range v2 {
14706 ee.EncodeBool(bool(k2))
14707 ee.EncodeInt(int64(v[bool(k2)]))
14712 for k2, v2 := range v {
14713 ee.WriteMapElemKey()
14715 ee.WriteMapElemValue()
14716 ee.EncodeInt(int64(v2))
14719 for k2, v2 := range v {
14721 ee.EncodeInt(int64(v2))
14728 func (e *Encoder) fastpathEncMapBoolInt64R(f *codecFnInfo, rv reflect.Value) {
14729 fastpathTV.EncMapBoolInt64V(rv2i(rv).(map[bool]int64), e)
14731 func (_ fastpathT) EncMapBoolInt64V(v map[bool]int64, e *Encoder) {
14736 ee, esep := e.e, e.hh.hasElemSeparators()
14737 ee.WriteMapStart(len(v))
14739 v2 := make([]bool, len(v))
14741 for k, _ := range v {
14745 sort.Sort(boolSlice(v2))
14747 for _, k2 := range v2 {
14748 ee.WriteMapElemKey()
14749 ee.EncodeBool(bool(k2))
14750 ee.WriteMapElemValue()
14751 ee.EncodeInt(int64(v[bool(k2)]))
14754 for _, k2 := range v2 {
14755 ee.EncodeBool(bool(k2))
14756 ee.EncodeInt(int64(v[bool(k2)]))
14761 for k2, v2 := range v {
14762 ee.WriteMapElemKey()
14764 ee.WriteMapElemValue()
14765 ee.EncodeInt(int64(v2))
14768 for k2, v2 := range v {
14770 ee.EncodeInt(int64(v2))
14777 func (e *Encoder) fastpathEncMapBoolFloat32R(f *codecFnInfo, rv reflect.Value) {
14778 fastpathTV.EncMapBoolFloat32V(rv2i(rv).(map[bool]float32), e)
14780 func (_ fastpathT) EncMapBoolFloat32V(v map[bool]float32, e *Encoder) {
14785 ee, esep := e.e, e.hh.hasElemSeparators()
14786 ee.WriteMapStart(len(v))
14788 v2 := make([]bool, len(v))
14790 for k, _ := range v {
14794 sort.Sort(boolSlice(v2))
14796 for _, k2 := range v2 {
14797 ee.WriteMapElemKey()
14798 ee.EncodeBool(bool(k2))
14799 ee.WriteMapElemValue()
14800 ee.EncodeFloat32(v[bool(k2)])
14803 for _, k2 := range v2 {
14804 ee.EncodeBool(bool(k2))
14805 ee.EncodeFloat32(v[bool(k2)])
14810 for k2, v2 := range v {
14811 ee.WriteMapElemKey()
14813 ee.WriteMapElemValue()
14814 ee.EncodeFloat32(v2)
14817 for k2, v2 := range v {
14819 ee.EncodeFloat32(v2)
14826 func (e *Encoder) fastpathEncMapBoolFloat64R(f *codecFnInfo, rv reflect.Value) {
14827 fastpathTV.EncMapBoolFloat64V(rv2i(rv).(map[bool]float64), e)
14829 func (_ fastpathT) EncMapBoolFloat64V(v map[bool]float64, e *Encoder) {
14834 ee, esep := e.e, e.hh.hasElemSeparators()
14835 ee.WriteMapStart(len(v))
14837 v2 := make([]bool, len(v))
14839 for k, _ := range v {
14843 sort.Sort(boolSlice(v2))
14845 for _, k2 := range v2 {
14846 ee.WriteMapElemKey()
14847 ee.EncodeBool(bool(k2))
14848 ee.WriteMapElemValue()
14849 ee.EncodeFloat64(v[bool(k2)])
14852 for _, k2 := range v2 {
14853 ee.EncodeBool(bool(k2))
14854 ee.EncodeFloat64(v[bool(k2)])
14859 for k2, v2 := range v {
14860 ee.WriteMapElemKey()
14862 ee.WriteMapElemValue()
14863 ee.EncodeFloat64(v2)
14866 for k2, v2 := range v {
14868 ee.EncodeFloat64(v2)
14875 func (e *Encoder) fastpathEncMapBoolBoolR(f *codecFnInfo, rv reflect.Value) {
14876 fastpathTV.EncMapBoolBoolV(rv2i(rv).(map[bool]bool), e)
14878 func (_ fastpathT) EncMapBoolBoolV(v map[bool]bool, e *Encoder) {
14883 ee, esep := e.e, e.hh.hasElemSeparators()
14884 ee.WriteMapStart(len(v))
14886 v2 := make([]bool, len(v))
14888 for k, _ := range v {
14892 sort.Sort(boolSlice(v2))
14894 for _, k2 := range v2 {
14895 ee.WriteMapElemKey()
14896 ee.EncodeBool(bool(k2))
14897 ee.WriteMapElemValue()
14898 ee.EncodeBool(v[bool(k2)])
14901 for _, k2 := range v2 {
14902 ee.EncodeBool(bool(k2))
14903 ee.EncodeBool(v[bool(k2)])
14908 for k2, v2 := range v {
14909 ee.WriteMapElemKey()
14911 ee.WriteMapElemValue()
14915 for k2, v2 := range v {
14926 // -- -- fast path type switch
14927 func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool {
14929 switch v := iv.(type) {
14931 case []interface{}:
14932 var v2 []interface{}
14933 v2, changed = fastpathTV.DecSliceIntfV(v, false, d)
14934 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
14937 case *[]interface{}:
14938 var v2 []interface{}
14939 v2, changed = fastpathTV.DecSliceIntfV(*v, true, d)
14945 v2, changed = fastpathTV.DecSliceStringV(v, false, d)
14946 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
14951 v2, changed = fastpathTV.DecSliceStringV(*v, true, d)
14957 v2, changed = fastpathTV.DecSliceFloat32V(v, false, d)
14958 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
14963 v2, changed = fastpathTV.DecSliceFloat32V(*v, true, d)
14969 v2, changed = fastpathTV.DecSliceFloat64V(v, false, d)
14970 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
14975 v2, changed = fastpathTV.DecSliceFloat64V(*v, true, d)
14981 v2, changed = fastpathTV.DecSliceUintV(v, false, d)
14982 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
14987 v2, changed = fastpathTV.DecSliceUintV(*v, true, d)
14993 v2, changed = fastpathTV.DecSliceUint16V(v, false, d)
14994 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
14999 v2, changed = fastpathTV.DecSliceUint16V(*v, true, d)
15005 v2, changed = fastpathTV.DecSliceUint32V(v, false, d)
15006 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
15011 v2, changed = fastpathTV.DecSliceUint32V(*v, true, d)
15017 v2, changed = fastpathTV.DecSliceUint64V(v, false, d)
15018 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
15023 v2, changed = fastpathTV.DecSliceUint64V(*v, true, d)
15029 v2, changed = fastpathTV.DecSliceUintptrV(v, false, d)
15030 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
15035 v2, changed = fastpathTV.DecSliceUintptrV(*v, true, d)
15041 v2, changed = fastpathTV.DecSliceIntV(v, false, d)
15042 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
15047 v2, changed = fastpathTV.DecSliceIntV(*v, true, d)
15053 v2, changed = fastpathTV.DecSliceInt8V(v, false, d)
15054 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
15059 v2, changed = fastpathTV.DecSliceInt8V(*v, true, d)
15065 v2, changed = fastpathTV.DecSliceInt16V(v, false, d)
15066 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
15071 v2, changed = fastpathTV.DecSliceInt16V(*v, true, d)
15077 v2, changed = fastpathTV.DecSliceInt32V(v, false, d)
15078 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
15083 v2, changed = fastpathTV.DecSliceInt32V(*v, true, d)
15089 v2, changed = fastpathTV.DecSliceInt64V(v, false, d)
15090 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
15095 v2, changed = fastpathTV.DecSliceInt64V(*v, true, d)
15101 v2, changed = fastpathTV.DecSliceBoolV(v, false, d)
15102 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
15107 v2, changed = fastpathTV.DecSliceBoolV(*v, true, d)
15112 case map[interface{}]interface{}:
15113 fastpathTV.DecMapIntfIntfV(v, false, d)
15114 case *map[interface{}]interface{}:
15115 var v2 map[interface{}]interface{}
15116 v2, changed = fastpathTV.DecMapIntfIntfV(*v, true, d)
15120 case map[interface{}]string:
15121 fastpathTV.DecMapIntfStringV(v, false, d)
15122 case *map[interface{}]string:
15123 var v2 map[interface{}]string
15124 v2, changed = fastpathTV.DecMapIntfStringV(*v, true, d)
15128 case map[interface{}]uint:
15129 fastpathTV.DecMapIntfUintV(v, false, d)
15130 case *map[interface{}]uint:
15131 var v2 map[interface{}]uint
15132 v2, changed = fastpathTV.DecMapIntfUintV(*v, true, d)
15136 case map[interface{}]uint8:
15137 fastpathTV.DecMapIntfUint8V(v, false, d)
15138 case *map[interface{}]uint8:
15139 var v2 map[interface{}]uint8
15140 v2, changed = fastpathTV.DecMapIntfUint8V(*v, true, d)
15144 case map[interface{}]uint16:
15145 fastpathTV.DecMapIntfUint16V(v, false, d)
15146 case *map[interface{}]uint16:
15147 var v2 map[interface{}]uint16
15148 v2, changed = fastpathTV.DecMapIntfUint16V(*v, true, d)
15152 case map[interface{}]uint32:
15153 fastpathTV.DecMapIntfUint32V(v, false, d)
15154 case *map[interface{}]uint32:
15155 var v2 map[interface{}]uint32
15156 v2, changed = fastpathTV.DecMapIntfUint32V(*v, true, d)
15160 case map[interface{}]uint64:
15161 fastpathTV.DecMapIntfUint64V(v, false, d)
15162 case *map[interface{}]uint64:
15163 var v2 map[interface{}]uint64
15164 v2, changed = fastpathTV.DecMapIntfUint64V(*v, true, d)
15168 case map[interface{}]uintptr:
15169 fastpathTV.DecMapIntfUintptrV(v, false, d)
15170 case *map[interface{}]uintptr:
15171 var v2 map[interface{}]uintptr
15172 v2, changed = fastpathTV.DecMapIntfUintptrV(*v, true, d)
15176 case map[interface{}]int:
15177 fastpathTV.DecMapIntfIntV(v, false, d)
15178 case *map[interface{}]int:
15179 var v2 map[interface{}]int
15180 v2, changed = fastpathTV.DecMapIntfIntV(*v, true, d)
15184 case map[interface{}]int8:
15185 fastpathTV.DecMapIntfInt8V(v, false, d)
15186 case *map[interface{}]int8:
15187 var v2 map[interface{}]int8
15188 v2, changed = fastpathTV.DecMapIntfInt8V(*v, true, d)
15192 case map[interface{}]int16:
15193 fastpathTV.DecMapIntfInt16V(v, false, d)
15194 case *map[interface{}]int16:
15195 var v2 map[interface{}]int16
15196 v2, changed = fastpathTV.DecMapIntfInt16V(*v, true, d)
15200 case map[interface{}]int32:
15201 fastpathTV.DecMapIntfInt32V(v, false, d)
15202 case *map[interface{}]int32:
15203 var v2 map[interface{}]int32
15204 v2, changed = fastpathTV.DecMapIntfInt32V(*v, true, d)
15208 case map[interface{}]int64:
15209 fastpathTV.DecMapIntfInt64V(v, false, d)
15210 case *map[interface{}]int64:
15211 var v2 map[interface{}]int64
15212 v2, changed = fastpathTV.DecMapIntfInt64V(*v, true, d)
15216 case map[interface{}]float32:
15217 fastpathTV.DecMapIntfFloat32V(v, false, d)
15218 case *map[interface{}]float32:
15219 var v2 map[interface{}]float32
15220 v2, changed = fastpathTV.DecMapIntfFloat32V(*v, true, d)
15224 case map[interface{}]float64:
15225 fastpathTV.DecMapIntfFloat64V(v, false, d)
15226 case *map[interface{}]float64:
15227 var v2 map[interface{}]float64
15228 v2, changed = fastpathTV.DecMapIntfFloat64V(*v, true, d)
15232 case map[interface{}]bool:
15233 fastpathTV.DecMapIntfBoolV(v, false, d)
15234 case *map[interface{}]bool:
15235 var v2 map[interface{}]bool
15236 v2, changed = fastpathTV.DecMapIntfBoolV(*v, true, d)
15240 case map[string]interface{}:
15241 fastpathTV.DecMapStringIntfV(v, false, d)
15242 case *map[string]interface{}:
15243 var v2 map[string]interface{}
15244 v2, changed = fastpathTV.DecMapStringIntfV(*v, true, d)
15248 case map[string]string:
15249 fastpathTV.DecMapStringStringV(v, false, d)
15250 case *map[string]string:
15251 var v2 map[string]string
15252 v2, changed = fastpathTV.DecMapStringStringV(*v, true, d)
15256 case map[string]uint:
15257 fastpathTV.DecMapStringUintV(v, false, d)
15258 case *map[string]uint:
15259 var v2 map[string]uint
15260 v2, changed = fastpathTV.DecMapStringUintV(*v, true, d)
15264 case map[string]uint8:
15265 fastpathTV.DecMapStringUint8V(v, false, d)
15266 case *map[string]uint8:
15267 var v2 map[string]uint8
15268 v2, changed = fastpathTV.DecMapStringUint8V(*v, true, d)
15272 case map[string]uint16:
15273 fastpathTV.DecMapStringUint16V(v, false, d)
15274 case *map[string]uint16:
15275 var v2 map[string]uint16
15276 v2, changed = fastpathTV.DecMapStringUint16V(*v, true, d)
15280 case map[string]uint32:
15281 fastpathTV.DecMapStringUint32V(v, false, d)
15282 case *map[string]uint32:
15283 var v2 map[string]uint32
15284 v2, changed = fastpathTV.DecMapStringUint32V(*v, true, d)
15288 case map[string]uint64:
15289 fastpathTV.DecMapStringUint64V(v, false, d)
15290 case *map[string]uint64:
15291 var v2 map[string]uint64
15292 v2, changed = fastpathTV.DecMapStringUint64V(*v, true, d)
15296 case map[string]uintptr:
15297 fastpathTV.DecMapStringUintptrV(v, false, d)
15298 case *map[string]uintptr:
15299 var v2 map[string]uintptr
15300 v2, changed = fastpathTV.DecMapStringUintptrV(*v, true, d)
15304 case map[string]int:
15305 fastpathTV.DecMapStringIntV(v, false, d)
15306 case *map[string]int:
15307 var v2 map[string]int
15308 v2, changed = fastpathTV.DecMapStringIntV(*v, true, d)
15312 case map[string]int8:
15313 fastpathTV.DecMapStringInt8V(v, false, d)
15314 case *map[string]int8:
15315 var v2 map[string]int8
15316 v2, changed = fastpathTV.DecMapStringInt8V(*v, true, d)
15320 case map[string]int16:
15321 fastpathTV.DecMapStringInt16V(v, false, d)
15322 case *map[string]int16:
15323 var v2 map[string]int16
15324 v2, changed = fastpathTV.DecMapStringInt16V(*v, true, d)
15328 case map[string]int32:
15329 fastpathTV.DecMapStringInt32V(v, false, d)
15330 case *map[string]int32:
15331 var v2 map[string]int32
15332 v2, changed = fastpathTV.DecMapStringInt32V(*v, true, d)
15336 case map[string]int64:
15337 fastpathTV.DecMapStringInt64V(v, false, d)
15338 case *map[string]int64:
15339 var v2 map[string]int64
15340 v2, changed = fastpathTV.DecMapStringInt64V(*v, true, d)
15344 case map[string]float32:
15345 fastpathTV.DecMapStringFloat32V(v, false, d)
15346 case *map[string]float32:
15347 var v2 map[string]float32
15348 v2, changed = fastpathTV.DecMapStringFloat32V(*v, true, d)
15352 case map[string]float64:
15353 fastpathTV.DecMapStringFloat64V(v, false, d)
15354 case *map[string]float64:
15355 var v2 map[string]float64
15356 v2, changed = fastpathTV.DecMapStringFloat64V(*v, true, d)
15360 case map[string]bool:
15361 fastpathTV.DecMapStringBoolV(v, false, d)
15362 case *map[string]bool:
15363 var v2 map[string]bool
15364 v2, changed = fastpathTV.DecMapStringBoolV(*v, true, d)
15368 case map[float32]interface{}:
15369 fastpathTV.DecMapFloat32IntfV(v, false, d)
15370 case *map[float32]interface{}:
15371 var v2 map[float32]interface{}
15372 v2, changed = fastpathTV.DecMapFloat32IntfV(*v, true, d)
15376 case map[float32]string:
15377 fastpathTV.DecMapFloat32StringV(v, false, d)
15378 case *map[float32]string:
15379 var v2 map[float32]string
15380 v2, changed = fastpathTV.DecMapFloat32StringV(*v, true, d)
15384 case map[float32]uint:
15385 fastpathTV.DecMapFloat32UintV(v, false, d)
15386 case *map[float32]uint:
15387 var v2 map[float32]uint
15388 v2, changed = fastpathTV.DecMapFloat32UintV(*v, true, d)
15392 case map[float32]uint8:
15393 fastpathTV.DecMapFloat32Uint8V(v, false, d)
15394 case *map[float32]uint8:
15395 var v2 map[float32]uint8
15396 v2, changed = fastpathTV.DecMapFloat32Uint8V(*v, true, d)
15400 case map[float32]uint16:
15401 fastpathTV.DecMapFloat32Uint16V(v, false, d)
15402 case *map[float32]uint16:
15403 var v2 map[float32]uint16
15404 v2, changed = fastpathTV.DecMapFloat32Uint16V(*v, true, d)
15408 case map[float32]uint32:
15409 fastpathTV.DecMapFloat32Uint32V(v, false, d)
15410 case *map[float32]uint32:
15411 var v2 map[float32]uint32
15412 v2, changed = fastpathTV.DecMapFloat32Uint32V(*v, true, d)
15416 case map[float32]uint64:
15417 fastpathTV.DecMapFloat32Uint64V(v, false, d)
15418 case *map[float32]uint64:
15419 var v2 map[float32]uint64
15420 v2, changed = fastpathTV.DecMapFloat32Uint64V(*v, true, d)
15424 case map[float32]uintptr:
15425 fastpathTV.DecMapFloat32UintptrV(v, false, d)
15426 case *map[float32]uintptr:
15427 var v2 map[float32]uintptr
15428 v2, changed = fastpathTV.DecMapFloat32UintptrV(*v, true, d)
15432 case map[float32]int:
15433 fastpathTV.DecMapFloat32IntV(v, false, d)
15434 case *map[float32]int:
15435 var v2 map[float32]int
15436 v2, changed = fastpathTV.DecMapFloat32IntV(*v, true, d)
15440 case map[float32]int8:
15441 fastpathTV.DecMapFloat32Int8V(v, false, d)
15442 case *map[float32]int8:
15443 var v2 map[float32]int8
15444 v2, changed = fastpathTV.DecMapFloat32Int8V(*v, true, d)
15448 case map[float32]int16:
15449 fastpathTV.DecMapFloat32Int16V(v, false, d)
15450 case *map[float32]int16:
15451 var v2 map[float32]int16
15452 v2, changed = fastpathTV.DecMapFloat32Int16V(*v, true, d)
15456 case map[float32]int32:
15457 fastpathTV.DecMapFloat32Int32V(v, false, d)
15458 case *map[float32]int32:
15459 var v2 map[float32]int32
15460 v2, changed = fastpathTV.DecMapFloat32Int32V(*v, true, d)
15464 case map[float32]int64:
15465 fastpathTV.DecMapFloat32Int64V(v, false, d)
15466 case *map[float32]int64:
15467 var v2 map[float32]int64
15468 v2, changed = fastpathTV.DecMapFloat32Int64V(*v, true, d)
15472 case map[float32]float32:
15473 fastpathTV.DecMapFloat32Float32V(v, false, d)
15474 case *map[float32]float32:
15475 var v2 map[float32]float32
15476 v2, changed = fastpathTV.DecMapFloat32Float32V(*v, true, d)
15480 case map[float32]float64:
15481 fastpathTV.DecMapFloat32Float64V(v, false, d)
15482 case *map[float32]float64:
15483 var v2 map[float32]float64
15484 v2, changed = fastpathTV.DecMapFloat32Float64V(*v, true, d)
15488 case map[float32]bool:
15489 fastpathTV.DecMapFloat32BoolV(v, false, d)
15490 case *map[float32]bool:
15491 var v2 map[float32]bool
15492 v2, changed = fastpathTV.DecMapFloat32BoolV(*v, true, d)
15496 case map[float64]interface{}:
15497 fastpathTV.DecMapFloat64IntfV(v, false, d)
15498 case *map[float64]interface{}:
15499 var v2 map[float64]interface{}
15500 v2, changed = fastpathTV.DecMapFloat64IntfV(*v, true, d)
15504 case map[float64]string:
15505 fastpathTV.DecMapFloat64StringV(v, false, d)
15506 case *map[float64]string:
15507 var v2 map[float64]string
15508 v2, changed = fastpathTV.DecMapFloat64StringV(*v, true, d)
15512 case map[float64]uint:
15513 fastpathTV.DecMapFloat64UintV(v, false, d)
15514 case *map[float64]uint:
15515 var v2 map[float64]uint
15516 v2, changed = fastpathTV.DecMapFloat64UintV(*v, true, d)
15520 case map[float64]uint8:
15521 fastpathTV.DecMapFloat64Uint8V(v, false, d)
15522 case *map[float64]uint8:
15523 var v2 map[float64]uint8
15524 v2, changed = fastpathTV.DecMapFloat64Uint8V(*v, true, d)
15528 case map[float64]uint16:
15529 fastpathTV.DecMapFloat64Uint16V(v, false, d)
15530 case *map[float64]uint16:
15531 var v2 map[float64]uint16
15532 v2, changed = fastpathTV.DecMapFloat64Uint16V(*v, true, d)
15536 case map[float64]uint32:
15537 fastpathTV.DecMapFloat64Uint32V(v, false, d)
15538 case *map[float64]uint32:
15539 var v2 map[float64]uint32
15540 v2, changed = fastpathTV.DecMapFloat64Uint32V(*v, true, d)
15544 case map[float64]uint64:
15545 fastpathTV.DecMapFloat64Uint64V(v, false, d)
15546 case *map[float64]uint64:
15547 var v2 map[float64]uint64
15548 v2, changed = fastpathTV.DecMapFloat64Uint64V(*v, true, d)
15552 case map[float64]uintptr:
15553 fastpathTV.DecMapFloat64UintptrV(v, false, d)
15554 case *map[float64]uintptr:
15555 var v2 map[float64]uintptr
15556 v2, changed = fastpathTV.DecMapFloat64UintptrV(*v, true, d)
15560 case map[float64]int:
15561 fastpathTV.DecMapFloat64IntV(v, false, d)
15562 case *map[float64]int:
15563 var v2 map[float64]int
15564 v2, changed = fastpathTV.DecMapFloat64IntV(*v, true, d)
15568 case map[float64]int8:
15569 fastpathTV.DecMapFloat64Int8V(v, false, d)
15570 case *map[float64]int8:
15571 var v2 map[float64]int8
15572 v2, changed = fastpathTV.DecMapFloat64Int8V(*v, true, d)
15576 case map[float64]int16:
15577 fastpathTV.DecMapFloat64Int16V(v, false, d)
15578 case *map[float64]int16:
15579 var v2 map[float64]int16
15580 v2, changed = fastpathTV.DecMapFloat64Int16V(*v, true, d)
15584 case map[float64]int32:
15585 fastpathTV.DecMapFloat64Int32V(v, false, d)
15586 case *map[float64]int32:
15587 var v2 map[float64]int32
15588 v2, changed = fastpathTV.DecMapFloat64Int32V(*v, true, d)
15592 case map[float64]int64:
15593 fastpathTV.DecMapFloat64Int64V(v, false, d)
15594 case *map[float64]int64:
15595 var v2 map[float64]int64
15596 v2, changed = fastpathTV.DecMapFloat64Int64V(*v, true, d)
15600 case map[float64]float32:
15601 fastpathTV.DecMapFloat64Float32V(v, false, d)
15602 case *map[float64]float32:
15603 var v2 map[float64]float32
15604 v2, changed = fastpathTV.DecMapFloat64Float32V(*v, true, d)
15608 case map[float64]float64:
15609 fastpathTV.DecMapFloat64Float64V(v, false, d)
15610 case *map[float64]float64:
15611 var v2 map[float64]float64
15612 v2, changed = fastpathTV.DecMapFloat64Float64V(*v, true, d)
15616 case map[float64]bool:
15617 fastpathTV.DecMapFloat64BoolV(v, false, d)
15618 case *map[float64]bool:
15619 var v2 map[float64]bool
15620 v2, changed = fastpathTV.DecMapFloat64BoolV(*v, true, d)
15624 case map[uint]interface{}:
15625 fastpathTV.DecMapUintIntfV(v, false, d)
15626 case *map[uint]interface{}:
15627 var v2 map[uint]interface{}
15628 v2, changed = fastpathTV.DecMapUintIntfV(*v, true, d)
15632 case map[uint]string:
15633 fastpathTV.DecMapUintStringV(v, false, d)
15634 case *map[uint]string:
15635 var v2 map[uint]string
15636 v2, changed = fastpathTV.DecMapUintStringV(*v, true, d)
15640 case map[uint]uint:
15641 fastpathTV.DecMapUintUintV(v, false, d)
15642 case *map[uint]uint:
15643 var v2 map[uint]uint
15644 v2, changed = fastpathTV.DecMapUintUintV(*v, true, d)
15648 case map[uint]uint8:
15649 fastpathTV.DecMapUintUint8V(v, false, d)
15650 case *map[uint]uint8:
15651 var v2 map[uint]uint8
15652 v2, changed = fastpathTV.DecMapUintUint8V(*v, true, d)
15656 case map[uint]uint16:
15657 fastpathTV.DecMapUintUint16V(v, false, d)
15658 case *map[uint]uint16:
15659 var v2 map[uint]uint16
15660 v2, changed = fastpathTV.DecMapUintUint16V(*v, true, d)
15664 case map[uint]uint32:
15665 fastpathTV.DecMapUintUint32V(v, false, d)
15666 case *map[uint]uint32:
15667 var v2 map[uint]uint32
15668 v2, changed = fastpathTV.DecMapUintUint32V(*v, true, d)
15672 case map[uint]uint64:
15673 fastpathTV.DecMapUintUint64V(v, false, d)
15674 case *map[uint]uint64:
15675 var v2 map[uint]uint64
15676 v2, changed = fastpathTV.DecMapUintUint64V(*v, true, d)
15680 case map[uint]uintptr:
15681 fastpathTV.DecMapUintUintptrV(v, false, d)
15682 case *map[uint]uintptr:
15683 var v2 map[uint]uintptr
15684 v2, changed = fastpathTV.DecMapUintUintptrV(*v, true, d)
15689 fastpathTV.DecMapUintIntV(v, false, d)
15690 case *map[uint]int:
15691 var v2 map[uint]int
15692 v2, changed = fastpathTV.DecMapUintIntV(*v, true, d)
15696 case map[uint]int8:
15697 fastpathTV.DecMapUintInt8V(v, false, d)
15698 case *map[uint]int8:
15699 var v2 map[uint]int8
15700 v2, changed = fastpathTV.DecMapUintInt8V(*v, true, d)
15704 case map[uint]int16:
15705 fastpathTV.DecMapUintInt16V(v, false, d)
15706 case *map[uint]int16:
15707 var v2 map[uint]int16
15708 v2, changed = fastpathTV.DecMapUintInt16V(*v, true, d)
15712 case map[uint]int32:
15713 fastpathTV.DecMapUintInt32V(v, false, d)
15714 case *map[uint]int32:
15715 var v2 map[uint]int32
15716 v2, changed = fastpathTV.DecMapUintInt32V(*v, true, d)
15720 case map[uint]int64:
15721 fastpathTV.DecMapUintInt64V(v, false, d)
15722 case *map[uint]int64:
15723 var v2 map[uint]int64
15724 v2, changed = fastpathTV.DecMapUintInt64V(*v, true, d)
15728 case map[uint]float32:
15729 fastpathTV.DecMapUintFloat32V(v, false, d)
15730 case *map[uint]float32:
15731 var v2 map[uint]float32
15732 v2, changed = fastpathTV.DecMapUintFloat32V(*v, true, d)
15736 case map[uint]float64:
15737 fastpathTV.DecMapUintFloat64V(v, false, d)
15738 case *map[uint]float64:
15739 var v2 map[uint]float64
15740 v2, changed = fastpathTV.DecMapUintFloat64V(*v, true, d)
15744 case map[uint]bool:
15745 fastpathTV.DecMapUintBoolV(v, false, d)
15746 case *map[uint]bool:
15747 var v2 map[uint]bool
15748 v2, changed = fastpathTV.DecMapUintBoolV(*v, true, d)
15752 case map[uint8]interface{}:
15753 fastpathTV.DecMapUint8IntfV(v, false, d)
15754 case *map[uint8]interface{}:
15755 var v2 map[uint8]interface{}
15756 v2, changed = fastpathTV.DecMapUint8IntfV(*v, true, d)
15760 case map[uint8]string:
15761 fastpathTV.DecMapUint8StringV(v, false, d)
15762 case *map[uint8]string:
15763 var v2 map[uint8]string
15764 v2, changed = fastpathTV.DecMapUint8StringV(*v, true, d)
15768 case map[uint8]uint:
15769 fastpathTV.DecMapUint8UintV(v, false, d)
15770 case *map[uint8]uint:
15771 var v2 map[uint8]uint
15772 v2, changed = fastpathTV.DecMapUint8UintV(*v, true, d)
15776 case map[uint8]uint8:
15777 fastpathTV.DecMapUint8Uint8V(v, false, d)
15778 case *map[uint8]uint8:
15779 var v2 map[uint8]uint8
15780 v2, changed = fastpathTV.DecMapUint8Uint8V(*v, true, d)
15784 case map[uint8]uint16:
15785 fastpathTV.DecMapUint8Uint16V(v, false, d)
15786 case *map[uint8]uint16:
15787 var v2 map[uint8]uint16
15788 v2, changed = fastpathTV.DecMapUint8Uint16V(*v, true, d)
15792 case map[uint8]uint32:
15793 fastpathTV.DecMapUint8Uint32V(v, false, d)
15794 case *map[uint8]uint32:
15795 var v2 map[uint8]uint32
15796 v2, changed = fastpathTV.DecMapUint8Uint32V(*v, true, d)
15800 case map[uint8]uint64:
15801 fastpathTV.DecMapUint8Uint64V(v, false, d)
15802 case *map[uint8]uint64:
15803 var v2 map[uint8]uint64
15804 v2, changed = fastpathTV.DecMapUint8Uint64V(*v, true, d)
15808 case map[uint8]uintptr:
15809 fastpathTV.DecMapUint8UintptrV(v, false, d)
15810 case *map[uint8]uintptr:
15811 var v2 map[uint8]uintptr
15812 v2, changed = fastpathTV.DecMapUint8UintptrV(*v, true, d)
15816 case map[uint8]int:
15817 fastpathTV.DecMapUint8IntV(v, false, d)
15818 case *map[uint8]int:
15819 var v2 map[uint8]int
15820 v2, changed = fastpathTV.DecMapUint8IntV(*v, true, d)
15824 case map[uint8]int8:
15825 fastpathTV.DecMapUint8Int8V(v, false, d)
15826 case *map[uint8]int8:
15827 var v2 map[uint8]int8
15828 v2, changed = fastpathTV.DecMapUint8Int8V(*v, true, d)
15832 case map[uint8]int16:
15833 fastpathTV.DecMapUint8Int16V(v, false, d)
15834 case *map[uint8]int16:
15835 var v2 map[uint8]int16
15836 v2, changed = fastpathTV.DecMapUint8Int16V(*v, true, d)
15840 case map[uint8]int32:
15841 fastpathTV.DecMapUint8Int32V(v, false, d)
15842 case *map[uint8]int32:
15843 var v2 map[uint8]int32
15844 v2, changed = fastpathTV.DecMapUint8Int32V(*v, true, d)
15848 case map[uint8]int64:
15849 fastpathTV.DecMapUint8Int64V(v, false, d)
15850 case *map[uint8]int64:
15851 var v2 map[uint8]int64
15852 v2, changed = fastpathTV.DecMapUint8Int64V(*v, true, d)
15856 case map[uint8]float32:
15857 fastpathTV.DecMapUint8Float32V(v, false, d)
15858 case *map[uint8]float32:
15859 var v2 map[uint8]float32
15860 v2, changed = fastpathTV.DecMapUint8Float32V(*v, true, d)
15864 case map[uint8]float64:
15865 fastpathTV.DecMapUint8Float64V(v, false, d)
15866 case *map[uint8]float64:
15867 var v2 map[uint8]float64
15868 v2, changed = fastpathTV.DecMapUint8Float64V(*v, true, d)
15872 case map[uint8]bool:
15873 fastpathTV.DecMapUint8BoolV(v, false, d)
15874 case *map[uint8]bool:
15875 var v2 map[uint8]bool
15876 v2, changed = fastpathTV.DecMapUint8BoolV(*v, true, d)
15880 case map[uint16]interface{}:
15881 fastpathTV.DecMapUint16IntfV(v, false, d)
15882 case *map[uint16]interface{}:
15883 var v2 map[uint16]interface{}
15884 v2, changed = fastpathTV.DecMapUint16IntfV(*v, true, d)
15888 case map[uint16]string:
15889 fastpathTV.DecMapUint16StringV(v, false, d)
15890 case *map[uint16]string:
15891 var v2 map[uint16]string
15892 v2, changed = fastpathTV.DecMapUint16StringV(*v, true, d)
15896 case map[uint16]uint:
15897 fastpathTV.DecMapUint16UintV(v, false, d)
15898 case *map[uint16]uint:
15899 var v2 map[uint16]uint
15900 v2, changed = fastpathTV.DecMapUint16UintV(*v, true, d)
15904 case map[uint16]uint8:
15905 fastpathTV.DecMapUint16Uint8V(v, false, d)
15906 case *map[uint16]uint8:
15907 var v2 map[uint16]uint8
15908 v2, changed = fastpathTV.DecMapUint16Uint8V(*v, true, d)
15912 case map[uint16]uint16:
15913 fastpathTV.DecMapUint16Uint16V(v, false, d)
15914 case *map[uint16]uint16:
15915 var v2 map[uint16]uint16
15916 v2, changed = fastpathTV.DecMapUint16Uint16V(*v, true, d)
15920 case map[uint16]uint32:
15921 fastpathTV.DecMapUint16Uint32V(v, false, d)
15922 case *map[uint16]uint32:
15923 var v2 map[uint16]uint32
15924 v2, changed = fastpathTV.DecMapUint16Uint32V(*v, true, d)
15928 case map[uint16]uint64:
15929 fastpathTV.DecMapUint16Uint64V(v, false, d)
15930 case *map[uint16]uint64:
15931 var v2 map[uint16]uint64
15932 v2, changed = fastpathTV.DecMapUint16Uint64V(*v, true, d)
15936 case map[uint16]uintptr:
15937 fastpathTV.DecMapUint16UintptrV(v, false, d)
15938 case *map[uint16]uintptr:
15939 var v2 map[uint16]uintptr
15940 v2, changed = fastpathTV.DecMapUint16UintptrV(*v, true, d)
15944 case map[uint16]int:
15945 fastpathTV.DecMapUint16IntV(v, false, d)
15946 case *map[uint16]int:
15947 var v2 map[uint16]int
15948 v2, changed = fastpathTV.DecMapUint16IntV(*v, true, d)
15952 case map[uint16]int8:
15953 fastpathTV.DecMapUint16Int8V(v, false, d)
15954 case *map[uint16]int8:
15955 var v2 map[uint16]int8
15956 v2, changed = fastpathTV.DecMapUint16Int8V(*v, true, d)
15960 case map[uint16]int16:
15961 fastpathTV.DecMapUint16Int16V(v, false, d)
15962 case *map[uint16]int16:
15963 var v2 map[uint16]int16
15964 v2, changed = fastpathTV.DecMapUint16Int16V(*v, true, d)
15968 case map[uint16]int32:
15969 fastpathTV.DecMapUint16Int32V(v, false, d)
15970 case *map[uint16]int32:
15971 var v2 map[uint16]int32
15972 v2, changed = fastpathTV.DecMapUint16Int32V(*v, true, d)
15976 case map[uint16]int64:
15977 fastpathTV.DecMapUint16Int64V(v, false, d)
15978 case *map[uint16]int64:
15979 var v2 map[uint16]int64
15980 v2, changed = fastpathTV.DecMapUint16Int64V(*v, true, d)
15984 case map[uint16]float32:
15985 fastpathTV.DecMapUint16Float32V(v, false, d)
15986 case *map[uint16]float32:
15987 var v2 map[uint16]float32
15988 v2, changed = fastpathTV.DecMapUint16Float32V(*v, true, d)
15992 case map[uint16]float64:
15993 fastpathTV.DecMapUint16Float64V(v, false, d)
15994 case *map[uint16]float64:
15995 var v2 map[uint16]float64
15996 v2, changed = fastpathTV.DecMapUint16Float64V(*v, true, d)
16000 case map[uint16]bool:
16001 fastpathTV.DecMapUint16BoolV(v, false, d)
16002 case *map[uint16]bool:
16003 var v2 map[uint16]bool
16004 v2, changed = fastpathTV.DecMapUint16BoolV(*v, true, d)
16008 case map[uint32]interface{}:
16009 fastpathTV.DecMapUint32IntfV(v, false, d)
16010 case *map[uint32]interface{}:
16011 var v2 map[uint32]interface{}
16012 v2, changed = fastpathTV.DecMapUint32IntfV(*v, true, d)
16016 case map[uint32]string:
16017 fastpathTV.DecMapUint32StringV(v, false, d)
16018 case *map[uint32]string:
16019 var v2 map[uint32]string
16020 v2, changed = fastpathTV.DecMapUint32StringV(*v, true, d)
16024 case map[uint32]uint:
16025 fastpathTV.DecMapUint32UintV(v, false, d)
16026 case *map[uint32]uint:
16027 var v2 map[uint32]uint
16028 v2, changed = fastpathTV.DecMapUint32UintV(*v, true, d)
16032 case map[uint32]uint8:
16033 fastpathTV.DecMapUint32Uint8V(v, false, d)
16034 case *map[uint32]uint8:
16035 var v2 map[uint32]uint8
16036 v2, changed = fastpathTV.DecMapUint32Uint8V(*v, true, d)
16040 case map[uint32]uint16:
16041 fastpathTV.DecMapUint32Uint16V(v, false, d)
16042 case *map[uint32]uint16:
16043 var v2 map[uint32]uint16
16044 v2, changed = fastpathTV.DecMapUint32Uint16V(*v, true, d)
16048 case map[uint32]uint32:
16049 fastpathTV.DecMapUint32Uint32V(v, false, d)
16050 case *map[uint32]uint32:
16051 var v2 map[uint32]uint32
16052 v2, changed = fastpathTV.DecMapUint32Uint32V(*v, true, d)
16056 case map[uint32]uint64:
16057 fastpathTV.DecMapUint32Uint64V(v, false, d)
16058 case *map[uint32]uint64:
16059 var v2 map[uint32]uint64
16060 v2, changed = fastpathTV.DecMapUint32Uint64V(*v, true, d)
16064 case map[uint32]uintptr:
16065 fastpathTV.DecMapUint32UintptrV(v, false, d)
16066 case *map[uint32]uintptr:
16067 var v2 map[uint32]uintptr
16068 v2, changed = fastpathTV.DecMapUint32UintptrV(*v, true, d)
16072 case map[uint32]int:
16073 fastpathTV.DecMapUint32IntV(v, false, d)
16074 case *map[uint32]int:
16075 var v2 map[uint32]int
16076 v2, changed = fastpathTV.DecMapUint32IntV(*v, true, d)
16080 case map[uint32]int8:
16081 fastpathTV.DecMapUint32Int8V(v, false, d)
16082 case *map[uint32]int8:
16083 var v2 map[uint32]int8
16084 v2, changed = fastpathTV.DecMapUint32Int8V(*v, true, d)
16088 case map[uint32]int16:
16089 fastpathTV.DecMapUint32Int16V(v, false, d)
16090 case *map[uint32]int16:
16091 var v2 map[uint32]int16
16092 v2, changed = fastpathTV.DecMapUint32Int16V(*v, true, d)
16096 case map[uint32]int32:
16097 fastpathTV.DecMapUint32Int32V(v, false, d)
16098 case *map[uint32]int32:
16099 var v2 map[uint32]int32
16100 v2, changed = fastpathTV.DecMapUint32Int32V(*v, true, d)
16104 case map[uint32]int64:
16105 fastpathTV.DecMapUint32Int64V(v, false, d)
16106 case *map[uint32]int64:
16107 var v2 map[uint32]int64
16108 v2, changed = fastpathTV.DecMapUint32Int64V(*v, true, d)
16112 case map[uint32]float32:
16113 fastpathTV.DecMapUint32Float32V(v, false, d)
16114 case *map[uint32]float32:
16115 var v2 map[uint32]float32
16116 v2, changed = fastpathTV.DecMapUint32Float32V(*v, true, d)
16120 case map[uint32]float64:
16121 fastpathTV.DecMapUint32Float64V(v, false, d)
16122 case *map[uint32]float64:
16123 var v2 map[uint32]float64
16124 v2, changed = fastpathTV.DecMapUint32Float64V(*v, true, d)
16128 case map[uint32]bool:
16129 fastpathTV.DecMapUint32BoolV(v, false, d)
16130 case *map[uint32]bool:
16131 var v2 map[uint32]bool
16132 v2, changed = fastpathTV.DecMapUint32BoolV(*v, true, d)
16136 case map[uint64]interface{}:
16137 fastpathTV.DecMapUint64IntfV(v, false, d)
16138 case *map[uint64]interface{}:
16139 var v2 map[uint64]interface{}
16140 v2, changed = fastpathTV.DecMapUint64IntfV(*v, true, d)
16144 case map[uint64]string:
16145 fastpathTV.DecMapUint64StringV(v, false, d)
16146 case *map[uint64]string:
16147 var v2 map[uint64]string
16148 v2, changed = fastpathTV.DecMapUint64StringV(*v, true, d)
16152 case map[uint64]uint:
16153 fastpathTV.DecMapUint64UintV(v, false, d)
16154 case *map[uint64]uint:
16155 var v2 map[uint64]uint
16156 v2, changed = fastpathTV.DecMapUint64UintV(*v, true, d)
16160 case map[uint64]uint8:
16161 fastpathTV.DecMapUint64Uint8V(v, false, d)
16162 case *map[uint64]uint8:
16163 var v2 map[uint64]uint8
16164 v2, changed = fastpathTV.DecMapUint64Uint8V(*v, true, d)
16168 case map[uint64]uint16:
16169 fastpathTV.DecMapUint64Uint16V(v, false, d)
16170 case *map[uint64]uint16:
16171 var v2 map[uint64]uint16
16172 v2, changed = fastpathTV.DecMapUint64Uint16V(*v, true, d)
16176 case map[uint64]uint32:
16177 fastpathTV.DecMapUint64Uint32V(v, false, d)
16178 case *map[uint64]uint32:
16179 var v2 map[uint64]uint32
16180 v2, changed = fastpathTV.DecMapUint64Uint32V(*v, true, d)
16184 case map[uint64]uint64:
16185 fastpathTV.DecMapUint64Uint64V(v, false, d)
16186 case *map[uint64]uint64:
16187 var v2 map[uint64]uint64
16188 v2, changed = fastpathTV.DecMapUint64Uint64V(*v, true, d)
16192 case map[uint64]uintptr:
16193 fastpathTV.DecMapUint64UintptrV(v, false, d)
16194 case *map[uint64]uintptr:
16195 var v2 map[uint64]uintptr
16196 v2, changed = fastpathTV.DecMapUint64UintptrV(*v, true, d)
16200 case map[uint64]int:
16201 fastpathTV.DecMapUint64IntV(v, false, d)
16202 case *map[uint64]int:
16203 var v2 map[uint64]int
16204 v2, changed = fastpathTV.DecMapUint64IntV(*v, true, d)
16208 case map[uint64]int8:
16209 fastpathTV.DecMapUint64Int8V(v, false, d)
16210 case *map[uint64]int8:
16211 var v2 map[uint64]int8
16212 v2, changed = fastpathTV.DecMapUint64Int8V(*v, true, d)
16216 case map[uint64]int16:
16217 fastpathTV.DecMapUint64Int16V(v, false, d)
16218 case *map[uint64]int16:
16219 var v2 map[uint64]int16
16220 v2, changed = fastpathTV.DecMapUint64Int16V(*v, true, d)
16224 case map[uint64]int32:
16225 fastpathTV.DecMapUint64Int32V(v, false, d)
16226 case *map[uint64]int32:
16227 var v2 map[uint64]int32
16228 v2, changed = fastpathTV.DecMapUint64Int32V(*v, true, d)
16232 case map[uint64]int64:
16233 fastpathTV.DecMapUint64Int64V(v, false, d)
16234 case *map[uint64]int64:
16235 var v2 map[uint64]int64
16236 v2, changed = fastpathTV.DecMapUint64Int64V(*v, true, d)
16240 case map[uint64]float32:
16241 fastpathTV.DecMapUint64Float32V(v, false, d)
16242 case *map[uint64]float32:
16243 var v2 map[uint64]float32
16244 v2, changed = fastpathTV.DecMapUint64Float32V(*v, true, d)
16248 case map[uint64]float64:
16249 fastpathTV.DecMapUint64Float64V(v, false, d)
16250 case *map[uint64]float64:
16251 var v2 map[uint64]float64
16252 v2, changed = fastpathTV.DecMapUint64Float64V(*v, true, d)
16256 case map[uint64]bool:
16257 fastpathTV.DecMapUint64BoolV(v, false, d)
16258 case *map[uint64]bool:
16259 var v2 map[uint64]bool
16260 v2, changed = fastpathTV.DecMapUint64BoolV(*v, true, d)
16264 case map[uintptr]interface{}:
16265 fastpathTV.DecMapUintptrIntfV(v, false, d)
16266 case *map[uintptr]interface{}:
16267 var v2 map[uintptr]interface{}
16268 v2, changed = fastpathTV.DecMapUintptrIntfV(*v, true, d)
16272 case map[uintptr]string:
16273 fastpathTV.DecMapUintptrStringV(v, false, d)
16274 case *map[uintptr]string:
16275 var v2 map[uintptr]string
16276 v2, changed = fastpathTV.DecMapUintptrStringV(*v, true, d)
16280 case map[uintptr]uint:
16281 fastpathTV.DecMapUintptrUintV(v, false, d)
16282 case *map[uintptr]uint:
16283 var v2 map[uintptr]uint
16284 v2, changed = fastpathTV.DecMapUintptrUintV(*v, true, d)
16288 case map[uintptr]uint8:
16289 fastpathTV.DecMapUintptrUint8V(v, false, d)
16290 case *map[uintptr]uint8:
16291 var v2 map[uintptr]uint8
16292 v2, changed = fastpathTV.DecMapUintptrUint8V(*v, true, d)
16296 case map[uintptr]uint16:
16297 fastpathTV.DecMapUintptrUint16V(v, false, d)
16298 case *map[uintptr]uint16:
16299 var v2 map[uintptr]uint16
16300 v2, changed = fastpathTV.DecMapUintptrUint16V(*v, true, d)
16304 case map[uintptr]uint32:
16305 fastpathTV.DecMapUintptrUint32V(v, false, d)
16306 case *map[uintptr]uint32:
16307 var v2 map[uintptr]uint32
16308 v2, changed = fastpathTV.DecMapUintptrUint32V(*v, true, d)
16312 case map[uintptr]uint64:
16313 fastpathTV.DecMapUintptrUint64V(v, false, d)
16314 case *map[uintptr]uint64:
16315 var v2 map[uintptr]uint64
16316 v2, changed = fastpathTV.DecMapUintptrUint64V(*v, true, d)
16320 case map[uintptr]uintptr:
16321 fastpathTV.DecMapUintptrUintptrV(v, false, d)
16322 case *map[uintptr]uintptr:
16323 var v2 map[uintptr]uintptr
16324 v2, changed = fastpathTV.DecMapUintptrUintptrV(*v, true, d)
16328 case map[uintptr]int:
16329 fastpathTV.DecMapUintptrIntV(v, false, d)
16330 case *map[uintptr]int:
16331 var v2 map[uintptr]int
16332 v2, changed = fastpathTV.DecMapUintptrIntV(*v, true, d)
16336 case map[uintptr]int8:
16337 fastpathTV.DecMapUintptrInt8V(v, false, d)
16338 case *map[uintptr]int8:
16339 var v2 map[uintptr]int8
16340 v2, changed = fastpathTV.DecMapUintptrInt8V(*v, true, d)
16344 case map[uintptr]int16:
16345 fastpathTV.DecMapUintptrInt16V(v, false, d)
16346 case *map[uintptr]int16:
16347 var v2 map[uintptr]int16
16348 v2, changed = fastpathTV.DecMapUintptrInt16V(*v, true, d)
16352 case map[uintptr]int32:
16353 fastpathTV.DecMapUintptrInt32V(v, false, d)
16354 case *map[uintptr]int32:
16355 var v2 map[uintptr]int32
16356 v2, changed = fastpathTV.DecMapUintptrInt32V(*v, true, d)
16360 case map[uintptr]int64:
16361 fastpathTV.DecMapUintptrInt64V(v, false, d)
16362 case *map[uintptr]int64:
16363 var v2 map[uintptr]int64
16364 v2, changed = fastpathTV.DecMapUintptrInt64V(*v, true, d)
16368 case map[uintptr]float32:
16369 fastpathTV.DecMapUintptrFloat32V(v, false, d)
16370 case *map[uintptr]float32:
16371 var v2 map[uintptr]float32
16372 v2, changed = fastpathTV.DecMapUintptrFloat32V(*v, true, d)
16376 case map[uintptr]float64:
16377 fastpathTV.DecMapUintptrFloat64V(v, false, d)
16378 case *map[uintptr]float64:
16379 var v2 map[uintptr]float64
16380 v2, changed = fastpathTV.DecMapUintptrFloat64V(*v, true, d)
16384 case map[uintptr]bool:
16385 fastpathTV.DecMapUintptrBoolV(v, false, d)
16386 case *map[uintptr]bool:
16387 var v2 map[uintptr]bool
16388 v2, changed = fastpathTV.DecMapUintptrBoolV(*v, true, d)
16392 case map[int]interface{}:
16393 fastpathTV.DecMapIntIntfV(v, false, d)
16394 case *map[int]interface{}:
16395 var v2 map[int]interface{}
16396 v2, changed = fastpathTV.DecMapIntIntfV(*v, true, d)
16400 case map[int]string:
16401 fastpathTV.DecMapIntStringV(v, false, d)
16402 case *map[int]string:
16403 var v2 map[int]string
16404 v2, changed = fastpathTV.DecMapIntStringV(*v, true, d)
16409 fastpathTV.DecMapIntUintV(v, false, d)
16410 case *map[int]uint:
16411 var v2 map[int]uint
16412 v2, changed = fastpathTV.DecMapIntUintV(*v, true, d)
16416 case map[int]uint8:
16417 fastpathTV.DecMapIntUint8V(v, false, d)
16418 case *map[int]uint8:
16419 var v2 map[int]uint8
16420 v2, changed = fastpathTV.DecMapIntUint8V(*v, true, d)
16424 case map[int]uint16:
16425 fastpathTV.DecMapIntUint16V(v, false, d)
16426 case *map[int]uint16:
16427 var v2 map[int]uint16
16428 v2, changed = fastpathTV.DecMapIntUint16V(*v, true, d)
16432 case map[int]uint32:
16433 fastpathTV.DecMapIntUint32V(v, false, d)
16434 case *map[int]uint32:
16435 var v2 map[int]uint32
16436 v2, changed = fastpathTV.DecMapIntUint32V(*v, true, d)
16440 case map[int]uint64:
16441 fastpathTV.DecMapIntUint64V(v, false, d)
16442 case *map[int]uint64:
16443 var v2 map[int]uint64
16444 v2, changed = fastpathTV.DecMapIntUint64V(*v, true, d)
16448 case map[int]uintptr:
16449 fastpathTV.DecMapIntUintptrV(v, false, d)
16450 case *map[int]uintptr:
16451 var v2 map[int]uintptr
16452 v2, changed = fastpathTV.DecMapIntUintptrV(*v, true, d)
16457 fastpathTV.DecMapIntIntV(v, false, d)
16460 v2, changed = fastpathTV.DecMapIntIntV(*v, true, d)
16465 fastpathTV.DecMapIntInt8V(v, false, d)
16466 case *map[int]int8:
16467 var v2 map[int]int8
16468 v2, changed = fastpathTV.DecMapIntInt8V(*v, true, d)
16472 case map[int]int16:
16473 fastpathTV.DecMapIntInt16V(v, false, d)
16474 case *map[int]int16:
16475 var v2 map[int]int16
16476 v2, changed = fastpathTV.DecMapIntInt16V(*v, true, d)
16480 case map[int]int32:
16481 fastpathTV.DecMapIntInt32V(v, false, d)
16482 case *map[int]int32:
16483 var v2 map[int]int32
16484 v2, changed = fastpathTV.DecMapIntInt32V(*v, true, d)
16488 case map[int]int64:
16489 fastpathTV.DecMapIntInt64V(v, false, d)
16490 case *map[int]int64:
16491 var v2 map[int]int64
16492 v2, changed = fastpathTV.DecMapIntInt64V(*v, true, d)
16496 case map[int]float32:
16497 fastpathTV.DecMapIntFloat32V(v, false, d)
16498 case *map[int]float32:
16499 var v2 map[int]float32
16500 v2, changed = fastpathTV.DecMapIntFloat32V(*v, true, d)
16504 case map[int]float64:
16505 fastpathTV.DecMapIntFloat64V(v, false, d)
16506 case *map[int]float64:
16507 var v2 map[int]float64
16508 v2, changed = fastpathTV.DecMapIntFloat64V(*v, true, d)
16513 fastpathTV.DecMapIntBoolV(v, false, d)
16514 case *map[int]bool:
16515 var v2 map[int]bool
16516 v2, changed = fastpathTV.DecMapIntBoolV(*v, true, d)
16520 case map[int8]interface{}:
16521 fastpathTV.DecMapInt8IntfV(v, false, d)
16522 case *map[int8]interface{}:
16523 var v2 map[int8]interface{}
16524 v2, changed = fastpathTV.DecMapInt8IntfV(*v, true, d)
16528 case map[int8]string:
16529 fastpathTV.DecMapInt8StringV(v, false, d)
16530 case *map[int8]string:
16531 var v2 map[int8]string
16532 v2, changed = fastpathTV.DecMapInt8StringV(*v, true, d)
16536 case map[int8]uint:
16537 fastpathTV.DecMapInt8UintV(v, false, d)
16538 case *map[int8]uint:
16539 var v2 map[int8]uint
16540 v2, changed = fastpathTV.DecMapInt8UintV(*v, true, d)
16544 case map[int8]uint8:
16545 fastpathTV.DecMapInt8Uint8V(v, false, d)
16546 case *map[int8]uint8:
16547 var v2 map[int8]uint8
16548 v2, changed = fastpathTV.DecMapInt8Uint8V(*v, true, d)
16552 case map[int8]uint16:
16553 fastpathTV.DecMapInt8Uint16V(v, false, d)
16554 case *map[int8]uint16:
16555 var v2 map[int8]uint16
16556 v2, changed = fastpathTV.DecMapInt8Uint16V(*v, true, d)
16560 case map[int8]uint32:
16561 fastpathTV.DecMapInt8Uint32V(v, false, d)
16562 case *map[int8]uint32:
16563 var v2 map[int8]uint32
16564 v2, changed = fastpathTV.DecMapInt8Uint32V(*v, true, d)
16568 case map[int8]uint64:
16569 fastpathTV.DecMapInt8Uint64V(v, false, d)
16570 case *map[int8]uint64:
16571 var v2 map[int8]uint64
16572 v2, changed = fastpathTV.DecMapInt8Uint64V(*v, true, d)
16576 case map[int8]uintptr:
16577 fastpathTV.DecMapInt8UintptrV(v, false, d)
16578 case *map[int8]uintptr:
16579 var v2 map[int8]uintptr
16580 v2, changed = fastpathTV.DecMapInt8UintptrV(*v, true, d)
16585 fastpathTV.DecMapInt8IntV(v, false, d)
16586 case *map[int8]int:
16587 var v2 map[int8]int
16588 v2, changed = fastpathTV.DecMapInt8IntV(*v, true, d)
16592 case map[int8]int8:
16593 fastpathTV.DecMapInt8Int8V(v, false, d)
16594 case *map[int8]int8:
16595 var v2 map[int8]int8
16596 v2, changed = fastpathTV.DecMapInt8Int8V(*v, true, d)
16600 case map[int8]int16:
16601 fastpathTV.DecMapInt8Int16V(v, false, d)
16602 case *map[int8]int16:
16603 var v2 map[int8]int16
16604 v2, changed = fastpathTV.DecMapInt8Int16V(*v, true, d)
16608 case map[int8]int32:
16609 fastpathTV.DecMapInt8Int32V(v, false, d)
16610 case *map[int8]int32:
16611 var v2 map[int8]int32
16612 v2, changed = fastpathTV.DecMapInt8Int32V(*v, true, d)
16616 case map[int8]int64:
16617 fastpathTV.DecMapInt8Int64V(v, false, d)
16618 case *map[int8]int64:
16619 var v2 map[int8]int64
16620 v2, changed = fastpathTV.DecMapInt8Int64V(*v, true, d)
16624 case map[int8]float32:
16625 fastpathTV.DecMapInt8Float32V(v, false, d)
16626 case *map[int8]float32:
16627 var v2 map[int8]float32
16628 v2, changed = fastpathTV.DecMapInt8Float32V(*v, true, d)
16632 case map[int8]float64:
16633 fastpathTV.DecMapInt8Float64V(v, false, d)
16634 case *map[int8]float64:
16635 var v2 map[int8]float64
16636 v2, changed = fastpathTV.DecMapInt8Float64V(*v, true, d)
16640 case map[int8]bool:
16641 fastpathTV.DecMapInt8BoolV(v, false, d)
16642 case *map[int8]bool:
16643 var v2 map[int8]bool
16644 v2, changed = fastpathTV.DecMapInt8BoolV(*v, true, d)
16648 case map[int16]interface{}:
16649 fastpathTV.DecMapInt16IntfV(v, false, d)
16650 case *map[int16]interface{}:
16651 var v2 map[int16]interface{}
16652 v2, changed = fastpathTV.DecMapInt16IntfV(*v, true, d)
16656 case map[int16]string:
16657 fastpathTV.DecMapInt16StringV(v, false, d)
16658 case *map[int16]string:
16659 var v2 map[int16]string
16660 v2, changed = fastpathTV.DecMapInt16StringV(*v, true, d)
16664 case map[int16]uint:
16665 fastpathTV.DecMapInt16UintV(v, false, d)
16666 case *map[int16]uint:
16667 var v2 map[int16]uint
16668 v2, changed = fastpathTV.DecMapInt16UintV(*v, true, d)
16672 case map[int16]uint8:
16673 fastpathTV.DecMapInt16Uint8V(v, false, d)
16674 case *map[int16]uint8:
16675 var v2 map[int16]uint8
16676 v2, changed = fastpathTV.DecMapInt16Uint8V(*v, true, d)
16680 case map[int16]uint16:
16681 fastpathTV.DecMapInt16Uint16V(v, false, d)
16682 case *map[int16]uint16:
16683 var v2 map[int16]uint16
16684 v2, changed = fastpathTV.DecMapInt16Uint16V(*v, true, d)
16688 case map[int16]uint32:
16689 fastpathTV.DecMapInt16Uint32V(v, false, d)
16690 case *map[int16]uint32:
16691 var v2 map[int16]uint32
16692 v2, changed = fastpathTV.DecMapInt16Uint32V(*v, true, d)
16696 case map[int16]uint64:
16697 fastpathTV.DecMapInt16Uint64V(v, false, d)
16698 case *map[int16]uint64:
16699 var v2 map[int16]uint64
16700 v2, changed = fastpathTV.DecMapInt16Uint64V(*v, true, d)
16704 case map[int16]uintptr:
16705 fastpathTV.DecMapInt16UintptrV(v, false, d)
16706 case *map[int16]uintptr:
16707 var v2 map[int16]uintptr
16708 v2, changed = fastpathTV.DecMapInt16UintptrV(*v, true, d)
16712 case map[int16]int:
16713 fastpathTV.DecMapInt16IntV(v, false, d)
16714 case *map[int16]int:
16715 var v2 map[int16]int
16716 v2, changed = fastpathTV.DecMapInt16IntV(*v, true, d)
16720 case map[int16]int8:
16721 fastpathTV.DecMapInt16Int8V(v, false, d)
16722 case *map[int16]int8:
16723 var v2 map[int16]int8
16724 v2, changed = fastpathTV.DecMapInt16Int8V(*v, true, d)
16728 case map[int16]int16:
16729 fastpathTV.DecMapInt16Int16V(v, false, d)
16730 case *map[int16]int16:
16731 var v2 map[int16]int16
16732 v2, changed = fastpathTV.DecMapInt16Int16V(*v, true, d)
16736 case map[int16]int32:
16737 fastpathTV.DecMapInt16Int32V(v, false, d)
16738 case *map[int16]int32:
16739 var v2 map[int16]int32
16740 v2, changed = fastpathTV.DecMapInt16Int32V(*v, true, d)
16744 case map[int16]int64:
16745 fastpathTV.DecMapInt16Int64V(v, false, d)
16746 case *map[int16]int64:
16747 var v2 map[int16]int64
16748 v2, changed = fastpathTV.DecMapInt16Int64V(*v, true, d)
16752 case map[int16]float32:
16753 fastpathTV.DecMapInt16Float32V(v, false, d)
16754 case *map[int16]float32:
16755 var v2 map[int16]float32
16756 v2, changed = fastpathTV.DecMapInt16Float32V(*v, true, d)
16760 case map[int16]float64:
16761 fastpathTV.DecMapInt16Float64V(v, false, d)
16762 case *map[int16]float64:
16763 var v2 map[int16]float64
16764 v2, changed = fastpathTV.DecMapInt16Float64V(*v, true, d)
16768 case map[int16]bool:
16769 fastpathTV.DecMapInt16BoolV(v, false, d)
16770 case *map[int16]bool:
16771 var v2 map[int16]bool
16772 v2, changed = fastpathTV.DecMapInt16BoolV(*v, true, d)
16776 case map[int32]interface{}:
16777 fastpathTV.DecMapInt32IntfV(v, false, d)
16778 case *map[int32]interface{}:
16779 var v2 map[int32]interface{}
16780 v2, changed = fastpathTV.DecMapInt32IntfV(*v, true, d)
16784 case map[int32]string:
16785 fastpathTV.DecMapInt32StringV(v, false, d)
16786 case *map[int32]string:
16787 var v2 map[int32]string
16788 v2, changed = fastpathTV.DecMapInt32StringV(*v, true, d)
16792 case map[int32]uint:
16793 fastpathTV.DecMapInt32UintV(v, false, d)
16794 case *map[int32]uint:
16795 var v2 map[int32]uint
16796 v2, changed = fastpathTV.DecMapInt32UintV(*v, true, d)
16800 case map[int32]uint8:
16801 fastpathTV.DecMapInt32Uint8V(v, false, d)
16802 case *map[int32]uint8:
16803 var v2 map[int32]uint8
16804 v2, changed = fastpathTV.DecMapInt32Uint8V(*v, true, d)
16808 case map[int32]uint16:
16809 fastpathTV.DecMapInt32Uint16V(v, false, d)
16810 case *map[int32]uint16:
16811 var v2 map[int32]uint16
16812 v2, changed = fastpathTV.DecMapInt32Uint16V(*v, true, d)
16816 case map[int32]uint32:
16817 fastpathTV.DecMapInt32Uint32V(v, false, d)
16818 case *map[int32]uint32:
16819 var v2 map[int32]uint32
16820 v2, changed = fastpathTV.DecMapInt32Uint32V(*v, true, d)
16824 case map[int32]uint64:
16825 fastpathTV.DecMapInt32Uint64V(v, false, d)
16826 case *map[int32]uint64:
16827 var v2 map[int32]uint64
16828 v2, changed = fastpathTV.DecMapInt32Uint64V(*v, true, d)
16832 case map[int32]uintptr:
16833 fastpathTV.DecMapInt32UintptrV(v, false, d)
16834 case *map[int32]uintptr:
16835 var v2 map[int32]uintptr
16836 v2, changed = fastpathTV.DecMapInt32UintptrV(*v, true, d)
16840 case map[int32]int:
16841 fastpathTV.DecMapInt32IntV(v, false, d)
16842 case *map[int32]int:
16843 var v2 map[int32]int
16844 v2, changed = fastpathTV.DecMapInt32IntV(*v, true, d)
16848 case map[int32]int8:
16849 fastpathTV.DecMapInt32Int8V(v, false, d)
16850 case *map[int32]int8:
16851 var v2 map[int32]int8
16852 v2, changed = fastpathTV.DecMapInt32Int8V(*v, true, d)
16856 case map[int32]int16:
16857 fastpathTV.DecMapInt32Int16V(v, false, d)
16858 case *map[int32]int16:
16859 var v2 map[int32]int16
16860 v2, changed = fastpathTV.DecMapInt32Int16V(*v, true, d)
16864 case map[int32]int32:
16865 fastpathTV.DecMapInt32Int32V(v, false, d)
16866 case *map[int32]int32:
16867 var v2 map[int32]int32
16868 v2, changed = fastpathTV.DecMapInt32Int32V(*v, true, d)
16872 case map[int32]int64:
16873 fastpathTV.DecMapInt32Int64V(v, false, d)
16874 case *map[int32]int64:
16875 var v2 map[int32]int64
16876 v2, changed = fastpathTV.DecMapInt32Int64V(*v, true, d)
16880 case map[int32]float32:
16881 fastpathTV.DecMapInt32Float32V(v, false, d)
16882 case *map[int32]float32:
16883 var v2 map[int32]float32
16884 v2, changed = fastpathTV.DecMapInt32Float32V(*v, true, d)
16888 case map[int32]float64:
16889 fastpathTV.DecMapInt32Float64V(v, false, d)
16890 case *map[int32]float64:
16891 var v2 map[int32]float64
16892 v2, changed = fastpathTV.DecMapInt32Float64V(*v, true, d)
16896 case map[int32]bool:
16897 fastpathTV.DecMapInt32BoolV(v, false, d)
16898 case *map[int32]bool:
16899 var v2 map[int32]bool
16900 v2, changed = fastpathTV.DecMapInt32BoolV(*v, true, d)
16904 case map[int64]interface{}:
16905 fastpathTV.DecMapInt64IntfV(v, false, d)
16906 case *map[int64]interface{}:
16907 var v2 map[int64]interface{}
16908 v2, changed = fastpathTV.DecMapInt64IntfV(*v, true, d)
16912 case map[int64]string:
16913 fastpathTV.DecMapInt64StringV(v, false, d)
16914 case *map[int64]string:
16915 var v2 map[int64]string
16916 v2, changed = fastpathTV.DecMapInt64StringV(*v, true, d)
16920 case map[int64]uint:
16921 fastpathTV.DecMapInt64UintV(v, false, d)
16922 case *map[int64]uint:
16923 var v2 map[int64]uint
16924 v2, changed = fastpathTV.DecMapInt64UintV(*v, true, d)
16928 case map[int64]uint8:
16929 fastpathTV.DecMapInt64Uint8V(v, false, d)
16930 case *map[int64]uint8:
16931 var v2 map[int64]uint8
16932 v2, changed = fastpathTV.DecMapInt64Uint8V(*v, true, d)
16936 case map[int64]uint16:
16937 fastpathTV.DecMapInt64Uint16V(v, false, d)
16938 case *map[int64]uint16:
16939 var v2 map[int64]uint16
16940 v2, changed = fastpathTV.DecMapInt64Uint16V(*v, true, d)
16944 case map[int64]uint32:
16945 fastpathTV.DecMapInt64Uint32V(v, false, d)
16946 case *map[int64]uint32:
16947 var v2 map[int64]uint32
16948 v2, changed = fastpathTV.DecMapInt64Uint32V(*v, true, d)
16952 case map[int64]uint64:
16953 fastpathTV.DecMapInt64Uint64V(v, false, d)
16954 case *map[int64]uint64:
16955 var v2 map[int64]uint64
16956 v2, changed = fastpathTV.DecMapInt64Uint64V(*v, true, d)
16960 case map[int64]uintptr:
16961 fastpathTV.DecMapInt64UintptrV(v, false, d)
16962 case *map[int64]uintptr:
16963 var v2 map[int64]uintptr
16964 v2, changed = fastpathTV.DecMapInt64UintptrV(*v, true, d)
16968 case map[int64]int:
16969 fastpathTV.DecMapInt64IntV(v, false, d)
16970 case *map[int64]int:
16971 var v2 map[int64]int
16972 v2, changed = fastpathTV.DecMapInt64IntV(*v, true, d)
16976 case map[int64]int8:
16977 fastpathTV.DecMapInt64Int8V(v, false, d)
16978 case *map[int64]int8:
16979 var v2 map[int64]int8
16980 v2, changed = fastpathTV.DecMapInt64Int8V(*v, true, d)
16984 case map[int64]int16:
16985 fastpathTV.DecMapInt64Int16V(v, false, d)
16986 case *map[int64]int16:
16987 var v2 map[int64]int16
16988 v2, changed = fastpathTV.DecMapInt64Int16V(*v, true, d)
16992 case map[int64]int32:
16993 fastpathTV.DecMapInt64Int32V(v, false, d)
16994 case *map[int64]int32:
16995 var v2 map[int64]int32
16996 v2, changed = fastpathTV.DecMapInt64Int32V(*v, true, d)
17000 case map[int64]int64:
17001 fastpathTV.DecMapInt64Int64V(v, false, d)
17002 case *map[int64]int64:
17003 var v2 map[int64]int64
17004 v2, changed = fastpathTV.DecMapInt64Int64V(*v, true, d)
17008 case map[int64]float32:
17009 fastpathTV.DecMapInt64Float32V(v, false, d)
17010 case *map[int64]float32:
17011 var v2 map[int64]float32
17012 v2, changed = fastpathTV.DecMapInt64Float32V(*v, true, d)
17016 case map[int64]float64:
17017 fastpathTV.DecMapInt64Float64V(v, false, d)
17018 case *map[int64]float64:
17019 var v2 map[int64]float64
17020 v2, changed = fastpathTV.DecMapInt64Float64V(*v, true, d)
17024 case map[int64]bool:
17025 fastpathTV.DecMapInt64BoolV(v, false, d)
17026 case *map[int64]bool:
17027 var v2 map[int64]bool
17028 v2, changed = fastpathTV.DecMapInt64BoolV(*v, true, d)
17032 case map[bool]interface{}:
17033 fastpathTV.DecMapBoolIntfV(v, false, d)
17034 case *map[bool]interface{}:
17035 var v2 map[bool]interface{}
17036 v2, changed = fastpathTV.DecMapBoolIntfV(*v, true, d)
17040 case map[bool]string:
17041 fastpathTV.DecMapBoolStringV(v, false, d)
17042 case *map[bool]string:
17043 var v2 map[bool]string
17044 v2, changed = fastpathTV.DecMapBoolStringV(*v, true, d)
17048 case map[bool]uint:
17049 fastpathTV.DecMapBoolUintV(v, false, d)
17050 case *map[bool]uint:
17051 var v2 map[bool]uint
17052 v2, changed = fastpathTV.DecMapBoolUintV(*v, true, d)
17056 case map[bool]uint8:
17057 fastpathTV.DecMapBoolUint8V(v, false, d)
17058 case *map[bool]uint8:
17059 var v2 map[bool]uint8
17060 v2, changed = fastpathTV.DecMapBoolUint8V(*v, true, d)
17064 case map[bool]uint16:
17065 fastpathTV.DecMapBoolUint16V(v, false, d)
17066 case *map[bool]uint16:
17067 var v2 map[bool]uint16
17068 v2, changed = fastpathTV.DecMapBoolUint16V(*v, true, d)
17072 case map[bool]uint32:
17073 fastpathTV.DecMapBoolUint32V(v, false, d)
17074 case *map[bool]uint32:
17075 var v2 map[bool]uint32
17076 v2, changed = fastpathTV.DecMapBoolUint32V(*v, true, d)
17080 case map[bool]uint64:
17081 fastpathTV.DecMapBoolUint64V(v, false, d)
17082 case *map[bool]uint64:
17083 var v2 map[bool]uint64
17084 v2, changed = fastpathTV.DecMapBoolUint64V(*v, true, d)
17088 case map[bool]uintptr:
17089 fastpathTV.DecMapBoolUintptrV(v, false, d)
17090 case *map[bool]uintptr:
17091 var v2 map[bool]uintptr
17092 v2, changed = fastpathTV.DecMapBoolUintptrV(*v, true, d)
17097 fastpathTV.DecMapBoolIntV(v, false, d)
17098 case *map[bool]int:
17099 var v2 map[bool]int
17100 v2, changed = fastpathTV.DecMapBoolIntV(*v, true, d)
17104 case map[bool]int8:
17105 fastpathTV.DecMapBoolInt8V(v, false, d)
17106 case *map[bool]int8:
17107 var v2 map[bool]int8
17108 v2, changed = fastpathTV.DecMapBoolInt8V(*v, true, d)
17112 case map[bool]int16:
17113 fastpathTV.DecMapBoolInt16V(v, false, d)
17114 case *map[bool]int16:
17115 var v2 map[bool]int16
17116 v2, changed = fastpathTV.DecMapBoolInt16V(*v, true, d)
17120 case map[bool]int32:
17121 fastpathTV.DecMapBoolInt32V(v, false, d)
17122 case *map[bool]int32:
17123 var v2 map[bool]int32
17124 v2, changed = fastpathTV.DecMapBoolInt32V(*v, true, d)
17128 case map[bool]int64:
17129 fastpathTV.DecMapBoolInt64V(v, false, d)
17130 case *map[bool]int64:
17131 var v2 map[bool]int64
17132 v2, changed = fastpathTV.DecMapBoolInt64V(*v, true, d)
17136 case map[bool]float32:
17137 fastpathTV.DecMapBoolFloat32V(v, false, d)
17138 case *map[bool]float32:
17139 var v2 map[bool]float32
17140 v2, changed = fastpathTV.DecMapBoolFloat32V(*v, true, d)
17144 case map[bool]float64:
17145 fastpathTV.DecMapBoolFloat64V(v, false, d)
17146 case *map[bool]float64:
17147 var v2 map[bool]float64
17148 v2, changed = fastpathTV.DecMapBoolFloat64V(*v, true, d)
17152 case map[bool]bool:
17153 fastpathTV.DecMapBoolBoolV(v, false, d)
17154 case *map[bool]bool:
17155 var v2 map[bool]bool
17156 v2, changed = fastpathTV.DecMapBoolBoolV(*v, true, d)
17161 _ = v // workaround https://github.com/golang/go/issues/12927 seen in go1.4
17167 func fastpathDecodeSetZeroTypeSwitch(iv interface{}) bool {
17168 switch v := iv.(type) {
17170 case *[]interface{}:
17203 case *map[interface{}]interface{}:
17205 case *map[interface{}]string:
17207 case *map[interface{}]uint:
17209 case *map[interface{}]uint8:
17211 case *map[interface{}]uint16:
17213 case *map[interface{}]uint32:
17215 case *map[interface{}]uint64:
17217 case *map[interface{}]uintptr:
17219 case *map[interface{}]int:
17221 case *map[interface{}]int8:
17223 case *map[interface{}]int16:
17225 case *map[interface{}]int32:
17227 case *map[interface{}]int64:
17229 case *map[interface{}]float32:
17231 case *map[interface{}]float64:
17233 case *map[interface{}]bool:
17235 case *map[string]interface{}:
17237 case *map[string]string:
17239 case *map[string]uint:
17241 case *map[string]uint8:
17243 case *map[string]uint16:
17245 case *map[string]uint32:
17247 case *map[string]uint64:
17249 case *map[string]uintptr:
17251 case *map[string]int:
17253 case *map[string]int8:
17255 case *map[string]int16:
17257 case *map[string]int32:
17259 case *map[string]int64:
17261 case *map[string]float32:
17263 case *map[string]float64:
17265 case *map[string]bool:
17267 case *map[float32]interface{}:
17269 case *map[float32]string:
17271 case *map[float32]uint:
17273 case *map[float32]uint8:
17275 case *map[float32]uint16:
17277 case *map[float32]uint32:
17279 case *map[float32]uint64:
17281 case *map[float32]uintptr:
17283 case *map[float32]int:
17285 case *map[float32]int8:
17287 case *map[float32]int16:
17289 case *map[float32]int32:
17291 case *map[float32]int64:
17293 case *map[float32]float32:
17295 case *map[float32]float64:
17297 case *map[float32]bool:
17299 case *map[float64]interface{}:
17301 case *map[float64]string:
17303 case *map[float64]uint:
17305 case *map[float64]uint8:
17307 case *map[float64]uint16:
17309 case *map[float64]uint32:
17311 case *map[float64]uint64:
17313 case *map[float64]uintptr:
17315 case *map[float64]int:
17317 case *map[float64]int8:
17319 case *map[float64]int16:
17321 case *map[float64]int32:
17323 case *map[float64]int64:
17325 case *map[float64]float32:
17327 case *map[float64]float64:
17329 case *map[float64]bool:
17331 case *map[uint]interface{}:
17333 case *map[uint]string:
17335 case *map[uint]uint:
17337 case *map[uint]uint8:
17339 case *map[uint]uint16:
17341 case *map[uint]uint32:
17343 case *map[uint]uint64:
17345 case *map[uint]uintptr:
17347 case *map[uint]int:
17349 case *map[uint]int8:
17351 case *map[uint]int16:
17353 case *map[uint]int32:
17355 case *map[uint]int64:
17357 case *map[uint]float32:
17359 case *map[uint]float64:
17361 case *map[uint]bool:
17363 case *map[uint8]interface{}:
17365 case *map[uint8]string:
17367 case *map[uint8]uint:
17369 case *map[uint8]uint8:
17371 case *map[uint8]uint16:
17373 case *map[uint8]uint32:
17375 case *map[uint8]uint64:
17377 case *map[uint8]uintptr:
17379 case *map[uint8]int:
17381 case *map[uint8]int8:
17383 case *map[uint8]int16:
17385 case *map[uint8]int32:
17387 case *map[uint8]int64:
17389 case *map[uint8]float32:
17391 case *map[uint8]float64:
17393 case *map[uint8]bool:
17395 case *map[uint16]interface{}:
17397 case *map[uint16]string:
17399 case *map[uint16]uint:
17401 case *map[uint16]uint8:
17403 case *map[uint16]uint16:
17405 case *map[uint16]uint32:
17407 case *map[uint16]uint64:
17409 case *map[uint16]uintptr:
17411 case *map[uint16]int:
17413 case *map[uint16]int8:
17415 case *map[uint16]int16:
17417 case *map[uint16]int32:
17419 case *map[uint16]int64:
17421 case *map[uint16]float32:
17423 case *map[uint16]float64:
17425 case *map[uint16]bool:
17427 case *map[uint32]interface{}:
17429 case *map[uint32]string:
17431 case *map[uint32]uint:
17433 case *map[uint32]uint8:
17435 case *map[uint32]uint16:
17437 case *map[uint32]uint32:
17439 case *map[uint32]uint64:
17441 case *map[uint32]uintptr:
17443 case *map[uint32]int:
17445 case *map[uint32]int8:
17447 case *map[uint32]int16:
17449 case *map[uint32]int32:
17451 case *map[uint32]int64:
17453 case *map[uint32]float32:
17455 case *map[uint32]float64:
17457 case *map[uint32]bool:
17459 case *map[uint64]interface{}:
17461 case *map[uint64]string:
17463 case *map[uint64]uint:
17465 case *map[uint64]uint8:
17467 case *map[uint64]uint16:
17469 case *map[uint64]uint32:
17471 case *map[uint64]uint64:
17473 case *map[uint64]uintptr:
17475 case *map[uint64]int:
17477 case *map[uint64]int8:
17479 case *map[uint64]int16:
17481 case *map[uint64]int32:
17483 case *map[uint64]int64:
17485 case *map[uint64]float32:
17487 case *map[uint64]float64:
17489 case *map[uint64]bool:
17491 case *map[uintptr]interface{}:
17493 case *map[uintptr]string:
17495 case *map[uintptr]uint:
17497 case *map[uintptr]uint8:
17499 case *map[uintptr]uint16:
17501 case *map[uintptr]uint32:
17503 case *map[uintptr]uint64:
17505 case *map[uintptr]uintptr:
17507 case *map[uintptr]int:
17509 case *map[uintptr]int8:
17511 case *map[uintptr]int16:
17513 case *map[uintptr]int32:
17515 case *map[uintptr]int64:
17517 case *map[uintptr]float32:
17519 case *map[uintptr]float64:
17521 case *map[uintptr]bool:
17523 case *map[int]interface{}:
17525 case *map[int]string:
17527 case *map[int]uint:
17529 case *map[int]uint8:
17531 case *map[int]uint16:
17533 case *map[int]uint32:
17535 case *map[int]uint64:
17537 case *map[int]uintptr:
17541 case *map[int]int8:
17543 case *map[int]int16:
17545 case *map[int]int32:
17547 case *map[int]int64:
17549 case *map[int]float32:
17551 case *map[int]float64:
17553 case *map[int]bool:
17555 case *map[int8]interface{}:
17557 case *map[int8]string:
17559 case *map[int8]uint:
17561 case *map[int8]uint8:
17563 case *map[int8]uint16:
17565 case *map[int8]uint32:
17567 case *map[int8]uint64:
17569 case *map[int8]uintptr:
17571 case *map[int8]int:
17573 case *map[int8]int8:
17575 case *map[int8]int16:
17577 case *map[int8]int32:
17579 case *map[int8]int64:
17581 case *map[int8]float32:
17583 case *map[int8]float64:
17585 case *map[int8]bool:
17587 case *map[int16]interface{}:
17589 case *map[int16]string:
17591 case *map[int16]uint:
17593 case *map[int16]uint8:
17595 case *map[int16]uint16:
17597 case *map[int16]uint32:
17599 case *map[int16]uint64:
17601 case *map[int16]uintptr:
17603 case *map[int16]int:
17605 case *map[int16]int8:
17607 case *map[int16]int16:
17609 case *map[int16]int32:
17611 case *map[int16]int64:
17613 case *map[int16]float32:
17615 case *map[int16]float64:
17617 case *map[int16]bool:
17619 case *map[int32]interface{}:
17621 case *map[int32]string:
17623 case *map[int32]uint:
17625 case *map[int32]uint8:
17627 case *map[int32]uint16:
17629 case *map[int32]uint32:
17631 case *map[int32]uint64:
17633 case *map[int32]uintptr:
17635 case *map[int32]int:
17637 case *map[int32]int8:
17639 case *map[int32]int16:
17641 case *map[int32]int32:
17643 case *map[int32]int64:
17645 case *map[int32]float32:
17647 case *map[int32]float64:
17649 case *map[int32]bool:
17651 case *map[int64]interface{}:
17653 case *map[int64]string:
17655 case *map[int64]uint:
17657 case *map[int64]uint8:
17659 case *map[int64]uint16:
17661 case *map[int64]uint32:
17663 case *map[int64]uint64:
17665 case *map[int64]uintptr:
17667 case *map[int64]int:
17669 case *map[int64]int8:
17671 case *map[int64]int16:
17673 case *map[int64]int32:
17675 case *map[int64]int64:
17677 case *map[int64]float32:
17679 case *map[int64]float64:
17681 case *map[int64]bool:
17683 case *map[bool]interface{}:
17685 case *map[bool]string:
17687 case *map[bool]uint:
17689 case *map[bool]uint8:
17691 case *map[bool]uint16:
17693 case *map[bool]uint32:
17695 case *map[bool]uint64:
17697 case *map[bool]uintptr:
17699 case *map[bool]int:
17701 case *map[bool]int8:
17703 case *map[bool]int16:
17705 case *map[bool]int32:
17707 case *map[bool]int64:
17709 case *map[bool]float32:
17711 case *map[bool]float64:
17713 case *map[bool]bool:
17716 _ = v // workaround https://github.com/golang/go/issues/12927 seen in go1.4
17722 // -- -- fast path functions
17724 func (d *Decoder) fastpathDecSliceIntfR(f *codecFnInfo, rv reflect.Value) {
17725 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
17726 vp := rv2i(rv).(*[]interface{})
17727 v, changed := fastpathTV.DecSliceIntfV(*vp, !array, d)
17732 v := rv2i(rv).([]interface{})
17733 v2, changed := fastpathTV.DecSliceIntfV(v, !array, d)
17734 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
17739 func (f fastpathT) DecSliceIntfX(vp *[]interface{}, d *Decoder) {
17740 v, changed := f.DecSliceIntfV(*vp, true, d)
17745 func (_ fastpathT) DecSliceIntfV(v []interface{}, canChange bool, d *Decoder) (_ []interface{}, changed bool) {
17747 slh, containerLenS := d.decSliceHelperStart()
17748 if containerLenS == 0 {
17751 v = []interface{}{}
17752 } else if len(v) != 0 {
17761 hasLen := containerLenS > 0
17763 if hasLen && canChange {
17764 if containerLenS > cap(v) {
17765 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
17766 if xlen <= cap(v) {
17769 v = make([]interface{}, xlen)
17772 } else if containerLenS != len(v) {
17773 v = v[:containerLenS]
17778 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
17779 if j == 0 && len(v) == 0 && canChange {
17781 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
17785 v = make([]interface{}, xlen)
17788 // if indefinite, etc, then expand the slice if necessary
17789 var decodeIntoBlank bool
17795 d.arrayCannotExpand(len(v), j+1)
17796 decodeIntoBlank = true
17799 slh.ElemContainerState(j)
17800 if decodeIntoBlank {
17802 } else if dd.TryDecodeAsNil() {
17812 } else if j == 0 && v == nil {
17813 v = make([]interface{}, 0)
17822 func (d *Decoder) fastpathDecSliceStringR(f *codecFnInfo, rv reflect.Value) {
17823 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
17824 vp := rv2i(rv).(*[]string)
17825 v, changed := fastpathTV.DecSliceStringV(*vp, !array, d)
17830 v := rv2i(rv).([]string)
17831 v2, changed := fastpathTV.DecSliceStringV(v, !array, d)
17832 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
17837 func (f fastpathT) DecSliceStringX(vp *[]string, d *Decoder) {
17838 v, changed := f.DecSliceStringV(*vp, true, d)
17843 func (_ fastpathT) DecSliceStringV(v []string, canChange bool, d *Decoder) (_ []string, changed bool) {
17845 slh, containerLenS := d.decSliceHelperStart()
17846 if containerLenS == 0 {
17850 } else if len(v) != 0 {
17859 hasLen := containerLenS > 0
17861 if hasLen && canChange {
17862 if containerLenS > cap(v) {
17863 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
17864 if xlen <= cap(v) {
17867 v = make([]string, xlen)
17870 } else if containerLenS != len(v) {
17871 v = v[:containerLenS]
17876 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
17877 if j == 0 && len(v) == 0 && canChange {
17879 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
17883 v = make([]string, xlen)
17886 // if indefinite, etc, then expand the slice if necessary
17887 var decodeIntoBlank bool
17893 d.arrayCannotExpand(len(v), j+1)
17894 decodeIntoBlank = true
17897 slh.ElemContainerState(j)
17898 if decodeIntoBlank {
17900 } else if dd.TryDecodeAsNil() {
17903 v[j] = dd.DecodeString()
17910 } else if j == 0 && v == nil {
17911 v = make([]string, 0)
17920 func (d *Decoder) fastpathDecSliceFloat32R(f *codecFnInfo, rv reflect.Value) {
17921 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
17922 vp := rv2i(rv).(*[]float32)
17923 v, changed := fastpathTV.DecSliceFloat32V(*vp, !array, d)
17928 v := rv2i(rv).([]float32)
17929 v2, changed := fastpathTV.DecSliceFloat32V(v, !array, d)
17930 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
17935 func (f fastpathT) DecSliceFloat32X(vp *[]float32, d *Decoder) {
17936 v, changed := f.DecSliceFloat32V(*vp, true, d)
17941 func (_ fastpathT) DecSliceFloat32V(v []float32, canChange bool, d *Decoder) (_ []float32, changed bool) {
17943 slh, containerLenS := d.decSliceHelperStart()
17944 if containerLenS == 0 {
17948 } else if len(v) != 0 {
17957 hasLen := containerLenS > 0
17959 if hasLen && canChange {
17960 if containerLenS > cap(v) {
17961 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
17962 if xlen <= cap(v) {
17965 v = make([]float32, xlen)
17968 } else if containerLenS != len(v) {
17969 v = v[:containerLenS]
17974 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
17975 if j == 0 && len(v) == 0 && canChange {
17977 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
17981 v = make([]float32, xlen)
17984 // if indefinite, etc, then expand the slice if necessary
17985 var decodeIntoBlank bool
17991 d.arrayCannotExpand(len(v), j+1)
17992 decodeIntoBlank = true
17995 slh.ElemContainerState(j)
17996 if decodeIntoBlank {
17998 } else if dd.TryDecodeAsNil() {
18001 v[j] = float32(chkOvf.Float32V(dd.DecodeFloat64()))
18008 } else if j == 0 && v == nil {
18009 v = make([]float32, 0)
18018 func (d *Decoder) fastpathDecSliceFloat64R(f *codecFnInfo, rv reflect.Value) {
18019 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18020 vp := rv2i(rv).(*[]float64)
18021 v, changed := fastpathTV.DecSliceFloat64V(*vp, !array, d)
18026 v := rv2i(rv).([]float64)
18027 v2, changed := fastpathTV.DecSliceFloat64V(v, !array, d)
18028 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18033 func (f fastpathT) DecSliceFloat64X(vp *[]float64, d *Decoder) {
18034 v, changed := f.DecSliceFloat64V(*vp, true, d)
18039 func (_ fastpathT) DecSliceFloat64V(v []float64, canChange bool, d *Decoder) (_ []float64, changed bool) {
18041 slh, containerLenS := d.decSliceHelperStart()
18042 if containerLenS == 0 {
18046 } else if len(v) != 0 {
18055 hasLen := containerLenS > 0
18057 if hasLen && canChange {
18058 if containerLenS > cap(v) {
18059 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18060 if xlen <= cap(v) {
18063 v = make([]float64, xlen)
18066 } else if containerLenS != len(v) {
18067 v = v[:containerLenS]
18072 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18073 if j == 0 && len(v) == 0 && canChange {
18075 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18079 v = make([]float64, xlen)
18082 // if indefinite, etc, then expand the slice if necessary
18083 var decodeIntoBlank bool
18089 d.arrayCannotExpand(len(v), j+1)
18090 decodeIntoBlank = true
18093 slh.ElemContainerState(j)
18094 if decodeIntoBlank {
18096 } else if dd.TryDecodeAsNil() {
18099 v[j] = dd.DecodeFloat64()
18106 } else if j == 0 && v == nil {
18107 v = make([]float64, 0)
18116 func (d *Decoder) fastpathDecSliceUintR(f *codecFnInfo, rv reflect.Value) {
18117 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18118 vp := rv2i(rv).(*[]uint)
18119 v, changed := fastpathTV.DecSliceUintV(*vp, !array, d)
18124 v := rv2i(rv).([]uint)
18125 v2, changed := fastpathTV.DecSliceUintV(v, !array, d)
18126 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18131 func (f fastpathT) DecSliceUintX(vp *[]uint, d *Decoder) {
18132 v, changed := f.DecSliceUintV(*vp, true, d)
18137 func (_ fastpathT) DecSliceUintV(v []uint, canChange bool, d *Decoder) (_ []uint, changed bool) {
18139 slh, containerLenS := d.decSliceHelperStart()
18140 if containerLenS == 0 {
18144 } else if len(v) != 0 {
18153 hasLen := containerLenS > 0
18155 if hasLen && canChange {
18156 if containerLenS > cap(v) {
18157 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18158 if xlen <= cap(v) {
18161 v = make([]uint, xlen)
18164 } else if containerLenS != len(v) {
18165 v = v[:containerLenS]
18170 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18171 if j == 0 && len(v) == 0 && canChange {
18173 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18177 v = make([]uint, xlen)
18180 // if indefinite, etc, then expand the slice if necessary
18181 var decodeIntoBlank bool
18187 d.arrayCannotExpand(len(v), j+1)
18188 decodeIntoBlank = true
18191 slh.ElemContainerState(j)
18192 if decodeIntoBlank {
18194 } else if dd.TryDecodeAsNil() {
18197 v[j] = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
18204 } else if j == 0 && v == nil {
18205 v = make([]uint, 0)
18214 func (d *Decoder) fastpathDecSliceUint8R(f *codecFnInfo, rv reflect.Value) {
18215 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18216 vp := rv2i(rv).(*[]uint8)
18217 v, changed := fastpathTV.DecSliceUint8V(*vp, !array, d)
18222 v := rv2i(rv).([]uint8)
18223 v2, changed := fastpathTV.DecSliceUint8V(v, !array, d)
18224 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18229 func (f fastpathT) DecSliceUint8X(vp *[]uint8, d *Decoder) {
18230 v, changed := f.DecSliceUint8V(*vp, true, d)
18235 func (_ fastpathT) DecSliceUint8V(v []uint8, canChange bool, d *Decoder) (_ []uint8, changed bool) {
18237 slh, containerLenS := d.decSliceHelperStart()
18238 if containerLenS == 0 {
18242 } else if len(v) != 0 {
18251 hasLen := containerLenS > 0
18253 if hasLen && canChange {
18254 if containerLenS > cap(v) {
18255 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
18256 if xlen <= cap(v) {
18259 v = make([]uint8, xlen)
18262 } else if containerLenS != len(v) {
18263 v = v[:containerLenS]
18268 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18269 if j == 0 && len(v) == 0 && canChange {
18271 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
18275 v = make([]uint8, xlen)
18278 // if indefinite, etc, then expand the slice if necessary
18279 var decodeIntoBlank bool
18285 d.arrayCannotExpand(len(v), j+1)
18286 decodeIntoBlank = true
18289 slh.ElemContainerState(j)
18290 if decodeIntoBlank {
18292 } else if dd.TryDecodeAsNil() {
18295 v[j] = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
18302 } else if j == 0 && v == nil {
18303 v = make([]uint8, 0)
18312 func (d *Decoder) fastpathDecSliceUint16R(f *codecFnInfo, rv reflect.Value) {
18313 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18314 vp := rv2i(rv).(*[]uint16)
18315 v, changed := fastpathTV.DecSliceUint16V(*vp, !array, d)
18320 v := rv2i(rv).([]uint16)
18321 v2, changed := fastpathTV.DecSliceUint16V(v, !array, d)
18322 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18327 func (f fastpathT) DecSliceUint16X(vp *[]uint16, d *Decoder) {
18328 v, changed := f.DecSliceUint16V(*vp, true, d)
18333 func (_ fastpathT) DecSliceUint16V(v []uint16, canChange bool, d *Decoder) (_ []uint16, changed bool) {
18335 slh, containerLenS := d.decSliceHelperStart()
18336 if containerLenS == 0 {
18340 } else if len(v) != 0 {
18349 hasLen := containerLenS > 0
18351 if hasLen && canChange {
18352 if containerLenS > cap(v) {
18353 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 2)
18354 if xlen <= cap(v) {
18357 v = make([]uint16, xlen)
18360 } else if containerLenS != len(v) {
18361 v = v[:containerLenS]
18366 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18367 if j == 0 && len(v) == 0 && canChange {
18369 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 2)
18373 v = make([]uint16, xlen)
18376 // if indefinite, etc, then expand the slice if necessary
18377 var decodeIntoBlank bool
18383 d.arrayCannotExpand(len(v), j+1)
18384 decodeIntoBlank = true
18387 slh.ElemContainerState(j)
18388 if decodeIntoBlank {
18390 } else if dd.TryDecodeAsNil() {
18393 v[j] = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
18400 } else if j == 0 && v == nil {
18401 v = make([]uint16, 0)
18410 func (d *Decoder) fastpathDecSliceUint32R(f *codecFnInfo, rv reflect.Value) {
18411 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18412 vp := rv2i(rv).(*[]uint32)
18413 v, changed := fastpathTV.DecSliceUint32V(*vp, !array, d)
18418 v := rv2i(rv).([]uint32)
18419 v2, changed := fastpathTV.DecSliceUint32V(v, !array, d)
18420 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18425 func (f fastpathT) DecSliceUint32X(vp *[]uint32, d *Decoder) {
18426 v, changed := f.DecSliceUint32V(*vp, true, d)
18431 func (_ fastpathT) DecSliceUint32V(v []uint32, canChange bool, d *Decoder) (_ []uint32, changed bool) {
18433 slh, containerLenS := d.decSliceHelperStart()
18434 if containerLenS == 0 {
18438 } else if len(v) != 0 {
18447 hasLen := containerLenS > 0
18449 if hasLen && canChange {
18450 if containerLenS > cap(v) {
18451 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
18452 if xlen <= cap(v) {
18455 v = make([]uint32, xlen)
18458 } else if containerLenS != len(v) {
18459 v = v[:containerLenS]
18464 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18465 if j == 0 && len(v) == 0 && canChange {
18467 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
18471 v = make([]uint32, xlen)
18474 // if indefinite, etc, then expand the slice if necessary
18475 var decodeIntoBlank bool
18481 d.arrayCannotExpand(len(v), j+1)
18482 decodeIntoBlank = true
18485 slh.ElemContainerState(j)
18486 if decodeIntoBlank {
18488 } else if dd.TryDecodeAsNil() {
18491 v[j] = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
18498 } else if j == 0 && v == nil {
18499 v = make([]uint32, 0)
18508 func (d *Decoder) fastpathDecSliceUint64R(f *codecFnInfo, rv reflect.Value) {
18509 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18510 vp := rv2i(rv).(*[]uint64)
18511 v, changed := fastpathTV.DecSliceUint64V(*vp, !array, d)
18516 v := rv2i(rv).([]uint64)
18517 v2, changed := fastpathTV.DecSliceUint64V(v, !array, d)
18518 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18523 func (f fastpathT) DecSliceUint64X(vp *[]uint64, d *Decoder) {
18524 v, changed := f.DecSliceUint64V(*vp, true, d)
18529 func (_ fastpathT) DecSliceUint64V(v []uint64, canChange bool, d *Decoder) (_ []uint64, changed bool) {
18531 slh, containerLenS := d.decSliceHelperStart()
18532 if containerLenS == 0 {
18536 } else if len(v) != 0 {
18545 hasLen := containerLenS > 0
18547 if hasLen && canChange {
18548 if containerLenS > cap(v) {
18549 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18550 if xlen <= cap(v) {
18553 v = make([]uint64, xlen)
18556 } else if containerLenS != len(v) {
18557 v = v[:containerLenS]
18562 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18563 if j == 0 && len(v) == 0 && canChange {
18565 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18569 v = make([]uint64, xlen)
18572 // if indefinite, etc, then expand the slice if necessary
18573 var decodeIntoBlank bool
18579 d.arrayCannotExpand(len(v), j+1)
18580 decodeIntoBlank = true
18583 slh.ElemContainerState(j)
18584 if decodeIntoBlank {
18586 } else if dd.TryDecodeAsNil() {
18589 v[j] = dd.DecodeUint64()
18596 } else if j == 0 && v == nil {
18597 v = make([]uint64, 0)
18606 func (d *Decoder) fastpathDecSliceUintptrR(f *codecFnInfo, rv reflect.Value) {
18607 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18608 vp := rv2i(rv).(*[]uintptr)
18609 v, changed := fastpathTV.DecSliceUintptrV(*vp, !array, d)
18614 v := rv2i(rv).([]uintptr)
18615 v2, changed := fastpathTV.DecSliceUintptrV(v, !array, d)
18616 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18621 func (f fastpathT) DecSliceUintptrX(vp *[]uintptr, d *Decoder) {
18622 v, changed := f.DecSliceUintptrV(*vp, true, d)
18627 func (_ fastpathT) DecSliceUintptrV(v []uintptr, canChange bool, d *Decoder) (_ []uintptr, changed bool) {
18629 slh, containerLenS := d.decSliceHelperStart()
18630 if containerLenS == 0 {
18634 } else if len(v) != 0 {
18643 hasLen := containerLenS > 0
18645 if hasLen && canChange {
18646 if containerLenS > cap(v) {
18647 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18648 if xlen <= cap(v) {
18651 v = make([]uintptr, xlen)
18654 } else if containerLenS != len(v) {
18655 v = v[:containerLenS]
18660 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18661 if j == 0 && len(v) == 0 && canChange {
18663 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18667 v = make([]uintptr, xlen)
18670 // if indefinite, etc, then expand the slice if necessary
18671 var decodeIntoBlank bool
18677 d.arrayCannotExpand(len(v), j+1)
18678 decodeIntoBlank = true
18681 slh.ElemContainerState(j)
18682 if decodeIntoBlank {
18684 } else if dd.TryDecodeAsNil() {
18687 v[j] = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
18694 } else if j == 0 && v == nil {
18695 v = make([]uintptr, 0)
18704 func (d *Decoder) fastpathDecSliceIntR(f *codecFnInfo, rv reflect.Value) {
18705 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18706 vp := rv2i(rv).(*[]int)
18707 v, changed := fastpathTV.DecSliceIntV(*vp, !array, d)
18712 v := rv2i(rv).([]int)
18713 v2, changed := fastpathTV.DecSliceIntV(v, !array, d)
18714 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18719 func (f fastpathT) DecSliceIntX(vp *[]int, d *Decoder) {
18720 v, changed := f.DecSliceIntV(*vp, true, d)
18725 func (_ fastpathT) DecSliceIntV(v []int, canChange bool, d *Decoder) (_ []int, changed bool) {
18727 slh, containerLenS := d.decSliceHelperStart()
18728 if containerLenS == 0 {
18732 } else if len(v) != 0 {
18741 hasLen := containerLenS > 0
18743 if hasLen && canChange {
18744 if containerLenS > cap(v) {
18745 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18746 if xlen <= cap(v) {
18749 v = make([]int, xlen)
18752 } else if containerLenS != len(v) {
18753 v = v[:containerLenS]
18758 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18759 if j == 0 && len(v) == 0 && canChange {
18761 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18765 v = make([]int, xlen)
18768 // if indefinite, etc, then expand the slice if necessary
18769 var decodeIntoBlank bool
18775 d.arrayCannotExpand(len(v), j+1)
18776 decodeIntoBlank = true
18779 slh.ElemContainerState(j)
18780 if decodeIntoBlank {
18782 } else if dd.TryDecodeAsNil() {
18785 v[j] = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
18792 } else if j == 0 && v == nil {
18802 func (d *Decoder) fastpathDecSliceInt8R(f *codecFnInfo, rv reflect.Value) {
18803 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18804 vp := rv2i(rv).(*[]int8)
18805 v, changed := fastpathTV.DecSliceInt8V(*vp, !array, d)
18810 v := rv2i(rv).([]int8)
18811 v2, changed := fastpathTV.DecSliceInt8V(v, !array, d)
18812 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18817 func (f fastpathT) DecSliceInt8X(vp *[]int8, d *Decoder) {
18818 v, changed := f.DecSliceInt8V(*vp, true, d)
18823 func (_ fastpathT) DecSliceInt8V(v []int8, canChange bool, d *Decoder) (_ []int8, changed bool) {
18825 slh, containerLenS := d.decSliceHelperStart()
18826 if containerLenS == 0 {
18830 } else if len(v) != 0 {
18839 hasLen := containerLenS > 0
18841 if hasLen && canChange {
18842 if containerLenS > cap(v) {
18843 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
18844 if xlen <= cap(v) {
18847 v = make([]int8, xlen)
18850 } else if containerLenS != len(v) {
18851 v = v[:containerLenS]
18856 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18857 if j == 0 && len(v) == 0 && canChange {
18859 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
18863 v = make([]int8, xlen)
18866 // if indefinite, etc, then expand the slice if necessary
18867 var decodeIntoBlank bool
18873 d.arrayCannotExpand(len(v), j+1)
18874 decodeIntoBlank = true
18877 slh.ElemContainerState(j)
18878 if decodeIntoBlank {
18880 } else if dd.TryDecodeAsNil() {
18883 v[j] = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
18890 } else if j == 0 && v == nil {
18891 v = make([]int8, 0)
18900 func (d *Decoder) fastpathDecSliceInt16R(f *codecFnInfo, rv reflect.Value) {
18901 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18902 vp := rv2i(rv).(*[]int16)
18903 v, changed := fastpathTV.DecSliceInt16V(*vp, !array, d)
18908 v := rv2i(rv).([]int16)
18909 v2, changed := fastpathTV.DecSliceInt16V(v, !array, d)
18910 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18915 func (f fastpathT) DecSliceInt16X(vp *[]int16, d *Decoder) {
18916 v, changed := f.DecSliceInt16V(*vp, true, d)
18921 func (_ fastpathT) DecSliceInt16V(v []int16, canChange bool, d *Decoder) (_ []int16, changed bool) {
18923 slh, containerLenS := d.decSliceHelperStart()
18924 if containerLenS == 0 {
18928 } else if len(v) != 0 {
18937 hasLen := containerLenS > 0
18939 if hasLen && canChange {
18940 if containerLenS > cap(v) {
18941 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 2)
18942 if xlen <= cap(v) {
18945 v = make([]int16, xlen)
18948 } else if containerLenS != len(v) {
18949 v = v[:containerLenS]
18954 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18955 if j == 0 && len(v) == 0 && canChange {
18957 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 2)
18961 v = make([]int16, xlen)
18964 // if indefinite, etc, then expand the slice if necessary
18965 var decodeIntoBlank bool
18971 d.arrayCannotExpand(len(v), j+1)
18972 decodeIntoBlank = true
18975 slh.ElemContainerState(j)
18976 if decodeIntoBlank {
18978 } else if dd.TryDecodeAsNil() {
18981 v[j] = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
18988 } else if j == 0 && v == nil {
18989 v = make([]int16, 0)
18998 func (d *Decoder) fastpathDecSliceInt32R(f *codecFnInfo, rv reflect.Value) {
18999 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
19000 vp := rv2i(rv).(*[]int32)
19001 v, changed := fastpathTV.DecSliceInt32V(*vp, !array, d)
19006 v := rv2i(rv).([]int32)
19007 v2, changed := fastpathTV.DecSliceInt32V(v, !array, d)
19008 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
19013 func (f fastpathT) DecSliceInt32X(vp *[]int32, d *Decoder) {
19014 v, changed := f.DecSliceInt32V(*vp, true, d)
19019 func (_ fastpathT) DecSliceInt32V(v []int32, canChange bool, d *Decoder) (_ []int32, changed bool) {
19021 slh, containerLenS := d.decSliceHelperStart()
19022 if containerLenS == 0 {
19026 } else if len(v) != 0 {
19035 hasLen := containerLenS > 0
19037 if hasLen && canChange {
19038 if containerLenS > cap(v) {
19039 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
19040 if xlen <= cap(v) {
19043 v = make([]int32, xlen)
19046 } else if containerLenS != len(v) {
19047 v = v[:containerLenS]
19052 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
19053 if j == 0 && len(v) == 0 && canChange {
19055 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
19059 v = make([]int32, xlen)
19062 // if indefinite, etc, then expand the slice if necessary
19063 var decodeIntoBlank bool
19069 d.arrayCannotExpand(len(v), j+1)
19070 decodeIntoBlank = true
19073 slh.ElemContainerState(j)
19074 if decodeIntoBlank {
19076 } else if dd.TryDecodeAsNil() {
19079 v[j] = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
19086 } else if j == 0 && v == nil {
19087 v = make([]int32, 0)
19096 func (d *Decoder) fastpathDecSliceInt64R(f *codecFnInfo, rv reflect.Value) {
19097 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
19098 vp := rv2i(rv).(*[]int64)
19099 v, changed := fastpathTV.DecSliceInt64V(*vp, !array, d)
19104 v := rv2i(rv).([]int64)
19105 v2, changed := fastpathTV.DecSliceInt64V(v, !array, d)
19106 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
19111 func (f fastpathT) DecSliceInt64X(vp *[]int64, d *Decoder) {
19112 v, changed := f.DecSliceInt64V(*vp, true, d)
19117 func (_ fastpathT) DecSliceInt64V(v []int64, canChange bool, d *Decoder) (_ []int64, changed bool) {
19119 slh, containerLenS := d.decSliceHelperStart()
19120 if containerLenS == 0 {
19124 } else if len(v) != 0 {
19133 hasLen := containerLenS > 0
19135 if hasLen && canChange {
19136 if containerLenS > cap(v) {
19137 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
19138 if xlen <= cap(v) {
19141 v = make([]int64, xlen)
19144 } else if containerLenS != len(v) {
19145 v = v[:containerLenS]
19150 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
19151 if j == 0 && len(v) == 0 && canChange {
19153 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
19157 v = make([]int64, xlen)
19160 // if indefinite, etc, then expand the slice if necessary
19161 var decodeIntoBlank bool
19167 d.arrayCannotExpand(len(v), j+1)
19168 decodeIntoBlank = true
19171 slh.ElemContainerState(j)
19172 if decodeIntoBlank {
19174 } else if dd.TryDecodeAsNil() {
19177 v[j] = dd.DecodeInt64()
19184 } else if j == 0 && v == nil {
19185 v = make([]int64, 0)
19194 func (d *Decoder) fastpathDecSliceBoolR(f *codecFnInfo, rv reflect.Value) {
19195 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
19196 vp := rv2i(rv).(*[]bool)
19197 v, changed := fastpathTV.DecSliceBoolV(*vp, !array, d)
19202 v := rv2i(rv).([]bool)
19203 v2, changed := fastpathTV.DecSliceBoolV(v, !array, d)
19204 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
19209 func (f fastpathT) DecSliceBoolX(vp *[]bool, d *Decoder) {
19210 v, changed := f.DecSliceBoolV(*vp, true, d)
19215 func (_ fastpathT) DecSliceBoolV(v []bool, canChange bool, d *Decoder) (_ []bool, changed bool) {
19217 slh, containerLenS := d.decSliceHelperStart()
19218 if containerLenS == 0 {
19222 } else if len(v) != 0 {
19231 hasLen := containerLenS > 0
19233 if hasLen && canChange {
19234 if containerLenS > cap(v) {
19235 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
19236 if xlen <= cap(v) {
19239 v = make([]bool, xlen)
19242 } else if containerLenS != len(v) {
19243 v = v[:containerLenS]
19248 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
19249 if j == 0 && len(v) == 0 && canChange {
19251 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
19255 v = make([]bool, xlen)
19258 // if indefinite, etc, then expand the slice if necessary
19259 var decodeIntoBlank bool
19262 v = append(v, false)
19265 d.arrayCannotExpand(len(v), j+1)
19266 decodeIntoBlank = true
19269 slh.ElemContainerState(j)
19270 if decodeIntoBlank {
19272 } else if dd.TryDecodeAsNil() {
19275 v[j] = dd.DecodeBool()
19282 } else if j == 0 && v == nil {
19283 v = make([]bool, 0)
19292 func (d *Decoder) fastpathDecMapIntfIntfR(f *codecFnInfo, rv reflect.Value) {
19293 if rv.Kind() == reflect.Ptr {
19294 vp := rv2i(rv).(*map[interface{}]interface{})
19295 v, changed := fastpathTV.DecMapIntfIntfV(*vp, true, d)
19300 fastpathTV.DecMapIntfIntfV(rv2i(rv).(map[interface{}]interface{}), false, d)
19303 func (f fastpathT) DecMapIntfIntfX(vp *map[interface{}]interface{}, d *Decoder) {
19304 v, changed := f.DecMapIntfIntfV(*vp, true, d)
19309 func (_ fastpathT) DecMapIntfIntfV(v map[interface{}]interface{}, canChange bool,
19310 d *Decoder) (_ map[interface{}]interface{}, changed bool) {
19311 dd, esep := d.d, d.hh.hasElemSeparators()
19312 containerLen := dd.ReadMapStart()
19313 if canChange && v == nil {
19314 xlen := decInferLen(containerLen, d.h.MaxInitLen, 32)
19315 v = make(map[interface{}]interface{}, xlen)
19318 if containerLen == 0 {
19323 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
19326 hasLen := containerLen > 0
19327 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19329 dd.ReadMapElemKey()
19333 if bv, bok := mk.([]byte); bok {
19337 dd.ReadMapElemValue()
19339 if dd.TryDecodeAsNil() {
19341 } else if d.h.DeleteOnNilMapValue {
19363 func (d *Decoder) fastpathDecMapIntfStringR(f *codecFnInfo, rv reflect.Value) {
19364 if rv.Kind() == reflect.Ptr {
19365 vp := rv2i(rv).(*map[interface{}]string)
19366 v, changed := fastpathTV.DecMapIntfStringV(*vp, true, d)
19371 fastpathTV.DecMapIntfStringV(rv2i(rv).(map[interface{}]string), false, d)
19374 func (f fastpathT) DecMapIntfStringX(vp *map[interface{}]string, d *Decoder) {
19375 v, changed := f.DecMapIntfStringV(*vp, true, d)
19380 func (_ fastpathT) DecMapIntfStringV(v map[interface{}]string, canChange bool,
19381 d *Decoder) (_ map[interface{}]string, changed bool) {
19382 dd, esep := d.d, d.hh.hasElemSeparators()
19383 containerLen := dd.ReadMapStart()
19384 if canChange && v == nil {
19385 xlen := decInferLen(containerLen, d.h.MaxInitLen, 32)
19386 v = make(map[interface{}]string, xlen)
19389 if containerLen == 0 {
19396 hasLen := containerLen > 0
19397 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19399 dd.ReadMapElemKey()
19403 if bv, bok := mk.([]byte); bok {
19407 dd.ReadMapElemValue()
19409 if dd.TryDecodeAsNil() {
19411 } else if d.h.DeleteOnNilMapValue {
19418 mv = dd.DecodeString()
19428 func (d *Decoder) fastpathDecMapIntfUintR(f *codecFnInfo, rv reflect.Value) {
19429 if rv.Kind() == reflect.Ptr {
19430 vp := rv2i(rv).(*map[interface{}]uint)
19431 v, changed := fastpathTV.DecMapIntfUintV(*vp, true, d)
19436 fastpathTV.DecMapIntfUintV(rv2i(rv).(map[interface{}]uint), false, d)
19439 func (f fastpathT) DecMapIntfUintX(vp *map[interface{}]uint, d *Decoder) {
19440 v, changed := f.DecMapIntfUintV(*vp, true, d)
19445 func (_ fastpathT) DecMapIntfUintV(v map[interface{}]uint, canChange bool,
19446 d *Decoder) (_ map[interface{}]uint, changed bool) {
19447 dd, esep := d.d, d.hh.hasElemSeparators()
19448 containerLen := dd.ReadMapStart()
19449 if canChange && v == nil {
19450 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
19451 v = make(map[interface{}]uint, xlen)
19454 if containerLen == 0 {
19461 hasLen := containerLen > 0
19462 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19464 dd.ReadMapElemKey()
19468 if bv, bok := mk.([]byte); bok {
19472 dd.ReadMapElemValue()
19474 if dd.TryDecodeAsNil() {
19476 } else if d.h.DeleteOnNilMapValue {
19483 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
19493 func (d *Decoder) fastpathDecMapIntfUint8R(f *codecFnInfo, rv reflect.Value) {
19494 if rv.Kind() == reflect.Ptr {
19495 vp := rv2i(rv).(*map[interface{}]uint8)
19496 v, changed := fastpathTV.DecMapIntfUint8V(*vp, true, d)
19501 fastpathTV.DecMapIntfUint8V(rv2i(rv).(map[interface{}]uint8), false, d)
19504 func (f fastpathT) DecMapIntfUint8X(vp *map[interface{}]uint8, d *Decoder) {
19505 v, changed := f.DecMapIntfUint8V(*vp, true, d)
19510 func (_ fastpathT) DecMapIntfUint8V(v map[interface{}]uint8, canChange bool,
19511 d *Decoder) (_ map[interface{}]uint8, changed bool) {
19512 dd, esep := d.d, d.hh.hasElemSeparators()
19513 containerLen := dd.ReadMapStart()
19514 if canChange && v == nil {
19515 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
19516 v = make(map[interface{}]uint8, xlen)
19519 if containerLen == 0 {
19526 hasLen := containerLen > 0
19527 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19529 dd.ReadMapElemKey()
19533 if bv, bok := mk.([]byte); bok {
19537 dd.ReadMapElemValue()
19539 if dd.TryDecodeAsNil() {
19541 } else if d.h.DeleteOnNilMapValue {
19548 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
19558 func (d *Decoder) fastpathDecMapIntfUint16R(f *codecFnInfo, rv reflect.Value) {
19559 if rv.Kind() == reflect.Ptr {
19560 vp := rv2i(rv).(*map[interface{}]uint16)
19561 v, changed := fastpathTV.DecMapIntfUint16V(*vp, true, d)
19566 fastpathTV.DecMapIntfUint16V(rv2i(rv).(map[interface{}]uint16), false, d)
19569 func (f fastpathT) DecMapIntfUint16X(vp *map[interface{}]uint16, d *Decoder) {
19570 v, changed := f.DecMapIntfUint16V(*vp, true, d)
19575 func (_ fastpathT) DecMapIntfUint16V(v map[interface{}]uint16, canChange bool,
19576 d *Decoder) (_ map[interface{}]uint16, changed bool) {
19577 dd, esep := d.d, d.hh.hasElemSeparators()
19578 containerLen := dd.ReadMapStart()
19579 if canChange && v == nil {
19580 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
19581 v = make(map[interface{}]uint16, xlen)
19584 if containerLen == 0 {
19591 hasLen := containerLen > 0
19592 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19594 dd.ReadMapElemKey()
19598 if bv, bok := mk.([]byte); bok {
19602 dd.ReadMapElemValue()
19604 if dd.TryDecodeAsNil() {
19606 } else if d.h.DeleteOnNilMapValue {
19613 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
19623 func (d *Decoder) fastpathDecMapIntfUint32R(f *codecFnInfo, rv reflect.Value) {
19624 if rv.Kind() == reflect.Ptr {
19625 vp := rv2i(rv).(*map[interface{}]uint32)
19626 v, changed := fastpathTV.DecMapIntfUint32V(*vp, true, d)
19631 fastpathTV.DecMapIntfUint32V(rv2i(rv).(map[interface{}]uint32), false, d)
19634 func (f fastpathT) DecMapIntfUint32X(vp *map[interface{}]uint32, d *Decoder) {
19635 v, changed := f.DecMapIntfUint32V(*vp, true, d)
19640 func (_ fastpathT) DecMapIntfUint32V(v map[interface{}]uint32, canChange bool,
19641 d *Decoder) (_ map[interface{}]uint32, changed bool) {
19642 dd, esep := d.d, d.hh.hasElemSeparators()
19643 containerLen := dd.ReadMapStart()
19644 if canChange && v == nil {
19645 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
19646 v = make(map[interface{}]uint32, xlen)
19649 if containerLen == 0 {
19656 hasLen := containerLen > 0
19657 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19659 dd.ReadMapElemKey()
19663 if bv, bok := mk.([]byte); bok {
19667 dd.ReadMapElemValue()
19669 if dd.TryDecodeAsNil() {
19671 } else if d.h.DeleteOnNilMapValue {
19678 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
19688 func (d *Decoder) fastpathDecMapIntfUint64R(f *codecFnInfo, rv reflect.Value) {
19689 if rv.Kind() == reflect.Ptr {
19690 vp := rv2i(rv).(*map[interface{}]uint64)
19691 v, changed := fastpathTV.DecMapIntfUint64V(*vp, true, d)
19696 fastpathTV.DecMapIntfUint64V(rv2i(rv).(map[interface{}]uint64), false, d)
19699 func (f fastpathT) DecMapIntfUint64X(vp *map[interface{}]uint64, d *Decoder) {
19700 v, changed := f.DecMapIntfUint64V(*vp, true, d)
19705 func (_ fastpathT) DecMapIntfUint64V(v map[interface{}]uint64, canChange bool,
19706 d *Decoder) (_ map[interface{}]uint64, changed bool) {
19707 dd, esep := d.d, d.hh.hasElemSeparators()
19708 containerLen := dd.ReadMapStart()
19709 if canChange && v == nil {
19710 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
19711 v = make(map[interface{}]uint64, xlen)
19714 if containerLen == 0 {
19721 hasLen := containerLen > 0
19722 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19724 dd.ReadMapElemKey()
19728 if bv, bok := mk.([]byte); bok {
19732 dd.ReadMapElemValue()
19734 if dd.TryDecodeAsNil() {
19736 } else if d.h.DeleteOnNilMapValue {
19743 mv = dd.DecodeUint64()
19753 func (d *Decoder) fastpathDecMapIntfUintptrR(f *codecFnInfo, rv reflect.Value) {
19754 if rv.Kind() == reflect.Ptr {
19755 vp := rv2i(rv).(*map[interface{}]uintptr)
19756 v, changed := fastpathTV.DecMapIntfUintptrV(*vp, true, d)
19761 fastpathTV.DecMapIntfUintptrV(rv2i(rv).(map[interface{}]uintptr), false, d)
19764 func (f fastpathT) DecMapIntfUintptrX(vp *map[interface{}]uintptr, d *Decoder) {
19765 v, changed := f.DecMapIntfUintptrV(*vp, true, d)
19770 func (_ fastpathT) DecMapIntfUintptrV(v map[interface{}]uintptr, canChange bool,
19771 d *Decoder) (_ map[interface{}]uintptr, changed bool) {
19772 dd, esep := d.d, d.hh.hasElemSeparators()
19773 containerLen := dd.ReadMapStart()
19774 if canChange && v == nil {
19775 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
19776 v = make(map[interface{}]uintptr, xlen)
19779 if containerLen == 0 {
19786 hasLen := containerLen > 0
19787 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19789 dd.ReadMapElemKey()
19793 if bv, bok := mk.([]byte); bok {
19797 dd.ReadMapElemValue()
19799 if dd.TryDecodeAsNil() {
19801 } else if d.h.DeleteOnNilMapValue {
19808 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
19818 func (d *Decoder) fastpathDecMapIntfIntR(f *codecFnInfo, rv reflect.Value) {
19819 if rv.Kind() == reflect.Ptr {
19820 vp := rv2i(rv).(*map[interface{}]int)
19821 v, changed := fastpathTV.DecMapIntfIntV(*vp, true, d)
19826 fastpathTV.DecMapIntfIntV(rv2i(rv).(map[interface{}]int), false, d)
19829 func (f fastpathT) DecMapIntfIntX(vp *map[interface{}]int, d *Decoder) {
19830 v, changed := f.DecMapIntfIntV(*vp, true, d)
19835 func (_ fastpathT) DecMapIntfIntV(v map[interface{}]int, canChange bool,
19836 d *Decoder) (_ map[interface{}]int, changed bool) {
19837 dd, esep := d.d, d.hh.hasElemSeparators()
19838 containerLen := dd.ReadMapStart()
19839 if canChange && v == nil {
19840 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
19841 v = make(map[interface{}]int, xlen)
19844 if containerLen == 0 {
19851 hasLen := containerLen > 0
19852 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19854 dd.ReadMapElemKey()
19858 if bv, bok := mk.([]byte); bok {
19862 dd.ReadMapElemValue()
19864 if dd.TryDecodeAsNil() {
19866 } else if d.h.DeleteOnNilMapValue {
19873 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
19883 func (d *Decoder) fastpathDecMapIntfInt8R(f *codecFnInfo, rv reflect.Value) {
19884 if rv.Kind() == reflect.Ptr {
19885 vp := rv2i(rv).(*map[interface{}]int8)
19886 v, changed := fastpathTV.DecMapIntfInt8V(*vp, true, d)
19891 fastpathTV.DecMapIntfInt8V(rv2i(rv).(map[interface{}]int8), false, d)
19894 func (f fastpathT) DecMapIntfInt8X(vp *map[interface{}]int8, d *Decoder) {
19895 v, changed := f.DecMapIntfInt8V(*vp, true, d)
19900 func (_ fastpathT) DecMapIntfInt8V(v map[interface{}]int8, canChange bool,
19901 d *Decoder) (_ map[interface{}]int8, changed bool) {
19902 dd, esep := d.d, d.hh.hasElemSeparators()
19903 containerLen := dd.ReadMapStart()
19904 if canChange && v == nil {
19905 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
19906 v = make(map[interface{}]int8, xlen)
19909 if containerLen == 0 {
19916 hasLen := containerLen > 0
19917 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19919 dd.ReadMapElemKey()
19923 if bv, bok := mk.([]byte); bok {
19927 dd.ReadMapElemValue()
19929 if dd.TryDecodeAsNil() {
19931 } else if d.h.DeleteOnNilMapValue {
19938 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
19948 func (d *Decoder) fastpathDecMapIntfInt16R(f *codecFnInfo, rv reflect.Value) {
19949 if rv.Kind() == reflect.Ptr {
19950 vp := rv2i(rv).(*map[interface{}]int16)
19951 v, changed := fastpathTV.DecMapIntfInt16V(*vp, true, d)
19956 fastpathTV.DecMapIntfInt16V(rv2i(rv).(map[interface{}]int16), false, d)
19959 func (f fastpathT) DecMapIntfInt16X(vp *map[interface{}]int16, d *Decoder) {
19960 v, changed := f.DecMapIntfInt16V(*vp, true, d)
19965 func (_ fastpathT) DecMapIntfInt16V(v map[interface{}]int16, canChange bool,
19966 d *Decoder) (_ map[interface{}]int16, changed bool) {
19967 dd, esep := d.d, d.hh.hasElemSeparators()
19968 containerLen := dd.ReadMapStart()
19969 if canChange && v == nil {
19970 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
19971 v = make(map[interface{}]int16, xlen)
19974 if containerLen == 0 {
19981 hasLen := containerLen > 0
19982 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19984 dd.ReadMapElemKey()
19988 if bv, bok := mk.([]byte); bok {
19992 dd.ReadMapElemValue()
19994 if dd.TryDecodeAsNil() {
19996 } else if d.h.DeleteOnNilMapValue {
20003 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
20013 func (d *Decoder) fastpathDecMapIntfInt32R(f *codecFnInfo, rv reflect.Value) {
20014 if rv.Kind() == reflect.Ptr {
20015 vp := rv2i(rv).(*map[interface{}]int32)
20016 v, changed := fastpathTV.DecMapIntfInt32V(*vp, true, d)
20021 fastpathTV.DecMapIntfInt32V(rv2i(rv).(map[interface{}]int32), false, d)
20024 func (f fastpathT) DecMapIntfInt32X(vp *map[interface{}]int32, d *Decoder) {
20025 v, changed := f.DecMapIntfInt32V(*vp, true, d)
20030 func (_ fastpathT) DecMapIntfInt32V(v map[interface{}]int32, canChange bool,
20031 d *Decoder) (_ map[interface{}]int32, changed bool) {
20032 dd, esep := d.d, d.hh.hasElemSeparators()
20033 containerLen := dd.ReadMapStart()
20034 if canChange && v == nil {
20035 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
20036 v = make(map[interface{}]int32, xlen)
20039 if containerLen == 0 {
20046 hasLen := containerLen > 0
20047 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20049 dd.ReadMapElemKey()
20053 if bv, bok := mk.([]byte); bok {
20057 dd.ReadMapElemValue()
20059 if dd.TryDecodeAsNil() {
20061 } else if d.h.DeleteOnNilMapValue {
20068 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
20078 func (d *Decoder) fastpathDecMapIntfInt64R(f *codecFnInfo, rv reflect.Value) {
20079 if rv.Kind() == reflect.Ptr {
20080 vp := rv2i(rv).(*map[interface{}]int64)
20081 v, changed := fastpathTV.DecMapIntfInt64V(*vp, true, d)
20086 fastpathTV.DecMapIntfInt64V(rv2i(rv).(map[interface{}]int64), false, d)
20089 func (f fastpathT) DecMapIntfInt64X(vp *map[interface{}]int64, d *Decoder) {
20090 v, changed := f.DecMapIntfInt64V(*vp, true, d)
20095 func (_ fastpathT) DecMapIntfInt64V(v map[interface{}]int64, canChange bool,
20096 d *Decoder) (_ map[interface{}]int64, changed bool) {
20097 dd, esep := d.d, d.hh.hasElemSeparators()
20098 containerLen := dd.ReadMapStart()
20099 if canChange && v == nil {
20100 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
20101 v = make(map[interface{}]int64, xlen)
20104 if containerLen == 0 {
20111 hasLen := containerLen > 0
20112 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20114 dd.ReadMapElemKey()
20118 if bv, bok := mk.([]byte); bok {
20122 dd.ReadMapElemValue()
20124 if dd.TryDecodeAsNil() {
20126 } else if d.h.DeleteOnNilMapValue {
20133 mv = dd.DecodeInt64()
20143 func (d *Decoder) fastpathDecMapIntfFloat32R(f *codecFnInfo, rv reflect.Value) {
20144 if rv.Kind() == reflect.Ptr {
20145 vp := rv2i(rv).(*map[interface{}]float32)
20146 v, changed := fastpathTV.DecMapIntfFloat32V(*vp, true, d)
20151 fastpathTV.DecMapIntfFloat32V(rv2i(rv).(map[interface{}]float32), false, d)
20154 func (f fastpathT) DecMapIntfFloat32X(vp *map[interface{}]float32, d *Decoder) {
20155 v, changed := f.DecMapIntfFloat32V(*vp, true, d)
20160 func (_ fastpathT) DecMapIntfFloat32V(v map[interface{}]float32, canChange bool,
20161 d *Decoder) (_ map[interface{}]float32, changed bool) {
20162 dd, esep := d.d, d.hh.hasElemSeparators()
20163 containerLen := dd.ReadMapStart()
20164 if canChange && v == nil {
20165 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
20166 v = make(map[interface{}]float32, xlen)
20169 if containerLen == 0 {
20176 hasLen := containerLen > 0
20177 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20179 dd.ReadMapElemKey()
20183 if bv, bok := mk.([]byte); bok {
20187 dd.ReadMapElemValue()
20189 if dd.TryDecodeAsNil() {
20191 } else if d.h.DeleteOnNilMapValue {
20198 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
20208 func (d *Decoder) fastpathDecMapIntfFloat64R(f *codecFnInfo, rv reflect.Value) {
20209 if rv.Kind() == reflect.Ptr {
20210 vp := rv2i(rv).(*map[interface{}]float64)
20211 v, changed := fastpathTV.DecMapIntfFloat64V(*vp, true, d)
20216 fastpathTV.DecMapIntfFloat64V(rv2i(rv).(map[interface{}]float64), false, d)
20219 func (f fastpathT) DecMapIntfFloat64X(vp *map[interface{}]float64, d *Decoder) {
20220 v, changed := f.DecMapIntfFloat64V(*vp, true, d)
20225 func (_ fastpathT) DecMapIntfFloat64V(v map[interface{}]float64, canChange bool,
20226 d *Decoder) (_ map[interface{}]float64, changed bool) {
20227 dd, esep := d.d, d.hh.hasElemSeparators()
20228 containerLen := dd.ReadMapStart()
20229 if canChange && v == nil {
20230 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
20231 v = make(map[interface{}]float64, xlen)
20234 if containerLen == 0 {
20241 hasLen := containerLen > 0
20242 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20244 dd.ReadMapElemKey()
20248 if bv, bok := mk.([]byte); bok {
20252 dd.ReadMapElemValue()
20254 if dd.TryDecodeAsNil() {
20256 } else if d.h.DeleteOnNilMapValue {
20263 mv = dd.DecodeFloat64()
20273 func (d *Decoder) fastpathDecMapIntfBoolR(f *codecFnInfo, rv reflect.Value) {
20274 if rv.Kind() == reflect.Ptr {
20275 vp := rv2i(rv).(*map[interface{}]bool)
20276 v, changed := fastpathTV.DecMapIntfBoolV(*vp, true, d)
20281 fastpathTV.DecMapIntfBoolV(rv2i(rv).(map[interface{}]bool), false, d)
20284 func (f fastpathT) DecMapIntfBoolX(vp *map[interface{}]bool, d *Decoder) {
20285 v, changed := f.DecMapIntfBoolV(*vp, true, d)
20290 func (_ fastpathT) DecMapIntfBoolV(v map[interface{}]bool, canChange bool,
20291 d *Decoder) (_ map[interface{}]bool, changed bool) {
20292 dd, esep := d.d, d.hh.hasElemSeparators()
20293 containerLen := dd.ReadMapStart()
20294 if canChange && v == nil {
20295 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
20296 v = make(map[interface{}]bool, xlen)
20299 if containerLen == 0 {
20306 hasLen := containerLen > 0
20307 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20309 dd.ReadMapElemKey()
20313 if bv, bok := mk.([]byte); bok {
20317 dd.ReadMapElemValue()
20319 if dd.TryDecodeAsNil() {
20321 } else if d.h.DeleteOnNilMapValue {
20328 mv = dd.DecodeBool()
20338 func (d *Decoder) fastpathDecMapStringIntfR(f *codecFnInfo, rv reflect.Value) {
20339 if rv.Kind() == reflect.Ptr {
20340 vp := rv2i(rv).(*map[string]interface{})
20341 v, changed := fastpathTV.DecMapStringIntfV(*vp, true, d)
20346 fastpathTV.DecMapStringIntfV(rv2i(rv).(map[string]interface{}), false, d)
20349 func (f fastpathT) DecMapStringIntfX(vp *map[string]interface{}, d *Decoder) {
20350 v, changed := f.DecMapStringIntfV(*vp, true, d)
20355 func (_ fastpathT) DecMapStringIntfV(v map[string]interface{}, canChange bool,
20356 d *Decoder) (_ map[string]interface{}, changed bool) {
20357 dd, esep := d.d, d.hh.hasElemSeparators()
20358 containerLen := dd.ReadMapStart()
20359 if canChange && v == nil {
20360 xlen := decInferLen(containerLen, d.h.MaxInitLen, 32)
20361 v = make(map[string]interface{}, xlen)
20364 if containerLen == 0 {
20369 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
20372 hasLen := containerLen > 0
20373 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20375 dd.ReadMapElemKey()
20377 mk = dd.DecodeString()
20379 dd.ReadMapElemValue()
20381 if dd.TryDecodeAsNil() {
20383 } else if d.h.DeleteOnNilMapValue {
20405 func (d *Decoder) fastpathDecMapStringStringR(f *codecFnInfo, rv reflect.Value) {
20406 if rv.Kind() == reflect.Ptr {
20407 vp := rv2i(rv).(*map[string]string)
20408 v, changed := fastpathTV.DecMapStringStringV(*vp, true, d)
20413 fastpathTV.DecMapStringStringV(rv2i(rv).(map[string]string), false, d)
20416 func (f fastpathT) DecMapStringStringX(vp *map[string]string, d *Decoder) {
20417 v, changed := f.DecMapStringStringV(*vp, true, d)
20422 func (_ fastpathT) DecMapStringStringV(v map[string]string, canChange bool,
20423 d *Decoder) (_ map[string]string, changed bool) {
20424 dd, esep := d.d, d.hh.hasElemSeparators()
20425 containerLen := dd.ReadMapStart()
20426 if canChange && v == nil {
20427 xlen := decInferLen(containerLen, d.h.MaxInitLen, 32)
20428 v = make(map[string]string, xlen)
20431 if containerLen == 0 {
20438 hasLen := containerLen > 0
20439 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20441 dd.ReadMapElemKey()
20443 mk = dd.DecodeString()
20445 dd.ReadMapElemValue()
20447 if dd.TryDecodeAsNil() {
20449 } else if d.h.DeleteOnNilMapValue {
20456 mv = dd.DecodeString()
20466 func (d *Decoder) fastpathDecMapStringUintR(f *codecFnInfo, rv reflect.Value) {
20467 if rv.Kind() == reflect.Ptr {
20468 vp := rv2i(rv).(*map[string]uint)
20469 v, changed := fastpathTV.DecMapStringUintV(*vp, true, d)
20474 fastpathTV.DecMapStringUintV(rv2i(rv).(map[string]uint), false, d)
20477 func (f fastpathT) DecMapStringUintX(vp *map[string]uint, d *Decoder) {
20478 v, changed := f.DecMapStringUintV(*vp, true, d)
20483 func (_ fastpathT) DecMapStringUintV(v map[string]uint, canChange bool,
20484 d *Decoder) (_ map[string]uint, changed bool) {
20485 dd, esep := d.d, d.hh.hasElemSeparators()
20486 containerLen := dd.ReadMapStart()
20487 if canChange && v == nil {
20488 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
20489 v = make(map[string]uint, xlen)
20492 if containerLen == 0 {
20499 hasLen := containerLen > 0
20500 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20502 dd.ReadMapElemKey()
20504 mk = dd.DecodeString()
20506 dd.ReadMapElemValue()
20508 if dd.TryDecodeAsNil() {
20510 } else if d.h.DeleteOnNilMapValue {
20517 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
20527 func (d *Decoder) fastpathDecMapStringUint8R(f *codecFnInfo, rv reflect.Value) {
20528 if rv.Kind() == reflect.Ptr {
20529 vp := rv2i(rv).(*map[string]uint8)
20530 v, changed := fastpathTV.DecMapStringUint8V(*vp, true, d)
20535 fastpathTV.DecMapStringUint8V(rv2i(rv).(map[string]uint8), false, d)
20538 func (f fastpathT) DecMapStringUint8X(vp *map[string]uint8, d *Decoder) {
20539 v, changed := f.DecMapStringUint8V(*vp, true, d)
20544 func (_ fastpathT) DecMapStringUint8V(v map[string]uint8, canChange bool,
20545 d *Decoder) (_ map[string]uint8, changed bool) {
20546 dd, esep := d.d, d.hh.hasElemSeparators()
20547 containerLen := dd.ReadMapStart()
20548 if canChange && v == nil {
20549 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
20550 v = make(map[string]uint8, xlen)
20553 if containerLen == 0 {
20560 hasLen := containerLen > 0
20561 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20563 dd.ReadMapElemKey()
20565 mk = dd.DecodeString()
20567 dd.ReadMapElemValue()
20569 if dd.TryDecodeAsNil() {
20571 } else if d.h.DeleteOnNilMapValue {
20578 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
20588 func (d *Decoder) fastpathDecMapStringUint16R(f *codecFnInfo, rv reflect.Value) {
20589 if rv.Kind() == reflect.Ptr {
20590 vp := rv2i(rv).(*map[string]uint16)
20591 v, changed := fastpathTV.DecMapStringUint16V(*vp, true, d)
20596 fastpathTV.DecMapStringUint16V(rv2i(rv).(map[string]uint16), false, d)
20599 func (f fastpathT) DecMapStringUint16X(vp *map[string]uint16, d *Decoder) {
20600 v, changed := f.DecMapStringUint16V(*vp, true, d)
20605 func (_ fastpathT) DecMapStringUint16V(v map[string]uint16, canChange bool,
20606 d *Decoder) (_ map[string]uint16, changed bool) {
20607 dd, esep := d.d, d.hh.hasElemSeparators()
20608 containerLen := dd.ReadMapStart()
20609 if canChange && v == nil {
20610 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
20611 v = make(map[string]uint16, xlen)
20614 if containerLen == 0 {
20621 hasLen := containerLen > 0
20622 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20624 dd.ReadMapElemKey()
20626 mk = dd.DecodeString()
20628 dd.ReadMapElemValue()
20630 if dd.TryDecodeAsNil() {
20632 } else if d.h.DeleteOnNilMapValue {
20639 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
20649 func (d *Decoder) fastpathDecMapStringUint32R(f *codecFnInfo, rv reflect.Value) {
20650 if rv.Kind() == reflect.Ptr {
20651 vp := rv2i(rv).(*map[string]uint32)
20652 v, changed := fastpathTV.DecMapStringUint32V(*vp, true, d)
20657 fastpathTV.DecMapStringUint32V(rv2i(rv).(map[string]uint32), false, d)
20660 func (f fastpathT) DecMapStringUint32X(vp *map[string]uint32, d *Decoder) {
20661 v, changed := f.DecMapStringUint32V(*vp, true, d)
20666 func (_ fastpathT) DecMapStringUint32V(v map[string]uint32, canChange bool,
20667 d *Decoder) (_ map[string]uint32, changed bool) {
20668 dd, esep := d.d, d.hh.hasElemSeparators()
20669 containerLen := dd.ReadMapStart()
20670 if canChange && v == nil {
20671 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
20672 v = make(map[string]uint32, xlen)
20675 if containerLen == 0 {
20682 hasLen := containerLen > 0
20683 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20685 dd.ReadMapElemKey()
20687 mk = dd.DecodeString()
20689 dd.ReadMapElemValue()
20691 if dd.TryDecodeAsNil() {
20693 } else if d.h.DeleteOnNilMapValue {
20700 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
20710 func (d *Decoder) fastpathDecMapStringUint64R(f *codecFnInfo, rv reflect.Value) {
20711 if rv.Kind() == reflect.Ptr {
20712 vp := rv2i(rv).(*map[string]uint64)
20713 v, changed := fastpathTV.DecMapStringUint64V(*vp, true, d)
20718 fastpathTV.DecMapStringUint64V(rv2i(rv).(map[string]uint64), false, d)
20721 func (f fastpathT) DecMapStringUint64X(vp *map[string]uint64, d *Decoder) {
20722 v, changed := f.DecMapStringUint64V(*vp, true, d)
20727 func (_ fastpathT) DecMapStringUint64V(v map[string]uint64, canChange bool,
20728 d *Decoder) (_ map[string]uint64, changed bool) {
20729 dd, esep := d.d, d.hh.hasElemSeparators()
20730 containerLen := dd.ReadMapStart()
20731 if canChange && v == nil {
20732 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
20733 v = make(map[string]uint64, xlen)
20736 if containerLen == 0 {
20743 hasLen := containerLen > 0
20744 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20746 dd.ReadMapElemKey()
20748 mk = dd.DecodeString()
20750 dd.ReadMapElemValue()
20752 if dd.TryDecodeAsNil() {
20754 } else if d.h.DeleteOnNilMapValue {
20761 mv = dd.DecodeUint64()
20771 func (d *Decoder) fastpathDecMapStringUintptrR(f *codecFnInfo, rv reflect.Value) {
20772 if rv.Kind() == reflect.Ptr {
20773 vp := rv2i(rv).(*map[string]uintptr)
20774 v, changed := fastpathTV.DecMapStringUintptrV(*vp, true, d)
20779 fastpathTV.DecMapStringUintptrV(rv2i(rv).(map[string]uintptr), false, d)
20782 func (f fastpathT) DecMapStringUintptrX(vp *map[string]uintptr, d *Decoder) {
20783 v, changed := f.DecMapStringUintptrV(*vp, true, d)
20788 func (_ fastpathT) DecMapStringUintptrV(v map[string]uintptr, canChange bool,
20789 d *Decoder) (_ map[string]uintptr, changed bool) {
20790 dd, esep := d.d, d.hh.hasElemSeparators()
20791 containerLen := dd.ReadMapStart()
20792 if canChange && v == nil {
20793 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
20794 v = make(map[string]uintptr, xlen)
20797 if containerLen == 0 {
20804 hasLen := containerLen > 0
20805 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20807 dd.ReadMapElemKey()
20809 mk = dd.DecodeString()
20811 dd.ReadMapElemValue()
20813 if dd.TryDecodeAsNil() {
20815 } else if d.h.DeleteOnNilMapValue {
20822 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
20832 func (d *Decoder) fastpathDecMapStringIntR(f *codecFnInfo, rv reflect.Value) {
20833 if rv.Kind() == reflect.Ptr {
20834 vp := rv2i(rv).(*map[string]int)
20835 v, changed := fastpathTV.DecMapStringIntV(*vp, true, d)
20840 fastpathTV.DecMapStringIntV(rv2i(rv).(map[string]int), false, d)
20843 func (f fastpathT) DecMapStringIntX(vp *map[string]int, d *Decoder) {
20844 v, changed := f.DecMapStringIntV(*vp, true, d)
20849 func (_ fastpathT) DecMapStringIntV(v map[string]int, canChange bool,
20850 d *Decoder) (_ map[string]int, changed bool) {
20851 dd, esep := d.d, d.hh.hasElemSeparators()
20852 containerLen := dd.ReadMapStart()
20853 if canChange && v == nil {
20854 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
20855 v = make(map[string]int, xlen)
20858 if containerLen == 0 {
20865 hasLen := containerLen > 0
20866 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20868 dd.ReadMapElemKey()
20870 mk = dd.DecodeString()
20872 dd.ReadMapElemValue()
20874 if dd.TryDecodeAsNil() {
20876 } else if d.h.DeleteOnNilMapValue {
20883 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
20893 func (d *Decoder) fastpathDecMapStringInt8R(f *codecFnInfo, rv reflect.Value) {
20894 if rv.Kind() == reflect.Ptr {
20895 vp := rv2i(rv).(*map[string]int8)
20896 v, changed := fastpathTV.DecMapStringInt8V(*vp, true, d)
20901 fastpathTV.DecMapStringInt8V(rv2i(rv).(map[string]int8), false, d)
20904 func (f fastpathT) DecMapStringInt8X(vp *map[string]int8, d *Decoder) {
20905 v, changed := f.DecMapStringInt8V(*vp, true, d)
20910 func (_ fastpathT) DecMapStringInt8V(v map[string]int8, canChange bool,
20911 d *Decoder) (_ map[string]int8, changed bool) {
20912 dd, esep := d.d, d.hh.hasElemSeparators()
20913 containerLen := dd.ReadMapStart()
20914 if canChange && v == nil {
20915 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
20916 v = make(map[string]int8, xlen)
20919 if containerLen == 0 {
20926 hasLen := containerLen > 0
20927 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20929 dd.ReadMapElemKey()
20931 mk = dd.DecodeString()
20933 dd.ReadMapElemValue()
20935 if dd.TryDecodeAsNil() {
20937 } else if d.h.DeleteOnNilMapValue {
20944 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
20954 func (d *Decoder) fastpathDecMapStringInt16R(f *codecFnInfo, rv reflect.Value) {
20955 if rv.Kind() == reflect.Ptr {
20956 vp := rv2i(rv).(*map[string]int16)
20957 v, changed := fastpathTV.DecMapStringInt16V(*vp, true, d)
20962 fastpathTV.DecMapStringInt16V(rv2i(rv).(map[string]int16), false, d)
20965 func (f fastpathT) DecMapStringInt16X(vp *map[string]int16, d *Decoder) {
20966 v, changed := f.DecMapStringInt16V(*vp, true, d)
20971 func (_ fastpathT) DecMapStringInt16V(v map[string]int16, canChange bool,
20972 d *Decoder) (_ map[string]int16, changed bool) {
20973 dd, esep := d.d, d.hh.hasElemSeparators()
20974 containerLen := dd.ReadMapStart()
20975 if canChange && v == nil {
20976 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
20977 v = make(map[string]int16, xlen)
20980 if containerLen == 0 {
20987 hasLen := containerLen > 0
20988 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20990 dd.ReadMapElemKey()
20992 mk = dd.DecodeString()
20994 dd.ReadMapElemValue()
20996 if dd.TryDecodeAsNil() {
20998 } else if d.h.DeleteOnNilMapValue {
21005 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
21015 func (d *Decoder) fastpathDecMapStringInt32R(f *codecFnInfo, rv reflect.Value) {
21016 if rv.Kind() == reflect.Ptr {
21017 vp := rv2i(rv).(*map[string]int32)
21018 v, changed := fastpathTV.DecMapStringInt32V(*vp, true, d)
21023 fastpathTV.DecMapStringInt32V(rv2i(rv).(map[string]int32), false, d)
21026 func (f fastpathT) DecMapStringInt32X(vp *map[string]int32, d *Decoder) {
21027 v, changed := f.DecMapStringInt32V(*vp, true, d)
21032 func (_ fastpathT) DecMapStringInt32V(v map[string]int32, canChange bool,
21033 d *Decoder) (_ map[string]int32, changed bool) {
21034 dd, esep := d.d, d.hh.hasElemSeparators()
21035 containerLen := dd.ReadMapStart()
21036 if canChange && v == nil {
21037 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
21038 v = make(map[string]int32, xlen)
21041 if containerLen == 0 {
21048 hasLen := containerLen > 0
21049 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21051 dd.ReadMapElemKey()
21053 mk = dd.DecodeString()
21055 dd.ReadMapElemValue()
21057 if dd.TryDecodeAsNil() {
21059 } else if d.h.DeleteOnNilMapValue {
21066 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
21076 func (d *Decoder) fastpathDecMapStringInt64R(f *codecFnInfo, rv reflect.Value) {
21077 if rv.Kind() == reflect.Ptr {
21078 vp := rv2i(rv).(*map[string]int64)
21079 v, changed := fastpathTV.DecMapStringInt64V(*vp, true, d)
21084 fastpathTV.DecMapStringInt64V(rv2i(rv).(map[string]int64), false, d)
21087 func (f fastpathT) DecMapStringInt64X(vp *map[string]int64, d *Decoder) {
21088 v, changed := f.DecMapStringInt64V(*vp, true, d)
21093 func (_ fastpathT) DecMapStringInt64V(v map[string]int64, canChange bool,
21094 d *Decoder) (_ map[string]int64, changed bool) {
21095 dd, esep := d.d, d.hh.hasElemSeparators()
21096 containerLen := dd.ReadMapStart()
21097 if canChange && v == nil {
21098 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
21099 v = make(map[string]int64, xlen)
21102 if containerLen == 0 {
21109 hasLen := containerLen > 0
21110 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21112 dd.ReadMapElemKey()
21114 mk = dd.DecodeString()
21116 dd.ReadMapElemValue()
21118 if dd.TryDecodeAsNil() {
21120 } else if d.h.DeleteOnNilMapValue {
21127 mv = dd.DecodeInt64()
21137 func (d *Decoder) fastpathDecMapStringFloat32R(f *codecFnInfo, rv reflect.Value) {
21138 if rv.Kind() == reflect.Ptr {
21139 vp := rv2i(rv).(*map[string]float32)
21140 v, changed := fastpathTV.DecMapStringFloat32V(*vp, true, d)
21145 fastpathTV.DecMapStringFloat32V(rv2i(rv).(map[string]float32), false, d)
21148 func (f fastpathT) DecMapStringFloat32X(vp *map[string]float32, d *Decoder) {
21149 v, changed := f.DecMapStringFloat32V(*vp, true, d)
21154 func (_ fastpathT) DecMapStringFloat32V(v map[string]float32, canChange bool,
21155 d *Decoder) (_ map[string]float32, changed bool) {
21156 dd, esep := d.d, d.hh.hasElemSeparators()
21157 containerLen := dd.ReadMapStart()
21158 if canChange && v == nil {
21159 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
21160 v = make(map[string]float32, xlen)
21163 if containerLen == 0 {
21170 hasLen := containerLen > 0
21171 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21173 dd.ReadMapElemKey()
21175 mk = dd.DecodeString()
21177 dd.ReadMapElemValue()
21179 if dd.TryDecodeAsNil() {
21181 } else if d.h.DeleteOnNilMapValue {
21188 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21198 func (d *Decoder) fastpathDecMapStringFloat64R(f *codecFnInfo, rv reflect.Value) {
21199 if rv.Kind() == reflect.Ptr {
21200 vp := rv2i(rv).(*map[string]float64)
21201 v, changed := fastpathTV.DecMapStringFloat64V(*vp, true, d)
21206 fastpathTV.DecMapStringFloat64V(rv2i(rv).(map[string]float64), false, d)
21209 func (f fastpathT) DecMapStringFloat64X(vp *map[string]float64, d *Decoder) {
21210 v, changed := f.DecMapStringFloat64V(*vp, true, d)
21215 func (_ fastpathT) DecMapStringFloat64V(v map[string]float64, canChange bool,
21216 d *Decoder) (_ map[string]float64, changed bool) {
21217 dd, esep := d.d, d.hh.hasElemSeparators()
21218 containerLen := dd.ReadMapStart()
21219 if canChange && v == nil {
21220 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
21221 v = make(map[string]float64, xlen)
21224 if containerLen == 0 {
21231 hasLen := containerLen > 0
21232 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21234 dd.ReadMapElemKey()
21236 mk = dd.DecodeString()
21238 dd.ReadMapElemValue()
21240 if dd.TryDecodeAsNil() {
21242 } else if d.h.DeleteOnNilMapValue {
21249 mv = dd.DecodeFloat64()
21259 func (d *Decoder) fastpathDecMapStringBoolR(f *codecFnInfo, rv reflect.Value) {
21260 if rv.Kind() == reflect.Ptr {
21261 vp := rv2i(rv).(*map[string]bool)
21262 v, changed := fastpathTV.DecMapStringBoolV(*vp, true, d)
21267 fastpathTV.DecMapStringBoolV(rv2i(rv).(map[string]bool), false, d)
21270 func (f fastpathT) DecMapStringBoolX(vp *map[string]bool, d *Decoder) {
21271 v, changed := f.DecMapStringBoolV(*vp, true, d)
21276 func (_ fastpathT) DecMapStringBoolV(v map[string]bool, canChange bool,
21277 d *Decoder) (_ map[string]bool, changed bool) {
21278 dd, esep := d.d, d.hh.hasElemSeparators()
21279 containerLen := dd.ReadMapStart()
21280 if canChange && v == nil {
21281 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
21282 v = make(map[string]bool, xlen)
21285 if containerLen == 0 {
21292 hasLen := containerLen > 0
21293 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21295 dd.ReadMapElemKey()
21297 mk = dd.DecodeString()
21299 dd.ReadMapElemValue()
21301 if dd.TryDecodeAsNil() {
21303 } else if d.h.DeleteOnNilMapValue {
21310 mv = dd.DecodeBool()
21320 func (d *Decoder) fastpathDecMapFloat32IntfR(f *codecFnInfo, rv reflect.Value) {
21321 if rv.Kind() == reflect.Ptr {
21322 vp := rv2i(rv).(*map[float32]interface{})
21323 v, changed := fastpathTV.DecMapFloat32IntfV(*vp, true, d)
21328 fastpathTV.DecMapFloat32IntfV(rv2i(rv).(map[float32]interface{}), false, d)
21331 func (f fastpathT) DecMapFloat32IntfX(vp *map[float32]interface{}, d *Decoder) {
21332 v, changed := f.DecMapFloat32IntfV(*vp, true, d)
21337 func (_ fastpathT) DecMapFloat32IntfV(v map[float32]interface{}, canChange bool,
21338 d *Decoder) (_ map[float32]interface{}, changed bool) {
21339 dd, esep := d.d, d.hh.hasElemSeparators()
21340 containerLen := dd.ReadMapStart()
21341 if canChange && v == nil {
21342 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
21343 v = make(map[float32]interface{}, xlen)
21346 if containerLen == 0 {
21351 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
21354 hasLen := containerLen > 0
21355 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21357 dd.ReadMapElemKey()
21359 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21361 dd.ReadMapElemValue()
21363 if dd.TryDecodeAsNil() {
21365 } else if d.h.DeleteOnNilMapValue {
21387 func (d *Decoder) fastpathDecMapFloat32StringR(f *codecFnInfo, rv reflect.Value) {
21388 if rv.Kind() == reflect.Ptr {
21389 vp := rv2i(rv).(*map[float32]string)
21390 v, changed := fastpathTV.DecMapFloat32StringV(*vp, true, d)
21395 fastpathTV.DecMapFloat32StringV(rv2i(rv).(map[float32]string), false, d)
21398 func (f fastpathT) DecMapFloat32StringX(vp *map[float32]string, d *Decoder) {
21399 v, changed := f.DecMapFloat32StringV(*vp, true, d)
21404 func (_ fastpathT) DecMapFloat32StringV(v map[float32]string, canChange bool,
21405 d *Decoder) (_ map[float32]string, changed bool) {
21406 dd, esep := d.d, d.hh.hasElemSeparators()
21407 containerLen := dd.ReadMapStart()
21408 if canChange && v == nil {
21409 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
21410 v = make(map[float32]string, xlen)
21413 if containerLen == 0 {
21420 hasLen := containerLen > 0
21421 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21423 dd.ReadMapElemKey()
21425 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21427 dd.ReadMapElemValue()
21429 if dd.TryDecodeAsNil() {
21431 } else if d.h.DeleteOnNilMapValue {
21438 mv = dd.DecodeString()
21448 func (d *Decoder) fastpathDecMapFloat32UintR(f *codecFnInfo, rv reflect.Value) {
21449 if rv.Kind() == reflect.Ptr {
21450 vp := rv2i(rv).(*map[float32]uint)
21451 v, changed := fastpathTV.DecMapFloat32UintV(*vp, true, d)
21456 fastpathTV.DecMapFloat32UintV(rv2i(rv).(map[float32]uint), false, d)
21459 func (f fastpathT) DecMapFloat32UintX(vp *map[float32]uint, d *Decoder) {
21460 v, changed := f.DecMapFloat32UintV(*vp, true, d)
21465 func (_ fastpathT) DecMapFloat32UintV(v map[float32]uint, canChange bool,
21466 d *Decoder) (_ map[float32]uint, changed bool) {
21467 dd, esep := d.d, d.hh.hasElemSeparators()
21468 containerLen := dd.ReadMapStart()
21469 if canChange && v == nil {
21470 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
21471 v = make(map[float32]uint, xlen)
21474 if containerLen == 0 {
21481 hasLen := containerLen > 0
21482 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21484 dd.ReadMapElemKey()
21486 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21488 dd.ReadMapElemValue()
21490 if dd.TryDecodeAsNil() {
21492 } else if d.h.DeleteOnNilMapValue {
21499 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
21509 func (d *Decoder) fastpathDecMapFloat32Uint8R(f *codecFnInfo, rv reflect.Value) {
21510 if rv.Kind() == reflect.Ptr {
21511 vp := rv2i(rv).(*map[float32]uint8)
21512 v, changed := fastpathTV.DecMapFloat32Uint8V(*vp, true, d)
21517 fastpathTV.DecMapFloat32Uint8V(rv2i(rv).(map[float32]uint8), false, d)
21520 func (f fastpathT) DecMapFloat32Uint8X(vp *map[float32]uint8, d *Decoder) {
21521 v, changed := f.DecMapFloat32Uint8V(*vp, true, d)
21526 func (_ fastpathT) DecMapFloat32Uint8V(v map[float32]uint8, canChange bool,
21527 d *Decoder) (_ map[float32]uint8, changed bool) {
21528 dd, esep := d.d, d.hh.hasElemSeparators()
21529 containerLen := dd.ReadMapStart()
21530 if canChange && v == nil {
21531 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
21532 v = make(map[float32]uint8, xlen)
21535 if containerLen == 0 {
21542 hasLen := containerLen > 0
21543 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21545 dd.ReadMapElemKey()
21547 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21549 dd.ReadMapElemValue()
21551 if dd.TryDecodeAsNil() {
21553 } else if d.h.DeleteOnNilMapValue {
21560 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
21570 func (d *Decoder) fastpathDecMapFloat32Uint16R(f *codecFnInfo, rv reflect.Value) {
21571 if rv.Kind() == reflect.Ptr {
21572 vp := rv2i(rv).(*map[float32]uint16)
21573 v, changed := fastpathTV.DecMapFloat32Uint16V(*vp, true, d)
21578 fastpathTV.DecMapFloat32Uint16V(rv2i(rv).(map[float32]uint16), false, d)
21581 func (f fastpathT) DecMapFloat32Uint16X(vp *map[float32]uint16, d *Decoder) {
21582 v, changed := f.DecMapFloat32Uint16V(*vp, true, d)
21587 func (_ fastpathT) DecMapFloat32Uint16V(v map[float32]uint16, canChange bool,
21588 d *Decoder) (_ map[float32]uint16, changed bool) {
21589 dd, esep := d.d, d.hh.hasElemSeparators()
21590 containerLen := dd.ReadMapStart()
21591 if canChange && v == nil {
21592 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
21593 v = make(map[float32]uint16, xlen)
21596 if containerLen == 0 {
21603 hasLen := containerLen > 0
21604 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21606 dd.ReadMapElemKey()
21608 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21610 dd.ReadMapElemValue()
21612 if dd.TryDecodeAsNil() {
21614 } else if d.h.DeleteOnNilMapValue {
21621 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
21631 func (d *Decoder) fastpathDecMapFloat32Uint32R(f *codecFnInfo, rv reflect.Value) {
21632 if rv.Kind() == reflect.Ptr {
21633 vp := rv2i(rv).(*map[float32]uint32)
21634 v, changed := fastpathTV.DecMapFloat32Uint32V(*vp, true, d)
21639 fastpathTV.DecMapFloat32Uint32V(rv2i(rv).(map[float32]uint32), false, d)
21642 func (f fastpathT) DecMapFloat32Uint32X(vp *map[float32]uint32, d *Decoder) {
21643 v, changed := f.DecMapFloat32Uint32V(*vp, true, d)
21648 func (_ fastpathT) DecMapFloat32Uint32V(v map[float32]uint32, canChange bool,
21649 d *Decoder) (_ map[float32]uint32, changed bool) {
21650 dd, esep := d.d, d.hh.hasElemSeparators()
21651 containerLen := dd.ReadMapStart()
21652 if canChange && v == nil {
21653 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
21654 v = make(map[float32]uint32, xlen)
21657 if containerLen == 0 {
21664 hasLen := containerLen > 0
21665 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21667 dd.ReadMapElemKey()
21669 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21671 dd.ReadMapElemValue()
21673 if dd.TryDecodeAsNil() {
21675 } else if d.h.DeleteOnNilMapValue {
21682 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
21692 func (d *Decoder) fastpathDecMapFloat32Uint64R(f *codecFnInfo, rv reflect.Value) {
21693 if rv.Kind() == reflect.Ptr {
21694 vp := rv2i(rv).(*map[float32]uint64)
21695 v, changed := fastpathTV.DecMapFloat32Uint64V(*vp, true, d)
21700 fastpathTV.DecMapFloat32Uint64V(rv2i(rv).(map[float32]uint64), false, d)
21703 func (f fastpathT) DecMapFloat32Uint64X(vp *map[float32]uint64, d *Decoder) {
21704 v, changed := f.DecMapFloat32Uint64V(*vp, true, d)
21709 func (_ fastpathT) DecMapFloat32Uint64V(v map[float32]uint64, canChange bool,
21710 d *Decoder) (_ map[float32]uint64, changed bool) {
21711 dd, esep := d.d, d.hh.hasElemSeparators()
21712 containerLen := dd.ReadMapStart()
21713 if canChange && v == nil {
21714 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
21715 v = make(map[float32]uint64, xlen)
21718 if containerLen == 0 {
21725 hasLen := containerLen > 0
21726 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21728 dd.ReadMapElemKey()
21730 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21732 dd.ReadMapElemValue()
21734 if dd.TryDecodeAsNil() {
21736 } else if d.h.DeleteOnNilMapValue {
21743 mv = dd.DecodeUint64()
21753 func (d *Decoder) fastpathDecMapFloat32UintptrR(f *codecFnInfo, rv reflect.Value) {
21754 if rv.Kind() == reflect.Ptr {
21755 vp := rv2i(rv).(*map[float32]uintptr)
21756 v, changed := fastpathTV.DecMapFloat32UintptrV(*vp, true, d)
21761 fastpathTV.DecMapFloat32UintptrV(rv2i(rv).(map[float32]uintptr), false, d)
21764 func (f fastpathT) DecMapFloat32UintptrX(vp *map[float32]uintptr, d *Decoder) {
21765 v, changed := f.DecMapFloat32UintptrV(*vp, true, d)
21770 func (_ fastpathT) DecMapFloat32UintptrV(v map[float32]uintptr, canChange bool,
21771 d *Decoder) (_ map[float32]uintptr, changed bool) {
21772 dd, esep := d.d, d.hh.hasElemSeparators()
21773 containerLen := dd.ReadMapStart()
21774 if canChange && v == nil {
21775 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
21776 v = make(map[float32]uintptr, xlen)
21779 if containerLen == 0 {
21786 hasLen := containerLen > 0
21787 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21789 dd.ReadMapElemKey()
21791 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21793 dd.ReadMapElemValue()
21795 if dd.TryDecodeAsNil() {
21797 } else if d.h.DeleteOnNilMapValue {
21804 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
21814 func (d *Decoder) fastpathDecMapFloat32IntR(f *codecFnInfo, rv reflect.Value) {
21815 if rv.Kind() == reflect.Ptr {
21816 vp := rv2i(rv).(*map[float32]int)
21817 v, changed := fastpathTV.DecMapFloat32IntV(*vp, true, d)
21822 fastpathTV.DecMapFloat32IntV(rv2i(rv).(map[float32]int), false, d)
21825 func (f fastpathT) DecMapFloat32IntX(vp *map[float32]int, d *Decoder) {
21826 v, changed := f.DecMapFloat32IntV(*vp, true, d)
21831 func (_ fastpathT) DecMapFloat32IntV(v map[float32]int, canChange bool,
21832 d *Decoder) (_ map[float32]int, changed bool) {
21833 dd, esep := d.d, d.hh.hasElemSeparators()
21834 containerLen := dd.ReadMapStart()
21835 if canChange && v == nil {
21836 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
21837 v = make(map[float32]int, xlen)
21840 if containerLen == 0 {
21847 hasLen := containerLen > 0
21848 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21850 dd.ReadMapElemKey()
21852 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21854 dd.ReadMapElemValue()
21856 if dd.TryDecodeAsNil() {
21858 } else if d.h.DeleteOnNilMapValue {
21865 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
21875 func (d *Decoder) fastpathDecMapFloat32Int8R(f *codecFnInfo, rv reflect.Value) {
21876 if rv.Kind() == reflect.Ptr {
21877 vp := rv2i(rv).(*map[float32]int8)
21878 v, changed := fastpathTV.DecMapFloat32Int8V(*vp, true, d)
21883 fastpathTV.DecMapFloat32Int8V(rv2i(rv).(map[float32]int8), false, d)
21886 func (f fastpathT) DecMapFloat32Int8X(vp *map[float32]int8, d *Decoder) {
21887 v, changed := f.DecMapFloat32Int8V(*vp, true, d)
21892 func (_ fastpathT) DecMapFloat32Int8V(v map[float32]int8, canChange bool,
21893 d *Decoder) (_ map[float32]int8, changed bool) {
21894 dd, esep := d.d, d.hh.hasElemSeparators()
21895 containerLen := dd.ReadMapStart()
21896 if canChange && v == nil {
21897 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
21898 v = make(map[float32]int8, xlen)
21901 if containerLen == 0 {
21908 hasLen := containerLen > 0
21909 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21911 dd.ReadMapElemKey()
21913 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21915 dd.ReadMapElemValue()
21917 if dd.TryDecodeAsNil() {
21919 } else if d.h.DeleteOnNilMapValue {
21926 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
21936 func (d *Decoder) fastpathDecMapFloat32Int16R(f *codecFnInfo, rv reflect.Value) {
21937 if rv.Kind() == reflect.Ptr {
21938 vp := rv2i(rv).(*map[float32]int16)
21939 v, changed := fastpathTV.DecMapFloat32Int16V(*vp, true, d)
21944 fastpathTV.DecMapFloat32Int16V(rv2i(rv).(map[float32]int16), false, d)
21947 func (f fastpathT) DecMapFloat32Int16X(vp *map[float32]int16, d *Decoder) {
21948 v, changed := f.DecMapFloat32Int16V(*vp, true, d)
21953 func (_ fastpathT) DecMapFloat32Int16V(v map[float32]int16, canChange bool,
21954 d *Decoder) (_ map[float32]int16, changed bool) {
21955 dd, esep := d.d, d.hh.hasElemSeparators()
21956 containerLen := dd.ReadMapStart()
21957 if canChange && v == nil {
21958 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
21959 v = make(map[float32]int16, xlen)
21962 if containerLen == 0 {
21969 hasLen := containerLen > 0
21970 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21972 dd.ReadMapElemKey()
21974 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21976 dd.ReadMapElemValue()
21978 if dd.TryDecodeAsNil() {
21980 } else if d.h.DeleteOnNilMapValue {
21987 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
21997 func (d *Decoder) fastpathDecMapFloat32Int32R(f *codecFnInfo, rv reflect.Value) {
21998 if rv.Kind() == reflect.Ptr {
21999 vp := rv2i(rv).(*map[float32]int32)
22000 v, changed := fastpathTV.DecMapFloat32Int32V(*vp, true, d)
22005 fastpathTV.DecMapFloat32Int32V(rv2i(rv).(map[float32]int32), false, d)
22008 func (f fastpathT) DecMapFloat32Int32X(vp *map[float32]int32, d *Decoder) {
22009 v, changed := f.DecMapFloat32Int32V(*vp, true, d)
22014 func (_ fastpathT) DecMapFloat32Int32V(v map[float32]int32, canChange bool,
22015 d *Decoder) (_ map[float32]int32, changed bool) {
22016 dd, esep := d.d, d.hh.hasElemSeparators()
22017 containerLen := dd.ReadMapStart()
22018 if canChange && v == nil {
22019 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
22020 v = make(map[float32]int32, xlen)
22023 if containerLen == 0 {
22030 hasLen := containerLen > 0
22031 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22033 dd.ReadMapElemKey()
22035 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
22037 dd.ReadMapElemValue()
22039 if dd.TryDecodeAsNil() {
22041 } else if d.h.DeleteOnNilMapValue {
22048 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
22058 func (d *Decoder) fastpathDecMapFloat32Int64R(f *codecFnInfo, rv reflect.Value) {
22059 if rv.Kind() == reflect.Ptr {
22060 vp := rv2i(rv).(*map[float32]int64)
22061 v, changed := fastpathTV.DecMapFloat32Int64V(*vp, true, d)
22066 fastpathTV.DecMapFloat32Int64V(rv2i(rv).(map[float32]int64), false, d)
22069 func (f fastpathT) DecMapFloat32Int64X(vp *map[float32]int64, d *Decoder) {
22070 v, changed := f.DecMapFloat32Int64V(*vp, true, d)
22075 func (_ fastpathT) DecMapFloat32Int64V(v map[float32]int64, canChange bool,
22076 d *Decoder) (_ map[float32]int64, changed bool) {
22077 dd, esep := d.d, d.hh.hasElemSeparators()
22078 containerLen := dd.ReadMapStart()
22079 if canChange && v == nil {
22080 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
22081 v = make(map[float32]int64, xlen)
22084 if containerLen == 0 {
22091 hasLen := containerLen > 0
22092 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22094 dd.ReadMapElemKey()
22096 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
22098 dd.ReadMapElemValue()
22100 if dd.TryDecodeAsNil() {
22102 } else if d.h.DeleteOnNilMapValue {
22109 mv = dd.DecodeInt64()
22119 func (d *Decoder) fastpathDecMapFloat32Float32R(f *codecFnInfo, rv reflect.Value) {
22120 if rv.Kind() == reflect.Ptr {
22121 vp := rv2i(rv).(*map[float32]float32)
22122 v, changed := fastpathTV.DecMapFloat32Float32V(*vp, true, d)
22127 fastpathTV.DecMapFloat32Float32V(rv2i(rv).(map[float32]float32), false, d)
22130 func (f fastpathT) DecMapFloat32Float32X(vp *map[float32]float32, d *Decoder) {
22131 v, changed := f.DecMapFloat32Float32V(*vp, true, d)
22136 func (_ fastpathT) DecMapFloat32Float32V(v map[float32]float32, canChange bool,
22137 d *Decoder) (_ map[float32]float32, changed bool) {
22138 dd, esep := d.d, d.hh.hasElemSeparators()
22139 containerLen := dd.ReadMapStart()
22140 if canChange && v == nil {
22141 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
22142 v = make(map[float32]float32, xlen)
22145 if containerLen == 0 {
22152 hasLen := containerLen > 0
22153 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22155 dd.ReadMapElemKey()
22157 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
22159 dd.ReadMapElemValue()
22161 if dd.TryDecodeAsNil() {
22163 } else if d.h.DeleteOnNilMapValue {
22170 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
22180 func (d *Decoder) fastpathDecMapFloat32Float64R(f *codecFnInfo, rv reflect.Value) {
22181 if rv.Kind() == reflect.Ptr {
22182 vp := rv2i(rv).(*map[float32]float64)
22183 v, changed := fastpathTV.DecMapFloat32Float64V(*vp, true, d)
22188 fastpathTV.DecMapFloat32Float64V(rv2i(rv).(map[float32]float64), false, d)
22191 func (f fastpathT) DecMapFloat32Float64X(vp *map[float32]float64, d *Decoder) {
22192 v, changed := f.DecMapFloat32Float64V(*vp, true, d)
22197 func (_ fastpathT) DecMapFloat32Float64V(v map[float32]float64, canChange bool,
22198 d *Decoder) (_ map[float32]float64, changed bool) {
22199 dd, esep := d.d, d.hh.hasElemSeparators()
22200 containerLen := dd.ReadMapStart()
22201 if canChange && v == nil {
22202 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
22203 v = make(map[float32]float64, xlen)
22206 if containerLen == 0 {
22213 hasLen := containerLen > 0
22214 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22216 dd.ReadMapElemKey()
22218 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
22220 dd.ReadMapElemValue()
22222 if dd.TryDecodeAsNil() {
22224 } else if d.h.DeleteOnNilMapValue {
22231 mv = dd.DecodeFloat64()
22241 func (d *Decoder) fastpathDecMapFloat32BoolR(f *codecFnInfo, rv reflect.Value) {
22242 if rv.Kind() == reflect.Ptr {
22243 vp := rv2i(rv).(*map[float32]bool)
22244 v, changed := fastpathTV.DecMapFloat32BoolV(*vp, true, d)
22249 fastpathTV.DecMapFloat32BoolV(rv2i(rv).(map[float32]bool), false, d)
22252 func (f fastpathT) DecMapFloat32BoolX(vp *map[float32]bool, d *Decoder) {
22253 v, changed := f.DecMapFloat32BoolV(*vp, true, d)
22258 func (_ fastpathT) DecMapFloat32BoolV(v map[float32]bool, canChange bool,
22259 d *Decoder) (_ map[float32]bool, changed bool) {
22260 dd, esep := d.d, d.hh.hasElemSeparators()
22261 containerLen := dd.ReadMapStart()
22262 if canChange && v == nil {
22263 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
22264 v = make(map[float32]bool, xlen)
22267 if containerLen == 0 {
22274 hasLen := containerLen > 0
22275 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22277 dd.ReadMapElemKey()
22279 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
22281 dd.ReadMapElemValue()
22283 if dd.TryDecodeAsNil() {
22285 } else if d.h.DeleteOnNilMapValue {
22292 mv = dd.DecodeBool()
22302 func (d *Decoder) fastpathDecMapFloat64IntfR(f *codecFnInfo, rv reflect.Value) {
22303 if rv.Kind() == reflect.Ptr {
22304 vp := rv2i(rv).(*map[float64]interface{})
22305 v, changed := fastpathTV.DecMapFloat64IntfV(*vp, true, d)
22310 fastpathTV.DecMapFloat64IntfV(rv2i(rv).(map[float64]interface{}), false, d)
22313 func (f fastpathT) DecMapFloat64IntfX(vp *map[float64]interface{}, d *Decoder) {
22314 v, changed := f.DecMapFloat64IntfV(*vp, true, d)
22319 func (_ fastpathT) DecMapFloat64IntfV(v map[float64]interface{}, canChange bool,
22320 d *Decoder) (_ map[float64]interface{}, changed bool) {
22321 dd, esep := d.d, d.hh.hasElemSeparators()
22322 containerLen := dd.ReadMapStart()
22323 if canChange && v == nil {
22324 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
22325 v = make(map[float64]interface{}, xlen)
22328 if containerLen == 0 {
22333 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
22336 hasLen := containerLen > 0
22337 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22339 dd.ReadMapElemKey()
22341 mk = dd.DecodeFloat64()
22343 dd.ReadMapElemValue()
22345 if dd.TryDecodeAsNil() {
22347 } else if d.h.DeleteOnNilMapValue {
22369 func (d *Decoder) fastpathDecMapFloat64StringR(f *codecFnInfo, rv reflect.Value) {
22370 if rv.Kind() == reflect.Ptr {
22371 vp := rv2i(rv).(*map[float64]string)
22372 v, changed := fastpathTV.DecMapFloat64StringV(*vp, true, d)
22377 fastpathTV.DecMapFloat64StringV(rv2i(rv).(map[float64]string), false, d)
22380 func (f fastpathT) DecMapFloat64StringX(vp *map[float64]string, d *Decoder) {
22381 v, changed := f.DecMapFloat64StringV(*vp, true, d)
22386 func (_ fastpathT) DecMapFloat64StringV(v map[float64]string, canChange bool,
22387 d *Decoder) (_ map[float64]string, changed bool) {
22388 dd, esep := d.d, d.hh.hasElemSeparators()
22389 containerLen := dd.ReadMapStart()
22390 if canChange && v == nil {
22391 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
22392 v = make(map[float64]string, xlen)
22395 if containerLen == 0 {
22402 hasLen := containerLen > 0
22403 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22405 dd.ReadMapElemKey()
22407 mk = dd.DecodeFloat64()
22409 dd.ReadMapElemValue()
22411 if dd.TryDecodeAsNil() {
22413 } else if d.h.DeleteOnNilMapValue {
22420 mv = dd.DecodeString()
22430 func (d *Decoder) fastpathDecMapFloat64UintR(f *codecFnInfo, rv reflect.Value) {
22431 if rv.Kind() == reflect.Ptr {
22432 vp := rv2i(rv).(*map[float64]uint)
22433 v, changed := fastpathTV.DecMapFloat64UintV(*vp, true, d)
22438 fastpathTV.DecMapFloat64UintV(rv2i(rv).(map[float64]uint), false, d)
22441 func (f fastpathT) DecMapFloat64UintX(vp *map[float64]uint, d *Decoder) {
22442 v, changed := f.DecMapFloat64UintV(*vp, true, d)
22447 func (_ fastpathT) DecMapFloat64UintV(v map[float64]uint, canChange bool,
22448 d *Decoder) (_ map[float64]uint, changed bool) {
22449 dd, esep := d.d, d.hh.hasElemSeparators()
22450 containerLen := dd.ReadMapStart()
22451 if canChange && v == nil {
22452 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
22453 v = make(map[float64]uint, xlen)
22456 if containerLen == 0 {
22463 hasLen := containerLen > 0
22464 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22466 dd.ReadMapElemKey()
22468 mk = dd.DecodeFloat64()
22470 dd.ReadMapElemValue()
22472 if dd.TryDecodeAsNil() {
22474 } else if d.h.DeleteOnNilMapValue {
22481 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
22491 func (d *Decoder) fastpathDecMapFloat64Uint8R(f *codecFnInfo, rv reflect.Value) {
22492 if rv.Kind() == reflect.Ptr {
22493 vp := rv2i(rv).(*map[float64]uint8)
22494 v, changed := fastpathTV.DecMapFloat64Uint8V(*vp, true, d)
22499 fastpathTV.DecMapFloat64Uint8V(rv2i(rv).(map[float64]uint8), false, d)
22502 func (f fastpathT) DecMapFloat64Uint8X(vp *map[float64]uint8, d *Decoder) {
22503 v, changed := f.DecMapFloat64Uint8V(*vp, true, d)
22508 func (_ fastpathT) DecMapFloat64Uint8V(v map[float64]uint8, canChange bool,
22509 d *Decoder) (_ map[float64]uint8, changed bool) {
22510 dd, esep := d.d, d.hh.hasElemSeparators()
22511 containerLen := dd.ReadMapStart()
22512 if canChange && v == nil {
22513 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
22514 v = make(map[float64]uint8, xlen)
22517 if containerLen == 0 {
22524 hasLen := containerLen > 0
22525 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22527 dd.ReadMapElemKey()
22529 mk = dd.DecodeFloat64()
22531 dd.ReadMapElemValue()
22533 if dd.TryDecodeAsNil() {
22535 } else if d.h.DeleteOnNilMapValue {
22542 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
22552 func (d *Decoder) fastpathDecMapFloat64Uint16R(f *codecFnInfo, rv reflect.Value) {
22553 if rv.Kind() == reflect.Ptr {
22554 vp := rv2i(rv).(*map[float64]uint16)
22555 v, changed := fastpathTV.DecMapFloat64Uint16V(*vp, true, d)
22560 fastpathTV.DecMapFloat64Uint16V(rv2i(rv).(map[float64]uint16), false, d)
22563 func (f fastpathT) DecMapFloat64Uint16X(vp *map[float64]uint16, d *Decoder) {
22564 v, changed := f.DecMapFloat64Uint16V(*vp, true, d)
22569 func (_ fastpathT) DecMapFloat64Uint16V(v map[float64]uint16, canChange bool,
22570 d *Decoder) (_ map[float64]uint16, changed bool) {
22571 dd, esep := d.d, d.hh.hasElemSeparators()
22572 containerLen := dd.ReadMapStart()
22573 if canChange && v == nil {
22574 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
22575 v = make(map[float64]uint16, xlen)
22578 if containerLen == 0 {
22585 hasLen := containerLen > 0
22586 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22588 dd.ReadMapElemKey()
22590 mk = dd.DecodeFloat64()
22592 dd.ReadMapElemValue()
22594 if dd.TryDecodeAsNil() {
22596 } else if d.h.DeleteOnNilMapValue {
22603 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
22613 func (d *Decoder) fastpathDecMapFloat64Uint32R(f *codecFnInfo, rv reflect.Value) {
22614 if rv.Kind() == reflect.Ptr {
22615 vp := rv2i(rv).(*map[float64]uint32)
22616 v, changed := fastpathTV.DecMapFloat64Uint32V(*vp, true, d)
22621 fastpathTV.DecMapFloat64Uint32V(rv2i(rv).(map[float64]uint32), false, d)
22624 func (f fastpathT) DecMapFloat64Uint32X(vp *map[float64]uint32, d *Decoder) {
22625 v, changed := f.DecMapFloat64Uint32V(*vp, true, d)
22630 func (_ fastpathT) DecMapFloat64Uint32V(v map[float64]uint32, canChange bool,
22631 d *Decoder) (_ map[float64]uint32, changed bool) {
22632 dd, esep := d.d, d.hh.hasElemSeparators()
22633 containerLen := dd.ReadMapStart()
22634 if canChange && v == nil {
22635 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
22636 v = make(map[float64]uint32, xlen)
22639 if containerLen == 0 {
22646 hasLen := containerLen > 0
22647 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22649 dd.ReadMapElemKey()
22651 mk = dd.DecodeFloat64()
22653 dd.ReadMapElemValue()
22655 if dd.TryDecodeAsNil() {
22657 } else if d.h.DeleteOnNilMapValue {
22664 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
22674 func (d *Decoder) fastpathDecMapFloat64Uint64R(f *codecFnInfo, rv reflect.Value) {
22675 if rv.Kind() == reflect.Ptr {
22676 vp := rv2i(rv).(*map[float64]uint64)
22677 v, changed := fastpathTV.DecMapFloat64Uint64V(*vp, true, d)
22682 fastpathTV.DecMapFloat64Uint64V(rv2i(rv).(map[float64]uint64), false, d)
22685 func (f fastpathT) DecMapFloat64Uint64X(vp *map[float64]uint64, d *Decoder) {
22686 v, changed := f.DecMapFloat64Uint64V(*vp, true, d)
22691 func (_ fastpathT) DecMapFloat64Uint64V(v map[float64]uint64, canChange bool,
22692 d *Decoder) (_ map[float64]uint64, changed bool) {
22693 dd, esep := d.d, d.hh.hasElemSeparators()
22694 containerLen := dd.ReadMapStart()
22695 if canChange && v == nil {
22696 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
22697 v = make(map[float64]uint64, xlen)
22700 if containerLen == 0 {
22707 hasLen := containerLen > 0
22708 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22710 dd.ReadMapElemKey()
22712 mk = dd.DecodeFloat64()
22714 dd.ReadMapElemValue()
22716 if dd.TryDecodeAsNil() {
22718 } else if d.h.DeleteOnNilMapValue {
22725 mv = dd.DecodeUint64()
22735 func (d *Decoder) fastpathDecMapFloat64UintptrR(f *codecFnInfo, rv reflect.Value) {
22736 if rv.Kind() == reflect.Ptr {
22737 vp := rv2i(rv).(*map[float64]uintptr)
22738 v, changed := fastpathTV.DecMapFloat64UintptrV(*vp, true, d)
22743 fastpathTV.DecMapFloat64UintptrV(rv2i(rv).(map[float64]uintptr), false, d)
22746 func (f fastpathT) DecMapFloat64UintptrX(vp *map[float64]uintptr, d *Decoder) {
22747 v, changed := f.DecMapFloat64UintptrV(*vp, true, d)
22752 func (_ fastpathT) DecMapFloat64UintptrV(v map[float64]uintptr, canChange bool,
22753 d *Decoder) (_ map[float64]uintptr, changed bool) {
22754 dd, esep := d.d, d.hh.hasElemSeparators()
22755 containerLen := dd.ReadMapStart()
22756 if canChange && v == nil {
22757 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
22758 v = make(map[float64]uintptr, xlen)
22761 if containerLen == 0 {
22768 hasLen := containerLen > 0
22769 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22771 dd.ReadMapElemKey()
22773 mk = dd.DecodeFloat64()
22775 dd.ReadMapElemValue()
22777 if dd.TryDecodeAsNil() {
22779 } else if d.h.DeleteOnNilMapValue {
22786 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
22796 func (d *Decoder) fastpathDecMapFloat64IntR(f *codecFnInfo, rv reflect.Value) {
22797 if rv.Kind() == reflect.Ptr {
22798 vp := rv2i(rv).(*map[float64]int)
22799 v, changed := fastpathTV.DecMapFloat64IntV(*vp, true, d)
22804 fastpathTV.DecMapFloat64IntV(rv2i(rv).(map[float64]int), false, d)
22807 func (f fastpathT) DecMapFloat64IntX(vp *map[float64]int, d *Decoder) {
22808 v, changed := f.DecMapFloat64IntV(*vp, true, d)
22813 func (_ fastpathT) DecMapFloat64IntV(v map[float64]int, canChange bool,
22814 d *Decoder) (_ map[float64]int, changed bool) {
22815 dd, esep := d.d, d.hh.hasElemSeparators()
22816 containerLen := dd.ReadMapStart()
22817 if canChange && v == nil {
22818 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
22819 v = make(map[float64]int, xlen)
22822 if containerLen == 0 {
22829 hasLen := containerLen > 0
22830 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22832 dd.ReadMapElemKey()
22834 mk = dd.DecodeFloat64()
22836 dd.ReadMapElemValue()
22838 if dd.TryDecodeAsNil() {
22840 } else if d.h.DeleteOnNilMapValue {
22847 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
22857 func (d *Decoder) fastpathDecMapFloat64Int8R(f *codecFnInfo, rv reflect.Value) {
22858 if rv.Kind() == reflect.Ptr {
22859 vp := rv2i(rv).(*map[float64]int8)
22860 v, changed := fastpathTV.DecMapFloat64Int8V(*vp, true, d)
22865 fastpathTV.DecMapFloat64Int8V(rv2i(rv).(map[float64]int8), false, d)
22868 func (f fastpathT) DecMapFloat64Int8X(vp *map[float64]int8, d *Decoder) {
22869 v, changed := f.DecMapFloat64Int8V(*vp, true, d)
22874 func (_ fastpathT) DecMapFloat64Int8V(v map[float64]int8, canChange bool,
22875 d *Decoder) (_ map[float64]int8, changed bool) {
22876 dd, esep := d.d, d.hh.hasElemSeparators()
22877 containerLen := dd.ReadMapStart()
22878 if canChange && v == nil {
22879 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
22880 v = make(map[float64]int8, xlen)
22883 if containerLen == 0 {
22890 hasLen := containerLen > 0
22891 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22893 dd.ReadMapElemKey()
22895 mk = dd.DecodeFloat64()
22897 dd.ReadMapElemValue()
22899 if dd.TryDecodeAsNil() {
22901 } else if d.h.DeleteOnNilMapValue {
22908 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
22918 func (d *Decoder) fastpathDecMapFloat64Int16R(f *codecFnInfo, rv reflect.Value) {
22919 if rv.Kind() == reflect.Ptr {
22920 vp := rv2i(rv).(*map[float64]int16)
22921 v, changed := fastpathTV.DecMapFloat64Int16V(*vp, true, d)
22926 fastpathTV.DecMapFloat64Int16V(rv2i(rv).(map[float64]int16), false, d)
22929 func (f fastpathT) DecMapFloat64Int16X(vp *map[float64]int16, d *Decoder) {
22930 v, changed := f.DecMapFloat64Int16V(*vp, true, d)
22935 func (_ fastpathT) DecMapFloat64Int16V(v map[float64]int16, canChange bool,
22936 d *Decoder) (_ map[float64]int16, changed bool) {
22937 dd, esep := d.d, d.hh.hasElemSeparators()
22938 containerLen := dd.ReadMapStart()
22939 if canChange && v == nil {
22940 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
22941 v = make(map[float64]int16, xlen)
22944 if containerLen == 0 {
22951 hasLen := containerLen > 0
22952 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22954 dd.ReadMapElemKey()
22956 mk = dd.DecodeFloat64()
22958 dd.ReadMapElemValue()
22960 if dd.TryDecodeAsNil() {
22962 } else if d.h.DeleteOnNilMapValue {
22969 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
22979 func (d *Decoder) fastpathDecMapFloat64Int32R(f *codecFnInfo, rv reflect.Value) {
22980 if rv.Kind() == reflect.Ptr {
22981 vp := rv2i(rv).(*map[float64]int32)
22982 v, changed := fastpathTV.DecMapFloat64Int32V(*vp, true, d)
22987 fastpathTV.DecMapFloat64Int32V(rv2i(rv).(map[float64]int32), false, d)
22990 func (f fastpathT) DecMapFloat64Int32X(vp *map[float64]int32, d *Decoder) {
22991 v, changed := f.DecMapFloat64Int32V(*vp, true, d)
22996 func (_ fastpathT) DecMapFloat64Int32V(v map[float64]int32, canChange bool,
22997 d *Decoder) (_ map[float64]int32, changed bool) {
22998 dd, esep := d.d, d.hh.hasElemSeparators()
22999 containerLen := dd.ReadMapStart()
23000 if canChange && v == nil {
23001 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
23002 v = make(map[float64]int32, xlen)
23005 if containerLen == 0 {
23012 hasLen := containerLen > 0
23013 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23015 dd.ReadMapElemKey()
23017 mk = dd.DecodeFloat64()
23019 dd.ReadMapElemValue()
23021 if dd.TryDecodeAsNil() {
23023 } else if d.h.DeleteOnNilMapValue {
23030 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
23040 func (d *Decoder) fastpathDecMapFloat64Int64R(f *codecFnInfo, rv reflect.Value) {
23041 if rv.Kind() == reflect.Ptr {
23042 vp := rv2i(rv).(*map[float64]int64)
23043 v, changed := fastpathTV.DecMapFloat64Int64V(*vp, true, d)
23048 fastpathTV.DecMapFloat64Int64V(rv2i(rv).(map[float64]int64), false, d)
23051 func (f fastpathT) DecMapFloat64Int64X(vp *map[float64]int64, d *Decoder) {
23052 v, changed := f.DecMapFloat64Int64V(*vp, true, d)
23057 func (_ fastpathT) DecMapFloat64Int64V(v map[float64]int64, canChange bool,
23058 d *Decoder) (_ map[float64]int64, changed bool) {
23059 dd, esep := d.d, d.hh.hasElemSeparators()
23060 containerLen := dd.ReadMapStart()
23061 if canChange && v == nil {
23062 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
23063 v = make(map[float64]int64, xlen)
23066 if containerLen == 0 {
23073 hasLen := containerLen > 0
23074 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23076 dd.ReadMapElemKey()
23078 mk = dd.DecodeFloat64()
23080 dd.ReadMapElemValue()
23082 if dd.TryDecodeAsNil() {
23084 } else if d.h.DeleteOnNilMapValue {
23091 mv = dd.DecodeInt64()
23101 func (d *Decoder) fastpathDecMapFloat64Float32R(f *codecFnInfo, rv reflect.Value) {
23102 if rv.Kind() == reflect.Ptr {
23103 vp := rv2i(rv).(*map[float64]float32)
23104 v, changed := fastpathTV.DecMapFloat64Float32V(*vp, true, d)
23109 fastpathTV.DecMapFloat64Float32V(rv2i(rv).(map[float64]float32), false, d)
23112 func (f fastpathT) DecMapFloat64Float32X(vp *map[float64]float32, d *Decoder) {
23113 v, changed := f.DecMapFloat64Float32V(*vp, true, d)
23118 func (_ fastpathT) DecMapFloat64Float32V(v map[float64]float32, canChange bool,
23119 d *Decoder) (_ map[float64]float32, changed bool) {
23120 dd, esep := d.d, d.hh.hasElemSeparators()
23121 containerLen := dd.ReadMapStart()
23122 if canChange && v == nil {
23123 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
23124 v = make(map[float64]float32, xlen)
23127 if containerLen == 0 {
23134 hasLen := containerLen > 0
23135 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23137 dd.ReadMapElemKey()
23139 mk = dd.DecodeFloat64()
23141 dd.ReadMapElemValue()
23143 if dd.TryDecodeAsNil() {
23145 } else if d.h.DeleteOnNilMapValue {
23152 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
23162 func (d *Decoder) fastpathDecMapFloat64Float64R(f *codecFnInfo, rv reflect.Value) {
23163 if rv.Kind() == reflect.Ptr {
23164 vp := rv2i(rv).(*map[float64]float64)
23165 v, changed := fastpathTV.DecMapFloat64Float64V(*vp, true, d)
23170 fastpathTV.DecMapFloat64Float64V(rv2i(rv).(map[float64]float64), false, d)
23173 func (f fastpathT) DecMapFloat64Float64X(vp *map[float64]float64, d *Decoder) {
23174 v, changed := f.DecMapFloat64Float64V(*vp, true, d)
23179 func (_ fastpathT) DecMapFloat64Float64V(v map[float64]float64, canChange bool,
23180 d *Decoder) (_ map[float64]float64, changed bool) {
23181 dd, esep := d.d, d.hh.hasElemSeparators()
23182 containerLen := dd.ReadMapStart()
23183 if canChange && v == nil {
23184 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
23185 v = make(map[float64]float64, xlen)
23188 if containerLen == 0 {
23195 hasLen := containerLen > 0
23196 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23198 dd.ReadMapElemKey()
23200 mk = dd.DecodeFloat64()
23202 dd.ReadMapElemValue()
23204 if dd.TryDecodeAsNil() {
23206 } else if d.h.DeleteOnNilMapValue {
23213 mv = dd.DecodeFloat64()
23223 func (d *Decoder) fastpathDecMapFloat64BoolR(f *codecFnInfo, rv reflect.Value) {
23224 if rv.Kind() == reflect.Ptr {
23225 vp := rv2i(rv).(*map[float64]bool)
23226 v, changed := fastpathTV.DecMapFloat64BoolV(*vp, true, d)
23231 fastpathTV.DecMapFloat64BoolV(rv2i(rv).(map[float64]bool), false, d)
23234 func (f fastpathT) DecMapFloat64BoolX(vp *map[float64]bool, d *Decoder) {
23235 v, changed := f.DecMapFloat64BoolV(*vp, true, d)
23240 func (_ fastpathT) DecMapFloat64BoolV(v map[float64]bool, canChange bool,
23241 d *Decoder) (_ map[float64]bool, changed bool) {
23242 dd, esep := d.d, d.hh.hasElemSeparators()
23243 containerLen := dd.ReadMapStart()
23244 if canChange && v == nil {
23245 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
23246 v = make(map[float64]bool, xlen)
23249 if containerLen == 0 {
23256 hasLen := containerLen > 0
23257 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23259 dd.ReadMapElemKey()
23261 mk = dd.DecodeFloat64()
23263 dd.ReadMapElemValue()
23265 if dd.TryDecodeAsNil() {
23267 } else if d.h.DeleteOnNilMapValue {
23274 mv = dd.DecodeBool()
23284 func (d *Decoder) fastpathDecMapUintIntfR(f *codecFnInfo, rv reflect.Value) {
23285 if rv.Kind() == reflect.Ptr {
23286 vp := rv2i(rv).(*map[uint]interface{})
23287 v, changed := fastpathTV.DecMapUintIntfV(*vp, true, d)
23292 fastpathTV.DecMapUintIntfV(rv2i(rv).(map[uint]interface{}), false, d)
23295 func (f fastpathT) DecMapUintIntfX(vp *map[uint]interface{}, d *Decoder) {
23296 v, changed := f.DecMapUintIntfV(*vp, true, d)
23301 func (_ fastpathT) DecMapUintIntfV(v map[uint]interface{}, canChange bool,
23302 d *Decoder) (_ map[uint]interface{}, changed bool) {
23303 dd, esep := d.d, d.hh.hasElemSeparators()
23304 containerLen := dd.ReadMapStart()
23305 if canChange && v == nil {
23306 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
23307 v = make(map[uint]interface{}, xlen)
23310 if containerLen == 0 {
23315 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
23318 hasLen := containerLen > 0
23319 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23321 dd.ReadMapElemKey()
23323 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23325 dd.ReadMapElemValue()
23327 if dd.TryDecodeAsNil() {
23329 } else if d.h.DeleteOnNilMapValue {
23351 func (d *Decoder) fastpathDecMapUintStringR(f *codecFnInfo, rv reflect.Value) {
23352 if rv.Kind() == reflect.Ptr {
23353 vp := rv2i(rv).(*map[uint]string)
23354 v, changed := fastpathTV.DecMapUintStringV(*vp, true, d)
23359 fastpathTV.DecMapUintStringV(rv2i(rv).(map[uint]string), false, d)
23362 func (f fastpathT) DecMapUintStringX(vp *map[uint]string, d *Decoder) {
23363 v, changed := f.DecMapUintStringV(*vp, true, d)
23368 func (_ fastpathT) DecMapUintStringV(v map[uint]string, canChange bool,
23369 d *Decoder) (_ map[uint]string, changed bool) {
23370 dd, esep := d.d, d.hh.hasElemSeparators()
23371 containerLen := dd.ReadMapStart()
23372 if canChange && v == nil {
23373 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
23374 v = make(map[uint]string, xlen)
23377 if containerLen == 0 {
23384 hasLen := containerLen > 0
23385 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23387 dd.ReadMapElemKey()
23389 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23391 dd.ReadMapElemValue()
23393 if dd.TryDecodeAsNil() {
23395 } else if d.h.DeleteOnNilMapValue {
23402 mv = dd.DecodeString()
23412 func (d *Decoder) fastpathDecMapUintUintR(f *codecFnInfo, rv reflect.Value) {
23413 if rv.Kind() == reflect.Ptr {
23414 vp := rv2i(rv).(*map[uint]uint)
23415 v, changed := fastpathTV.DecMapUintUintV(*vp, true, d)
23420 fastpathTV.DecMapUintUintV(rv2i(rv).(map[uint]uint), false, d)
23423 func (f fastpathT) DecMapUintUintX(vp *map[uint]uint, d *Decoder) {
23424 v, changed := f.DecMapUintUintV(*vp, true, d)
23429 func (_ fastpathT) DecMapUintUintV(v map[uint]uint, canChange bool,
23430 d *Decoder) (_ map[uint]uint, changed bool) {
23431 dd, esep := d.d, d.hh.hasElemSeparators()
23432 containerLen := dd.ReadMapStart()
23433 if canChange && v == nil {
23434 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
23435 v = make(map[uint]uint, xlen)
23438 if containerLen == 0 {
23445 hasLen := containerLen > 0
23446 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23448 dd.ReadMapElemKey()
23450 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23452 dd.ReadMapElemValue()
23454 if dd.TryDecodeAsNil() {
23456 } else if d.h.DeleteOnNilMapValue {
23463 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23473 func (d *Decoder) fastpathDecMapUintUint8R(f *codecFnInfo, rv reflect.Value) {
23474 if rv.Kind() == reflect.Ptr {
23475 vp := rv2i(rv).(*map[uint]uint8)
23476 v, changed := fastpathTV.DecMapUintUint8V(*vp, true, d)
23481 fastpathTV.DecMapUintUint8V(rv2i(rv).(map[uint]uint8), false, d)
23484 func (f fastpathT) DecMapUintUint8X(vp *map[uint]uint8, d *Decoder) {
23485 v, changed := f.DecMapUintUint8V(*vp, true, d)
23490 func (_ fastpathT) DecMapUintUint8V(v map[uint]uint8, canChange bool,
23491 d *Decoder) (_ map[uint]uint8, changed bool) {
23492 dd, esep := d.d, d.hh.hasElemSeparators()
23493 containerLen := dd.ReadMapStart()
23494 if canChange && v == nil {
23495 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
23496 v = make(map[uint]uint8, xlen)
23499 if containerLen == 0 {
23506 hasLen := containerLen > 0
23507 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23509 dd.ReadMapElemKey()
23511 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23513 dd.ReadMapElemValue()
23515 if dd.TryDecodeAsNil() {
23517 } else if d.h.DeleteOnNilMapValue {
23524 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
23534 func (d *Decoder) fastpathDecMapUintUint16R(f *codecFnInfo, rv reflect.Value) {
23535 if rv.Kind() == reflect.Ptr {
23536 vp := rv2i(rv).(*map[uint]uint16)
23537 v, changed := fastpathTV.DecMapUintUint16V(*vp, true, d)
23542 fastpathTV.DecMapUintUint16V(rv2i(rv).(map[uint]uint16), false, d)
23545 func (f fastpathT) DecMapUintUint16X(vp *map[uint]uint16, d *Decoder) {
23546 v, changed := f.DecMapUintUint16V(*vp, true, d)
23551 func (_ fastpathT) DecMapUintUint16V(v map[uint]uint16, canChange bool,
23552 d *Decoder) (_ map[uint]uint16, changed bool) {
23553 dd, esep := d.d, d.hh.hasElemSeparators()
23554 containerLen := dd.ReadMapStart()
23555 if canChange && v == nil {
23556 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
23557 v = make(map[uint]uint16, xlen)
23560 if containerLen == 0 {
23567 hasLen := containerLen > 0
23568 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23570 dd.ReadMapElemKey()
23572 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23574 dd.ReadMapElemValue()
23576 if dd.TryDecodeAsNil() {
23578 } else if d.h.DeleteOnNilMapValue {
23585 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
23595 func (d *Decoder) fastpathDecMapUintUint32R(f *codecFnInfo, rv reflect.Value) {
23596 if rv.Kind() == reflect.Ptr {
23597 vp := rv2i(rv).(*map[uint]uint32)
23598 v, changed := fastpathTV.DecMapUintUint32V(*vp, true, d)
23603 fastpathTV.DecMapUintUint32V(rv2i(rv).(map[uint]uint32), false, d)
23606 func (f fastpathT) DecMapUintUint32X(vp *map[uint]uint32, d *Decoder) {
23607 v, changed := f.DecMapUintUint32V(*vp, true, d)
23612 func (_ fastpathT) DecMapUintUint32V(v map[uint]uint32, canChange bool,
23613 d *Decoder) (_ map[uint]uint32, changed bool) {
23614 dd, esep := d.d, d.hh.hasElemSeparators()
23615 containerLen := dd.ReadMapStart()
23616 if canChange && v == nil {
23617 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
23618 v = make(map[uint]uint32, xlen)
23621 if containerLen == 0 {
23628 hasLen := containerLen > 0
23629 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23631 dd.ReadMapElemKey()
23633 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23635 dd.ReadMapElemValue()
23637 if dd.TryDecodeAsNil() {
23639 } else if d.h.DeleteOnNilMapValue {
23646 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
23656 func (d *Decoder) fastpathDecMapUintUint64R(f *codecFnInfo, rv reflect.Value) {
23657 if rv.Kind() == reflect.Ptr {
23658 vp := rv2i(rv).(*map[uint]uint64)
23659 v, changed := fastpathTV.DecMapUintUint64V(*vp, true, d)
23664 fastpathTV.DecMapUintUint64V(rv2i(rv).(map[uint]uint64), false, d)
23667 func (f fastpathT) DecMapUintUint64X(vp *map[uint]uint64, d *Decoder) {
23668 v, changed := f.DecMapUintUint64V(*vp, true, d)
23673 func (_ fastpathT) DecMapUintUint64V(v map[uint]uint64, canChange bool,
23674 d *Decoder) (_ map[uint]uint64, changed bool) {
23675 dd, esep := d.d, d.hh.hasElemSeparators()
23676 containerLen := dd.ReadMapStart()
23677 if canChange && v == nil {
23678 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
23679 v = make(map[uint]uint64, xlen)
23682 if containerLen == 0 {
23689 hasLen := containerLen > 0
23690 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23692 dd.ReadMapElemKey()
23694 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23696 dd.ReadMapElemValue()
23698 if dd.TryDecodeAsNil() {
23700 } else if d.h.DeleteOnNilMapValue {
23707 mv = dd.DecodeUint64()
23717 func (d *Decoder) fastpathDecMapUintUintptrR(f *codecFnInfo, rv reflect.Value) {
23718 if rv.Kind() == reflect.Ptr {
23719 vp := rv2i(rv).(*map[uint]uintptr)
23720 v, changed := fastpathTV.DecMapUintUintptrV(*vp, true, d)
23725 fastpathTV.DecMapUintUintptrV(rv2i(rv).(map[uint]uintptr), false, d)
23728 func (f fastpathT) DecMapUintUintptrX(vp *map[uint]uintptr, d *Decoder) {
23729 v, changed := f.DecMapUintUintptrV(*vp, true, d)
23734 func (_ fastpathT) DecMapUintUintptrV(v map[uint]uintptr, canChange bool,
23735 d *Decoder) (_ map[uint]uintptr, changed bool) {
23736 dd, esep := d.d, d.hh.hasElemSeparators()
23737 containerLen := dd.ReadMapStart()
23738 if canChange && v == nil {
23739 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
23740 v = make(map[uint]uintptr, xlen)
23743 if containerLen == 0 {
23750 hasLen := containerLen > 0
23751 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23753 dd.ReadMapElemKey()
23755 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23757 dd.ReadMapElemValue()
23759 if dd.TryDecodeAsNil() {
23761 } else if d.h.DeleteOnNilMapValue {
23768 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23778 func (d *Decoder) fastpathDecMapUintIntR(f *codecFnInfo, rv reflect.Value) {
23779 if rv.Kind() == reflect.Ptr {
23780 vp := rv2i(rv).(*map[uint]int)
23781 v, changed := fastpathTV.DecMapUintIntV(*vp, true, d)
23786 fastpathTV.DecMapUintIntV(rv2i(rv).(map[uint]int), false, d)
23789 func (f fastpathT) DecMapUintIntX(vp *map[uint]int, d *Decoder) {
23790 v, changed := f.DecMapUintIntV(*vp, true, d)
23795 func (_ fastpathT) DecMapUintIntV(v map[uint]int, canChange bool,
23796 d *Decoder) (_ map[uint]int, changed bool) {
23797 dd, esep := d.d, d.hh.hasElemSeparators()
23798 containerLen := dd.ReadMapStart()
23799 if canChange && v == nil {
23800 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
23801 v = make(map[uint]int, xlen)
23804 if containerLen == 0 {
23811 hasLen := containerLen > 0
23812 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23814 dd.ReadMapElemKey()
23816 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23818 dd.ReadMapElemValue()
23820 if dd.TryDecodeAsNil() {
23822 } else if d.h.DeleteOnNilMapValue {
23829 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
23839 func (d *Decoder) fastpathDecMapUintInt8R(f *codecFnInfo, rv reflect.Value) {
23840 if rv.Kind() == reflect.Ptr {
23841 vp := rv2i(rv).(*map[uint]int8)
23842 v, changed := fastpathTV.DecMapUintInt8V(*vp, true, d)
23847 fastpathTV.DecMapUintInt8V(rv2i(rv).(map[uint]int8), false, d)
23850 func (f fastpathT) DecMapUintInt8X(vp *map[uint]int8, d *Decoder) {
23851 v, changed := f.DecMapUintInt8V(*vp, true, d)
23856 func (_ fastpathT) DecMapUintInt8V(v map[uint]int8, canChange bool,
23857 d *Decoder) (_ map[uint]int8, changed bool) {
23858 dd, esep := d.d, d.hh.hasElemSeparators()
23859 containerLen := dd.ReadMapStart()
23860 if canChange && v == nil {
23861 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
23862 v = make(map[uint]int8, xlen)
23865 if containerLen == 0 {
23872 hasLen := containerLen > 0
23873 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23875 dd.ReadMapElemKey()
23877 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23879 dd.ReadMapElemValue()
23881 if dd.TryDecodeAsNil() {
23883 } else if d.h.DeleteOnNilMapValue {
23890 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
23900 func (d *Decoder) fastpathDecMapUintInt16R(f *codecFnInfo, rv reflect.Value) {
23901 if rv.Kind() == reflect.Ptr {
23902 vp := rv2i(rv).(*map[uint]int16)
23903 v, changed := fastpathTV.DecMapUintInt16V(*vp, true, d)
23908 fastpathTV.DecMapUintInt16V(rv2i(rv).(map[uint]int16), false, d)
23911 func (f fastpathT) DecMapUintInt16X(vp *map[uint]int16, d *Decoder) {
23912 v, changed := f.DecMapUintInt16V(*vp, true, d)
23917 func (_ fastpathT) DecMapUintInt16V(v map[uint]int16, canChange bool,
23918 d *Decoder) (_ map[uint]int16, changed bool) {
23919 dd, esep := d.d, d.hh.hasElemSeparators()
23920 containerLen := dd.ReadMapStart()
23921 if canChange && v == nil {
23922 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
23923 v = make(map[uint]int16, xlen)
23926 if containerLen == 0 {
23933 hasLen := containerLen > 0
23934 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23936 dd.ReadMapElemKey()
23938 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23940 dd.ReadMapElemValue()
23942 if dd.TryDecodeAsNil() {
23944 } else if d.h.DeleteOnNilMapValue {
23951 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
23961 func (d *Decoder) fastpathDecMapUintInt32R(f *codecFnInfo, rv reflect.Value) {
23962 if rv.Kind() == reflect.Ptr {
23963 vp := rv2i(rv).(*map[uint]int32)
23964 v, changed := fastpathTV.DecMapUintInt32V(*vp, true, d)
23969 fastpathTV.DecMapUintInt32V(rv2i(rv).(map[uint]int32), false, d)
23972 func (f fastpathT) DecMapUintInt32X(vp *map[uint]int32, d *Decoder) {
23973 v, changed := f.DecMapUintInt32V(*vp, true, d)
23978 func (_ fastpathT) DecMapUintInt32V(v map[uint]int32, canChange bool,
23979 d *Decoder) (_ map[uint]int32, changed bool) {
23980 dd, esep := d.d, d.hh.hasElemSeparators()
23981 containerLen := dd.ReadMapStart()
23982 if canChange && v == nil {
23983 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
23984 v = make(map[uint]int32, xlen)
23987 if containerLen == 0 {
23994 hasLen := containerLen > 0
23995 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23997 dd.ReadMapElemKey()
23999 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
24001 dd.ReadMapElemValue()
24003 if dd.TryDecodeAsNil() {
24005 } else if d.h.DeleteOnNilMapValue {
24012 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
24022 func (d *Decoder) fastpathDecMapUintInt64R(f *codecFnInfo, rv reflect.Value) {
24023 if rv.Kind() == reflect.Ptr {
24024 vp := rv2i(rv).(*map[uint]int64)
24025 v, changed := fastpathTV.DecMapUintInt64V(*vp, true, d)
24030 fastpathTV.DecMapUintInt64V(rv2i(rv).(map[uint]int64), false, d)
24033 func (f fastpathT) DecMapUintInt64X(vp *map[uint]int64, d *Decoder) {
24034 v, changed := f.DecMapUintInt64V(*vp, true, d)
24039 func (_ fastpathT) DecMapUintInt64V(v map[uint]int64, canChange bool,
24040 d *Decoder) (_ map[uint]int64, changed bool) {
24041 dd, esep := d.d, d.hh.hasElemSeparators()
24042 containerLen := dd.ReadMapStart()
24043 if canChange && v == nil {
24044 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
24045 v = make(map[uint]int64, xlen)
24048 if containerLen == 0 {
24055 hasLen := containerLen > 0
24056 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24058 dd.ReadMapElemKey()
24060 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
24062 dd.ReadMapElemValue()
24064 if dd.TryDecodeAsNil() {
24066 } else if d.h.DeleteOnNilMapValue {
24073 mv = dd.DecodeInt64()
24083 func (d *Decoder) fastpathDecMapUintFloat32R(f *codecFnInfo, rv reflect.Value) {
24084 if rv.Kind() == reflect.Ptr {
24085 vp := rv2i(rv).(*map[uint]float32)
24086 v, changed := fastpathTV.DecMapUintFloat32V(*vp, true, d)
24091 fastpathTV.DecMapUintFloat32V(rv2i(rv).(map[uint]float32), false, d)
24094 func (f fastpathT) DecMapUintFloat32X(vp *map[uint]float32, d *Decoder) {
24095 v, changed := f.DecMapUintFloat32V(*vp, true, d)
24100 func (_ fastpathT) DecMapUintFloat32V(v map[uint]float32, canChange bool,
24101 d *Decoder) (_ map[uint]float32, changed bool) {
24102 dd, esep := d.d, d.hh.hasElemSeparators()
24103 containerLen := dd.ReadMapStart()
24104 if canChange && v == nil {
24105 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
24106 v = make(map[uint]float32, xlen)
24109 if containerLen == 0 {
24116 hasLen := containerLen > 0
24117 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24119 dd.ReadMapElemKey()
24121 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
24123 dd.ReadMapElemValue()
24125 if dd.TryDecodeAsNil() {
24127 } else if d.h.DeleteOnNilMapValue {
24134 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
24144 func (d *Decoder) fastpathDecMapUintFloat64R(f *codecFnInfo, rv reflect.Value) {
24145 if rv.Kind() == reflect.Ptr {
24146 vp := rv2i(rv).(*map[uint]float64)
24147 v, changed := fastpathTV.DecMapUintFloat64V(*vp, true, d)
24152 fastpathTV.DecMapUintFloat64V(rv2i(rv).(map[uint]float64), false, d)
24155 func (f fastpathT) DecMapUintFloat64X(vp *map[uint]float64, d *Decoder) {
24156 v, changed := f.DecMapUintFloat64V(*vp, true, d)
24161 func (_ fastpathT) DecMapUintFloat64V(v map[uint]float64, canChange bool,
24162 d *Decoder) (_ map[uint]float64, changed bool) {
24163 dd, esep := d.d, d.hh.hasElemSeparators()
24164 containerLen := dd.ReadMapStart()
24165 if canChange && v == nil {
24166 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
24167 v = make(map[uint]float64, xlen)
24170 if containerLen == 0 {
24177 hasLen := containerLen > 0
24178 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24180 dd.ReadMapElemKey()
24182 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
24184 dd.ReadMapElemValue()
24186 if dd.TryDecodeAsNil() {
24188 } else if d.h.DeleteOnNilMapValue {
24195 mv = dd.DecodeFloat64()
24205 func (d *Decoder) fastpathDecMapUintBoolR(f *codecFnInfo, rv reflect.Value) {
24206 if rv.Kind() == reflect.Ptr {
24207 vp := rv2i(rv).(*map[uint]bool)
24208 v, changed := fastpathTV.DecMapUintBoolV(*vp, true, d)
24213 fastpathTV.DecMapUintBoolV(rv2i(rv).(map[uint]bool), false, d)
24216 func (f fastpathT) DecMapUintBoolX(vp *map[uint]bool, d *Decoder) {
24217 v, changed := f.DecMapUintBoolV(*vp, true, d)
24222 func (_ fastpathT) DecMapUintBoolV(v map[uint]bool, canChange bool,
24223 d *Decoder) (_ map[uint]bool, changed bool) {
24224 dd, esep := d.d, d.hh.hasElemSeparators()
24225 containerLen := dd.ReadMapStart()
24226 if canChange && v == nil {
24227 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
24228 v = make(map[uint]bool, xlen)
24231 if containerLen == 0 {
24238 hasLen := containerLen > 0
24239 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24241 dd.ReadMapElemKey()
24243 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
24245 dd.ReadMapElemValue()
24247 if dd.TryDecodeAsNil() {
24249 } else if d.h.DeleteOnNilMapValue {
24256 mv = dd.DecodeBool()
24266 func (d *Decoder) fastpathDecMapUint8IntfR(f *codecFnInfo, rv reflect.Value) {
24267 if rv.Kind() == reflect.Ptr {
24268 vp := rv2i(rv).(*map[uint8]interface{})
24269 v, changed := fastpathTV.DecMapUint8IntfV(*vp, true, d)
24274 fastpathTV.DecMapUint8IntfV(rv2i(rv).(map[uint8]interface{}), false, d)
24277 func (f fastpathT) DecMapUint8IntfX(vp *map[uint8]interface{}, d *Decoder) {
24278 v, changed := f.DecMapUint8IntfV(*vp, true, d)
24283 func (_ fastpathT) DecMapUint8IntfV(v map[uint8]interface{}, canChange bool,
24284 d *Decoder) (_ map[uint8]interface{}, changed bool) {
24285 dd, esep := d.d, d.hh.hasElemSeparators()
24286 containerLen := dd.ReadMapStart()
24287 if canChange && v == nil {
24288 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
24289 v = make(map[uint8]interface{}, xlen)
24292 if containerLen == 0 {
24297 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
24300 hasLen := containerLen > 0
24301 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24303 dd.ReadMapElemKey()
24305 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24307 dd.ReadMapElemValue()
24309 if dd.TryDecodeAsNil() {
24311 } else if d.h.DeleteOnNilMapValue {
24333 func (d *Decoder) fastpathDecMapUint8StringR(f *codecFnInfo, rv reflect.Value) {
24334 if rv.Kind() == reflect.Ptr {
24335 vp := rv2i(rv).(*map[uint8]string)
24336 v, changed := fastpathTV.DecMapUint8StringV(*vp, true, d)
24341 fastpathTV.DecMapUint8StringV(rv2i(rv).(map[uint8]string), false, d)
24344 func (f fastpathT) DecMapUint8StringX(vp *map[uint8]string, d *Decoder) {
24345 v, changed := f.DecMapUint8StringV(*vp, true, d)
24350 func (_ fastpathT) DecMapUint8StringV(v map[uint8]string, canChange bool,
24351 d *Decoder) (_ map[uint8]string, changed bool) {
24352 dd, esep := d.d, d.hh.hasElemSeparators()
24353 containerLen := dd.ReadMapStart()
24354 if canChange && v == nil {
24355 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
24356 v = make(map[uint8]string, xlen)
24359 if containerLen == 0 {
24366 hasLen := containerLen > 0
24367 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24369 dd.ReadMapElemKey()
24371 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24373 dd.ReadMapElemValue()
24375 if dd.TryDecodeAsNil() {
24377 } else if d.h.DeleteOnNilMapValue {
24384 mv = dd.DecodeString()
24394 func (d *Decoder) fastpathDecMapUint8UintR(f *codecFnInfo, rv reflect.Value) {
24395 if rv.Kind() == reflect.Ptr {
24396 vp := rv2i(rv).(*map[uint8]uint)
24397 v, changed := fastpathTV.DecMapUint8UintV(*vp, true, d)
24402 fastpathTV.DecMapUint8UintV(rv2i(rv).(map[uint8]uint), false, d)
24405 func (f fastpathT) DecMapUint8UintX(vp *map[uint8]uint, d *Decoder) {
24406 v, changed := f.DecMapUint8UintV(*vp, true, d)
24411 func (_ fastpathT) DecMapUint8UintV(v map[uint8]uint, canChange bool,
24412 d *Decoder) (_ map[uint8]uint, changed bool) {
24413 dd, esep := d.d, d.hh.hasElemSeparators()
24414 containerLen := dd.ReadMapStart()
24415 if canChange && v == nil {
24416 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
24417 v = make(map[uint8]uint, xlen)
24420 if containerLen == 0 {
24427 hasLen := containerLen > 0
24428 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24430 dd.ReadMapElemKey()
24432 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24434 dd.ReadMapElemValue()
24436 if dd.TryDecodeAsNil() {
24438 } else if d.h.DeleteOnNilMapValue {
24445 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
24455 func (d *Decoder) fastpathDecMapUint8Uint8R(f *codecFnInfo, rv reflect.Value) {
24456 if rv.Kind() == reflect.Ptr {
24457 vp := rv2i(rv).(*map[uint8]uint8)
24458 v, changed := fastpathTV.DecMapUint8Uint8V(*vp, true, d)
24463 fastpathTV.DecMapUint8Uint8V(rv2i(rv).(map[uint8]uint8), false, d)
24466 func (f fastpathT) DecMapUint8Uint8X(vp *map[uint8]uint8, d *Decoder) {
24467 v, changed := f.DecMapUint8Uint8V(*vp, true, d)
24472 func (_ fastpathT) DecMapUint8Uint8V(v map[uint8]uint8, canChange bool,
24473 d *Decoder) (_ map[uint8]uint8, changed bool) {
24474 dd, esep := d.d, d.hh.hasElemSeparators()
24475 containerLen := dd.ReadMapStart()
24476 if canChange && v == nil {
24477 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
24478 v = make(map[uint8]uint8, xlen)
24481 if containerLen == 0 {
24488 hasLen := containerLen > 0
24489 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24491 dd.ReadMapElemKey()
24493 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24495 dd.ReadMapElemValue()
24497 if dd.TryDecodeAsNil() {
24499 } else if d.h.DeleteOnNilMapValue {
24506 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24516 func (d *Decoder) fastpathDecMapUint8Uint16R(f *codecFnInfo, rv reflect.Value) {
24517 if rv.Kind() == reflect.Ptr {
24518 vp := rv2i(rv).(*map[uint8]uint16)
24519 v, changed := fastpathTV.DecMapUint8Uint16V(*vp, true, d)
24524 fastpathTV.DecMapUint8Uint16V(rv2i(rv).(map[uint8]uint16), false, d)
24527 func (f fastpathT) DecMapUint8Uint16X(vp *map[uint8]uint16, d *Decoder) {
24528 v, changed := f.DecMapUint8Uint16V(*vp, true, d)
24533 func (_ fastpathT) DecMapUint8Uint16V(v map[uint8]uint16, canChange bool,
24534 d *Decoder) (_ map[uint8]uint16, changed bool) {
24535 dd, esep := d.d, d.hh.hasElemSeparators()
24536 containerLen := dd.ReadMapStart()
24537 if canChange && v == nil {
24538 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
24539 v = make(map[uint8]uint16, xlen)
24542 if containerLen == 0 {
24549 hasLen := containerLen > 0
24550 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24552 dd.ReadMapElemKey()
24554 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24556 dd.ReadMapElemValue()
24558 if dd.TryDecodeAsNil() {
24560 } else if d.h.DeleteOnNilMapValue {
24567 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
24577 func (d *Decoder) fastpathDecMapUint8Uint32R(f *codecFnInfo, rv reflect.Value) {
24578 if rv.Kind() == reflect.Ptr {
24579 vp := rv2i(rv).(*map[uint8]uint32)
24580 v, changed := fastpathTV.DecMapUint8Uint32V(*vp, true, d)
24585 fastpathTV.DecMapUint8Uint32V(rv2i(rv).(map[uint8]uint32), false, d)
24588 func (f fastpathT) DecMapUint8Uint32X(vp *map[uint8]uint32, d *Decoder) {
24589 v, changed := f.DecMapUint8Uint32V(*vp, true, d)
24594 func (_ fastpathT) DecMapUint8Uint32V(v map[uint8]uint32, canChange bool,
24595 d *Decoder) (_ map[uint8]uint32, changed bool) {
24596 dd, esep := d.d, d.hh.hasElemSeparators()
24597 containerLen := dd.ReadMapStart()
24598 if canChange && v == nil {
24599 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
24600 v = make(map[uint8]uint32, xlen)
24603 if containerLen == 0 {
24610 hasLen := containerLen > 0
24611 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24613 dd.ReadMapElemKey()
24615 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24617 dd.ReadMapElemValue()
24619 if dd.TryDecodeAsNil() {
24621 } else if d.h.DeleteOnNilMapValue {
24628 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
24638 func (d *Decoder) fastpathDecMapUint8Uint64R(f *codecFnInfo, rv reflect.Value) {
24639 if rv.Kind() == reflect.Ptr {
24640 vp := rv2i(rv).(*map[uint8]uint64)
24641 v, changed := fastpathTV.DecMapUint8Uint64V(*vp, true, d)
24646 fastpathTV.DecMapUint8Uint64V(rv2i(rv).(map[uint8]uint64), false, d)
24649 func (f fastpathT) DecMapUint8Uint64X(vp *map[uint8]uint64, d *Decoder) {
24650 v, changed := f.DecMapUint8Uint64V(*vp, true, d)
24655 func (_ fastpathT) DecMapUint8Uint64V(v map[uint8]uint64, canChange bool,
24656 d *Decoder) (_ map[uint8]uint64, changed bool) {
24657 dd, esep := d.d, d.hh.hasElemSeparators()
24658 containerLen := dd.ReadMapStart()
24659 if canChange && v == nil {
24660 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
24661 v = make(map[uint8]uint64, xlen)
24664 if containerLen == 0 {
24671 hasLen := containerLen > 0
24672 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24674 dd.ReadMapElemKey()
24676 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24678 dd.ReadMapElemValue()
24680 if dd.TryDecodeAsNil() {
24682 } else if d.h.DeleteOnNilMapValue {
24689 mv = dd.DecodeUint64()
24699 func (d *Decoder) fastpathDecMapUint8UintptrR(f *codecFnInfo, rv reflect.Value) {
24700 if rv.Kind() == reflect.Ptr {
24701 vp := rv2i(rv).(*map[uint8]uintptr)
24702 v, changed := fastpathTV.DecMapUint8UintptrV(*vp, true, d)
24707 fastpathTV.DecMapUint8UintptrV(rv2i(rv).(map[uint8]uintptr), false, d)
24710 func (f fastpathT) DecMapUint8UintptrX(vp *map[uint8]uintptr, d *Decoder) {
24711 v, changed := f.DecMapUint8UintptrV(*vp, true, d)
24716 func (_ fastpathT) DecMapUint8UintptrV(v map[uint8]uintptr, canChange bool,
24717 d *Decoder) (_ map[uint8]uintptr, changed bool) {
24718 dd, esep := d.d, d.hh.hasElemSeparators()
24719 containerLen := dd.ReadMapStart()
24720 if canChange && v == nil {
24721 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
24722 v = make(map[uint8]uintptr, xlen)
24725 if containerLen == 0 {
24732 hasLen := containerLen > 0
24733 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24735 dd.ReadMapElemKey()
24737 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24739 dd.ReadMapElemValue()
24741 if dd.TryDecodeAsNil() {
24743 } else if d.h.DeleteOnNilMapValue {
24750 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
24760 func (d *Decoder) fastpathDecMapUint8IntR(f *codecFnInfo, rv reflect.Value) {
24761 if rv.Kind() == reflect.Ptr {
24762 vp := rv2i(rv).(*map[uint8]int)
24763 v, changed := fastpathTV.DecMapUint8IntV(*vp, true, d)
24768 fastpathTV.DecMapUint8IntV(rv2i(rv).(map[uint8]int), false, d)
24771 func (f fastpathT) DecMapUint8IntX(vp *map[uint8]int, d *Decoder) {
24772 v, changed := f.DecMapUint8IntV(*vp, true, d)
24777 func (_ fastpathT) DecMapUint8IntV(v map[uint8]int, canChange bool,
24778 d *Decoder) (_ map[uint8]int, changed bool) {
24779 dd, esep := d.d, d.hh.hasElemSeparators()
24780 containerLen := dd.ReadMapStart()
24781 if canChange && v == nil {
24782 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
24783 v = make(map[uint8]int, xlen)
24786 if containerLen == 0 {
24793 hasLen := containerLen > 0
24794 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24796 dd.ReadMapElemKey()
24798 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24800 dd.ReadMapElemValue()
24802 if dd.TryDecodeAsNil() {
24804 } else if d.h.DeleteOnNilMapValue {
24811 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
24821 func (d *Decoder) fastpathDecMapUint8Int8R(f *codecFnInfo, rv reflect.Value) {
24822 if rv.Kind() == reflect.Ptr {
24823 vp := rv2i(rv).(*map[uint8]int8)
24824 v, changed := fastpathTV.DecMapUint8Int8V(*vp, true, d)
24829 fastpathTV.DecMapUint8Int8V(rv2i(rv).(map[uint8]int8), false, d)
24832 func (f fastpathT) DecMapUint8Int8X(vp *map[uint8]int8, d *Decoder) {
24833 v, changed := f.DecMapUint8Int8V(*vp, true, d)
24838 func (_ fastpathT) DecMapUint8Int8V(v map[uint8]int8, canChange bool,
24839 d *Decoder) (_ map[uint8]int8, changed bool) {
24840 dd, esep := d.d, d.hh.hasElemSeparators()
24841 containerLen := dd.ReadMapStart()
24842 if canChange && v == nil {
24843 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
24844 v = make(map[uint8]int8, xlen)
24847 if containerLen == 0 {
24854 hasLen := containerLen > 0
24855 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24857 dd.ReadMapElemKey()
24859 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24861 dd.ReadMapElemValue()
24863 if dd.TryDecodeAsNil() {
24865 } else if d.h.DeleteOnNilMapValue {
24872 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
24882 func (d *Decoder) fastpathDecMapUint8Int16R(f *codecFnInfo, rv reflect.Value) {
24883 if rv.Kind() == reflect.Ptr {
24884 vp := rv2i(rv).(*map[uint8]int16)
24885 v, changed := fastpathTV.DecMapUint8Int16V(*vp, true, d)
24890 fastpathTV.DecMapUint8Int16V(rv2i(rv).(map[uint8]int16), false, d)
24893 func (f fastpathT) DecMapUint8Int16X(vp *map[uint8]int16, d *Decoder) {
24894 v, changed := f.DecMapUint8Int16V(*vp, true, d)
24899 func (_ fastpathT) DecMapUint8Int16V(v map[uint8]int16, canChange bool,
24900 d *Decoder) (_ map[uint8]int16, changed bool) {
24901 dd, esep := d.d, d.hh.hasElemSeparators()
24902 containerLen := dd.ReadMapStart()
24903 if canChange && v == nil {
24904 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
24905 v = make(map[uint8]int16, xlen)
24908 if containerLen == 0 {
24915 hasLen := containerLen > 0
24916 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24918 dd.ReadMapElemKey()
24920 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24922 dd.ReadMapElemValue()
24924 if dd.TryDecodeAsNil() {
24926 } else if d.h.DeleteOnNilMapValue {
24933 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
24943 func (d *Decoder) fastpathDecMapUint8Int32R(f *codecFnInfo, rv reflect.Value) {
24944 if rv.Kind() == reflect.Ptr {
24945 vp := rv2i(rv).(*map[uint8]int32)
24946 v, changed := fastpathTV.DecMapUint8Int32V(*vp, true, d)
24951 fastpathTV.DecMapUint8Int32V(rv2i(rv).(map[uint8]int32), false, d)
24954 func (f fastpathT) DecMapUint8Int32X(vp *map[uint8]int32, d *Decoder) {
24955 v, changed := f.DecMapUint8Int32V(*vp, true, d)
24960 func (_ fastpathT) DecMapUint8Int32V(v map[uint8]int32, canChange bool,
24961 d *Decoder) (_ map[uint8]int32, changed bool) {
24962 dd, esep := d.d, d.hh.hasElemSeparators()
24963 containerLen := dd.ReadMapStart()
24964 if canChange && v == nil {
24965 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
24966 v = make(map[uint8]int32, xlen)
24969 if containerLen == 0 {
24976 hasLen := containerLen > 0
24977 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24979 dd.ReadMapElemKey()
24981 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24983 dd.ReadMapElemValue()
24985 if dd.TryDecodeAsNil() {
24987 } else if d.h.DeleteOnNilMapValue {
24994 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
25004 func (d *Decoder) fastpathDecMapUint8Int64R(f *codecFnInfo, rv reflect.Value) {
25005 if rv.Kind() == reflect.Ptr {
25006 vp := rv2i(rv).(*map[uint8]int64)
25007 v, changed := fastpathTV.DecMapUint8Int64V(*vp, true, d)
25012 fastpathTV.DecMapUint8Int64V(rv2i(rv).(map[uint8]int64), false, d)
25015 func (f fastpathT) DecMapUint8Int64X(vp *map[uint8]int64, d *Decoder) {
25016 v, changed := f.DecMapUint8Int64V(*vp, true, d)
25021 func (_ fastpathT) DecMapUint8Int64V(v map[uint8]int64, canChange bool,
25022 d *Decoder) (_ map[uint8]int64, changed bool) {
25023 dd, esep := d.d, d.hh.hasElemSeparators()
25024 containerLen := dd.ReadMapStart()
25025 if canChange && v == nil {
25026 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
25027 v = make(map[uint8]int64, xlen)
25030 if containerLen == 0 {
25037 hasLen := containerLen > 0
25038 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25040 dd.ReadMapElemKey()
25042 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
25044 dd.ReadMapElemValue()
25046 if dd.TryDecodeAsNil() {
25048 } else if d.h.DeleteOnNilMapValue {
25055 mv = dd.DecodeInt64()
25065 func (d *Decoder) fastpathDecMapUint8Float32R(f *codecFnInfo, rv reflect.Value) {
25066 if rv.Kind() == reflect.Ptr {
25067 vp := rv2i(rv).(*map[uint8]float32)
25068 v, changed := fastpathTV.DecMapUint8Float32V(*vp, true, d)
25073 fastpathTV.DecMapUint8Float32V(rv2i(rv).(map[uint8]float32), false, d)
25076 func (f fastpathT) DecMapUint8Float32X(vp *map[uint8]float32, d *Decoder) {
25077 v, changed := f.DecMapUint8Float32V(*vp, true, d)
25082 func (_ fastpathT) DecMapUint8Float32V(v map[uint8]float32, canChange bool,
25083 d *Decoder) (_ map[uint8]float32, changed bool) {
25084 dd, esep := d.d, d.hh.hasElemSeparators()
25085 containerLen := dd.ReadMapStart()
25086 if canChange && v == nil {
25087 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
25088 v = make(map[uint8]float32, xlen)
25091 if containerLen == 0 {
25098 hasLen := containerLen > 0
25099 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25101 dd.ReadMapElemKey()
25103 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
25105 dd.ReadMapElemValue()
25107 if dd.TryDecodeAsNil() {
25109 } else if d.h.DeleteOnNilMapValue {
25116 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
25126 func (d *Decoder) fastpathDecMapUint8Float64R(f *codecFnInfo, rv reflect.Value) {
25127 if rv.Kind() == reflect.Ptr {
25128 vp := rv2i(rv).(*map[uint8]float64)
25129 v, changed := fastpathTV.DecMapUint8Float64V(*vp, true, d)
25134 fastpathTV.DecMapUint8Float64V(rv2i(rv).(map[uint8]float64), false, d)
25137 func (f fastpathT) DecMapUint8Float64X(vp *map[uint8]float64, d *Decoder) {
25138 v, changed := f.DecMapUint8Float64V(*vp, true, d)
25143 func (_ fastpathT) DecMapUint8Float64V(v map[uint8]float64, canChange bool,
25144 d *Decoder) (_ map[uint8]float64, changed bool) {
25145 dd, esep := d.d, d.hh.hasElemSeparators()
25146 containerLen := dd.ReadMapStart()
25147 if canChange && v == nil {
25148 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
25149 v = make(map[uint8]float64, xlen)
25152 if containerLen == 0 {
25159 hasLen := containerLen > 0
25160 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25162 dd.ReadMapElemKey()
25164 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
25166 dd.ReadMapElemValue()
25168 if dd.TryDecodeAsNil() {
25170 } else if d.h.DeleteOnNilMapValue {
25177 mv = dd.DecodeFloat64()
25187 func (d *Decoder) fastpathDecMapUint8BoolR(f *codecFnInfo, rv reflect.Value) {
25188 if rv.Kind() == reflect.Ptr {
25189 vp := rv2i(rv).(*map[uint8]bool)
25190 v, changed := fastpathTV.DecMapUint8BoolV(*vp, true, d)
25195 fastpathTV.DecMapUint8BoolV(rv2i(rv).(map[uint8]bool), false, d)
25198 func (f fastpathT) DecMapUint8BoolX(vp *map[uint8]bool, d *Decoder) {
25199 v, changed := f.DecMapUint8BoolV(*vp, true, d)
25204 func (_ fastpathT) DecMapUint8BoolV(v map[uint8]bool, canChange bool,
25205 d *Decoder) (_ map[uint8]bool, changed bool) {
25206 dd, esep := d.d, d.hh.hasElemSeparators()
25207 containerLen := dd.ReadMapStart()
25208 if canChange && v == nil {
25209 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
25210 v = make(map[uint8]bool, xlen)
25213 if containerLen == 0 {
25220 hasLen := containerLen > 0
25221 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25223 dd.ReadMapElemKey()
25225 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
25227 dd.ReadMapElemValue()
25229 if dd.TryDecodeAsNil() {
25231 } else if d.h.DeleteOnNilMapValue {
25238 mv = dd.DecodeBool()
25248 func (d *Decoder) fastpathDecMapUint16IntfR(f *codecFnInfo, rv reflect.Value) {
25249 if rv.Kind() == reflect.Ptr {
25250 vp := rv2i(rv).(*map[uint16]interface{})
25251 v, changed := fastpathTV.DecMapUint16IntfV(*vp, true, d)
25256 fastpathTV.DecMapUint16IntfV(rv2i(rv).(map[uint16]interface{}), false, d)
25259 func (f fastpathT) DecMapUint16IntfX(vp *map[uint16]interface{}, d *Decoder) {
25260 v, changed := f.DecMapUint16IntfV(*vp, true, d)
25265 func (_ fastpathT) DecMapUint16IntfV(v map[uint16]interface{}, canChange bool,
25266 d *Decoder) (_ map[uint16]interface{}, changed bool) {
25267 dd, esep := d.d, d.hh.hasElemSeparators()
25268 containerLen := dd.ReadMapStart()
25269 if canChange && v == nil {
25270 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
25271 v = make(map[uint16]interface{}, xlen)
25274 if containerLen == 0 {
25279 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
25282 hasLen := containerLen > 0
25283 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25285 dd.ReadMapElemKey()
25287 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25289 dd.ReadMapElemValue()
25291 if dd.TryDecodeAsNil() {
25293 } else if d.h.DeleteOnNilMapValue {
25315 func (d *Decoder) fastpathDecMapUint16StringR(f *codecFnInfo, rv reflect.Value) {
25316 if rv.Kind() == reflect.Ptr {
25317 vp := rv2i(rv).(*map[uint16]string)
25318 v, changed := fastpathTV.DecMapUint16StringV(*vp, true, d)
25323 fastpathTV.DecMapUint16StringV(rv2i(rv).(map[uint16]string), false, d)
25326 func (f fastpathT) DecMapUint16StringX(vp *map[uint16]string, d *Decoder) {
25327 v, changed := f.DecMapUint16StringV(*vp, true, d)
25332 func (_ fastpathT) DecMapUint16StringV(v map[uint16]string, canChange bool,
25333 d *Decoder) (_ map[uint16]string, changed bool) {
25334 dd, esep := d.d, d.hh.hasElemSeparators()
25335 containerLen := dd.ReadMapStart()
25336 if canChange && v == nil {
25337 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
25338 v = make(map[uint16]string, xlen)
25341 if containerLen == 0 {
25348 hasLen := containerLen > 0
25349 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25351 dd.ReadMapElemKey()
25353 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25355 dd.ReadMapElemValue()
25357 if dd.TryDecodeAsNil() {
25359 } else if d.h.DeleteOnNilMapValue {
25366 mv = dd.DecodeString()
25376 func (d *Decoder) fastpathDecMapUint16UintR(f *codecFnInfo, rv reflect.Value) {
25377 if rv.Kind() == reflect.Ptr {
25378 vp := rv2i(rv).(*map[uint16]uint)
25379 v, changed := fastpathTV.DecMapUint16UintV(*vp, true, d)
25384 fastpathTV.DecMapUint16UintV(rv2i(rv).(map[uint16]uint), false, d)
25387 func (f fastpathT) DecMapUint16UintX(vp *map[uint16]uint, d *Decoder) {
25388 v, changed := f.DecMapUint16UintV(*vp, true, d)
25393 func (_ fastpathT) DecMapUint16UintV(v map[uint16]uint, canChange bool,
25394 d *Decoder) (_ map[uint16]uint, changed bool) {
25395 dd, esep := d.d, d.hh.hasElemSeparators()
25396 containerLen := dd.ReadMapStart()
25397 if canChange && v == nil {
25398 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
25399 v = make(map[uint16]uint, xlen)
25402 if containerLen == 0 {
25409 hasLen := containerLen > 0
25410 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25412 dd.ReadMapElemKey()
25414 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25416 dd.ReadMapElemValue()
25418 if dd.TryDecodeAsNil() {
25420 } else if d.h.DeleteOnNilMapValue {
25427 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
25437 func (d *Decoder) fastpathDecMapUint16Uint8R(f *codecFnInfo, rv reflect.Value) {
25438 if rv.Kind() == reflect.Ptr {
25439 vp := rv2i(rv).(*map[uint16]uint8)
25440 v, changed := fastpathTV.DecMapUint16Uint8V(*vp, true, d)
25445 fastpathTV.DecMapUint16Uint8V(rv2i(rv).(map[uint16]uint8), false, d)
25448 func (f fastpathT) DecMapUint16Uint8X(vp *map[uint16]uint8, d *Decoder) {
25449 v, changed := f.DecMapUint16Uint8V(*vp, true, d)
25454 func (_ fastpathT) DecMapUint16Uint8V(v map[uint16]uint8, canChange bool,
25455 d *Decoder) (_ map[uint16]uint8, changed bool) {
25456 dd, esep := d.d, d.hh.hasElemSeparators()
25457 containerLen := dd.ReadMapStart()
25458 if canChange && v == nil {
25459 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
25460 v = make(map[uint16]uint8, xlen)
25463 if containerLen == 0 {
25470 hasLen := containerLen > 0
25471 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25473 dd.ReadMapElemKey()
25475 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25477 dd.ReadMapElemValue()
25479 if dd.TryDecodeAsNil() {
25481 } else if d.h.DeleteOnNilMapValue {
25488 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
25498 func (d *Decoder) fastpathDecMapUint16Uint16R(f *codecFnInfo, rv reflect.Value) {
25499 if rv.Kind() == reflect.Ptr {
25500 vp := rv2i(rv).(*map[uint16]uint16)
25501 v, changed := fastpathTV.DecMapUint16Uint16V(*vp, true, d)
25506 fastpathTV.DecMapUint16Uint16V(rv2i(rv).(map[uint16]uint16), false, d)
25509 func (f fastpathT) DecMapUint16Uint16X(vp *map[uint16]uint16, d *Decoder) {
25510 v, changed := f.DecMapUint16Uint16V(*vp, true, d)
25515 func (_ fastpathT) DecMapUint16Uint16V(v map[uint16]uint16, canChange bool,
25516 d *Decoder) (_ map[uint16]uint16, changed bool) {
25517 dd, esep := d.d, d.hh.hasElemSeparators()
25518 containerLen := dd.ReadMapStart()
25519 if canChange && v == nil {
25520 xlen := decInferLen(containerLen, d.h.MaxInitLen, 4)
25521 v = make(map[uint16]uint16, xlen)
25524 if containerLen == 0 {
25531 hasLen := containerLen > 0
25532 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25534 dd.ReadMapElemKey()
25536 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25538 dd.ReadMapElemValue()
25540 if dd.TryDecodeAsNil() {
25542 } else if d.h.DeleteOnNilMapValue {
25549 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25559 func (d *Decoder) fastpathDecMapUint16Uint32R(f *codecFnInfo, rv reflect.Value) {
25560 if rv.Kind() == reflect.Ptr {
25561 vp := rv2i(rv).(*map[uint16]uint32)
25562 v, changed := fastpathTV.DecMapUint16Uint32V(*vp, true, d)
25567 fastpathTV.DecMapUint16Uint32V(rv2i(rv).(map[uint16]uint32), false, d)
25570 func (f fastpathT) DecMapUint16Uint32X(vp *map[uint16]uint32, d *Decoder) {
25571 v, changed := f.DecMapUint16Uint32V(*vp, true, d)
25576 func (_ fastpathT) DecMapUint16Uint32V(v map[uint16]uint32, canChange bool,
25577 d *Decoder) (_ map[uint16]uint32, changed bool) {
25578 dd, esep := d.d, d.hh.hasElemSeparators()
25579 containerLen := dd.ReadMapStart()
25580 if canChange && v == nil {
25581 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
25582 v = make(map[uint16]uint32, xlen)
25585 if containerLen == 0 {
25592 hasLen := containerLen > 0
25593 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25595 dd.ReadMapElemKey()
25597 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25599 dd.ReadMapElemValue()
25601 if dd.TryDecodeAsNil() {
25603 } else if d.h.DeleteOnNilMapValue {
25610 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
25620 func (d *Decoder) fastpathDecMapUint16Uint64R(f *codecFnInfo, rv reflect.Value) {
25621 if rv.Kind() == reflect.Ptr {
25622 vp := rv2i(rv).(*map[uint16]uint64)
25623 v, changed := fastpathTV.DecMapUint16Uint64V(*vp, true, d)
25628 fastpathTV.DecMapUint16Uint64V(rv2i(rv).(map[uint16]uint64), false, d)
25631 func (f fastpathT) DecMapUint16Uint64X(vp *map[uint16]uint64, d *Decoder) {
25632 v, changed := f.DecMapUint16Uint64V(*vp, true, d)
25637 func (_ fastpathT) DecMapUint16Uint64V(v map[uint16]uint64, canChange bool,
25638 d *Decoder) (_ map[uint16]uint64, changed bool) {
25639 dd, esep := d.d, d.hh.hasElemSeparators()
25640 containerLen := dd.ReadMapStart()
25641 if canChange && v == nil {
25642 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
25643 v = make(map[uint16]uint64, xlen)
25646 if containerLen == 0 {
25653 hasLen := containerLen > 0
25654 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25656 dd.ReadMapElemKey()
25658 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25660 dd.ReadMapElemValue()
25662 if dd.TryDecodeAsNil() {
25664 } else if d.h.DeleteOnNilMapValue {
25671 mv = dd.DecodeUint64()
25681 func (d *Decoder) fastpathDecMapUint16UintptrR(f *codecFnInfo, rv reflect.Value) {
25682 if rv.Kind() == reflect.Ptr {
25683 vp := rv2i(rv).(*map[uint16]uintptr)
25684 v, changed := fastpathTV.DecMapUint16UintptrV(*vp, true, d)
25689 fastpathTV.DecMapUint16UintptrV(rv2i(rv).(map[uint16]uintptr), false, d)
25692 func (f fastpathT) DecMapUint16UintptrX(vp *map[uint16]uintptr, d *Decoder) {
25693 v, changed := f.DecMapUint16UintptrV(*vp, true, d)
25698 func (_ fastpathT) DecMapUint16UintptrV(v map[uint16]uintptr, canChange bool,
25699 d *Decoder) (_ map[uint16]uintptr, changed bool) {
25700 dd, esep := d.d, d.hh.hasElemSeparators()
25701 containerLen := dd.ReadMapStart()
25702 if canChange && v == nil {
25703 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
25704 v = make(map[uint16]uintptr, xlen)
25707 if containerLen == 0 {
25714 hasLen := containerLen > 0
25715 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25717 dd.ReadMapElemKey()
25719 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25721 dd.ReadMapElemValue()
25723 if dd.TryDecodeAsNil() {
25725 } else if d.h.DeleteOnNilMapValue {
25732 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
25742 func (d *Decoder) fastpathDecMapUint16IntR(f *codecFnInfo, rv reflect.Value) {
25743 if rv.Kind() == reflect.Ptr {
25744 vp := rv2i(rv).(*map[uint16]int)
25745 v, changed := fastpathTV.DecMapUint16IntV(*vp, true, d)
25750 fastpathTV.DecMapUint16IntV(rv2i(rv).(map[uint16]int), false, d)
25753 func (f fastpathT) DecMapUint16IntX(vp *map[uint16]int, d *Decoder) {
25754 v, changed := f.DecMapUint16IntV(*vp, true, d)
25759 func (_ fastpathT) DecMapUint16IntV(v map[uint16]int, canChange bool,
25760 d *Decoder) (_ map[uint16]int, changed bool) {
25761 dd, esep := d.d, d.hh.hasElemSeparators()
25762 containerLen := dd.ReadMapStart()
25763 if canChange && v == nil {
25764 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
25765 v = make(map[uint16]int, xlen)
25768 if containerLen == 0 {
25775 hasLen := containerLen > 0
25776 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25778 dd.ReadMapElemKey()
25780 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25782 dd.ReadMapElemValue()
25784 if dd.TryDecodeAsNil() {
25786 } else if d.h.DeleteOnNilMapValue {
25793 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
25803 func (d *Decoder) fastpathDecMapUint16Int8R(f *codecFnInfo, rv reflect.Value) {
25804 if rv.Kind() == reflect.Ptr {
25805 vp := rv2i(rv).(*map[uint16]int8)
25806 v, changed := fastpathTV.DecMapUint16Int8V(*vp, true, d)
25811 fastpathTV.DecMapUint16Int8V(rv2i(rv).(map[uint16]int8), false, d)
25814 func (f fastpathT) DecMapUint16Int8X(vp *map[uint16]int8, d *Decoder) {
25815 v, changed := f.DecMapUint16Int8V(*vp, true, d)
25820 func (_ fastpathT) DecMapUint16Int8V(v map[uint16]int8, canChange bool,
25821 d *Decoder) (_ map[uint16]int8, changed bool) {
25822 dd, esep := d.d, d.hh.hasElemSeparators()
25823 containerLen := dd.ReadMapStart()
25824 if canChange && v == nil {
25825 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
25826 v = make(map[uint16]int8, xlen)
25829 if containerLen == 0 {
25836 hasLen := containerLen > 0
25837 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25839 dd.ReadMapElemKey()
25841 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25843 dd.ReadMapElemValue()
25845 if dd.TryDecodeAsNil() {
25847 } else if d.h.DeleteOnNilMapValue {
25854 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
25864 func (d *Decoder) fastpathDecMapUint16Int16R(f *codecFnInfo, rv reflect.Value) {
25865 if rv.Kind() == reflect.Ptr {
25866 vp := rv2i(rv).(*map[uint16]int16)
25867 v, changed := fastpathTV.DecMapUint16Int16V(*vp, true, d)
25872 fastpathTV.DecMapUint16Int16V(rv2i(rv).(map[uint16]int16), false, d)
25875 func (f fastpathT) DecMapUint16Int16X(vp *map[uint16]int16, d *Decoder) {
25876 v, changed := f.DecMapUint16Int16V(*vp, true, d)
25881 func (_ fastpathT) DecMapUint16Int16V(v map[uint16]int16, canChange bool,
25882 d *Decoder) (_ map[uint16]int16, changed bool) {
25883 dd, esep := d.d, d.hh.hasElemSeparators()
25884 containerLen := dd.ReadMapStart()
25885 if canChange && v == nil {
25886 xlen := decInferLen(containerLen, d.h.MaxInitLen, 4)
25887 v = make(map[uint16]int16, xlen)
25890 if containerLen == 0 {
25897 hasLen := containerLen > 0
25898 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25900 dd.ReadMapElemKey()
25902 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25904 dd.ReadMapElemValue()
25906 if dd.TryDecodeAsNil() {
25908 } else if d.h.DeleteOnNilMapValue {
25915 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
25925 func (d *Decoder) fastpathDecMapUint16Int32R(f *codecFnInfo, rv reflect.Value) {
25926 if rv.Kind() == reflect.Ptr {
25927 vp := rv2i(rv).(*map[uint16]int32)
25928 v, changed := fastpathTV.DecMapUint16Int32V(*vp, true, d)
25933 fastpathTV.DecMapUint16Int32V(rv2i(rv).(map[uint16]int32), false, d)
25936 func (f fastpathT) DecMapUint16Int32X(vp *map[uint16]int32, d *Decoder) {
25937 v, changed := f.DecMapUint16Int32V(*vp, true, d)
25942 func (_ fastpathT) DecMapUint16Int32V(v map[uint16]int32, canChange bool,
25943 d *Decoder) (_ map[uint16]int32, changed bool) {
25944 dd, esep := d.d, d.hh.hasElemSeparators()
25945 containerLen := dd.ReadMapStart()
25946 if canChange && v == nil {
25947 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
25948 v = make(map[uint16]int32, xlen)
25951 if containerLen == 0 {
25958 hasLen := containerLen > 0
25959 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25961 dd.ReadMapElemKey()
25963 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25965 dd.ReadMapElemValue()
25967 if dd.TryDecodeAsNil() {
25969 } else if d.h.DeleteOnNilMapValue {
25976 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
25986 func (d *Decoder) fastpathDecMapUint16Int64R(f *codecFnInfo, rv reflect.Value) {
25987 if rv.Kind() == reflect.Ptr {
25988 vp := rv2i(rv).(*map[uint16]int64)
25989 v, changed := fastpathTV.DecMapUint16Int64V(*vp, true, d)
25994 fastpathTV.DecMapUint16Int64V(rv2i(rv).(map[uint16]int64), false, d)
25997 func (f fastpathT) DecMapUint16Int64X(vp *map[uint16]int64, d *Decoder) {
25998 v, changed := f.DecMapUint16Int64V(*vp, true, d)
26003 func (_ fastpathT) DecMapUint16Int64V(v map[uint16]int64, canChange bool,
26004 d *Decoder) (_ map[uint16]int64, changed bool) {
26005 dd, esep := d.d, d.hh.hasElemSeparators()
26006 containerLen := dd.ReadMapStart()
26007 if canChange && v == nil {
26008 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
26009 v = make(map[uint16]int64, xlen)
26012 if containerLen == 0 {
26019 hasLen := containerLen > 0
26020 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26022 dd.ReadMapElemKey()
26024 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
26026 dd.ReadMapElemValue()
26028 if dd.TryDecodeAsNil() {
26030 } else if d.h.DeleteOnNilMapValue {
26037 mv = dd.DecodeInt64()
26047 func (d *Decoder) fastpathDecMapUint16Float32R(f *codecFnInfo, rv reflect.Value) {
26048 if rv.Kind() == reflect.Ptr {
26049 vp := rv2i(rv).(*map[uint16]float32)
26050 v, changed := fastpathTV.DecMapUint16Float32V(*vp, true, d)
26055 fastpathTV.DecMapUint16Float32V(rv2i(rv).(map[uint16]float32), false, d)
26058 func (f fastpathT) DecMapUint16Float32X(vp *map[uint16]float32, d *Decoder) {
26059 v, changed := f.DecMapUint16Float32V(*vp, true, d)
26064 func (_ fastpathT) DecMapUint16Float32V(v map[uint16]float32, canChange bool,
26065 d *Decoder) (_ map[uint16]float32, changed bool) {
26066 dd, esep := d.d, d.hh.hasElemSeparators()
26067 containerLen := dd.ReadMapStart()
26068 if canChange && v == nil {
26069 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
26070 v = make(map[uint16]float32, xlen)
26073 if containerLen == 0 {
26080 hasLen := containerLen > 0
26081 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26083 dd.ReadMapElemKey()
26085 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
26087 dd.ReadMapElemValue()
26089 if dd.TryDecodeAsNil() {
26091 } else if d.h.DeleteOnNilMapValue {
26098 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
26108 func (d *Decoder) fastpathDecMapUint16Float64R(f *codecFnInfo, rv reflect.Value) {
26109 if rv.Kind() == reflect.Ptr {
26110 vp := rv2i(rv).(*map[uint16]float64)
26111 v, changed := fastpathTV.DecMapUint16Float64V(*vp, true, d)
26116 fastpathTV.DecMapUint16Float64V(rv2i(rv).(map[uint16]float64), false, d)
26119 func (f fastpathT) DecMapUint16Float64X(vp *map[uint16]float64, d *Decoder) {
26120 v, changed := f.DecMapUint16Float64V(*vp, true, d)
26125 func (_ fastpathT) DecMapUint16Float64V(v map[uint16]float64, canChange bool,
26126 d *Decoder) (_ map[uint16]float64, changed bool) {
26127 dd, esep := d.d, d.hh.hasElemSeparators()
26128 containerLen := dd.ReadMapStart()
26129 if canChange && v == nil {
26130 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
26131 v = make(map[uint16]float64, xlen)
26134 if containerLen == 0 {
26141 hasLen := containerLen > 0
26142 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26144 dd.ReadMapElemKey()
26146 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
26148 dd.ReadMapElemValue()
26150 if dd.TryDecodeAsNil() {
26152 } else if d.h.DeleteOnNilMapValue {
26159 mv = dd.DecodeFloat64()
26169 func (d *Decoder) fastpathDecMapUint16BoolR(f *codecFnInfo, rv reflect.Value) {
26170 if rv.Kind() == reflect.Ptr {
26171 vp := rv2i(rv).(*map[uint16]bool)
26172 v, changed := fastpathTV.DecMapUint16BoolV(*vp, true, d)
26177 fastpathTV.DecMapUint16BoolV(rv2i(rv).(map[uint16]bool), false, d)
26180 func (f fastpathT) DecMapUint16BoolX(vp *map[uint16]bool, d *Decoder) {
26181 v, changed := f.DecMapUint16BoolV(*vp, true, d)
26186 func (_ fastpathT) DecMapUint16BoolV(v map[uint16]bool, canChange bool,
26187 d *Decoder) (_ map[uint16]bool, changed bool) {
26188 dd, esep := d.d, d.hh.hasElemSeparators()
26189 containerLen := dd.ReadMapStart()
26190 if canChange && v == nil {
26191 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
26192 v = make(map[uint16]bool, xlen)
26195 if containerLen == 0 {
26202 hasLen := containerLen > 0
26203 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26205 dd.ReadMapElemKey()
26207 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
26209 dd.ReadMapElemValue()
26211 if dd.TryDecodeAsNil() {
26213 } else if d.h.DeleteOnNilMapValue {
26220 mv = dd.DecodeBool()
26230 func (d *Decoder) fastpathDecMapUint32IntfR(f *codecFnInfo, rv reflect.Value) {
26231 if rv.Kind() == reflect.Ptr {
26232 vp := rv2i(rv).(*map[uint32]interface{})
26233 v, changed := fastpathTV.DecMapUint32IntfV(*vp, true, d)
26238 fastpathTV.DecMapUint32IntfV(rv2i(rv).(map[uint32]interface{}), false, d)
26241 func (f fastpathT) DecMapUint32IntfX(vp *map[uint32]interface{}, d *Decoder) {
26242 v, changed := f.DecMapUint32IntfV(*vp, true, d)
26247 func (_ fastpathT) DecMapUint32IntfV(v map[uint32]interface{}, canChange bool,
26248 d *Decoder) (_ map[uint32]interface{}, changed bool) {
26249 dd, esep := d.d, d.hh.hasElemSeparators()
26250 containerLen := dd.ReadMapStart()
26251 if canChange && v == nil {
26252 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
26253 v = make(map[uint32]interface{}, xlen)
26256 if containerLen == 0 {
26261 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
26264 hasLen := containerLen > 0
26265 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26267 dd.ReadMapElemKey()
26269 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26271 dd.ReadMapElemValue()
26273 if dd.TryDecodeAsNil() {
26275 } else if d.h.DeleteOnNilMapValue {
26297 func (d *Decoder) fastpathDecMapUint32StringR(f *codecFnInfo, rv reflect.Value) {
26298 if rv.Kind() == reflect.Ptr {
26299 vp := rv2i(rv).(*map[uint32]string)
26300 v, changed := fastpathTV.DecMapUint32StringV(*vp, true, d)
26305 fastpathTV.DecMapUint32StringV(rv2i(rv).(map[uint32]string), false, d)
26308 func (f fastpathT) DecMapUint32StringX(vp *map[uint32]string, d *Decoder) {
26309 v, changed := f.DecMapUint32StringV(*vp, true, d)
26314 func (_ fastpathT) DecMapUint32StringV(v map[uint32]string, canChange bool,
26315 d *Decoder) (_ map[uint32]string, changed bool) {
26316 dd, esep := d.d, d.hh.hasElemSeparators()
26317 containerLen := dd.ReadMapStart()
26318 if canChange && v == nil {
26319 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
26320 v = make(map[uint32]string, xlen)
26323 if containerLen == 0 {
26330 hasLen := containerLen > 0
26331 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26333 dd.ReadMapElemKey()
26335 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26337 dd.ReadMapElemValue()
26339 if dd.TryDecodeAsNil() {
26341 } else if d.h.DeleteOnNilMapValue {
26348 mv = dd.DecodeString()
26358 func (d *Decoder) fastpathDecMapUint32UintR(f *codecFnInfo, rv reflect.Value) {
26359 if rv.Kind() == reflect.Ptr {
26360 vp := rv2i(rv).(*map[uint32]uint)
26361 v, changed := fastpathTV.DecMapUint32UintV(*vp, true, d)
26366 fastpathTV.DecMapUint32UintV(rv2i(rv).(map[uint32]uint), false, d)
26369 func (f fastpathT) DecMapUint32UintX(vp *map[uint32]uint, d *Decoder) {
26370 v, changed := f.DecMapUint32UintV(*vp, true, d)
26375 func (_ fastpathT) DecMapUint32UintV(v map[uint32]uint, canChange bool,
26376 d *Decoder) (_ map[uint32]uint, changed bool) {
26377 dd, esep := d.d, d.hh.hasElemSeparators()
26378 containerLen := dd.ReadMapStart()
26379 if canChange && v == nil {
26380 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
26381 v = make(map[uint32]uint, xlen)
26384 if containerLen == 0 {
26391 hasLen := containerLen > 0
26392 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26394 dd.ReadMapElemKey()
26396 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26398 dd.ReadMapElemValue()
26400 if dd.TryDecodeAsNil() {
26402 } else if d.h.DeleteOnNilMapValue {
26409 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
26419 func (d *Decoder) fastpathDecMapUint32Uint8R(f *codecFnInfo, rv reflect.Value) {
26420 if rv.Kind() == reflect.Ptr {
26421 vp := rv2i(rv).(*map[uint32]uint8)
26422 v, changed := fastpathTV.DecMapUint32Uint8V(*vp, true, d)
26427 fastpathTV.DecMapUint32Uint8V(rv2i(rv).(map[uint32]uint8), false, d)
26430 func (f fastpathT) DecMapUint32Uint8X(vp *map[uint32]uint8, d *Decoder) {
26431 v, changed := f.DecMapUint32Uint8V(*vp, true, d)
26436 func (_ fastpathT) DecMapUint32Uint8V(v map[uint32]uint8, canChange bool,
26437 d *Decoder) (_ map[uint32]uint8, changed bool) {
26438 dd, esep := d.d, d.hh.hasElemSeparators()
26439 containerLen := dd.ReadMapStart()
26440 if canChange && v == nil {
26441 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
26442 v = make(map[uint32]uint8, xlen)
26445 if containerLen == 0 {
26452 hasLen := containerLen > 0
26453 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26455 dd.ReadMapElemKey()
26457 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26459 dd.ReadMapElemValue()
26461 if dd.TryDecodeAsNil() {
26463 } else if d.h.DeleteOnNilMapValue {
26470 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
26480 func (d *Decoder) fastpathDecMapUint32Uint16R(f *codecFnInfo, rv reflect.Value) {
26481 if rv.Kind() == reflect.Ptr {
26482 vp := rv2i(rv).(*map[uint32]uint16)
26483 v, changed := fastpathTV.DecMapUint32Uint16V(*vp, true, d)
26488 fastpathTV.DecMapUint32Uint16V(rv2i(rv).(map[uint32]uint16), false, d)
26491 func (f fastpathT) DecMapUint32Uint16X(vp *map[uint32]uint16, d *Decoder) {
26492 v, changed := f.DecMapUint32Uint16V(*vp, true, d)
26497 func (_ fastpathT) DecMapUint32Uint16V(v map[uint32]uint16, canChange bool,
26498 d *Decoder) (_ map[uint32]uint16, changed bool) {
26499 dd, esep := d.d, d.hh.hasElemSeparators()
26500 containerLen := dd.ReadMapStart()
26501 if canChange && v == nil {
26502 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
26503 v = make(map[uint32]uint16, xlen)
26506 if containerLen == 0 {
26513 hasLen := containerLen > 0
26514 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26516 dd.ReadMapElemKey()
26518 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26520 dd.ReadMapElemValue()
26522 if dd.TryDecodeAsNil() {
26524 } else if d.h.DeleteOnNilMapValue {
26531 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
26541 func (d *Decoder) fastpathDecMapUint32Uint32R(f *codecFnInfo, rv reflect.Value) {
26542 if rv.Kind() == reflect.Ptr {
26543 vp := rv2i(rv).(*map[uint32]uint32)
26544 v, changed := fastpathTV.DecMapUint32Uint32V(*vp, true, d)
26549 fastpathTV.DecMapUint32Uint32V(rv2i(rv).(map[uint32]uint32), false, d)
26552 func (f fastpathT) DecMapUint32Uint32X(vp *map[uint32]uint32, d *Decoder) {
26553 v, changed := f.DecMapUint32Uint32V(*vp, true, d)
26558 func (_ fastpathT) DecMapUint32Uint32V(v map[uint32]uint32, canChange bool,
26559 d *Decoder) (_ map[uint32]uint32, changed bool) {
26560 dd, esep := d.d, d.hh.hasElemSeparators()
26561 containerLen := dd.ReadMapStart()
26562 if canChange && v == nil {
26563 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
26564 v = make(map[uint32]uint32, xlen)
26567 if containerLen == 0 {
26574 hasLen := containerLen > 0
26575 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26577 dd.ReadMapElemKey()
26579 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26581 dd.ReadMapElemValue()
26583 if dd.TryDecodeAsNil() {
26585 } else if d.h.DeleteOnNilMapValue {
26592 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26602 func (d *Decoder) fastpathDecMapUint32Uint64R(f *codecFnInfo, rv reflect.Value) {
26603 if rv.Kind() == reflect.Ptr {
26604 vp := rv2i(rv).(*map[uint32]uint64)
26605 v, changed := fastpathTV.DecMapUint32Uint64V(*vp, true, d)
26610 fastpathTV.DecMapUint32Uint64V(rv2i(rv).(map[uint32]uint64), false, d)
26613 func (f fastpathT) DecMapUint32Uint64X(vp *map[uint32]uint64, d *Decoder) {
26614 v, changed := f.DecMapUint32Uint64V(*vp, true, d)
26619 func (_ fastpathT) DecMapUint32Uint64V(v map[uint32]uint64, canChange bool,
26620 d *Decoder) (_ map[uint32]uint64, changed bool) {
26621 dd, esep := d.d, d.hh.hasElemSeparators()
26622 containerLen := dd.ReadMapStart()
26623 if canChange && v == nil {
26624 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
26625 v = make(map[uint32]uint64, xlen)
26628 if containerLen == 0 {
26635 hasLen := containerLen > 0
26636 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26638 dd.ReadMapElemKey()
26640 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26642 dd.ReadMapElemValue()
26644 if dd.TryDecodeAsNil() {
26646 } else if d.h.DeleteOnNilMapValue {
26653 mv = dd.DecodeUint64()
26663 func (d *Decoder) fastpathDecMapUint32UintptrR(f *codecFnInfo, rv reflect.Value) {
26664 if rv.Kind() == reflect.Ptr {
26665 vp := rv2i(rv).(*map[uint32]uintptr)
26666 v, changed := fastpathTV.DecMapUint32UintptrV(*vp, true, d)
26671 fastpathTV.DecMapUint32UintptrV(rv2i(rv).(map[uint32]uintptr), false, d)
26674 func (f fastpathT) DecMapUint32UintptrX(vp *map[uint32]uintptr, d *Decoder) {
26675 v, changed := f.DecMapUint32UintptrV(*vp, true, d)
26680 func (_ fastpathT) DecMapUint32UintptrV(v map[uint32]uintptr, canChange bool,
26681 d *Decoder) (_ map[uint32]uintptr, changed bool) {
26682 dd, esep := d.d, d.hh.hasElemSeparators()
26683 containerLen := dd.ReadMapStart()
26684 if canChange && v == nil {
26685 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
26686 v = make(map[uint32]uintptr, xlen)
26689 if containerLen == 0 {
26696 hasLen := containerLen > 0
26697 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26699 dd.ReadMapElemKey()
26701 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26703 dd.ReadMapElemValue()
26705 if dd.TryDecodeAsNil() {
26707 } else if d.h.DeleteOnNilMapValue {
26714 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
26724 func (d *Decoder) fastpathDecMapUint32IntR(f *codecFnInfo, rv reflect.Value) {
26725 if rv.Kind() == reflect.Ptr {
26726 vp := rv2i(rv).(*map[uint32]int)
26727 v, changed := fastpathTV.DecMapUint32IntV(*vp, true, d)
26732 fastpathTV.DecMapUint32IntV(rv2i(rv).(map[uint32]int), false, d)
26735 func (f fastpathT) DecMapUint32IntX(vp *map[uint32]int, d *Decoder) {
26736 v, changed := f.DecMapUint32IntV(*vp, true, d)
26741 func (_ fastpathT) DecMapUint32IntV(v map[uint32]int, canChange bool,
26742 d *Decoder) (_ map[uint32]int, changed bool) {
26743 dd, esep := d.d, d.hh.hasElemSeparators()
26744 containerLen := dd.ReadMapStart()
26745 if canChange && v == nil {
26746 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
26747 v = make(map[uint32]int, xlen)
26750 if containerLen == 0 {
26757 hasLen := containerLen > 0
26758 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26760 dd.ReadMapElemKey()
26762 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26764 dd.ReadMapElemValue()
26766 if dd.TryDecodeAsNil() {
26768 } else if d.h.DeleteOnNilMapValue {
26775 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
26785 func (d *Decoder) fastpathDecMapUint32Int8R(f *codecFnInfo, rv reflect.Value) {
26786 if rv.Kind() == reflect.Ptr {
26787 vp := rv2i(rv).(*map[uint32]int8)
26788 v, changed := fastpathTV.DecMapUint32Int8V(*vp, true, d)
26793 fastpathTV.DecMapUint32Int8V(rv2i(rv).(map[uint32]int8), false, d)
26796 func (f fastpathT) DecMapUint32Int8X(vp *map[uint32]int8, d *Decoder) {
26797 v, changed := f.DecMapUint32Int8V(*vp, true, d)
26802 func (_ fastpathT) DecMapUint32Int8V(v map[uint32]int8, canChange bool,
26803 d *Decoder) (_ map[uint32]int8, changed bool) {
26804 dd, esep := d.d, d.hh.hasElemSeparators()
26805 containerLen := dd.ReadMapStart()
26806 if canChange && v == nil {
26807 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
26808 v = make(map[uint32]int8, xlen)
26811 if containerLen == 0 {
26818 hasLen := containerLen > 0
26819 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26821 dd.ReadMapElemKey()
26823 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26825 dd.ReadMapElemValue()
26827 if dd.TryDecodeAsNil() {
26829 } else if d.h.DeleteOnNilMapValue {
26836 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
26846 func (d *Decoder) fastpathDecMapUint32Int16R(f *codecFnInfo, rv reflect.Value) {
26847 if rv.Kind() == reflect.Ptr {
26848 vp := rv2i(rv).(*map[uint32]int16)
26849 v, changed := fastpathTV.DecMapUint32Int16V(*vp, true, d)
26854 fastpathTV.DecMapUint32Int16V(rv2i(rv).(map[uint32]int16), false, d)
26857 func (f fastpathT) DecMapUint32Int16X(vp *map[uint32]int16, d *Decoder) {
26858 v, changed := f.DecMapUint32Int16V(*vp, true, d)
26863 func (_ fastpathT) DecMapUint32Int16V(v map[uint32]int16, canChange bool,
26864 d *Decoder) (_ map[uint32]int16, changed bool) {
26865 dd, esep := d.d, d.hh.hasElemSeparators()
26866 containerLen := dd.ReadMapStart()
26867 if canChange && v == nil {
26868 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
26869 v = make(map[uint32]int16, xlen)
26872 if containerLen == 0 {
26879 hasLen := containerLen > 0
26880 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26882 dd.ReadMapElemKey()
26884 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26886 dd.ReadMapElemValue()
26888 if dd.TryDecodeAsNil() {
26890 } else if d.h.DeleteOnNilMapValue {
26897 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
26907 func (d *Decoder) fastpathDecMapUint32Int32R(f *codecFnInfo, rv reflect.Value) {
26908 if rv.Kind() == reflect.Ptr {
26909 vp := rv2i(rv).(*map[uint32]int32)
26910 v, changed := fastpathTV.DecMapUint32Int32V(*vp, true, d)
26915 fastpathTV.DecMapUint32Int32V(rv2i(rv).(map[uint32]int32), false, d)
26918 func (f fastpathT) DecMapUint32Int32X(vp *map[uint32]int32, d *Decoder) {
26919 v, changed := f.DecMapUint32Int32V(*vp, true, d)
26924 func (_ fastpathT) DecMapUint32Int32V(v map[uint32]int32, canChange bool,
26925 d *Decoder) (_ map[uint32]int32, changed bool) {
26926 dd, esep := d.d, d.hh.hasElemSeparators()
26927 containerLen := dd.ReadMapStart()
26928 if canChange && v == nil {
26929 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
26930 v = make(map[uint32]int32, xlen)
26933 if containerLen == 0 {
26940 hasLen := containerLen > 0
26941 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26943 dd.ReadMapElemKey()
26945 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26947 dd.ReadMapElemValue()
26949 if dd.TryDecodeAsNil() {
26951 } else if d.h.DeleteOnNilMapValue {
26958 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
26968 func (d *Decoder) fastpathDecMapUint32Int64R(f *codecFnInfo, rv reflect.Value) {
26969 if rv.Kind() == reflect.Ptr {
26970 vp := rv2i(rv).(*map[uint32]int64)
26971 v, changed := fastpathTV.DecMapUint32Int64V(*vp, true, d)
26976 fastpathTV.DecMapUint32Int64V(rv2i(rv).(map[uint32]int64), false, d)
26979 func (f fastpathT) DecMapUint32Int64X(vp *map[uint32]int64, d *Decoder) {
26980 v, changed := f.DecMapUint32Int64V(*vp, true, d)
26985 func (_ fastpathT) DecMapUint32Int64V(v map[uint32]int64, canChange bool,
26986 d *Decoder) (_ map[uint32]int64, changed bool) {
26987 dd, esep := d.d, d.hh.hasElemSeparators()
26988 containerLen := dd.ReadMapStart()
26989 if canChange && v == nil {
26990 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
26991 v = make(map[uint32]int64, xlen)
26994 if containerLen == 0 {
27001 hasLen := containerLen > 0
27002 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27004 dd.ReadMapElemKey()
27006 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
27008 dd.ReadMapElemValue()
27010 if dd.TryDecodeAsNil() {
27012 } else if d.h.DeleteOnNilMapValue {
27019 mv = dd.DecodeInt64()
27029 func (d *Decoder) fastpathDecMapUint32Float32R(f *codecFnInfo, rv reflect.Value) {
27030 if rv.Kind() == reflect.Ptr {
27031 vp := rv2i(rv).(*map[uint32]float32)
27032 v, changed := fastpathTV.DecMapUint32Float32V(*vp, true, d)
27037 fastpathTV.DecMapUint32Float32V(rv2i(rv).(map[uint32]float32), false, d)
27040 func (f fastpathT) DecMapUint32Float32X(vp *map[uint32]float32, d *Decoder) {
27041 v, changed := f.DecMapUint32Float32V(*vp, true, d)
27046 func (_ fastpathT) DecMapUint32Float32V(v map[uint32]float32, canChange bool,
27047 d *Decoder) (_ map[uint32]float32, changed bool) {
27048 dd, esep := d.d, d.hh.hasElemSeparators()
27049 containerLen := dd.ReadMapStart()
27050 if canChange && v == nil {
27051 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
27052 v = make(map[uint32]float32, xlen)
27055 if containerLen == 0 {
27062 hasLen := containerLen > 0
27063 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27065 dd.ReadMapElemKey()
27067 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
27069 dd.ReadMapElemValue()
27071 if dd.TryDecodeAsNil() {
27073 } else if d.h.DeleteOnNilMapValue {
27080 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
27090 func (d *Decoder) fastpathDecMapUint32Float64R(f *codecFnInfo, rv reflect.Value) {
27091 if rv.Kind() == reflect.Ptr {
27092 vp := rv2i(rv).(*map[uint32]float64)
27093 v, changed := fastpathTV.DecMapUint32Float64V(*vp, true, d)
27098 fastpathTV.DecMapUint32Float64V(rv2i(rv).(map[uint32]float64), false, d)
27101 func (f fastpathT) DecMapUint32Float64X(vp *map[uint32]float64, d *Decoder) {
27102 v, changed := f.DecMapUint32Float64V(*vp, true, d)
27107 func (_ fastpathT) DecMapUint32Float64V(v map[uint32]float64, canChange bool,
27108 d *Decoder) (_ map[uint32]float64, changed bool) {
27109 dd, esep := d.d, d.hh.hasElemSeparators()
27110 containerLen := dd.ReadMapStart()
27111 if canChange && v == nil {
27112 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
27113 v = make(map[uint32]float64, xlen)
27116 if containerLen == 0 {
27123 hasLen := containerLen > 0
27124 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27126 dd.ReadMapElemKey()
27128 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
27130 dd.ReadMapElemValue()
27132 if dd.TryDecodeAsNil() {
27134 } else if d.h.DeleteOnNilMapValue {
27141 mv = dd.DecodeFloat64()
27151 func (d *Decoder) fastpathDecMapUint32BoolR(f *codecFnInfo, rv reflect.Value) {
27152 if rv.Kind() == reflect.Ptr {
27153 vp := rv2i(rv).(*map[uint32]bool)
27154 v, changed := fastpathTV.DecMapUint32BoolV(*vp, true, d)
27159 fastpathTV.DecMapUint32BoolV(rv2i(rv).(map[uint32]bool), false, d)
27162 func (f fastpathT) DecMapUint32BoolX(vp *map[uint32]bool, d *Decoder) {
27163 v, changed := f.DecMapUint32BoolV(*vp, true, d)
27168 func (_ fastpathT) DecMapUint32BoolV(v map[uint32]bool, canChange bool,
27169 d *Decoder) (_ map[uint32]bool, changed bool) {
27170 dd, esep := d.d, d.hh.hasElemSeparators()
27171 containerLen := dd.ReadMapStart()
27172 if canChange && v == nil {
27173 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
27174 v = make(map[uint32]bool, xlen)
27177 if containerLen == 0 {
27184 hasLen := containerLen > 0
27185 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27187 dd.ReadMapElemKey()
27189 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
27191 dd.ReadMapElemValue()
27193 if dd.TryDecodeAsNil() {
27195 } else if d.h.DeleteOnNilMapValue {
27202 mv = dd.DecodeBool()
27212 func (d *Decoder) fastpathDecMapUint64IntfR(f *codecFnInfo, rv reflect.Value) {
27213 if rv.Kind() == reflect.Ptr {
27214 vp := rv2i(rv).(*map[uint64]interface{})
27215 v, changed := fastpathTV.DecMapUint64IntfV(*vp, true, d)
27220 fastpathTV.DecMapUint64IntfV(rv2i(rv).(map[uint64]interface{}), false, d)
27223 func (f fastpathT) DecMapUint64IntfX(vp *map[uint64]interface{}, d *Decoder) {
27224 v, changed := f.DecMapUint64IntfV(*vp, true, d)
27229 func (_ fastpathT) DecMapUint64IntfV(v map[uint64]interface{}, canChange bool,
27230 d *Decoder) (_ map[uint64]interface{}, changed bool) {
27231 dd, esep := d.d, d.hh.hasElemSeparators()
27232 containerLen := dd.ReadMapStart()
27233 if canChange && v == nil {
27234 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
27235 v = make(map[uint64]interface{}, xlen)
27238 if containerLen == 0 {
27243 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
27246 hasLen := containerLen > 0
27247 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27249 dd.ReadMapElemKey()
27251 mk = dd.DecodeUint64()
27253 dd.ReadMapElemValue()
27255 if dd.TryDecodeAsNil() {
27257 } else if d.h.DeleteOnNilMapValue {
27279 func (d *Decoder) fastpathDecMapUint64StringR(f *codecFnInfo, rv reflect.Value) {
27280 if rv.Kind() == reflect.Ptr {
27281 vp := rv2i(rv).(*map[uint64]string)
27282 v, changed := fastpathTV.DecMapUint64StringV(*vp, true, d)
27287 fastpathTV.DecMapUint64StringV(rv2i(rv).(map[uint64]string), false, d)
27290 func (f fastpathT) DecMapUint64StringX(vp *map[uint64]string, d *Decoder) {
27291 v, changed := f.DecMapUint64StringV(*vp, true, d)
27296 func (_ fastpathT) DecMapUint64StringV(v map[uint64]string, canChange bool,
27297 d *Decoder) (_ map[uint64]string, changed bool) {
27298 dd, esep := d.d, d.hh.hasElemSeparators()
27299 containerLen := dd.ReadMapStart()
27300 if canChange && v == nil {
27301 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
27302 v = make(map[uint64]string, xlen)
27305 if containerLen == 0 {
27312 hasLen := containerLen > 0
27313 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27315 dd.ReadMapElemKey()
27317 mk = dd.DecodeUint64()
27319 dd.ReadMapElemValue()
27321 if dd.TryDecodeAsNil() {
27323 } else if d.h.DeleteOnNilMapValue {
27330 mv = dd.DecodeString()
27340 func (d *Decoder) fastpathDecMapUint64UintR(f *codecFnInfo, rv reflect.Value) {
27341 if rv.Kind() == reflect.Ptr {
27342 vp := rv2i(rv).(*map[uint64]uint)
27343 v, changed := fastpathTV.DecMapUint64UintV(*vp, true, d)
27348 fastpathTV.DecMapUint64UintV(rv2i(rv).(map[uint64]uint), false, d)
27351 func (f fastpathT) DecMapUint64UintX(vp *map[uint64]uint, d *Decoder) {
27352 v, changed := f.DecMapUint64UintV(*vp, true, d)
27357 func (_ fastpathT) DecMapUint64UintV(v map[uint64]uint, canChange bool,
27358 d *Decoder) (_ map[uint64]uint, changed bool) {
27359 dd, esep := d.d, d.hh.hasElemSeparators()
27360 containerLen := dd.ReadMapStart()
27361 if canChange && v == nil {
27362 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
27363 v = make(map[uint64]uint, xlen)
27366 if containerLen == 0 {
27373 hasLen := containerLen > 0
27374 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27376 dd.ReadMapElemKey()
27378 mk = dd.DecodeUint64()
27380 dd.ReadMapElemValue()
27382 if dd.TryDecodeAsNil() {
27384 } else if d.h.DeleteOnNilMapValue {
27391 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
27401 func (d *Decoder) fastpathDecMapUint64Uint8R(f *codecFnInfo, rv reflect.Value) {
27402 if rv.Kind() == reflect.Ptr {
27403 vp := rv2i(rv).(*map[uint64]uint8)
27404 v, changed := fastpathTV.DecMapUint64Uint8V(*vp, true, d)
27409 fastpathTV.DecMapUint64Uint8V(rv2i(rv).(map[uint64]uint8), false, d)
27412 func (f fastpathT) DecMapUint64Uint8X(vp *map[uint64]uint8, d *Decoder) {
27413 v, changed := f.DecMapUint64Uint8V(*vp, true, d)
27418 func (_ fastpathT) DecMapUint64Uint8V(v map[uint64]uint8, canChange bool,
27419 d *Decoder) (_ map[uint64]uint8, changed bool) {
27420 dd, esep := d.d, d.hh.hasElemSeparators()
27421 containerLen := dd.ReadMapStart()
27422 if canChange && v == nil {
27423 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
27424 v = make(map[uint64]uint8, xlen)
27427 if containerLen == 0 {
27434 hasLen := containerLen > 0
27435 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27437 dd.ReadMapElemKey()
27439 mk = dd.DecodeUint64()
27441 dd.ReadMapElemValue()
27443 if dd.TryDecodeAsNil() {
27445 } else if d.h.DeleteOnNilMapValue {
27452 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
27462 func (d *Decoder) fastpathDecMapUint64Uint16R(f *codecFnInfo, rv reflect.Value) {
27463 if rv.Kind() == reflect.Ptr {
27464 vp := rv2i(rv).(*map[uint64]uint16)
27465 v, changed := fastpathTV.DecMapUint64Uint16V(*vp, true, d)
27470 fastpathTV.DecMapUint64Uint16V(rv2i(rv).(map[uint64]uint16), false, d)
27473 func (f fastpathT) DecMapUint64Uint16X(vp *map[uint64]uint16, d *Decoder) {
27474 v, changed := f.DecMapUint64Uint16V(*vp, true, d)
27479 func (_ fastpathT) DecMapUint64Uint16V(v map[uint64]uint16, canChange bool,
27480 d *Decoder) (_ map[uint64]uint16, changed bool) {
27481 dd, esep := d.d, d.hh.hasElemSeparators()
27482 containerLen := dd.ReadMapStart()
27483 if canChange && v == nil {
27484 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
27485 v = make(map[uint64]uint16, xlen)
27488 if containerLen == 0 {
27495 hasLen := containerLen > 0
27496 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27498 dd.ReadMapElemKey()
27500 mk = dd.DecodeUint64()
27502 dd.ReadMapElemValue()
27504 if dd.TryDecodeAsNil() {
27506 } else if d.h.DeleteOnNilMapValue {
27513 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
27523 func (d *Decoder) fastpathDecMapUint64Uint32R(f *codecFnInfo, rv reflect.Value) {
27524 if rv.Kind() == reflect.Ptr {
27525 vp := rv2i(rv).(*map[uint64]uint32)
27526 v, changed := fastpathTV.DecMapUint64Uint32V(*vp, true, d)
27531 fastpathTV.DecMapUint64Uint32V(rv2i(rv).(map[uint64]uint32), false, d)
27534 func (f fastpathT) DecMapUint64Uint32X(vp *map[uint64]uint32, d *Decoder) {
27535 v, changed := f.DecMapUint64Uint32V(*vp, true, d)
27540 func (_ fastpathT) DecMapUint64Uint32V(v map[uint64]uint32, canChange bool,
27541 d *Decoder) (_ map[uint64]uint32, changed bool) {
27542 dd, esep := d.d, d.hh.hasElemSeparators()
27543 containerLen := dd.ReadMapStart()
27544 if canChange && v == nil {
27545 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
27546 v = make(map[uint64]uint32, xlen)
27549 if containerLen == 0 {
27556 hasLen := containerLen > 0
27557 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27559 dd.ReadMapElemKey()
27561 mk = dd.DecodeUint64()
27563 dd.ReadMapElemValue()
27565 if dd.TryDecodeAsNil() {
27567 } else if d.h.DeleteOnNilMapValue {
27574 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
27584 func (d *Decoder) fastpathDecMapUint64Uint64R(f *codecFnInfo, rv reflect.Value) {
27585 if rv.Kind() == reflect.Ptr {
27586 vp := rv2i(rv).(*map[uint64]uint64)
27587 v, changed := fastpathTV.DecMapUint64Uint64V(*vp, true, d)
27592 fastpathTV.DecMapUint64Uint64V(rv2i(rv).(map[uint64]uint64), false, d)
27595 func (f fastpathT) DecMapUint64Uint64X(vp *map[uint64]uint64, d *Decoder) {
27596 v, changed := f.DecMapUint64Uint64V(*vp, true, d)
27601 func (_ fastpathT) DecMapUint64Uint64V(v map[uint64]uint64, canChange bool,
27602 d *Decoder) (_ map[uint64]uint64, changed bool) {
27603 dd, esep := d.d, d.hh.hasElemSeparators()
27604 containerLen := dd.ReadMapStart()
27605 if canChange && v == nil {
27606 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
27607 v = make(map[uint64]uint64, xlen)
27610 if containerLen == 0 {
27617 hasLen := containerLen > 0
27618 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27620 dd.ReadMapElemKey()
27622 mk = dd.DecodeUint64()
27624 dd.ReadMapElemValue()
27626 if dd.TryDecodeAsNil() {
27628 } else if d.h.DeleteOnNilMapValue {
27635 mv = dd.DecodeUint64()
27645 func (d *Decoder) fastpathDecMapUint64UintptrR(f *codecFnInfo, rv reflect.Value) {
27646 if rv.Kind() == reflect.Ptr {
27647 vp := rv2i(rv).(*map[uint64]uintptr)
27648 v, changed := fastpathTV.DecMapUint64UintptrV(*vp, true, d)
27653 fastpathTV.DecMapUint64UintptrV(rv2i(rv).(map[uint64]uintptr), false, d)
27656 func (f fastpathT) DecMapUint64UintptrX(vp *map[uint64]uintptr, d *Decoder) {
27657 v, changed := f.DecMapUint64UintptrV(*vp, true, d)
27662 func (_ fastpathT) DecMapUint64UintptrV(v map[uint64]uintptr, canChange bool,
27663 d *Decoder) (_ map[uint64]uintptr, changed bool) {
27664 dd, esep := d.d, d.hh.hasElemSeparators()
27665 containerLen := dd.ReadMapStart()
27666 if canChange && v == nil {
27667 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
27668 v = make(map[uint64]uintptr, xlen)
27671 if containerLen == 0 {
27678 hasLen := containerLen > 0
27679 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27681 dd.ReadMapElemKey()
27683 mk = dd.DecodeUint64()
27685 dd.ReadMapElemValue()
27687 if dd.TryDecodeAsNil() {
27689 } else if d.h.DeleteOnNilMapValue {
27696 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
27706 func (d *Decoder) fastpathDecMapUint64IntR(f *codecFnInfo, rv reflect.Value) {
27707 if rv.Kind() == reflect.Ptr {
27708 vp := rv2i(rv).(*map[uint64]int)
27709 v, changed := fastpathTV.DecMapUint64IntV(*vp, true, d)
27714 fastpathTV.DecMapUint64IntV(rv2i(rv).(map[uint64]int), false, d)
27717 func (f fastpathT) DecMapUint64IntX(vp *map[uint64]int, d *Decoder) {
27718 v, changed := f.DecMapUint64IntV(*vp, true, d)
27723 func (_ fastpathT) DecMapUint64IntV(v map[uint64]int, canChange bool,
27724 d *Decoder) (_ map[uint64]int, changed bool) {
27725 dd, esep := d.d, d.hh.hasElemSeparators()
27726 containerLen := dd.ReadMapStart()
27727 if canChange && v == nil {
27728 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
27729 v = make(map[uint64]int, xlen)
27732 if containerLen == 0 {
27739 hasLen := containerLen > 0
27740 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27742 dd.ReadMapElemKey()
27744 mk = dd.DecodeUint64()
27746 dd.ReadMapElemValue()
27748 if dd.TryDecodeAsNil() {
27750 } else if d.h.DeleteOnNilMapValue {
27757 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
27767 func (d *Decoder) fastpathDecMapUint64Int8R(f *codecFnInfo, rv reflect.Value) {
27768 if rv.Kind() == reflect.Ptr {
27769 vp := rv2i(rv).(*map[uint64]int8)
27770 v, changed := fastpathTV.DecMapUint64Int8V(*vp, true, d)
27775 fastpathTV.DecMapUint64Int8V(rv2i(rv).(map[uint64]int8), false, d)
27778 func (f fastpathT) DecMapUint64Int8X(vp *map[uint64]int8, d *Decoder) {
27779 v, changed := f.DecMapUint64Int8V(*vp, true, d)
27784 func (_ fastpathT) DecMapUint64Int8V(v map[uint64]int8, canChange bool,
27785 d *Decoder) (_ map[uint64]int8, changed bool) {
27786 dd, esep := d.d, d.hh.hasElemSeparators()
27787 containerLen := dd.ReadMapStart()
27788 if canChange && v == nil {
27789 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
27790 v = make(map[uint64]int8, xlen)
27793 if containerLen == 0 {
27800 hasLen := containerLen > 0
27801 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27803 dd.ReadMapElemKey()
27805 mk = dd.DecodeUint64()
27807 dd.ReadMapElemValue()
27809 if dd.TryDecodeAsNil() {
27811 } else if d.h.DeleteOnNilMapValue {
27818 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
27828 func (d *Decoder) fastpathDecMapUint64Int16R(f *codecFnInfo, rv reflect.Value) {
27829 if rv.Kind() == reflect.Ptr {
27830 vp := rv2i(rv).(*map[uint64]int16)
27831 v, changed := fastpathTV.DecMapUint64Int16V(*vp, true, d)
27836 fastpathTV.DecMapUint64Int16V(rv2i(rv).(map[uint64]int16), false, d)
27839 func (f fastpathT) DecMapUint64Int16X(vp *map[uint64]int16, d *Decoder) {
27840 v, changed := f.DecMapUint64Int16V(*vp, true, d)
27845 func (_ fastpathT) DecMapUint64Int16V(v map[uint64]int16, canChange bool,
27846 d *Decoder) (_ map[uint64]int16, changed bool) {
27847 dd, esep := d.d, d.hh.hasElemSeparators()
27848 containerLen := dd.ReadMapStart()
27849 if canChange && v == nil {
27850 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
27851 v = make(map[uint64]int16, xlen)
27854 if containerLen == 0 {
27861 hasLen := containerLen > 0
27862 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27864 dd.ReadMapElemKey()
27866 mk = dd.DecodeUint64()
27868 dd.ReadMapElemValue()
27870 if dd.TryDecodeAsNil() {
27872 } else if d.h.DeleteOnNilMapValue {
27879 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
27889 func (d *Decoder) fastpathDecMapUint64Int32R(f *codecFnInfo, rv reflect.Value) {
27890 if rv.Kind() == reflect.Ptr {
27891 vp := rv2i(rv).(*map[uint64]int32)
27892 v, changed := fastpathTV.DecMapUint64Int32V(*vp, true, d)
27897 fastpathTV.DecMapUint64Int32V(rv2i(rv).(map[uint64]int32), false, d)
27900 func (f fastpathT) DecMapUint64Int32X(vp *map[uint64]int32, d *Decoder) {
27901 v, changed := f.DecMapUint64Int32V(*vp, true, d)
27906 func (_ fastpathT) DecMapUint64Int32V(v map[uint64]int32, canChange bool,
27907 d *Decoder) (_ map[uint64]int32, changed bool) {
27908 dd, esep := d.d, d.hh.hasElemSeparators()
27909 containerLen := dd.ReadMapStart()
27910 if canChange && v == nil {
27911 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
27912 v = make(map[uint64]int32, xlen)
27915 if containerLen == 0 {
27922 hasLen := containerLen > 0
27923 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27925 dd.ReadMapElemKey()
27927 mk = dd.DecodeUint64()
27929 dd.ReadMapElemValue()
27931 if dd.TryDecodeAsNil() {
27933 } else if d.h.DeleteOnNilMapValue {
27940 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
27950 func (d *Decoder) fastpathDecMapUint64Int64R(f *codecFnInfo, rv reflect.Value) {
27951 if rv.Kind() == reflect.Ptr {
27952 vp := rv2i(rv).(*map[uint64]int64)
27953 v, changed := fastpathTV.DecMapUint64Int64V(*vp, true, d)
27958 fastpathTV.DecMapUint64Int64V(rv2i(rv).(map[uint64]int64), false, d)
27961 func (f fastpathT) DecMapUint64Int64X(vp *map[uint64]int64, d *Decoder) {
27962 v, changed := f.DecMapUint64Int64V(*vp, true, d)
27967 func (_ fastpathT) DecMapUint64Int64V(v map[uint64]int64, canChange bool,
27968 d *Decoder) (_ map[uint64]int64, changed bool) {
27969 dd, esep := d.d, d.hh.hasElemSeparators()
27970 containerLen := dd.ReadMapStart()
27971 if canChange && v == nil {
27972 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
27973 v = make(map[uint64]int64, xlen)
27976 if containerLen == 0 {
27983 hasLen := containerLen > 0
27984 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27986 dd.ReadMapElemKey()
27988 mk = dd.DecodeUint64()
27990 dd.ReadMapElemValue()
27992 if dd.TryDecodeAsNil() {
27994 } else if d.h.DeleteOnNilMapValue {
28001 mv = dd.DecodeInt64()
28011 func (d *Decoder) fastpathDecMapUint64Float32R(f *codecFnInfo, rv reflect.Value) {
28012 if rv.Kind() == reflect.Ptr {
28013 vp := rv2i(rv).(*map[uint64]float32)
28014 v, changed := fastpathTV.DecMapUint64Float32V(*vp, true, d)
28019 fastpathTV.DecMapUint64Float32V(rv2i(rv).(map[uint64]float32), false, d)
28022 func (f fastpathT) DecMapUint64Float32X(vp *map[uint64]float32, d *Decoder) {
28023 v, changed := f.DecMapUint64Float32V(*vp, true, d)
28028 func (_ fastpathT) DecMapUint64Float32V(v map[uint64]float32, canChange bool,
28029 d *Decoder) (_ map[uint64]float32, changed bool) {
28030 dd, esep := d.d, d.hh.hasElemSeparators()
28031 containerLen := dd.ReadMapStart()
28032 if canChange && v == nil {
28033 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
28034 v = make(map[uint64]float32, xlen)
28037 if containerLen == 0 {
28044 hasLen := containerLen > 0
28045 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28047 dd.ReadMapElemKey()
28049 mk = dd.DecodeUint64()
28051 dd.ReadMapElemValue()
28053 if dd.TryDecodeAsNil() {
28055 } else if d.h.DeleteOnNilMapValue {
28062 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
28072 func (d *Decoder) fastpathDecMapUint64Float64R(f *codecFnInfo, rv reflect.Value) {
28073 if rv.Kind() == reflect.Ptr {
28074 vp := rv2i(rv).(*map[uint64]float64)
28075 v, changed := fastpathTV.DecMapUint64Float64V(*vp, true, d)
28080 fastpathTV.DecMapUint64Float64V(rv2i(rv).(map[uint64]float64), false, d)
28083 func (f fastpathT) DecMapUint64Float64X(vp *map[uint64]float64, d *Decoder) {
28084 v, changed := f.DecMapUint64Float64V(*vp, true, d)
28089 func (_ fastpathT) DecMapUint64Float64V(v map[uint64]float64, canChange bool,
28090 d *Decoder) (_ map[uint64]float64, changed bool) {
28091 dd, esep := d.d, d.hh.hasElemSeparators()
28092 containerLen := dd.ReadMapStart()
28093 if canChange && v == nil {
28094 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
28095 v = make(map[uint64]float64, xlen)
28098 if containerLen == 0 {
28105 hasLen := containerLen > 0
28106 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28108 dd.ReadMapElemKey()
28110 mk = dd.DecodeUint64()
28112 dd.ReadMapElemValue()
28114 if dd.TryDecodeAsNil() {
28116 } else if d.h.DeleteOnNilMapValue {
28123 mv = dd.DecodeFloat64()
28133 func (d *Decoder) fastpathDecMapUint64BoolR(f *codecFnInfo, rv reflect.Value) {
28134 if rv.Kind() == reflect.Ptr {
28135 vp := rv2i(rv).(*map[uint64]bool)
28136 v, changed := fastpathTV.DecMapUint64BoolV(*vp, true, d)
28141 fastpathTV.DecMapUint64BoolV(rv2i(rv).(map[uint64]bool), false, d)
28144 func (f fastpathT) DecMapUint64BoolX(vp *map[uint64]bool, d *Decoder) {
28145 v, changed := f.DecMapUint64BoolV(*vp, true, d)
28150 func (_ fastpathT) DecMapUint64BoolV(v map[uint64]bool, canChange bool,
28151 d *Decoder) (_ map[uint64]bool, changed bool) {
28152 dd, esep := d.d, d.hh.hasElemSeparators()
28153 containerLen := dd.ReadMapStart()
28154 if canChange && v == nil {
28155 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
28156 v = make(map[uint64]bool, xlen)
28159 if containerLen == 0 {
28166 hasLen := containerLen > 0
28167 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28169 dd.ReadMapElemKey()
28171 mk = dd.DecodeUint64()
28173 dd.ReadMapElemValue()
28175 if dd.TryDecodeAsNil() {
28177 } else if d.h.DeleteOnNilMapValue {
28184 mv = dd.DecodeBool()
28194 func (d *Decoder) fastpathDecMapUintptrIntfR(f *codecFnInfo, rv reflect.Value) {
28195 if rv.Kind() == reflect.Ptr {
28196 vp := rv2i(rv).(*map[uintptr]interface{})
28197 v, changed := fastpathTV.DecMapUintptrIntfV(*vp, true, d)
28202 fastpathTV.DecMapUintptrIntfV(rv2i(rv).(map[uintptr]interface{}), false, d)
28205 func (f fastpathT) DecMapUintptrIntfX(vp *map[uintptr]interface{}, d *Decoder) {
28206 v, changed := f.DecMapUintptrIntfV(*vp, true, d)
28211 func (_ fastpathT) DecMapUintptrIntfV(v map[uintptr]interface{}, canChange bool,
28212 d *Decoder) (_ map[uintptr]interface{}, changed bool) {
28213 dd, esep := d.d, d.hh.hasElemSeparators()
28214 containerLen := dd.ReadMapStart()
28215 if canChange && v == nil {
28216 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
28217 v = make(map[uintptr]interface{}, xlen)
28220 if containerLen == 0 {
28225 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
28228 hasLen := containerLen > 0
28229 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28231 dd.ReadMapElemKey()
28233 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28235 dd.ReadMapElemValue()
28237 if dd.TryDecodeAsNil() {
28239 } else if d.h.DeleteOnNilMapValue {
28261 func (d *Decoder) fastpathDecMapUintptrStringR(f *codecFnInfo, rv reflect.Value) {
28262 if rv.Kind() == reflect.Ptr {
28263 vp := rv2i(rv).(*map[uintptr]string)
28264 v, changed := fastpathTV.DecMapUintptrStringV(*vp, true, d)
28269 fastpathTV.DecMapUintptrStringV(rv2i(rv).(map[uintptr]string), false, d)
28272 func (f fastpathT) DecMapUintptrStringX(vp *map[uintptr]string, d *Decoder) {
28273 v, changed := f.DecMapUintptrStringV(*vp, true, d)
28278 func (_ fastpathT) DecMapUintptrStringV(v map[uintptr]string, canChange bool,
28279 d *Decoder) (_ map[uintptr]string, changed bool) {
28280 dd, esep := d.d, d.hh.hasElemSeparators()
28281 containerLen := dd.ReadMapStart()
28282 if canChange && v == nil {
28283 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
28284 v = make(map[uintptr]string, xlen)
28287 if containerLen == 0 {
28294 hasLen := containerLen > 0
28295 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28297 dd.ReadMapElemKey()
28299 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28301 dd.ReadMapElemValue()
28303 if dd.TryDecodeAsNil() {
28305 } else if d.h.DeleteOnNilMapValue {
28312 mv = dd.DecodeString()
28322 func (d *Decoder) fastpathDecMapUintptrUintR(f *codecFnInfo, rv reflect.Value) {
28323 if rv.Kind() == reflect.Ptr {
28324 vp := rv2i(rv).(*map[uintptr]uint)
28325 v, changed := fastpathTV.DecMapUintptrUintV(*vp, true, d)
28330 fastpathTV.DecMapUintptrUintV(rv2i(rv).(map[uintptr]uint), false, d)
28333 func (f fastpathT) DecMapUintptrUintX(vp *map[uintptr]uint, d *Decoder) {
28334 v, changed := f.DecMapUintptrUintV(*vp, true, d)
28339 func (_ fastpathT) DecMapUintptrUintV(v map[uintptr]uint, canChange bool,
28340 d *Decoder) (_ map[uintptr]uint, changed bool) {
28341 dd, esep := d.d, d.hh.hasElemSeparators()
28342 containerLen := dd.ReadMapStart()
28343 if canChange && v == nil {
28344 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
28345 v = make(map[uintptr]uint, xlen)
28348 if containerLen == 0 {
28355 hasLen := containerLen > 0
28356 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28358 dd.ReadMapElemKey()
28360 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28362 dd.ReadMapElemValue()
28364 if dd.TryDecodeAsNil() {
28366 } else if d.h.DeleteOnNilMapValue {
28373 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28383 func (d *Decoder) fastpathDecMapUintptrUint8R(f *codecFnInfo, rv reflect.Value) {
28384 if rv.Kind() == reflect.Ptr {
28385 vp := rv2i(rv).(*map[uintptr]uint8)
28386 v, changed := fastpathTV.DecMapUintptrUint8V(*vp, true, d)
28391 fastpathTV.DecMapUintptrUint8V(rv2i(rv).(map[uintptr]uint8), false, d)
28394 func (f fastpathT) DecMapUintptrUint8X(vp *map[uintptr]uint8, d *Decoder) {
28395 v, changed := f.DecMapUintptrUint8V(*vp, true, d)
28400 func (_ fastpathT) DecMapUintptrUint8V(v map[uintptr]uint8, canChange bool,
28401 d *Decoder) (_ map[uintptr]uint8, changed bool) {
28402 dd, esep := d.d, d.hh.hasElemSeparators()
28403 containerLen := dd.ReadMapStart()
28404 if canChange && v == nil {
28405 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
28406 v = make(map[uintptr]uint8, xlen)
28409 if containerLen == 0 {
28416 hasLen := containerLen > 0
28417 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28419 dd.ReadMapElemKey()
28421 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28423 dd.ReadMapElemValue()
28425 if dd.TryDecodeAsNil() {
28427 } else if d.h.DeleteOnNilMapValue {
28434 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
28444 func (d *Decoder) fastpathDecMapUintptrUint16R(f *codecFnInfo, rv reflect.Value) {
28445 if rv.Kind() == reflect.Ptr {
28446 vp := rv2i(rv).(*map[uintptr]uint16)
28447 v, changed := fastpathTV.DecMapUintptrUint16V(*vp, true, d)
28452 fastpathTV.DecMapUintptrUint16V(rv2i(rv).(map[uintptr]uint16), false, d)
28455 func (f fastpathT) DecMapUintptrUint16X(vp *map[uintptr]uint16, d *Decoder) {
28456 v, changed := f.DecMapUintptrUint16V(*vp, true, d)
28461 func (_ fastpathT) DecMapUintptrUint16V(v map[uintptr]uint16, canChange bool,
28462 d *Decoder) (_ map[uintptr]uint16, changed bool) {
28463 dd, esep := d.d, d.hh.hasElemSeparators()
28464 containerLen := dd.ReadMapStart()
28465 if canChange && v == nil {
28466 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
28467 v = make(map[uintptr]uint16, xlen)
28470 if containerLen == 0 {
28477 hasLen := containerLen > 0
28478 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28480 dd.ReadMapElemKey()
28482 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28484 dd.ReadMapElemValue()
28486 if dd.TryDecodeAsNil() {
28488 } else if d.h.DeleteOnNilMapValue {
28495 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
28505 func (d *Decoder) fastpathDecMapUintptrUint32R(f *codecFnInfo, rv reflect.Value) {
28506 if rv.Kind() == reflect.Ptr {
28507 vp := rv2i(rv).(*map[uintptr]uint32)
28508 v, changed := fastpathTV.DecMapUintptrUint32V(*vp, true, d)
28513 fastpathTV.DecMapUintptrUint32V(rv2i(rv).(map[uintptr]uint32), false, d)
28516 func (f fastpathT) DecMapUintptrUint32X(vp *map[uintptr]uint32, d *Decoder) {
28517 v, changed := f.DecMapUintptrUint32V(*vp, true, d)
28522 func (_ fastpathT) DecMapUintptrUint32V(v map[uintptr]uint32, canChange bool,
28523 d *Decoder) (_ map[uintptr]uint32, changed bool) {
28524 dd, esep := d.d, d.hh.hasElemSeparators()
28525 containerLen := dd.ReadMapStart()
28526 if canChange && v == nil {
28527 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
28528 v = make(map[uintptr]uint32, xlen)
28531 if containerLen == 0 {
28538 hasLen := containerLen > 0
28539 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28541 dd.ReadMapElemKey()
28543 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28545 dd.ReadMapElemValue()
28547 if dd.TryDecodeAsNil() {
28549 } else if d.h.DeleteOnNilMapValue {
28556 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
28566 func (d *Decoder) fastpathDecMapUintptrUint64R(f *codecFnInfo, rv reflect.Value) {
28567 if rv.Kind() == reflect.Ptr {
28568 vp := rv2i(rv).(*map[uintptr]uint64)
28569 v, changed := fastpathTV.DecMapUintptrUint64V(*vp, true, d)
28574 fastpathTV.DecMapUintptrUint64V(rv2i(rv).(map[uintptr]uint64), false, d)
28577 func (f fastpathT) DecMapUintptrUint64X(vp *map[uintptr]uint64, d *Decoder) {
28578 v, changed := f.DecMapUintptrUint64V(*vp, true, d)
28583 func (_ fastpathT) DecMapUintptrUint64V(v map[uintptr]uint64, canChange bool,
28584 d *Decoder) (_ map[uintptr]uint64, changed bool) {
28585 dd, esep := d.d, d.hh.hasElemSeparators()
28586 containerLen := dd.ReadMapStart()
28587 if canChange && v == nil {
28588 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
28589 v = make(map[uintptr]uint64, xlen)
28592 if containerLen == 0 {
28599 hasLen := containerLen > 0
28600 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28602 dd.ReadMapElemKey()
28604 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28606 dd.ReadMapElemValue()
28608 if dd.TryDecodeAsNil() {
28610 } else if d.h.DeleteOnNilMapValue {
28617 mv = dd.DecodeUint64()
28627 func (d *Decoder) fastpathDecMapUintptrUintptrR(f *codecFnInfo, rv reflect.Value) {
28628 if rv.Kind() == reflect.Ptr {
28629 vp := rv2i(rv).(*map[uintptr]uintptr)
28630 v, changed := fastpathTV.DecMapUintptrUintptrV(*vp, true, d)
28635 fastpathTV.DecMapUintptrUintptrV(rv2i(rv).(map[uintptr]uintptr), false, d)
28638 func (f fastpathT) DecMapUintptrUintptrX(vp *map[uintptr]uintptr, d *Decoder) {
28639 v, changed := f.DecMapUintptrUintptrV(*vp, true, d)
28644 func (_ fastpathT) DecMapUintptrUintptrV(v map[uintptr]uintptr, canChange bool,
28645 d *Decoder) (_ map[uintptr]uintptr, changed bool) {
28646 dd, esep := d.d, d.hh.hasElemSeparators()
28647 containerLen := dd.ReadMapStart()
28648 if canChange && v == nil {
28649 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
28650 v = make(map[uintptr]uintptr, xlen)
28653 if containerLen == 0 {
28660 hasLen := containerLen > 0
28661 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28663 dd.ReadMapElemKey()
28665 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28667 dd.ReadMapElemValue()
28669 if dd.TryDecodeAsNil() {
28671 } else if d.h.DeleteOnNilMapValue {
28678 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28688 func (d *Decoder) fastpathDecMapUintptrIntR(f *codecFnInfo, rv reflect.Value) {
28689 if rv.Kind() == reflect.Ptr {
28690 vp := rv2i(rv).(*map[uintptr]int)
28691 v, changed := fastpathTV.DecMapUintptrIntV(*vp, true, d)
28696 fastpathTV.DecMapUintptrIntV(rv2i(rv).(map[uintptr]int), false, d)
28699 func (f fastpathT) DecMapUintptrIntX(vp *map[uintptr]int, d *Decoder) {
28700 v, changed := f.DecMapUintptrIntV(*vp, true, d)
28705 func (_ fastpathT) DecMapUintptrIntV(v map[uintptr]int, canChange bool,
28706 d *Decoder) (_ map[uintptr]int, changed bool) {
28707 dd, esep := d.d, d.hh.hasElemSeparators()
28708 containerLen := dd.ReadMapStart()
28709 if canChange && v == nil {
28710 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
28711 v = make(map[uintptr]int, xlen)
28714 if containerLen == 0 {
28721 hasLen := containerLen > 0
28722 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28724 dd.ReadMapElemKey()
28726 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28728 dd.ReadMapElemValue()
28730 if dd.TryDecodeAsNil() {
28732 } else if d.h.DeleteOnNilMapValue {
28739 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
28749 func (d *Decoder) fastpathDecMapUintptrInt8R(f *codecFnInfo, rv reflect.Value) {
28750 if rv.Kind() == reflect.Ptr {
28751 vp := rv2i(rv).(*map[uintptr]int8)
28752 v, changed := fastpathTV.DecMapUintptrInt8V(*vp, true, d)
28757 fastpathTV.DecMapUintptrInt8V(rv2i(rv).(map[uintptr]int8), false, d)
28760 func (f fastpathT) DecMapUintptrInt8X(vp *map[uintptr]int8, d *Decoder) {
28761 v, changed := f.DecMapUintptrInt8V(*vp, true, d)
28766 func (_ fastpathT) DecMapUintptrInt8V(v map[uintptr]int8, canChange bool,
28767 d *Decoder) (_ map[uintptr]int8, changed bool) {
28768 dd, esep := d.d, d.hh.hasElemSeparators()
28769 containerLen := dd.ReadMapStart()
28770 if canChange && v == nil {
28771 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
28772 v = make(map[uintptr]int8, xlen)
28775 if containerLen == 0 {
28782 hasLen := containerLen > 0
28783 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28785 dd.ReadMapElemKey()
28787 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28789 dd.ReadMapElemValue()
28791 if dd.TryDecodeAsNil() {
28793 } else if d.h.DeleteOnNilMapValue {
28800 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
28810 func (d *Decoder) fastpathDecMapUintptrInt16R(f *codecFnInfo, rv reflect.Value) {
28811 if rv.Kind() == reflect.Ptr {
28812 vp := rv2i(rv).(*map[uintptr]int16)
28813 v, changed := fastpathTV.DecMapUintptrInt16V(*vp, true, d)
28818 fastpathTV.DecMapUintptrInt16V(rv2i(rv).(map[uintptr]int16), false, d)
28821 func (f fastpathT) DecMapUintptrInt16X(vp *map[uintptr]int16, d *Decoder) {
28822 v, changed := f.DecMapUintptrInt16V(*vp, true, d)
28827 func (_ fastpathT) DecMapUintptrInt16V(v map[uintptr]int16, canChange bool,
28828 d *Decoder) (_ map[uintptr]int16, changed bool) {
28829 dd, esep := d.d, d.hh.hasElemSeparators()
28830 containerLen := dd.ReadMapStart()
28831 if canChange && v == nil {
28832 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
28833 v = make(map[uintptr]int16, xlen)
28836 if containerLen == 0 {
28843 hasLen := containerLen > 0
28844 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28846 dd.ReadMapElemKey()
28848 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28850 dd.ReadMapElemValue()
28852 if dd.TryDecodeAsNil() {
28854 } else if d.h.DeleteOnNilMapValue {
28861 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
28871 func (d *Decoder) fastpathDecMapUintptrInt32R(f *codecFnInfo, rv reflect.Value) {
28872 if rv.Kind() == reflect.Ptr {
28873 vp := rv2i(rv).(*map[uintptr]int32)
28874 v, changed := fastpathTV.DecMapUintptrInt32V(*vp, true, d)
28879 fastpathTV.DecMapUintptrInt32V(rv2i(rv).(map[uintptr]int32), false, d)
28882 func (f fastpathT) DecMapUintptrInt32X(vp *map[uintptr]int32, d *Decoder) {
28883 v, changed := f.DecMapUintptrInt32V(*vp, true, d)
28888 func (_ fastpathT) DecMapUintptrInt32V(v map[uintptr]int32, canChange bool,
28889 d *Decoder) (_ map[uintptr]int32, changed bool) {
28890 dd, esep := d.d, d.hh.hasElemSeparators()
28891 containerLen := dd.ReadMapStart()
28892 if canChange && v == nil {
28893 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
28894 v = make(map[uintptr]int32, xlen)
28897 if containerLen == 0 {
28904 hasLen := containerLen > 0
28905 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28907 dd.ReadMapElemKey()
28909 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28911 dd.ReadMapElemValue()
28913 if dd.TryDecodeAsNil() {
28915 } else if d.h.DeleteOnNilMapValue {
28922 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
28932 func (d *Decoder) fastpathDecMapUintptrInt64R(f *codecFnInfo, rv reflect.Value) {
28933 if rv.Kind() == reflect.Ptr {
28934 vp := rv2i(rv).(*map[uintptr]int64)
28935 v, changed := fastpathTV.DecMapUintptrInt64V(*vp, true, d)
28940 fastpathTV.DecMapUintptrInt64V(rv2i(rv).(map[uintptr]int64), false, d)
28943 func (f fastpathT) DecMapUintptrInt64X(vp *map[uintptr]int64, d *Decoder) {
28944 v, changed := f.DecMapUintptrInt64V(*vp, true, d)
28949 func (_ fastpathT) DecMapUintptrInt64V(v map[uintptr]int64, canChange bool,
28950 d *Decoder) (_ map[uintptr]int64, changed bool) {
28951 dd, esep := d.d, d.hh.hasElemSeparators()
28952 containerLen := dd.ReadMapStart()
28953 if canChange && v == nil {
28954 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
28955 v = make(map[uintptr]int64, xlen)
28958 if containerLen == 0 {
28965 hasLen := containerLen > 0
28966 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28968 dd.ReadMapElemKey()
28970 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28972 dd.ReadMapElemValue()
28974 if dd.TryDecodeAsNil() {
28976 } else if d.h.DeleteOnNilMapValue {
28983 mv = dd.DecodeInt64()
28993 func (d *Decoder) fastpathDecMapUintptrFloat32R(f *codecFnInfo, rv reflect.Value) {
28994 if rv.Kind() == reflect.Ptr {
28995 vp := rv2i(rv).(*map[uintptr]float32)
28996 v, changed := fastpathTV.DecMapUintptrFloat32V(*vp, true, d)
29001 fastpathTV.DecMapUintptrFloat32V(rv2i(rv).(map[uintptr]float32), false, d)
29004 func (f fastpathT) DecMapUintptrFloat32X(vp *map[uintptr]float32, d *Decoder) {
29005 v, changed := f.DecMapUintptrFloat32V(*vp, true, d)
29010 func (_ fastpathT) DecMapUintptrFloat32V(v map[uintptr]float32, canChange bool,
29011 d *Decoder) (_ map[uintptr]float32, changed bool) {
29012 dd, esep := d.d, d.hh.hasElemSeparators()
29013 containerLen := dd.ReadMapStart()
29014 if canChange && v == nil {
29015 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
29016 v = make(map[uintptr]float32, xlen)
29019 if containerLen == 0 {
29026 hasLen := containerLen > 0
29027 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29029 dd.ReadMapElemKey()
29031 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
29033 dd.ReadMapElemValue()
29035 if dd.TryDecodeAsNil() {
29037 } else if d.h.DeleteOnNilMapValue {
29044 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
29054 func (d *Decoder) fastpathDecMapUintptrFloat64R(f *codecFnInfo, rv reflect.Value) {
29055 if rv.Kind() == reflect.Ptr {
29056 vp := rv2i(rv).(*map[uintptr]float64)
29057 v, changed := fastpathTV.DecMapUintptrFloat64V(*vp, true, d)
29062 fastpathTV.DecMapUintptrFloat64V(rv2i(rv).(map[uintptr]float64), false, d)
29065 func (f fastpathT) DecMapUintptrFloat64X(vp *map[uintptr]float64, d *Decoder) {
29066 v, changed := f.DecMapUintptrFloat64V(*vp, true, d)
29071 func (_ fastpathT) DecMapUintptrFloat64V(v map[uintptr]float64, canChange bool,
29072 d *Decoder) (_ map[uintptr]float64, changed bool) {
29073 dd, esep := d.d, d.hh.hasElemSeparators()
29074 containerLen := dd.ReadMapStart()
29075 if canChange && v == nil {
29076 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
29077 v = make(map[uintptr]float64, xlen)
29080 if containerLen == 0 {
29087 hasLen := containerLen > 0
29088 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29090 dd.ReadMapElemKey()
29092 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
29094 dd.ReadMapElemValue()
29096 if dd.TryDecodeAsNil() {
29098 } else if d.h.DeleteOnNilMapValue {
29105 mv = dd.DecodeFloat64()
29115 func (d *Decoder) fastpathDecMapUintptrBoolR(f *codecFnInfo, rv reflect.Value) {
29116 if rv.Kind() == reflect.Ptr {
29117 vp := rv2i(rv).(*map[uintptr]bool)
29118 v, changed := fastpathTV.DecMapUintptrBoolV(*vp, true, d)
29123 fastpathTV.DecMapUintptrBoolV(rv2i(rv).(map[uintptr]bool), false, d)
29126 func (f fastpathT) DecMapUintptrBoolX(vp *map[uintptr]bool, d *Decoder) {
29127 v, changed := f.DecMapUintptrBoolV(*vp, true, d)
29132 func (_ fastpathT) DecMapUintptrBoolV(v map[uintptr]bool, canChange bool,
29133 d *Decoder) (_ map[uintptr]bool, changed bool) {
29134 dd, esep := d.d, d.hh.hasElemSeparators()
29135 containerLen := dd.ReadMapStart()
29136 if canChange && v == nil {
29137 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
29138 v = make(map[uintptr]bool, xlen)
29141 if containerLen == 0 {
29148 hasLen := containerLen > 0
29149 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29151 dd.ReadMapElemKey()
29153 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
29155 dd.ReadMapElemValue()
29157 if dd.TryDecodeAsNil() {
29159 } else if d.h.DeleteOnNilMapValue {
29166 mv = dd.DecodeBool()
29176 func (d *Decoder) fastpathDecMapIntIntfR(f *codecFnInfo, rv reflect.Value) {
29177 if rv.Kind() == reflect.Ptr {
29178 vp := rv2i(rv).(*map[int]interface{})
29179 v, changed := fastpathTV.DecMapIntIntfV(*vp, true, d)
29184 fastpathTV.DecMapIntIntfV(rv2i(rv).(map[int]interface{}), false, d)
29187 func (f fastpathT) DecMapIntIntfX(vp *map[int]interface{}, d *Decoder) {
29188 v, changed := f.DecMapIntIntfV(*vp, true, d)
29193 func (_ fastpathT) DecMapIntIntfV(v map[int]interface{}, canChange bool,
29194 d *Decoder) (_ map[int]interface{}, changed bool) {
29195 dd, esep := d.d, d.hh.hasElemSeparators()
29196 containerLen := dd.ReadMapStart()
29197 if canChange && v == nil {
29198 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
29199 v = make(map[int]interface{}, xlen)
29202 if containerLen == 0 {
29207 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
29210 hasLen := containerLen > 0
29211 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29213 dd.ReadMapElemKey()
29215 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29217 dd.ReadMapElemValue()
29219 if dd.TryDecodeAsNil() {
29221 } else if d.h.DeleteOnNilMapValue {
29243 func (d *Decoder) fastpathDecMapIntStringR(f *codecFnInfo, rv reflect.Value) {
29244 if rv.Kind() == reflect.Ptr {
29245 vp := rv2i(rv).(*map[int]string)
29246 v, changed := fastpathTV.DecMapIntStringV(*vp, true, d)
29251 fastpathTV.DecMapIntStringV(rv2i(rv).(map[int]string), false, d)
29254 func (f fastpathT) DecMapIntStringX(vp *map[int]string, d *Decoder) {
29255 v, changed := f.DecMapIntStringV(*vp, true, d)
29260 func (_ fastpathT) DecMapIntStringV(v map[int]string, canChange bool,
29261 d *Decoder) (_ map[int]string, changed bool) {
29262 dd, esep := d.d, d.hh.hasElemSeparators()
29263 containerLen := dd.ReadMapStart()
29264 if canChange && v == nil {
29265 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
29266 v = make(map[int]string, xlen)
29269 if containerLen == 0 {
29276 hasLen := containerLen > 0
29277 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29279 dd.ReadMapElemKey()
29281 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29283 dd.ReadMapElemValue()
29285 if dd.TryDecodeAsNil() {
29287 } else if d.h.DeleteOnNilMapValue {
29294 mv = dd.DecodeString()
29304 func (d *Decoder) fastpathDecMapIntUintR(f *codecFnInfo, rv reflect.Value) {
29305 if rv.Kind() == reflect.Ptr {
29306 vp := rv2i(rv).(*map[int]uint)
29307 v, changed := fastpathTV.DecMapIntUintV(*vp, true, d)
29312 fastpathTV.DecMapIntUintV(rv2i(rv).(map[int]uint), false, d)
29315 func (f fastpathT) DecMapIntUintX(vp *map[int]uint, d *Decoder) {
29316 v, changed := f.DecMapIntUintV(*vp, true, d)
29321 func (_ fastpathT) DecMapIntUintV(v map[int]uint, canChange bool,
29322 d *Decoder) (_ map[int]uint, changed bool) {
29323 dd, esep := d.d, d.hh.hasElemSeparators()
29324 containerLen := dd.ReadMapStart()
29325 if canChange && v == nil {
29326 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
29327 v = make(map[int]uint, xlen)
29330 if containerLen == 0 {
29337 hasLen := containerLen > 0
29338 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29340 dd.ReadMapElemKey()
29342 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29344 dd.ReadMapElemValue()
29346 if dd.TryDecodeAsNil() {
29348 } else if d.h.DeleteOnNilMapValue {
29355 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
29365 func (d *Decoder) fastpathDecMapIntUint8R(f *codecFnInfo, rv reflect.Value) {
29366 if rv.Kind() == reflect.Ptr {
29367 vp := rv2i(rv).(*map[int]uint8)
29368 v, changed := fastpathTV.DecMapIntUint8V(*vp, true, d)
29373 fastpathTV.DecMapIntUint8V(rv2i(rv).(map[int]uint8), false, d)
29376 func (f fastpathT) DecMapIntUint8X(vp *map[int]uint8, d *Decoder) {
29377 v, changed := f.DecMapIntUint8V(*vp, true, d)
29382 func (_ fastpathT) DecMapIntUint8V(v map[int]uint8, canChange bool,
29383 d *Decoder) (_ map[int]uint8, changed bool) {
29384 dd, esep := d.d, d.hh.hasElemSeparators()
29385 containerLen := dd.ReadMapStart()
29386 if canChange && v == nil {
29387 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
29388 v = make(map[int]uint8, xlen)
29391 if containerLen == 0 {
29398 hasLen := containerLen > 0
29399 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29401 dd.ReadMapElemKey()
29403 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29405 dd.ReadMapElemValue()
29407 if dd.TryDecodeAsNil() {
29409 } else if d.h.DeleteOnNilMapValue {
29416 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
29426 func (d *Decoder) fastpathDecMapIntUint16R(f *codecFnInfo, rv reflect.Value) {
29427 if rv.Kind() == reflect.Ptr {
29428 vp := rv2i(rv).(*map[int]uint16)
29429 v, changed := fastpathTV.DecMapIntUint16V(*vp, true, d)
29434 fastpathTV.DecMapIntUint16V(rv2i(rv).(map[int]uint16), false, d)
29437 func (f fastpathT) DecMapIntUint16X(vp *map[int]uint16, d *Decoder) {
29438 v, changed := f.DecMapIntUint16V(*vp, true, d)
29443 func (_ fastpathT) DecMapIntUint16V(v map[int]uint16, canChange bool,
29444 d *Decoder) (_ map[int]uint16, changed bool) {
29445 dd, esep := d.d, d.hh.hasElemSeparators()
29446 containerLen := dd.ReadMapStart()
29447 if canChange && v == nil {
29448 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
29449 v = make(map[int]uint16, xlen)
29452 if containerLen == 0 {
29459 hasLen := containerLen > 0
29460 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29462 dd.ReadMapElemKey()
29464 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29466 dd.ReadMapElemValue()
29468 if dd.TryDecodeAsNil() {
29470 } else if d.h.DeleteOnNilMapValue {
29477 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
29487 func (d *Decoder) fastpathDecMapIntUint32R(f *codecFnInfo, rv reflect.Value) {
29488 if rv.Kind() == reflect.Ptr {
29489 vp := rv2i(rv).(*map[int]uint32)
29490 v, changed := fastpathTV.DecMapIntUint32V(*vp, true, d)
29495 fastpathTV.DecMapIntUint32V(rv2i(rv).(map[int]uint32), false, d)
29498 func (f fastpathT) DecMapIntUint32X(vp *map[int]uint32, d *Decoder) {
29499 v, changed := f.DecMapIntUint32V(*vp, true, d)
29504 func (_ fastpathT) DecMapIntUint32V(v map[int]uint32, canChange bool,
29505 d *Decoder) (_ map[int]uint32, changed bool) {
29506 dd, esep := d.d, d.hh.hasElemSeparators()
29507 containerLen := dd.ReadMapStart()
29508 if canChange && v == nil {
29509 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
29510 v = make(map[int]uint32, xlen)
29513 if containerLen == 0 {
29520 hasLen := containerLen > 0
29521 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29523 dd.ReadMapElemKey()
29525 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29527 dd.ReadMapElemValue()
29529 if dd.TryDecodeAsNil() {
29531 } else if d.h.DeleteOnNilMapValue {
29538 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
29548 func (d *Decoder) fastpathDecMapIntUint64R(f *codecFnInfo, rv reflect.Value) {
29549 if rv.Kind() == reflect.Ptr {
29550 vp := rv2i(rv).(*map[int]uint64)
29551 v, changed := fastpathTV.DecMapIntUint64V(*vp, true, d)
29556 fastpathTV.DecMapIntUint64V(rv2i(rv).(map[int]uint64), false, d)
29559 func (f fastpathT) DecMapIntUint64X(vp *map[int]uint64, d *Decoder) {
29560 v, changed := f.DecMapIntUint64V(*vp, true, d)
29565 func (_ fastpathT) DecMapIntUint64V(v map[int]uint64, canChange bool,
29566 d *Decoder) (_ map[int]uint64, changed bool) {
29567 dd, esep := d.d, d.hh.hasElemSeparators()
29568 containerLen := dd.ReadMapStart()
29569 if canChange && v == nil {
29570 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
29571 v = make(map[int]uint64, xlen)
29574 if containerLen == 0 {
29581 hasLen := containerLen > 0
29582 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29584 dd.ReadMapElemKey()
29586 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29588 dd.ReadMapElemValue()
29590 if dd.TryDecodeAsNil() {
29592 } else if d.h.DeleteOnNilMapValue {
29599 mv = dd.DecodeUint64()
29609 func (d *Decoder) fastpathDecMapIntUintptrR(f *codecFnInfo, rv reflect.Value) {
29610 if rv.Kind() == reflect.Ptr {
29611 vp := rv2i(rv).(*map[int]uintptr)
29612 v, changed := fastpathTV.DecMapIntUintptrV(*vp, true, d)
29617 fastpathTV.DecMapIntUintptrV(rv2i(rv).(map[int]uintptr), false, d)
29620 func (f fastpathT) DecMapIntUintptrX(vp *map[int]uintptr, d *Decoder) {
29621 v, changed := f.DecMapIntUintptrV(*vp, true, d)
29626 func (_ fastpathT) DecMapIntUintptrV(v map[int]uintptr, canChange bool,
29627 d *Decoder) (_ map[int]uintptr, changed bool) {
29628 dd, esep := d.d, d.hh.hasElemSeparators()
29629 containerLen := dd.ReadMapStart()
29630 if canChange && v == nil {
29631 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
29632 v = make(map[int]uintptr, xlen)
29635 if containerLen == 0 {
29642 hasLen := containerLen > 0
29643 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29645 dd.ReadMapElemKey()
29647 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29649 dd.ReadMapElemValue()
29651 if dd.TryDecodeAsNil() {
29653 } else if d.h.DeleteOnNilMapValue {
29660 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
29670 func (d *Decoder) fastpathDecMapIntIntR(f *codecFnInfo, rv reflect.Value) {
29671 if rv.Kind() == reflect.Ptr {
29672 vp := rv2i(rv).(*map[int]int)
29673 v, changed := fastpathTV.DecMapIntIntV(*vp, true, d)
29678 fastpathTV.DecMapIntIntV(rv2i(rv).(map[int]int), false, d)
29681 func (f fastpathT) DecMapIntIntX(vp *map[int]int, d *Decoder) {
29682 v, changed := f.DecMapIntIntV(*vp, true, d)
29687 func (_ fastpathT) DecMapIntIntV(v map[int]int, canChange bool,
29688 d *Decoder) (_ map[int]int, changed bool) {
29689 dd, esep := d.d, d.hh.hasElemSeparators()
29690 containerLen := dd.ReadMapStart()
29691 if canChange && v == nil {
29692 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
29693 v = make(map[int]int, xlen)
29696 if containerLen == 0 {
29703 hasLen := containerLen > 0
29704 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29706 dd.ReadMapElemKey()
29708 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29710 dd.ReadMapElemValue()
29712 if dd.TryDecodeAsNil() {
29714 } else if d.h.DeleteOnNilMapValue {
29721 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29731 func (d *Decoder) fastpathDecMapIntInt8R(f *codecFnInfo, rv reflect.Value) {
29732 if rv.Kind() == reflect.Ptr {
29733 vp := rv2i(rv).(*map[int]int8)
29734 v, changed := fastpathTV.DecMapIntInt8V(*vp, true, d)
29739 fastpathTV.DecMapIntInt8V(rv2i(rv).(map[int]int8), false, d)
29742 func (f fastpathT) DecMapIntInt8X(vp *map[int]int8, d *Decoder) {
29743 v, changed := f.DecMapIntInt8V(*vp, true, d)
29748 func (_ fastpathT) DecMapIntInt8V(v map[int]int8, canChange bool,
29749 d *Decoder) (_ map[int]int8, changed bool) {
29750 dd, esep := d.d, d.hh.hasElemSeparators()
29751 containerLen := dd.ReadMapStart()
29752 if canChange && v == nil {
29753 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
29754 v = make(map[int]int8, xlen)
29757 if containerLen == 0 {
29764 hasLen := containerLen > 0
29765 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29767 dd.ReadMapElemKey()
29769 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29771 dd.ReadMapElemValue()
29773 if dd.TryDecodeAsNil() {
29775 } else if d.h.DeleteOnNilMapValue {
29782 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
29792 func (d *Decoder) fastpathDecMapIntInt16R(f *codecFnInfo, rv reflect.Value) {
29793 if rv.Kind() == reflect.Ptr {
29794 vp := rv2i(rv).(*map[int]int16)
29795 v, changed := fastpathTV.DecMapIntInt16V(*vp, true, d)
29800 fastpathTV.DecMapIntInt16V(rv2i(rv).(map[int]int16), false, d)
29803 func (f fastpathT) DecMapIntInt16X(vp *map[int]int16, d *Decoder) {
29804 v, changed := f.DecMapIntInt16V(*vp, true, d)
29809 func (_ fastpathT) DecMapIntInt16V(v map[int]int16, canChange bool,
29810 d *Decoder) (_ map[int]int16, changed bool) {
29811 dd, esep := d.d, d.hh.hasElemSeparators()
29812 containerLen := dd.ReadMapStart()
29813 if canChange && v == nil {
29814 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
29815 v = make(map[int]int16, xlen)
29818 if containerLen == 0 {
29825 hasLen := containerLen > 0
29826 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29828 dd.ReadMapElemKey()
29830 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29832 dd.ReadMapElemValue()
29834 if dd.TryDecodeAsNil() {
29836 } else if d.h.DeleteOnNilMapValue {
29843 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
29853 func (d *Decoder) fastpathDecMapIntInt32R(f *codecFnInfo, rv reflect.Value) {
29854 if rv.Kind() == reflect.Ptr {
29855 vp := rv2i(rv).(*map[int]int32)
29856 v, changed := fastpathTV.DecMapIntInt32V(*vp, true, d)
29861 fastpathTV.DecMapIntInt32V(rv2i(rv).(map[int]int32), false, d)
29864 func (f fastpathT) DecMapIntInt32X(vp *map[int]int32, d *Decoder) {
29865 v, changed := f.DecMapIntInt32V(*vp, true, d)
29870 func (_ fastpathT) DecMapIntInt32V(v map[int]int32, canChange bool,
29871 d *Decoder) (_ map[int]int32, changed bool) {
29872 dd, esep := d.d, d.hh.hasElemSeparators()
29873 containerLen := dd.ReadMapStart()
29874 if canChange && v == nil {
29875 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
29876 v = make(map[int]int32, xlen)
29879 if containerLen == 0 {
29886 hasLen := containerLen > 0
29887 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29889 dd.ReadMapElemKey()
29891 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29893 dd.ReadMapElemValue()
29895 if dd.TryDecodeAsNil() {
29897 } else if d.h.DeleteOnNilMapValue {
29904 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
29914 func (d *Decoder) fastpathDecMapIntInt64R(f *codecFnInfo, rv reflect.Value) {
29915 if rv.Kind() == reflect.Ptr {
29916 vp := rv2i(rv).(*map[int]int64)
29917 v, changed := fastpathTV.DecMapIntInt64V(*vp, true, d)
29922 fastpathTV.DecMapIntInt64V(rv2i(rv).(map[int]int64), false, d)
29925 func (f fastpathT) DecMapIntInt64X(vp *map[int]int64, d *Decoder) {
29926 v, changed := f.DecMapIntInt64V(*vp, true, d)
29931 func (_ fastpathT) DecMapIntInt64V(v map[int]int64, canChange bool,
29932 d *Decoder) (_ map[int]int64, changed bool) {
29933 dd, esep := d.d, d.hh.hasElemSeparators()
29934 containerLen := dd.ReadMapStart()
29935 if canChange && v == nil {
29936 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
29937 v = make(map[int]int64, xlen)
29940 if containerLen == 0 {
29947 hasLen := containerLen > 0
29948 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29950 dd.ReadMapElemKey()
29952 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29954 dd.ReadMapElemValue()
29956 if dd.TryDecodeAsNil() {
29958 } else if d.h.DeleteOnNilMapValue {
29965 mv = dd.DecodeInt64()
29975 func (d *Decoder) fastpathDecMapIntFloat32R(f *codecFnInfo, rv reflect.Value) {
29976 if rv.Kind() == reflect.Ptr {
29977 vp := rv2i(rv).(*map[int]float32)
29978 v, changed := fastpathTV.DecMapIntFloat32V(*vp, true, d)
29983 fastpathTV.DecMapIntFloat32V(rv2i(rv).(map[int]float32), false, d)
29986 func (f fastpathT) DecMapIntFloat32X(vp *map[int]float32, d *Decoder) {
29987 v, changed := f.DecMapIntFloat32V(*vp, true, d)
29992 func (_ fastpathT) DecMapIntFloat32V(v map[int]float32, canChange bool,
29993 d *Decoder) (_ map[int]float32, changed bool) {
29994 dd, esep := d.d, d.hh.hasElemSeparators()
29995 containerLen := dd.ReadMapStart()
29996 if canChange && v == nil {
29997 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
29998 v = make(map[int]float32, xlen)
30001 if containerLen == 0 {
30008 hasLen := containerLen > 0
30009 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30011 dd.ReadMapElemKey()
30013 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
30015 dd.ReadMapElemValue()
30017 if dd.TryDecodeAsNil() {
30019 } else if d.h.DeleteOnNilMapValue {
30026 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
30036 func (d *Decoder) fastpathDecMapIntFloat64R(f *codecFnInfo, rv reflect.Value) {
30037 if rv.Kind() == reflect.Ptr {
30038 vp := rv2i(rv).(*map[int]float64)
30039 v, changed := fastpathTV.DecMapIntFloat64V(*vp, true, d)
30044 fastpathTV.DecMapIntFloat64V(rv2i(rv).(map[int]float64), false, d)
30047 func (f fastpathT) DecMapIntFloat64X(vp *map[int]float64, d *Decoder) {
30048 v, changed := f.DecMapIntFloat64V(*vp, true, d)
30053 func (_ fastpathT) DecMapIntFloat64V(v map[int]float64, canChange bool,
30054 d *Decoder) (_ map[int]float64, changed bool) {
30055 dd, esep := d.d, d.hh.hasElemSeparators()
30056 containerLen := dd.ReadMapStart()
30057 if canChange && v == nil {
30058 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
30059 v = make(map[int]float64, xlen)
30062 if containerLen == 0 {
30069 hasLen := containerLen > 0
30070 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30072 dd.ReadMapElemKey()
30074 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
30076 dd.ReadMapElemValue()
30078 if dd.TryDecodeAsNil() {
30080 } else if d.h.DeleteOnNilMapValue {
30087 mv = dd.DecodeFloat64()
30097 func (d *Decoder) fastpathDecMapIntBoolR(f *codecFnInfo, rv reflect.Value) {
30098 if rv.Kind() == reflect.Ptr {
30099 vp := rv2i(rv).(*map[int]bool)
30100 v, changed := fastpathTV.DecMapIntBoolV(*vp, true, d)
30105 fastpathTV.DecMapIntBoolV(rv2i(rv).(map[int]bool), false, d)
30108 func (f fastpathT) DecMapIntBoolX(vp *map[int]bool, d *Decoder) {
30109 v, changed := f.DecMapIntBoolV(*vp, true, d)
30114 func (_ fastpathT) DecMapIntBoolV(v map[int]bool, canChange bool,
30115 d *Decoder) (_ map[int]bool, changed bool) {
30116 dd, esep := d.d, d.hh.hasElemSeparators()
30117 containerLen := dd.ReadMapStart()
30118 if canChange && v == nil {
30119 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
30120 v = make(map[int]bool, xlen)
30123 if containerLen == 0 {
30130 hasLen := containerLen > 0
30131 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30133 dd.ReadMapElemKey()
30135 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
30137 dd.ReadMapElemValue()
30139 if dd.TryDecodeAsNil() {
30141 } else if d.h.DeleteOnNilMapValue {
30148 mv = dd.DecodeBool()
30158 func (d *Decoder) fastpathDecMapInt8IntfR(f *codecFnInfo, rv reflect.Value) {
30159 if rv.Kind() == reflect.Ptr {
30160 vp := rv2i(rv).(*map[int8]interface{})
30161 v, changed := fastpathTV.DecMapInt8IntfV(*vp, true, d)
30166 fastpathTV.DecMapInt8IntfV(rv2i(rv).(map[int8]interface{}), false, d)
30169 func (f fastpathT) DecMapInt8IntfX(vp *map[int8]interface{}, d *Decoder) {
30170 v, changed := f.DecMapInt8IntfV(*vp, true, d)
30175 func (_ fastpathT) DecMapInt8IntfV(v map[int8]interface{}, canChange bool,
30176 d *Decoder) (_ map[int8]interface{}, changed bool) {
30177 dd, esep := d.d, d.hh.hasElemSeparators()
30178 containerLen := dd.ReadMapStart()
30179 if canChange && v == nil {
30180 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
30181 v = make(map[int8]interface{}, xlen)
30184 if containerLen == 0 {
30189 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
30192 hasLen := containerLen > 0
30193 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30195 dd.ReadMapElemKey()
30197 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30199 dd.ReadMapElemValue()
30201 if dd.TryDecodeAsNil() {
30203 } else if d.h.DeleteOnNilMapValue {
30225 func (d *Decoder) fastpathDecMapInt8StringR(f *codecFnInfo, rv reflect.Value) {
30226 if rv.Kind() == reflect.Ptr {
30227 vp := rv2i(rv).(*map[int8]string)
30228 v, changed := fastpathTV.DecMapInt8StringV(*vp, true, d)
30233 fastpathTV.DecMapInt8StringV(rv2i(rv).(map[int8]string), false, d)
30236 func (f fastpathT) DecMapInt8StringX(vp *map[int8]string, d *Decoder) {
30237 v, changed := f.DecMapInt8StringV(*vp, true, d)
30242 func (_ fastpathT) DecMapInt8StringV(v map[int8]string, canChange bool,
30243 d *Decoder) (_ map[int8]string, changed bool) {
30244 dd, esep := d.d, d.hh.hasElemSeparators()
30245 containerLen := dd.ReadMapStart()
30246 if canChange && v == nil {
30247 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
30248 v = make(map[int8]string, xlen)
30251 if containerLen == 0 {
30258 hasLen := containerLen > 0
30259 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30261 dd.ReadMapElemKey()
30263 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30265 dd.ReadMapElemValue()
30267 if dd.TryDecodeAsNil() {
30269 } else if d.h.DeleteOnNilMapValue {
30276 mv = dd.DecodeString()
30286 func (d *Decoder) fastpathDecMapInt8UintR(f *codecFnInfo, rv reflect.Value) {
30287 if rv.Kind() == reflect.Ptr {
30288 vp := rv2i(rv).(*map[int8]uint)
30289 v, changed := fastpathTV.DecMapInt8UintV(*vp, true, d)
30294 fastpathTV.DecMapInt8UintV(rv2i(rv).(map[int8]uint), false, d)
30297 func (f fastpathT) DecMapInt8UintX(vp *map[int8]uint, d *Decoder) {
30298 v, changed := f.DecMapInt8UintV(*vp, true, d)
30303 func (_ fastpathT) DecMapInt8UintV(v map[int8]uint, canChange bool,
30304 d *Decoder) (_ map[int8]uint, changed bool) {
30305 dd, esep := d.d, d.hh.hasElemSeparators()
30306 containerLen := dd.ReadMapStart()
30307 if canChange && v == nil {
30308 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
30309 v = make(map[int8]uint, xlen)
30312 if containerLen == 0 {
30319 hasLen := containerLen > 0
30320 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30322 dd.ReadMapElemKey()
30324 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30326 dd.ReadMapElemValue()
30328 if dd.TryDecodeAsNil() {
30330 } else if d.h.DeleteOnNilMapValue {
30337 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
30347 func (d *Decoder) fastpathDecMapInt8Uint8R(f *codecFnInfo, rv reflect.Value) {
30348 if rv.Kind() == reflect.Ptr {
30349 vp := rv2i(rv).(*map[int8]uint8)
30350 v, changed := fastpathTV.DecMapInt8Uint8V(*vp, true, d)
30355 fastpathTV.DecMapInt8Uint8V(rv2i(rv).(map[int8]uint8), false, d)
30358 func (f fastpathT) DecMapInt8Uint8X(vp *map[int8]uint8, d *Decoder) {
30359 v, changed := f.DecMapInt8Uint8V(*vp, true, d)
30364 func (_ fastpathT) DecMapInt8Uint8V(v map[int8]uint8, canChange bool,
30365 d *Decoder) (_ map[int8]uint8, changed bool) {
30366 dd, esep := d.d, d.hh.hasElemSeparators()
30367 containerLen := dd.ReadMapStart()
30368 if canChange && v == nil {
30369 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
30370 v = make(map[int8]uint8, xlen)
30373 if containerLen == 0 {
30380 hasLen := containerLen > 0
30381 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30383 dd.ReadMapElemKey()
30385 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30387 dd.ReadMapElemValue()
30389 if dd.TryDecodeAsNil() {
30391 } else if d.h.DeleteOnNilMapValue {
30398 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
30408 func (d *Decoder) fastpathDecMapInt8Uint16R(f *codecFnInfo, rv reflect.Value) {
30409 if rv.Kind() == reflect.Ptr {
30410 vp := rv2i(rv).(*map[int8]uint16)
30411 v, changed := fastpathTV.DecMapInt8Uint16V(*vp, true, d)
30416 fastpathTV.DecMapInt8Uint16V(rv2i(rv).(map[int8]uint16), false, d)
30419 func (f fastpathT) DecMapInt8Uint16X(vp *map[int8]uint16, d *Decoder) {
30420 v, changed := f.DecMapInt8Uint16V(*vp, true, d)
30425 func (_ fastpathT) DecMapInt8Uint16V(v map[int8]uint16, canChange bool,
30426 d *Decoder) (_ map[int8]uint16, changed bool) {
30427 dd, esep := d.d, d.hh.hasElemSeparators()
30428 containerLen := dd.ReadMapStart()
30429 if canChange && v == nil {
30430 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
30431 v = make(map[int8]uint16, xlen)
30434 if containerLen == 0 {
30441 hasLen := containerLen > 0
30442 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30444 dd.ReadMapElemKey()
30446 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30448 dd.ReadMapElemValue()
30450 if dd.TryDecodeAsNil() {
30452 } else if d.h.DeleteOnNilMapValue {
30459 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
30469 func (d *Decoder) fastpathDecMapInt8Uint32R(f *codecFnInfo, rv reflect.Value) {
30470 if rv.Kind() == reflect.Ptr {
30471 vp := rv2i(rv).(*map[int8]uint32)
30472 v, changed := fastpathTV.DecMapInt8Uint32V(*vp, true, d)
30477 fastpathTV.DecMapInt8Uint32V(rv2i(rv).(map[int8]uint32), false, d)
30480 func (f fastpathT) DecMapInt8Uint32X(vp *map[int8]uint32, d *Decoder) {
30481 v, changed := f.DecMapInt8Uint32V(*vp, true, d)
30486 func (_ fastpathT) DecMapInt8Uint32V(v map[int8]uint32, canChange bool,
30487 d *Decoder) (_ map[int8]uint32, changed bool) {
30488 dd, esep := d.d, d.hh.hasElemSeparators()
30489 containerLen := dd.ReadMapStart()
30490 if canChange && v == nil {
30491 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
30492 v = make(map[int8]uint32, xlen)
30495 if containerLen == 0 {
30502 hasLen := containerLen > 0
30503 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30505 dd.ReadMapElemKey()
30507 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30509 dd.ReadMapElemValue()
30511 if dd.TryDecodeAsNil() {
30513 } else if d.h.DeleteOnNilMapValue {
30520 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
30530 func (d *Decoder) fastpathDecMapInt8Uint64R(f *codecFnInfo, rv reflect.Value) {
30531 if rv.Kind() == reflect.Ptr {
30532 vp := rv2i(rv).(*map[int8]uint64)
30533 v, changed := fastpathTV.DecMapInt8Uint64V(*vp, true, d)
30538 fastpathTV.DecMapInt8Uint64V(rv2i(rv).(map[int8]uint64), false, d)
30541 func (f fastpathT) DecMapInt8Uint64X(vp *map[int8]uint64, d *Decoder) {
30542 v, changed := f.DecMapInt8Uint64V(*vp, true, d)
30547 func (_ fastpathT) DecMapInt8Uint64V(v map[int8]uint64, canChange bool,
30548 d *Decoder) (_ map[int8]uint64, changed bool) {
30549 dd, esep := d.d, d.hh.hasElemSeparators()
30550 containerLen := dd.ReadMapStart()
30551 if canChange && v == nil {
30552 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
30553 v = make(map[int8]uint64, xlen)
30556 if containerLen == 0 {
30563 hasLen := containerLen > 0
30564 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30566 dd.ReadMapElemKey()
30568 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30570 dd.ReadMapElemValue()
30572 if dd.TryDecodeAsNil() {
30574 } else if d.h.DeleteOnNilMapValue {
30581 mv = dd.DecodeUint64()
30591 func (d *Decoder) fastpathDecMapInt8UintptrR(f *codecFnInfo, rv reflect.Value) {
30592 if rv.Kind() == reflect.Ptr {
30593 vp := rv2i(rv).(*map[int8]uintptr)
30594 v, changed := fastpathTV.DecMapInt8UintptrV(*vp, true, d)
30599 fastpathTV.DecMapInt8UintptrV(rv2i(rv).(map[int8]uintptr), false, d)
30602 func (f fastpathT) DecMapInt8UintptrX(vp *map[int8]uintptr, d *Decoder) {
30603 v, changed := f.DecMapInt8UintptrV(*vp, true, d)
30608 func (_ fastpathT) DecMapInt8UintptrV(v map[int8]uintptr, canChange bool,
30609 d *Decoder) (_ map[int8]uintptr, changed bool) {
30610 dd, esep := d.d, d.hh.hasElemSeparators()
30611 containerLen := dd.ReadMapStart()
30612 if canChange && v == nil {
30613 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
30614 v = make(map[int8]uintptr, xlen)
30617 if containerLen == 0 {
30624 hasLen := containerLen > 0
30625 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30627 dd.ReadMapElemKey()
30629 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30631 dd.ReadMapElemValue()
30633 if dd.TryDecodeAsNil() {
30635 } else if d.h.DeleteOnNilMapValue {
30642 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
30652 func (d *Decoder) fastpathDecMapInt8IntR(f *codecFnInfo, rv reflect.Value) {
30653 if rv.Kind() == reflect.Ptr {
30654 vp := rv2i(rv).(*map[int8]int)
30655 v, changed := fastpathTV.DecMapInt8IntV(*vp, true, d)
30660 fastpathTV.DecMapInt8IntV(rv2i(rv).(map[int8]int), false, d)
30663 func (f fastpathT) DecMapInt8IntX(vp *map[int8]int, d *Decoder) {
30664 v, changed := f.DecMapInt8IntV(*vp, true, d)
30669 func (_ fastpathT) DecMapInt8IntV(v map[int8]int, canChange bool,
30670 d *Decoder) (_ map[int8]int, changed bool) {
30671 dd, esep := d.d, d.hh.hasElemSeparators()
30672 containerLen := dd.ReadMapStart()
30673 if canChange && v == nil {
30674 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
30675 v = make(map[int8]int, xlen)
30678 if containerLen == 0 {
30685 hasLen := containerLen > 0
30686 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30688 dd.ReadMapElemKey()
30690 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30692 dd.ReadMapElemValue()
30694 if dd.TryDecodeAsNil() {
30696 } else if d.h.DeleteOnNilMapValue {
30703 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
30713 func (d *Decoder) fastpathDecMapInt8Int8R(f *codecFnInfo, rv reflect.Value) {
30714 if rv.Kind() == reflect.Ptr {
30715 vp := rv2i(rv).(*map[int8]int8)
30716 v, changed := fastpathTV.DecMapInt8Int8V(*vp, true, d)
30721 fastpathTV.DecMapInt8Int8V(rv2i(rv).(map[int8]int8), false, d)
30724 func (f fastpathT) DecMapInt8Int8X(vp *map[int8]int8, d *Decoder) {
30725 v, changed := f.DecMapInt8Int8V(*vp, true, d)
30730 func (_ fastpathT) DecMapInt8Int8V(v map[int8]int8, canChange bool,
30731 d *Decoder) (_ map[int8]int8, changed bool) {
30732 dd, esep := d.d, d.hh.hasElemSeparators()
30733 containerLen := dd.ReadMapStart()
30734 if canChange && v == nil {
30735 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
30736 v = make(map[int8]int8, xlen)
30739 if containerLen == 0 {
30746 hasLen := containerLen > 0
30747 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30749 dd.ReadMapElemKey()
30751 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30753 dd.ReadMapElemValue()
30755 if dd.TryDecodeAsNil() {
30757 } else if d.h.DeleteOnNilMapValue {
30764 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30774 func (d *Decoder) fastpathDecMapInt8Int16R(f *codecFnInfo, rv reflect.Value) {
30775 if rv.Kind() == reflect.Ptr {
30776 vp := rv2i(rv).(*map[int8]int16)
30777 v, changed := fastpathTV.DecMapInt8Int16V(*vp, true, d)
30782 fastpathTV.DecMapInt8Int16V(rv2i(rv).(map[int8]int16), false, d)
30785 func (f fastpathT) DecMapInt8Int16X(vp *map[int8]int16, d *Decoder) {
30786 v, changed := f.DecMapInt8Int16V(*vp, true, d)
30791 func (_ fastpathT) DecMapInt8Int16V(v map[int8]int16, canChange bool,
30792 d *Decoder) (_ map[int8]int16, changed bool) {
30793 dd, esep := d.d, d.hh.hasElemSeparators()
30794 containerLen := dd.ReadMapStart()
30795 if canChange && v == nil {
30796 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
30797 v = make(map[int8]int16, xlen)
30800 if containerLen == 0 {
30807 hasLen := containerLen > 0
30808 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30810 dd.ReadMapElemKey()
30812 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30814 dd.ReadMapElemValue()
30816 if dd.TryDecodeAsNil() {
30818 } else if d.h.DeleteOnNilMapValue {
30825 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
30835 func (d *Decoder) fastpathDecMapInt8Int32R(f *codecFnInfo, rv reflect.Value) {
30836 if rv.Kind() == reflect.Ptr {
30837 vp := rv2i(rv).(*map[int8]int32)
30838 v, changed := fastpathTV.DecMapInt8Int32V(*vp, true, d)
30843 fastpathTV.DecMapInt8Int32V(rv2i(rv).(map[int8]int32), false, d)
30846 func (f fastpathT) DecMapInt8Int32X(vp *map[int8]int32, d *Decoder) {
30847 v, changed := f.DecMapInt8Int32V(*vp, true, d)
30852 func (_ fastpathT) DecMapInt8Int32V(v map[int8]int32, canChange bool,
30853 d *Decoder) (_ map[int8]int32, changed bool) {
30854 dd, esep := d.d, d.hh.hasElemSeparators()
30855 containerLen := dd.ReadMapStart()
30856 if canChange && v == nil {
30857 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
30858 v = make(map[int8]int32, xlen)
30861 if containerLen == 0 {
30868 hasLen := containerLen > 0
30869 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30871 dd.ReadMapElemKey()
30873 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30875 dd.ReadMapElemValue()
30877 if dd.TryDecodeAsNil() {
30879 } else if d.h.DeleteOnNilMapValue {
30886 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
30896 func (d *Decoder) fastpathDecMapInt8Int64R(f *codecFnInfo, rv reflect.Value) {
30897 if rv.Kind() == reflect.Ptr {
30898 vp := rv2i(rv).(*map[int8]int64)
30899 v, changed := fastpathTV.DecMapInt8Int64V(*vp, true, d)
30904 fastpathTV.DecMapInt8Int64V(rv2i(rv).(map[int8]int64), false, d)
30907 func (f fastpathT) DecMapInt8Int64X(vp *map[int8]int64, d *Decoder) {
30908 v, changed := f.DecMapInt8Int64V(*vp, true, d)
30913 func (_ fastpathT) DecMapInt8Int64V(v map[int8]int64, canChange bool,
30914 d *Decoder) (_ map[int8]int64, changed bool) {
30915 dd, esep := d.d, d.hh.hasElemSeparators()
30916 containerLen := dd.ReadMapStart()
30917 if canChange && v == nil {
30918 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
30919 v = make(map[int8]int64, xlen)
30922 if containerLen == 0 {
30929 hasLen := containerLen > 0
30930 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30932 dd.ReadMapElemKey()
30934 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30936 dd.ReadMapElemValue()
30938 if dd.TryDecodeAsNil() {
30940 } else if d.h.DeleteOnNilMapValue {
30947 mv = dd.DecodeInt64()
30957 func (d *Decoder) fastpathDecMapInt8Float32R(f *codecFnInfo, rv reflect.Value) {
30958 if rv.Kind() == reflect.Ptr {
30959 vp := rv2i(rv).(*map[int8]float32)
30960 v, changed := fastpathTV.DecMapInt8Float32V(*vp, true, d)
30965 fastpathTV.DecMapInt8Float32V(rv2i(rv).(map[int8]float32), false, d)
30968 func (f fastpathT) DecMapInt8Float32X(vp *map[int8]float32, d *Decoder) {
30969 v, changed := f.DecMapInt8Float32V(*vp, true, d)
30974 func (_ fastpathT) DecMapInt8Float32V(v map[int8]float32, canChange bool,
30975 d *Decoder) (_ map[int8]float32, changed bool) {
30976 dd, esep := d.d, d.hh.hasElemSeparators()
30977 containerLen := dd.ReadMapStart()
30978 if canChange && v == nil {
30979 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
30980 v = make(map[int8]float32, xlen)
30983 if containerLen == 0 {
30990 hasLen := containerLen > 0
30991 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30993 dd.ReadMapElemKey()
30995 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30997 dd.ReadMapElemValue()
30999 if dd.TryDecodeAsNil() {
31001 } else if d.h.DeleteOnNilMapValue {
31008 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
31018 func (d *Decoder) fastpathDecMapInt8Float64R(f *codecFnInfo, rv reflect.Value) {
31019 if rv.Kind() == reflect.Ptr {
31020 vp := rv2i(rv).(*map[int8]float64)
31021 v, changed := fastpathTV.DecMapInt8Float64V(*vp, true, d)
31026 fastpathTV.DecMapInt8Float64V(rv2i(rv).(map[int8]float64), false, d)
31029 func (f fastpathT) DecMapInt8Float64X(vp *map[int8]float64, d *Decoder) {
31030 v, changed := f.DecMapInt8Float64V(*vp, true, d)
31035 func (_ fastpathT) DecMapInt8Float64V(v map[int8]float64, canChange bool,
31036 d *Decoder) (_ map[int8]float64, changed bool) {
31037 dd, esep := d.d, d.hh.hasElemSeparators()
31038 containerLen := dd.ReadMapStart()
31039 if canChange && v == nil {
31040 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
31041 v = make(map[int8]float64, xlen)
31044 if containerLen == 0 {
31051 hasLen := containerLen > 0
31052 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31054 dd.ReadMapElemKey()
31056 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
31058 dd.ReadMapElemValue()
31060 if dd.TryDecodeAsNil() {
31062 } else if d.h.DeleteOnNilMapValue {
31069 mv = dd.DecodeFloat64()
31079 func (d *Decoder) fastpathDecMapInt8BoolR(f *codecFnInfo, rv reflect.Value) {
31080 if rv.Kind() == reflect.Ptr {
31081 vp := rv2i(rv).(*map[int8]bool)
31082 v, changed := fastpathTV.DecMapInt8BoolV(*vp, true, d)
31087 fastpathTV.DecMapInt8BoolV(rv2i(rv).(map[int8]bool), false, d)
31090 func (f fastpathT) DecMapInt8BoolX(vp *map[int8]bool, d *Decoder) {
31091 v, changed := f.DecMapInt8BoolV(*vp, true, d)
31096 func (_ fastpathT) DecMapInt8BoolV(v map[int8]bool, canChange bool,
31097 d *Decoder) (_ map[int8]bool, changed bool) {
31098 dd, esep := d.d, d.hh.hasElemSeparators()
31099 containerLen := dd.ReadMapStart()
31100 if canChange && v == nil {
31101 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
31102 v = make(map[int8]bool, xlen)
31105 if containerLen == 0 {
31112 hasLen := containerLen > 0
31113 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31115 dd.ReadMapElemKey()
31117 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
31119 dd.ReadMapElemValue()
31121 if dd.TryDecodeAsNil() {
31123 } else if d.h.DeleteOnNilMapValue {
31130 mv = dd.DecodeBool()
31140 func (d *Decoder) fastpathDecMapInt16IntfR(f *codecFnInfo, rv reflect.Value) {
31141 if rv.Kind() == reflect.Ptr {
31142 vp := rv2i(rv).(*map[int16]interface{})
31143 v, changed := fastpathTV.DecMapInt16IntfV(*vp, true, d)
31148 fastpathTV.DecMapInt16IntfV(rv2i(rv).(map[int16]interface{}), false, d)
31151 func (f fastpathT) DecMapInt16IntfX(vp *map[int16]interface{}, d *Decoder) {
31152 v, changed := f.DecMapInt16IntfV(*vp, true, d)
31157 func (_ fastpathT) DecMapInt16IntfV(v map[int16]interface{}, canChange bool,
31158 d *Decoder) (_ map[int16]interface{}, changed bool) {
31159 dd, esep := d.d, d.hh.hasElemSeparators()
31160 containerLen := dd.ReadMapStart()
31161 if canChange && v == nil {
31162 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
31163 v = make(map[int16]interface{}, xlen)
31166 if containerLen == 0 {
31171 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
31174 hasLen := containerLen > 0
31175 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31177 dd.ReadMapElemKey()
31179 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31181 dd.ReadMapElemValue()
31183 if dd.TryDecodeAsNil() {
31185 } else if d.h.DeleteOnNilMapValue {
31207 func (d *Decoder) fastpathDecMapInt16StringR(f *codecFnInfo, rv reflect.Value) {
31208 if rv.Kind() == reflect.Ptr {
31209 vp := rv2i(rv).(*map[int16]string)
31210 v, changed := fastpathTV.DecMapInt16StringV(*vp, true, d)
31215 fastpathTV.DecMapInt16StringV(rv2i(rv).(map[int16]string), false, d)
31218 func (f fastpathT) DecMapInt16StringX(vp *map[int16]string, d *Decoder) {
31219 v, changed := f.DecMapInt16StringV(*vp, true, d)
31224 func (_ fastpathT) DecMapInt16StringV(v map[int16]string, canChange bool,
31225 d *Decoder) (_ map[int16]string, changed bool) {
31226 dd, esep := d.d, d.hh.hasElemSeparators()
31227 containerLen := dd.ReadMapStart()
31228 if canChange && v == nil {
31229 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
31230 v = make(map[int16]string, xlen)
31233 if containerLen == 0 {
31240 hasLen := containerLen > 0
31241 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31243 dd.ReadMapElemKey()
31245 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31247 dd.ReadMapElemValue()
31249 if dd.TryDecodeAsNil() {
31251 } else if d.h.DeleteOnNilMapValue {
31258 mv = dd.DecodeString()
31268 func (d *Decoder) fastpathDecMapInt16UintR(f *codecFnInfo, rv reflect.Value) {
31269 if rv.Kind() == reflect.Ptr {
31270 vp := rv2i(rv).(*map[int16]uint)
31271 v, changed := fastpathTV.DecMapInt16UintV(*vp, true, d)
31276 fastpathTV.DecMapInt16UintV(rv2i(rv).(map[int16]uint), false, d)
31279 func (f fastpathT) DecMapInt16UintX(vp *map[int16]uint, d *Decoder) {
31280 v, changed := f.DecMapInt16UintV(*vp, true, d)
31285 func (_ fastpathT) DecMapInt16UintV(v map[int16]uint, canChange bool,
31286 d *Decoder) (_ map[int16]uint, changed bool) {
31287 dd, esep := d.d, d.hh.hasElemSeparators()
31288 containerLen := dd.ReadMapStart()
31289 if canChange && v == nil {
31290 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
31291 v = make(map[int16]uint, xlen)
31294 if containerLen == 0 {
31301 hasLen := containerLen > 0
31302 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31304 dd.ReadMapElemKey()
31306 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31308 dd.ReadMapElemValue()
31310 if dd.TryDecodeAsNil() {
31312 } else if d.h.DeleteOnNilMapValue {
31319 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
31329 func (d *Decoder) fastpathDecMapInt16Uint8R(f *codecFnInfo, rv reflect.Value) {
31330 if rv.Kind() == reflect.Ptr {
31331 vp := rv2i(rv).(*map[int16]uint8)
31332 v, changed := fastpathTV.DecMapInt16Uint8V(*vp, true, d)
31337 fastpathTV.DecMapInt16Uint8V(rv2i(rv).(map[int16]uint8), false, d)
31340 func (f fastpathT) DecMapInt16Uint8X(vp *map[int16]uint8, d *Decoder) {
31341 v, changed := f.DecMapInt16Uint8V(*vp, true, d)
31346 func (_ fastpathT) DecMapInt16Uint8V(v map[int16]uint8, canChange bool,
31347 d *Decoder) (_ map[int16]uint8, changed bool) {
31348 dd, esep := d.d, d.hh.hasElemSeparators()
31349 containerLen := dd.ReadMapStart()
31350 if canChange && v == nil {
31351 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
31352 v = make(map[int16]uint8, xlen)
31355 if containerLen == 0 {
31362 hasLen := containerLen > 0
31363 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31365 dd.ReadMapElemKey()
31367 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31369 dd.ReadMapElemValue()
31371 if dd.TryDecodeAsNil() {
31373 } else if d.h.DeleteOnNilMapValue {
31380 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
31390 func (d *Decoder) fastpathDecMapInt16Uint16R(f *codecFnInfo, rv reflect.Value) {
31391 if rv.Kind() == reflect.Ptr {
31392 vp := rv2i(rv).(*map[int16]uint16)
31393 v, changed := fastpathTV.DecMapInt16Uint16V(*vp, true, d)
31398 fastpathTV.DecMapInt16Uint16V(rv2i(rv).(map[int16]uint16), false, d)
31401 func (f fastpathT) DecMapInt16Uint16X(vp *map[int16]uint16, d *Decoder) {
31402 v, changed := f.DecMapInt16Uint16V(*vp, true, d)
31407 func (_ fastpathT) DecMapInt16Uint16V(v map[int16]uint16, canChange bool,
31408 d *Decoder) (_ map[int16]uint16, changed bool) {
31409 dd, esep := d.d, d.hh.hasElemSeparators()
31410 containerLen := dd.ReadMapStart()
31411 if canChange && v == nil {
31412 xlen := decInferLen(containerLen, d.h.MaxInitLen, 4)
31413 v = make(map[int16]uint16, xlen)
31416 if containerLen == 0 {
31423 hasLen := containerLen > 0
31424 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31426 dd.ReadMapElemKey()
31428 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31430 dd.ReadMapElemValue()
31432 if dd.TryDecodeAsNil() {
31434 } else if d.h.DeleteOnNilMapValue {
31441 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
31451 func (d *Decoder) fastpathDecMapInt16Uint32R(f *codecFnInfo, rv reflect.Value) {
31452 if rv.Kind() == reflect.Ptr {
31453 vp := rv2i(rv).(*map[int16]uint32)
31454 v, changed := fastpathTV.DecMapInt16Uint32V(*vp, true, d)
31459 fastpathTV.DecMapInt16Uint32V(rv2i(rv).(map[int16]uint32), false, d)
31462 func (f fastpathT) DecMapInt16Uint32X(vp *map[int16]uint32, d *Decoder) {
31463 v, changed := f.DecMapInt16Uint32V(*vp, true, d)
31468 func (_ fastpathT) DecMapInt16Uint32V(v map[int16]uint32, canChange bool,
31469 d *Decoder) (_ map[int16]uint32, changed bool) {
31470 dd, esep := d.d, d.hh.hasElemSeparators()
31471 containerLen := dd.ReadMapStart()
31472 if canChange && v == nil {
31473 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
31474 v = make(map[int16]uint32, xlen)
31477 if containerLen == 0 {
31484 hasLen := containerLen > 0
31485 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31487 dd.ReadMapElemKey()
31489 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31491 dd.ReadMapElemValue()
31493 if dd.TryDecodeAsNil() {
31495 } else if d.h.DeleteOnNilMapValue {
31502 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
31512 func (d *Decoder) fastpathDecMapInt16Uint64R(f *codecFnInfo, rv reflect.Value) {
31513 if rv.Kind() == reflect.Ptr {
31514 vp := rv2i(rv).(*map[int16]uint64)
31515 v, changed := fastpathTV.DecMapInt16Uint64V(*vp, true, d)
31520 fastpathTV.DecMapInt16Uint64V(rv2i(rv).(map[int16]uint64), false, d)
31523 func (f fastpathT) DecMapInt16Uint64X(vp *map[int16]uint64, d *Decoder) {
31524 v, changed := f.DecMapInt16Uint64V(*vp, true, d)
31529 func (_ fastpathT) DecMapInt16Uint64V(v map[int16]uint64, canChange bool,
31530 d *Decoder) (_ map[int16]uint64, changed bool) {
31531 dd, esep := d.d, d.hh.hasElemSeparators()
31532 containerLen := dd.ReadMapStart()
31533 if canChange && v == nil {
31534 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
31535 v = make(map[int16]uint64, xlen)
31538 if containerLen == 0 {
31545 hasLen := containerLen > 0
31546 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31548 dd.ReadMapElemKey()
31550 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31552 dd.ReadMapElemValue()
31554 if dd.TryDecodeAsNil() {
31556 } else if d.h.DeleteOnNilMapValue {
31563 mv = dd.DecodeUint64()
31573 func (d *Decoder) fastpathDecMapInt16UintptrR(f *codecFnInfo, rv reflect.Value) {
31574 if rv.Kind() == reflect.Ptr {
31575 vp := rv2i(rv).(*map[int16]uintptr)
31576 v, changed := fastpathTV.DecMapInt16UintptrV(*vp, true, d)
31581 fastpathTV.DecMapInt16UintptrV(rv2i(rv).(map[int16]uintptr), false, d)
31584 func (f fastpathT) DecMapInt16UintptrX(vp *map[int16]uintptr, d *Decoder) {
31585 v, changed := f.DecMapInt16UintptrV(*vp, true, d)
31590 func (_ fastpathT) DecMapInt16UintptrV(v map[int16]uintptr, canChange bool,
31591 d *Decoder) (_ map[int16]uintptr, changed bool) {
31592 dd, esep := d.d, d.hh.hasElemSeparators()
31593 containerLen := dd.ReadMapStart()
31594 if canChange && v == nil {
31595 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
31596 v = make(map[int16]uintptr, xlen)
31599 if containerLen == 0 {
31606 hasLen := containerLen > 0
31607 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31609 dd.ReadMapElemKey()
31611 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31613 dd.ReadMapElemValue()
31615 if dd.TryDecodeAsNil() {
31617 } else if d.h.DeleteOnNilMapValue {
31624 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
31634 func (d *Decoder) fastpathDecMapInt16IntR(f *codecFnInfo, rv reflect.Value) {
31635 if rv.Kind() == reflect.Ptr {
31636 vp := rv2i(rv).(*map[int16]int)
31637 v, changed := fastpathTV.DecMapInt16IntV(*vp, true, d)
31642 fastpathTV.DecMapInt16IntV(rv2i(rv).(map[int16]int), false, d)
31645 func (f fastpathT) DecMapInt16IntX(vp *map[int16]int, d *Decoder) {
31646 v, changed := f.DecMapInt16IntV(*vp, true, d)
31651 func (_ fastpathT) DecMapInt16IntV(v map[int16]int, canChange bool,
31652 d *Decoder) (_ map[int16]int, changed bool) {
31653 dd, esep := d.d, d.hh.hasElemSeparators()
31654 containerLen := dd.ReadMapStart()
31655 if canChange && v == nil {
31656 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
31657 v = make(map[int16]int, xlen)
31660 if containerLen == 0 {
31667 hasLen := containerLen > 0
31668 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31670 dd.ReadMapElemKey()
31672 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31674 dd.ReadMapElemValue()
31676 if dd.TryDecodeAsNil() {
31678 } else if d.h.DeleteOnNilMapValue {
31685 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
31695 func (d *Decoder) fastpathDecMapInt16Int8R(f *codecFnInfo, rv reflect.Value) {
31696 if rv.Kind() == reflect.Ptr {
31697 vp := rv2i(rv).(*map[int16]int8)
31698 v, changed := fastpathTV.DecMapInt16Int8V(*vp, true, d)
31703 fastpathTV.DecMapInt16Int8V(rv2i(rv).(map[int16]int8), false, d)
31706 func (f fastpathT) DecMapInt16Int8X(vp *map[int16]int8, d *Decoder) {
31707 v, changed := f.DecMapInt16Int8V(*vp, true, d)
31712 func (_ fastpathT) DecMapInt16Int8V(v map[int16]int8, canChange bool,
31713 d *Decoder) (_ map[int16]int8, changed bool) {
31714 dd, esep := d.d, d.hh.hasElemSeparators()
31715 containerLen := dd.ReadMapStart()
31716 if canChange && v == nil {
31717 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
31718 v = make(map[int16]int8, xlen)
31721 if containerLen == 0 {
31728 hasLen := containerLen > 0
31729 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31731 dd.ReadMapElemKey()
31733 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31735 dd.ReadMapElemValue()
31737 if dd.TryDecodeAsNil() {
31739 } else if d.h.DeleteOnNilMapValue {
31746 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
31756 func (d *Decoder) fastpathDecMapInt16Int16R(f *codecFnInfo, rv reflect.Value) {
31757 if rv.Kind() == reflect.Ptr {
31758 vp := rv2i(rv).(*map[int16]int16)
31759 v, changed := fastpathTV.DecMapInt16Int16V(*vp, true, d)
31764 fastpathTV.DecMapInt16Int16V(rv2i(rv).(map[int16]int16), false, d)
31767 func (f fastpathT) DecMapInt16Int16X(vp *map[int16]int16, d *Decoder) {
31768 v, changed := f.DecMapInt16Int16V(*vp, true, d)
31773 func (_ fastpathT) DecMapInt16Int16V(v map[int16]int16, canChange bool,
31774 d *Decoder) (_ map[int16]int16, changed bool) {
31775 dd, esep := d.d, d.hh.hasElemSeparators()
31776 containerLen := dd.ReadMapStart()
31777 if canChange && v == nil {
31778 xlen := decInferLen(containerLen, d.h.MaxInitLen, 4)
31779 v = make(map[int16]int16, xlen)
31782 if containerLen == 0 {
31789 hasLen := containerLen > 0
31790 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31792 dd.ReadMapElemKey()
31794 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31796 dd.ReadMapElemValue()
31798 if dd.TryDecodeAsNil() {
31800 } else if d.h.DeleteOnNilMapValue {
31807 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31817 func (d *Decoder) fastpathDecMapInt16Int32R(f *codecFnInfo, rv reflect.Value) {
31818 if rv.Kind() == reflect.Ptr {
31819 vp := rv2i(rv).(*map[int16]int32)
31820 v, changed := fastpathTV.DecMapInt16Int32V(*vp, true, d)
31825 fastpathTV.DecMapInt16Int32V(rv2i(rv).(map[int16]int32), false, d)
31828 func (f fastpathT) DecMapInt16Int32X(vp *map[int16]int32, d *Decoder) {
31829 v, changed := f.DecMapInt16Int32V(*vp, true, d)
31834 func (_ fastpathT) DecMapInt16Int32V(v map[int16]int32, canChange bool,
31835 d *Decoder) (_ map[int16]int32, changed bool) {
31836 dd, esep := d.d, d.hh.hasElemSeparators()
31837 containerLen := dd.ReadMapStart()
31838 if canChange && v == nil {
31839 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
31840 v = make(map[int16]int32, xlen)
31843 if containerLen == 0 {
31850 hasLen := containerLen > 0
31851 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31853 dd.ReadMapElemKey()
31855 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31857 dd.ReadMapElemValue()
31859 if dd.TryDecodeAsNil() {
31861 } else if d.h.DeleteOnNilMapValue {
31868 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
31878 func (d *Decoder) fastpathDecMapInt16Int64R(f *codecFnInfo, rv reflect.Value) {
31879 if rv.Kind() == reflect.Ptr {
31880 vp := rv2i(rv).(*map[int16]int64)
31881 v, changed := fastpathTV.DecMapInt16Int64V(*vp, true, d)
31886 fastpathTV.DecMapInt16Int64V(rv2i(rv).(map[int16]int64), false, d)
31889 func (f fastpathT) DecMapInt16Int64X(vp *map[int16]int64, d *Decoder) {
31890 v, changed := f.DecMapInt16Int64V(*vp, true, d)
31895 func (_ fastpathT) DecMapInt16Int64V(v map[int16]int64, canChange bool,
31896 d *Decoder) (_ map[int16]int64, changed bool) {
31897 dd, esep := d.d, d.hh.hasElemSeparators()
31898 containerLen := dd.ReadMapStart()
31899 if canChange && v == nil {
31900 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
31901 v = make(map[int16]int64, xlen)
31904 if containerLen == 0 {
31911 hasLen := containerLen > 0
31912 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31914 dd.ReadMapElemKey()
31916 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31918 dd.ReadMapElemValue()
31920 if dd.TryDecodeAsNil() {
31922 } else if d.h.DeleteOnNilMapValue {
31929 mv = dd.DecodeInt64()
31939 func (d *Decoder) fastpathDecMapInt16Float32R(f *codecFnInfo, rv reflect.Value) {
31940 if rv.Kind() == reflect.Ptr {
31941 vp := rv2i(rv).(*map[int16]float32)
31942 v, changed := fastpathTV.DecMapInt16Float32V(*vp, true, d)
31947 fastpathTV.DecMapInt16Float32V(rv2i(rv).(map[int16]float32), false, d)
31950 func (f fastpathT) DecMapInt16Float32X(vp *map[int16]float32, d *Decoder) {
31951 v, changed := f.DecMapInt16Float32V(*vp, true, d)
31956 func (_ fastpathT) DecMapInt16Float32V(v map[int16]float32, canChange bool,
31957 d *Decoder) (_ map[int16]float32, changed bool) {
31958 dd, esep := d.d, d.hh.hasElemSeparators()
31959 containerLen := dd.ReadMapStart()
31960 if canChange && v == nil {
31961 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
31962 v = make(map[int16]float32, xlen)
31965 if containerLen == 0 {
31972 hasLen := containerLen > 0
31973 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31975 dd.ReadMapElemKey()
31977 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31979 dd.ReadMapElemValue()
31981 if dd.TryDecodeAsNil() {
31983 } else if d.h.DeleteOnNilMapValue {
31990 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
32000 func (d *Decoder) fastpathDecMapInt16Float64R(f *codecFnInfo, rv reflect.Value) {
32001 if rv.Kind() == reflect.Ptr {
32002 vp := rv2i(rv).(*map[int16]float64)
32003 v, changed := fastpathTV.DecMapInt16Float64V(*vp, true, d)
32008 fastpathTV.DecMapInt16Float64V(rv2i(rv).(map[int16]float64), false, d)
32011 func (f fastpathT) DecMapInt16Float64X(vp *map[int16]float64, d *Decoder) {
32012 v, changed := f.DecMapInt16Float64V(*vp, true, d)
32017 func (_ fastpathT) DecMapInt16Float64V(v map[int16]float64, canChange bool,
32018 d *Decoder) (_ map[int16]float64, changed bool) {
32019 dd, esep := d.d, d.hh.hasElemSeparators()
32020 containerLen := dd.ReadMapStart()
32021 if canChange && v == nil {
32022 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
32023 v = make(map[int16]float64, xlen)
32026 if containerLen == 0 {
32033 hasLen := containerLen > 0
32034 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32036 dd.ReadMapElemKey()
32038 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
32040 dd.ReadMapElemValue()
32042 if dd.TryDecodeAsNil() {
32044 } else if d.h.DeleteOnNilMapValue {
32051 mv = dd.DecodeFloat64()
32061 func (d *Decoder) fastpathDecMapInt16BoolR(f *codecFnInfo, rv reflect.Value) {
32062 if rv.Kind() == reflect.Ptr {
32063 vp := rv2i(rv).(*map[int16]bool)
32064 v, changed := fastpathTV.DecMapInt16BoolV(*vp, true, d)
32069 fastpathTV.DecMapInt16BoolV(rv2i(rv).(map[int16]bool), false, d)
32072 func (f fastpathT) DecMapInt16BoolX(vp *map[int16]bool, d *Decoder) {
32073 v, changed := f.DecMapInt16BoolV(*vp, true, d)
32078 func (_ fastpathT) DecMapInt16BoolV(v map[int16]bool, canChange bool,
32079 d *Decoder) (_ map[int16]bool, changed bool) {
32080 dd, esep := d.d, d.hh.hasElemSeparators()
32081 containerLen := dd.ReadMapStart()
32082 if canChange && v == nil {
32083 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
32084 v = make(map[int16]bool, xlen)
32087 if containerLen == 0 {
32094 hasLen := containerLen > 0
32095 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32097 dd.ReadMapElemKey()
32099 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
32101 dd.ReadMapElemValue()
32103 if dd.TryDecodeAsNil() {
32105 } else if d.h.DeleteOnNilMapValue {
32112 mv = dd.DecodeBool()
32122 func (d *Decoder) fastpathDecMapInt32IntfR(f *codecFnInfo, rv reflect.Value) {
32123 if rv.Kind() == reflect.Ptr {
32124 vp := rv2i(rv).(*map[int32]interface{})
32125 v, changed := fastpathTV.DecMapInt32IntfV(*vp, true, d)
32130 fastpathTV.DecMapInt32IntfV(rv2i(rv).(map[int32]interface{}), false, d)
32133 func (f fastpathT) DecMapInt32IntfX(vp *map[int32]interface{}, d *Decoder) {
32134 v, changed := f.DecMapInt32IntfV(*vp, true, d)
32139 func (_ fastpathT) DecMapInt32IntfV(v map[int32]interface{}, canChange bool,
32140 d *Decoder) (_ map[int32]interface{}, changed bool) {
32141 dd, esep := d.d, d.hh.hasElemSeparators()
32142 containerLen := dd.ReadMapStart()
32143 if canChange && v == nil {
32144 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
32145 v = make(map[int32]interface{}, xlen)
32148 if containerLen == 0 {
32153 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
32156 hasLen := containerLen > 0
32157 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32159 dd.ReadMapElemKey()
32161 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32163 dd.ReadMapElemValue()
32165 if dd.TryDecodeAsNil() {
32167 } else if d.h.DeleteOnNilMapValue {
32189 func (d *Decoder) fastpathDecMapInt32StringR(f *codecFnInfo, rv reflect.Value) {
32190 if rv.Kind() == reflect.Ptr {
32191 vp := rv2i(rv).(*map[int32]string)
32192 v, changed := fastpathTV.DecMapInt32StringV(*vp, true, d)
32197 fastpathTV.DecMapInt32StringV(rv2i(rv).(map[int32]string), false, d)
32200 func (f fastpathT) DecMapInt32StringX(vp *map[int32]string, d *Decoder) {
32201 v, changed := f.DecMapInt32StringV(*vp, true, d)
32206 func (_ fastpathT) DecMapInt32StringV(v map[int32]string, canChange bool,
32207 d *Decoder) (_ map[int32]string, changed bool) {
32208 dd, esep := d.d, d.hh.hasElemSeparators()
32209 containerLen := dd.ReadMapStart()
32210 if canChange && v == nil {
32211 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
32212 v = make(map[int32]string, xlen)
32215 if containerLen == 0 {
32222 hasLen := containerLen > 0
32223 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32225 dd.ReadMapElemKey()
32227 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32229 dd.ReadMapElemValue()
32231 if dd.TryDecodeAsNil() {
32233 } else if d.h.DeleteOnNilMapValue {
32240 mv = dd.DecodeString()
32250 func (d *Decoder) fastpathDecMapInt32UintR(f *codecFnInfo, rv reflect.Value) {
32251 if rv.Kind() == reflect.Ptr {
32252 vp := rv2i(rv).(*map[int32]uint)
32253 v, changed := fastpathTV.DecMapInt32UintV(*vp, true, d)
32258 fastpathTV.DecMapInt32UintV(rv2i(rv).(map[int32]uint), false, d)
32261 func (f fastpathT) DecMapInt32UintX(vp *map[int32]uint, d *Decoder) {
32262 v, changed := f.DecMapInt32UintV(*vp, true, d)
32267 func (_ fastpathT) DecMapInt32UintV(v map[int32]uint, canChange bool,
32268 d *Decoder) (_ map[int32]uint, changed bool) {
32269 dd, esep := d.d, d.hh.hasElemSeparators()
32270 containerLen := dd.ReadMapStart()
32271 if canChange && v == nil {
32272 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
32273 v = make(map[int32]uint, xlen)
32276 if containerLen == 0 {
32283 hasLen := containerLen > 0
32284 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32286 dd.ReadMapElemKey()
32288 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32290 dd.ReadMapElemValue()
32292 if dd.TryDecodeAsNil() {
32294 } else if d.h.DeleteOnNilMapValue {
32301 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
32311 func (d *Decoder) fastpathDecMapInt32Uint8R(f *codecFnInfo, rv reflect.Value) {
32312 if rv.Kind() == reflect.Ptr {
32313 vp := rv2i(rv).(*map[int32]uint8)
32314 v, changed := fastpathTV.DecMapInt32Uint8V(*vp, true, d)
32319 fastpathTV.DecMapInt32Uint8V(rv2i(rv).(map[int32]uint8), false, d)
32322 func (f fastpathT) DecMapInt32Uint8X(vp *map[int32]uint8, d *Decoder) {
32323 v, changed := f.DecMapInt32Uint8V(*vp, true, d)
32328 func (_ fastpathT) DecMapInt32Uint8V(v map[int32]uint8, canChange bool,
32329 d *Decoder) (_ map[int32]uint8, changed bool) {
32330 dd, esep := d.d, d.hh.hasElemSeparators()
32331 containerLen := dd.ReadMapStart()
32332 if canChange && v == nil {
32333 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
32334 v = make(map[int32]uint8, xlen)
32337 if containerLen == 0 {
32344 hasLen := containerLen > 0
32345 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32347 dd.ReadMapElemKey()
32349 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32351 dd.ReadMapElemValue()
32353 if dd.TryDecodeAsNil() {
32355 } else if d.h.DeleteOnNilMapValue {
32362 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
32372 func (d *Decoder) fastpathDecMapInt32Uint16R(f *codecFnInfo, rv reflect.Value) {
32373 if rv.Kind() == reflect.Ptr {
32374 vp := rv2i(rv).(*map[int32]uint16)
32375 v, changed := fastpathTV.DecMapInt32Uint16V(*vp, true, d)
32380 fastpathTV.DecMapInt32Uint16V(rv2i(rv).(map[int32]uint16), false, d)
32383 func (f fastpathT) DecMapInt32Uint16X(vp *map[int32]uint16, d *Decoder) {
32384 v, changed := f.DecMapInt32Uint16V(*vp, true, d)
32389 func (_ fastpathT) DecMapInt32Uint16V(v map[int32]uint16, canChange bool,
32390 d *Decoder) (_ map[int32]uint16, changed bool) {
32391 dd, esep := d.d, d.hh.hasElemSeparators()
32392 containerLen := dd.ReadMapStart()
32393 if canChange && v == nil {
32394 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
32395 v = make(map[int32]uint16, xlen)
32398 if containerLen == 0 {
32405 hasLen := containerLen > 0
32406 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32408 dd.ReadMapElemKey()
32410 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32412 dd.ReadMapElemValue()
32414 if dd.TryDecodeAsNil() {
32416 } else if d.h.DeleteOnNilMapValue {
32423 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
32433 func (d *Decoder) fastpathDecMapInt32Uint32R(f *codecFnInfo, rv reflect.Value) {
32434 if rv.Kind() == reflect.Ptr {
32435 vp := rv2i(rv).(*map[int32]uint32)
32436 v, changed := fastpathTV.DecMapInt32Uint32V(*vp, true, d)
32441 fastpathTV.DecMapInt32Uint32V(rv2i(rv).(map[int32]uint32), false, d)
32444 func (f fastpathT) DecMapInt32Uint32X(vp *map[int32]uint32, d *Decoder) {
32445 v, changed := f.DecMapInt32Uint32V(*vp, true, d)
32450 func (_ fastpathT) DecMapInt32Uint32V(v map[int32]uint32, canChange bool,
32451 d *Decoder) (_ map[int32]uint32, changed bool) {
32452 dd, esep := d.d, d.hh.hasElemSeparators()
32453 containerLen := dd.ReadMapStart()
32454 if canChange && v == nil {
32455 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
32456 v = make(map[int32]uint32, xlen)
32459 if containerLen == 0 {
32466 hasLen := containerLen > 0
32467 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32469 dd.ReadMapElemKey()
32471 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32473 dd.ReadMapElemValue()
32475 if dd.TryDecodeAsNil() {
32477 } else if d.h.DeleteOnNilMapValue {
32484 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
32494 func (d *Decoder) fastpathDecMapInt32Uint64R(f *codecFnInfo, rv reflect.Value) {
32495 if rv.Kind() == reflect.Ptr {
32496 vp := rv2i(rv).(*map[int32]uint64)
32497 v, changed := fastpathTV.DecMapInt32Uint64V(*vp, true, d)
32502 fastpathTV.DecMapInt32Uint64V(rv2i(rv).(map[int32]uint64), false, d)
32505 func (f fastpathT) DecMapInt32Uint64X(vp *map[int32]uint64, d *Decoder) {
32506 v, changed := f.DecMapInt32Uint64V(*vp, true, d)
32511 func (_ fastpathT) DecMapInt32Uint64V(v map[int32]uint64, canChange bool,
32512 d *Decoder) (_ map[int32]uint64, changed bool) {
32513 dd, esep := d.d, d.hh.hasElemSeparators()
32514 containerLen := dd.ReadMapStart()
32515 if canChange && v == nil {
32516 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
32517 v = make(map[int32]uint64, xlen)
32520 if containerLen == 0 {
32527 hasLen := containerLen > 0
32528 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32530 dd.ReadMapElemKey()
32532 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32534 dd.ReadMapElemValue()
32536 if dd.TryDecodeAsNil() {
32538 } else if d.h.DeleteOnNilMapValue {
32545 mv = dd.DecodeUint64()
32555 func (d *Decoder) fastpathDecMapInt32UintptrR(f *codecFnInfo, rv reflect.Value) {
32556 if rv.Kind() == reflect.Ptr {
32557 vp := rv2i(rv).(*map[int32]uintptr)
32558 v, changed := fastpathTV.DecMapInt32UintptrV(*vp, true, d)
32563 fastpathTV.DecMapInt32UintptrV(rv2i(rv).(map[int32]uintptr), false, d)
32566 func (f fastpathT) DecMapInt32UintptrX(vp *map[int32]uintptr, d *Decoder) {
32567 v, changed := f.DecMapInt32UintptrV(*vp, true, d)
32572 func (_ fastpathT) DecMapInt32UintptrV(v map[int32]uintptr, canChange bool,
32573 d *Decoder) (_ map[int32]uintptr, changed bool) {
32574 dd, esep := d.d, d.hh.hasElemSeparators()
32575 containerLen := dd.ReadMapStart()
32576 if canChange && v == nil {
32577 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
32578 v = make(map[int32]uintptr, xlen)
32581 if containerLen == 0 {
32588 hasLen := containerLen > 0
32589 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32591 dd.ReadMapElemKey()
32593 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32595 dd.ReadMapElemValue()
32597 if dd.TryDecodeAsNil() {
32599 } else if d.h.DeleteOnNilMapValue {
32606 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
32616 func (d *Decoder) fastpathDecMapInt32IntR(f *codecFnInfo, rv reflect.Value) {
32617 if rv.Kind() == reflect.Ptr {
32618 vp := rv2i(rv).(*map[int32]int)
32619 v, changed := fastpathTV.DecMapInt32IntV(*vp, true, d)
32624 fastpathTV.DecMapInt32IntV(rv2i(rv).(map[int32]int), false, d)
32627 func (f fastpathT) DecMapInt32IntX(vp *map[int32]int, d *Decoder) {
32628 v, changed := f.DecMapInt32IntV(*vp, true, d)
32633 func (_ fastpathT) DecMapInt32IntV(v map[int32]int, canChange bool,
32634 d *Decoder) (_ map[int32]int, changed bool) {
32635 dd, esep := d.d, d.hh.hasElemSeparators()
32636 containerLen := dd.ReadMapStart()
32637 if canChange && v == nil {
32638 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
32639 v = make(map[int32]int, xlen)
32642 if containerLen == 0 {
32649 hasLen := containerLen > 0
32650 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32652 dd.ReadMapElemKey()
32654 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32656 dd.ReadMapElemValue()
32658 if dd.TryDecodeAsNil() {
32660 } else if d.h.DeleteOnNilMapValue {
32667 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
32677 func (d *Decoder) fastpathDecMapInt32Int8R(f *codecFnInfo, rv reflect.Value) {
32678 if rv.Kind() == reflect.Ptr {
32679 vp := rv2i(rv).(*map[int32]int8)
32680 v, changed := fastpathTV.DecMapInt32Int8V(*vp, true, d)
32685 fastpathTV.DecMapInt32Int8V(rv2i(rv).(map[int32]int8), false, d)
32688 func (f fastpathT) DecMapInt32Int8X(vp *map[int32]int8, d *Decoder) {
32689 v, changed := f.DecMapInt32Int8V(*vp, true, d)
32694 func (_ fastpathT) DecMapInt32Int8V(v map[int32]int8, canChange bool,
32695 d *Decoder) (_ map[int32]int8, changed bool) {
32696 dd, esep := d.d, d.hh.hasElemSeparators()
32697 containerLen := dd.ReadMapStart()
32698 if canChange && v == nil {
32699 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
32700 v = make(map[int32]int8, xlen)
32703 if containerLen == 0 {
32710 hasLen := containerLen > 0
32711 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32713 dd.ReadMapElemKey()
32715 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32717 dd.ReadMapElemValue()
32719 if dd.TryDecodeAsNil() {
32721 } else if d.h.DeleteOnNilMapValue {
32728 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
32738 func (d *Decoder) fastpathDecMapInt32Int16R(f *codecFnInfo, rv reflect.Value) {
32739 if rv.Kind() == reflect.Ptr {
32740 vp := rv2i(rv).(*map[int32]int16)
32741 v, changed := fastpathTV.DecMapInt32Int16V(*vp, true, d)
32746 fastpathTV.DecMapInt32Int16V(rv2i(rv).(map[int32]int16), false, d)
32749 func (f fastpathT) DecMapInt32Int16X(vp *map[int32]int16, d *Decoder) {
32750 v, changed := f.DecMapInt32Int16V(*vp, true, d)
32755 func (_ fastpathT) DecMapInt32Int16V(v map[int32]int16, canChange bool,
32756 d *Decoder) (_ map[int32]int16, changed bool) {
32757 dd, esep := d.d, d.hh.hasElemSeparators()
32758 containerLen := dd.ReadMapStart()
32759 if canChange && v == nil {
32760 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
32761 v = make(map[int32]int16, xlen)
32764 if containerLen == 0 {
32771 hasLen := containerLen > 0
32772 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32774 dd.ReadMapElemKey()
32776 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32778 dd.ReadMapElemValue()
32780 if dd.TryDecodeAsNil() {
32782 } else if d.h.DeleteOnNilMapValue {
32789 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
32799 func (d *Decoder) fastpathDecMapInt32Int32R(f *codecFnInfo, rv reflect.Value) {
32800 if rv.Kind() == reflect.Ptr {
32801 vp := rv2i(rv).(*map[int32]int32)
32802 v, changed := fastpathTV.DecMapInt32Int32V(*vp, true, d)
32807 fastpathTV.DecMapInt32Int32V(rv2i(rv).(map[int32]int32), false, d)
32810 func (f fastpathT) DecMapInt32Int32X(vp *map[int32]int32, d *Decoder) {
32811 v, changed := f.DecMapInt32Int32V(*vp, true, d)
32816 func (_ fastpathT) DecMapInt32Int32V(v map[int32]int32, canChange bool,
32817 d *Decoder) (_ map[int32]int32, changed bool) {
32818 dd, esep := d.d, d.hh.hasElemSeparators()
32819 containerLen := dd.ReadMapStart()
32820 if canChange && v == nil {
32821 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
32822 v = make(map[int32]int32, xlen)
32825 if containerLen == 0 {
32832 hasLen := containerLen > 0
32833 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32835 dd.ReadMapElemKey()
32837 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32839 dd.ReadMapElemValue()
32841 if dd.TryDecodeAsNil() {
32843 } else if d.h.DeleteOnNilMapValue {
32850 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32860 func (d *Decoder) fastpathDecMapInt32Int64R(f *codecFnInfo, rv reflect.Value) {
32861 if rv.Kind() == reflect.Ptr {
32862 vp := rv2i(rv).(*map[int32]int64)
32863 v, changed := fastpathTV.DecMapInt32Int64V(*vp, true, d)
32868 fastpathTV.DecMapInt32Int64V(rv2i(rv).(map[int32]int64), false, d)
32871 func (f fastpathT) DecMapInt32Int64X(vp *map[int32]int64, d *Decoder) {
32872 v, changed := f.DecMapInt32Int64V(*vp, true, d)
32877 func (_ fastpathT) DecMapInt32Int64V(v map[int32]int64, canChange bool,
32878 d *Decoder) (_ map[int32]int64, changed bool) {
32879 dd, esep := d.d, d.hh.hasElemSeparators()
32880 containerLen := dd.ReadMapStart()
32881 if canChange && v == nil {
32882 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
32883 v = make(map[int32]int64, xlen)
32886 if containerLen == 0 {
32893 hasLen := containerLen > 0
32894 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32896 dd.ReadMapElemKey()
32898 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32900 dd.ReadMapElemValue()
32902 if dd.TryDecodeAsNil() {
32904 } else if d.h.DeleteOnNilMapValue {
32911 mv = dd.DecodeInt64()
32921 func (d *Decoder) fastpathDecMapInt32Float32R(f *codecFnInfo, rv reflect.Value) {
32922 if rv.Kind() == reflect.Ptr {
32923 vp := rv2i(rv).(*map[int32]float32)
32924 v, changed := fastpathTV.DecMapInt32Float32V(*vp, true, d)
32929 fastpathTV.DecMapInt32Float32V(rv2i(rv).(map[int32]float32), false, d)
32932 func (f fastpathT) DecMapInt32Float32X(vp *map[int32]float32, d *Decoder) {
32933 v, changed := f.DecMapInt32Float32V(*vp, true, d)
32938 func (_ fastpathT) DecMapInt32Float32V(v map[int32]float32, canChange bool,
32939 d *Decoder) (_ map[int32]float32, changed bool) {
32940 dd, esep := d.d, d.hh.hasElemSeparators()
32941 containerLen := dd.ReadMapStart()
32942 if canChange && v == nil {
32943 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
32944 v = make(map[int32]float32, xlen)
32947 if containerLen == 0 {
32954 hasLen := containerLen > 0
32955 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32957 dd.ReadMapElemKey()
32959 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32961 dd.ReadMapElemValue()
32963 if dd.TryDecodeAsNil() {
32965 } else if d.h.DeleteOnNilMapValue {
32972 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
32982 func (d *Decoder) fastpathDecMapInt32Float64R(f *codecFnInfo, rv reflect.Value) {
32983 if rv.Kind() == reflect.Ptr {
32984 vp := rv2i(rv).(*map[int32]float64)
32985 v, changed := fastpathTV.DecMapInt32Float64V(*vp, true, d)
32990 fastpathTV.DecMapInt32Float64V(rv2i(rv).(map[int32]float64), false, d)
32993 func (f fastpathT) DecMapInt32Float64X(vp *map[int32]float64, d *Decoder) {
32994 v, changed := f.DecMapInt32Float64V(*vp, true, d)
32999 func (_ fastpathT) DecMapInt32Float64V(v map[int32]float64, canChange bool,
33000 d *Decoder) (_ map[int32]float64, changed bool) {
33001 dd, esep := d.d, d.hh.hasElemSeparators()
33002 containerLen := dd.ReadMapStart()
33003 if canChange && v == nil {
33004 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
33005 v = make(map[int32]float64, xlen)
33008 if containerLen == 0 {
33015 hasLen := containerLen > 0
33016 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33018 dd.ReadMapElemKey()
33020 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
33022 dd.ReadMapElemValue()
33024 if dd.TryDecodeAsNil() {
33026 } else if d.h.DeleteOnNilMapValue {
33033 mv = dd.DecodeFloat64()
33043 func (d *Decoder) fastpathDecMapInt32BoolR(f *codecFnInfo, rv reflect.Value) {
33044 if rv.Kind() == reflect.Ptr {
33045 vp := rv2i(rv).(*map[int32]bool)
33046 v, changed := fastpathTV.DecMapInt32BoolV(*vp, true, d)
33051 fastpathTV.DecMapInt32BoolV(rv2i(rv).(map[int32]bool), false, d)
33054 func (f fastpathT) DecMapInt32BoolX(vp *map[int32]bool, d *Decoder) {
33055 v, changed := f.DecMapInt32BoolV(*vp, true, d)
33060 func (_ fastpathT) DecMapInt32BoolV(v map[int32]bool, canChange bool,
33061 d *Decoder) (_ map[int32]bool, changed bool) {
33062 dd, esep := d.d, d.hh.hasElemSeparators()
33063 containerLen := dd.ReadMapStart()
33064 if canChange && v == nil {
33065 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
33066 v = make(map[int32]bool, xlen)
33069 if containerLen == 0 {
33076 hasLen := containerLen > 0
33077 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33079 dd.ReadMapElemKey()
33081 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
33083 dd.ReadMapElemValue()
33085 if dd.TryDecodeAsNil() {
33087 } else if d.h.DeleteOnNilMapValue {
33094 mv = dd.DecodeBool()
33104 func (d *Decoder) fastpathDecMapInt64IntfR(f *codecFnInfo, rv reflect.Value) {
33105 if rv.Kind() == reflect.Ptr {
33106 vp := rv2i(rv).(*map[int64]interface{})
33107 v, changed := fastpathTV.DecMapInt64IntfV(*vp, true, d)
33112 fastpathTV.DecMapInt64IntfV(rv2i(rv).(map[int64]interface{}), false, d)
33115 func (f fastpathT) DecMapInt64IntfX(vp *map[int64]interface{}, d *Decoder) {
33116 v, changed := f.DecMapInt64IntfV(*vp, true, d)
33121 func (_ fastpathT) DecMapInt64IntfV(v map[int64]interface{}, canChange bool,
33122 d *Decoder) (_ map[int64]interface{}, changed bool) {
33123 dd, esep := d.d, d.hh.hasElemSeparators()
33124 containerLen := dd.ReadMapStart()
33125 if canChange && v == nil {
33126 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
33127 v = make(map[int64]interface{}, xlen)
33130 if containerLen == 0 {
33135 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
33138 hasLen := containerLen > 0
33139 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33141 dd.ReadMapElemKey()
33143 mk = dd.DecodeInt64()
33145 dd.ReadMapElemValue()
33147 if dd.TryDecodeAsNil() {
33149 } else if d.h.DeleteOnNilMapValue {
33171 func (d *Decoder) fastpathDecMapInt64StringR(f *codecFnInfo, rv reflect.Value) {
33172 if rv.Kind() == reflect.Ptr {
33173 vp := rv2i(rv).(*map[int64]string)
33174 v, changed := fastpathTV.DecMapInt64StringV(*vp, true, d)
33179 fastpathTV.DecMapInt64StringV(rv2i(rv).(map[int64]string), false, d)
33182 func (f fastpathT) DecMapInt64StringX(vp *map[int64]string, d *Decoder) {
33183 v, changed := f.DecMapInt64StringV(*vp, true, d)
33188 func (_ fastpathT) DecMapInt64StringV(v map[int64]string, canChange bool,
33189 d *Decoder) (_ map[int64]string, changed bool) {
33190 dd, esep := d.d, d.hh.hasElemSeparators()
33191 containerLen := dd.ReadMapStart()
33192 if canChange && v == nil {
33193 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
33194 v = make(map[int64]string, xlen)
33197 if containerLen == 0 {
33204 hasLen := containerLen > 0
33205 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33207 dd.ReadMapElemKey()
33209 mk = dd.DecodeInt64()
33211 dd.ReadMapElemValue()
33213 if dd.TryDecodeAsNil() {
33215 } else if d.h.DeleteOnNilMapValue {
33222 mv = dd.DecodeString()
33232 func (d *Decoder) fastpathDecMapInt64UintR(f *codecFnInfo, rv reflect.Value) {
33233 if rv.Kind() == reflect.Ptr {
33234 vp := rv2i(rv).(*map[int64]uint)
33235 v, changed := fastpathTV.DecMapInt64UintV(*vp, true, d)
33240 fastpathTV.DecMapInt64UintV(rv2i(rv).(map[int64]uint), false, d)
33243 func (f fastpathT) DecMapInt64UintX(vp *map[int64]uint, d *Decoder) {
33244 v, changed := f.DecMapInt64UintV(*vp, true, d)
33249 func (_ fastpathT) DecMapInt64UintV(v map[int64]uint, canChange bool,
33250 d *Decoder) (_ map[int64]uint, changed bool) {
33251 dd, esep := d.d, d.hh.hasElemSeparators()
33252 containerLen := dd.ReadMapStart()
33253 if canChange && v == nil {
33254 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
33255 v = make(map[int64]uint, xlen)
33258 if containerLen == 0 {
33265 hasLen := containerLen > 0
33266 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33268 dd.ReadMapElemKey()
33270 mk = dd.DecodeInt64()
33272 dd.ReadMapElemValue()
33274 if dd.TryDecodeAsNil() {
33276 } else if d.h.DeleteOnNilMapValue {
33283 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
33293 func (d *Decoder) fastpathDecMapInt64Uint8R(f *codecFnInfo, rv reflect.Value) {
33294 if rv.Kind() == reflect.Ptr {
33295 vp := rv2i(rv).(*map[int64]uint8)
33296 v, changed := fastpathTV.DecMapInt64Uint8V(*vp, true, d)
33301 fastpathTV.DecMapInt64Uint8V(rv2i(rv).(map[int64]uint8), false, d)
33304 func (f fastpathT) DecMapInt64Uint8X(vp *map[int64]uint8, d *Decoder) {
33305 v, changed := f.DecMapInt64Uint8V(*vp, true, d)
33310 func (_ fastpathT) DecMapInt64Uint8V(v map[int64]uint8, canChange bool,
33311 d *Decoder) (_ map[int64]uint8, changed bool) {
33312 dd, esep := d.d, d.hh.hasElemSeparators()
33313 containerLen := dd.ReadMapStart()
33314 if canChange && v == nil {
33315 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
33316 v = make(map[int64]uint8, xlen)
33319 if containerLen == 0 {
33326 hasLen := containerLen > 0
33327 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33329 dd.ReadMapElemKey()
33331 mk = dd.DecodeInt64()
33333 dd.ReadMapElemValue()
33335 if dd.TryDecodeAsNil() {
33337 } else if d.h.DeleteOnNilMapValue {
33344 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
33354 func (d *Decoder) fastpathDecMapInt64Uint16R(f *codecFnInfo, rv reflect.Value) {
33355 if rv.Kind() == reflect.Ptr {
33356 vp := rv2i(rv).(*map[int64]uint16)
33357 v, changed := fastpathTV.DecMapInt64Uint16V(*vp, true, d)
33362 fastpathTV.DecMapInt64Uint16V(rv2i(rv).(map[int64]uint16), false, d)
33365 func (f fastpathT) DecMapInt64Uint16X(vp *map[int64]uint16, d *Decoder) {
33366 v, changed := f.DecMapInt64Uint16V(*vp, true, d)
33371 func (_ fastpathT) DecMapInt64Uint16V(v map[int64]uint16, canChange bool,
33372 d *Decoder) (_ map[int64]uint16, changed bool) {
33373 dd, esep := d.d, d.hh.hasElemSeparators()
33374 containerLen := dd.ReadMapStart()
33375 if canChange && v == nil {
33376 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
33377 v = make(map[int64]uint16, xlen)
33380 if containerLen == 0 {
33387 hasLen := containerLen > 0
33388 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33390 dd.ReadMapElemKey()
33392 mk = dd.DecodeInt64()
33394 dd.ReadMapElemValue()
33396 if dd.TryDecodeAsNil() {
33398 } else if d.h.DeleteOnNilMapValue {
33405 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
33415 func (d *Decoder) fastpathDecMapInt64Uint32R(f *codecFnInfo, rv reflect.Value) {
33416 if rv.Kind() == reflect.Ptr {
33417 vp := rv2i(rv).(*map[int64]uint32)
33418 v, changed := fastpathTV.DecMapInt64Uint32V(*vp, true, d)
33423 fastpathTV.DecMapInt64Uint32V(rv2i(rv).(map[int64]uint32), false, d)
33426 func (f fastpathT) DecMapInt64Uint32X(vp *map[int64]uint32, d *Decoder) {
33427 v, changed := f.DecMapInt64Uint32V(*vp, true, d)
33432 func (_ fastpathT) DecMapInt64Uint32V(v map[int64]uint32, canChange bool,
33433 d *Decoder) (_ map[int64]uint32, changed bool) {
33434 dd, esep := d.d, d.hh.hasElemSeparators()
33435 containerLen := dd.ReadMapStart()
33436 if canChange && v == nil {
33437 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
33438 v = make(map[int64]uint32, xlen)
33441 if containerLen == 0 {
33448 hasLen := containerLen > 0
33449 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33451 dd.ReadMapElemKey()
33453 mk = dd.DecodeInt64()
33455 dd.ReadMapElemValue()
33457 if dd.TryDecodeAsNil() {
33459 } else if d.h.DeleteOnNilMapValue {
33466 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
33476 func (d *Decoder) fastpathDecMapInt64Uint64R(f *codecFnInfo, rv reflect.Value) {
33477 if rv.Kind() == reflect.Ptr {
33478 vp := rv2i(rv).(*map[int64]uint64)
33479 v, changed := fastpathTV.DecMapInt64Uint64V(*vp, true, d)
33484 fastpathTV.DecMapInt64Uint64V(rv2i(rv).(map[int64]uint64), false, d)
33487 func (f fastpathT) DecMapInt64Uint64X(vp *map[int64]uint64, d *Decoder) {
33488 v, changed := f.DecMapInt64Uint64V(*vp, true, d)
33493 func (_ fastpathT) DecMapInt64Uint64V(v map[int64]uint64, canChange bool,
33494 d *Decoder) (_ map[int64]uint64, changed bool) {
33495 dd, esep := d.d, d.hh.hasElemSeparators()
33496 containerLen := dd.ReadMapStart()
33497 if canChange && v == nil {
33498 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
33499 v = make(map[int64]uint64, xlen)
33502 if containerLen == 0 {
33509 hasLen := containerLen > 0
33510 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33512 dd.ReadMapElemKey()
33514 mk = dd.DecodeInt64()
33516 dd.ReadMapElemValue()
33518 if dd.TryDecodeAsNil() {
33520 } else if d.h.DeleteOnNilMapValue {
33527 mv = dd.DecodeUint64()
33537 func (d *Decoder) fastpathDecMapInt64UintptrR(f *codecFnInfo, rv reflect.Value) {
33538 if rv.Kind() == reflect.Ptr {
33539 vp := rv2i(rv).(*map[int64]uintptr)
33540 v, changed := fastpathTV.DecMapInt64UintptrV(*vp, true, d)
33545 fastpathTV.DecMapInt64UintptrV(rv2i(rv).(map[int64]uintptr), false, d)
33548 func (f fastpathT) DecMapInt64UintptrX(vp *map[int64]uintptr, d *Decoder) {
33549 v, changed := f.DecMapInt64UintptrV(*vp, true, d)
33554 func (_ fastpathT) DecMapInt64UintptrV(v map[int64]uintptr, canChange bool,
33555 d *Decoder) (_ map[int64]uintptr, changed bool) {
33556 dd, esep := d.d, d.hh.hasElemSeparators()
33557 containerLen := dd.ReadMapStart()
33558 if canChange && v == nil {
33559 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
33560 v = make(map[int64]uintptr, xlen)
33563 if containerLen == 0 {
33570 hasLen := containerLen > 0
33571 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33573 dd.ReadMapElemKey()
33575 mk = dd.DecodeInt64()
33577 dd.ReadMapElemValue()
33579 if dd.TryDecodeAsNil() {
33581 } else if d.h.DeleteOnNilMapValue {
33588 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
33598 func (d *Decoder) fastpathDecMapInt64IntR(f *codecFnInfo, rv reflect.Value) {
33599 if rv.Kind() == reflect.Ptr {
33600 vp := rv2i(rv).(*map[int64]int)
33601 v, changed := fastpathTV.DecMapInt64IntV(*vp, true, d)
33606 fastpathTV.DecMapInt64IntV(rv2i(rv).(map[int64]int), false, d)
33609 func (f fastpathT) DecMapInt64IntX(vp *map[int64]int, d *Decoder) {
33610 v, changed := f.DecMapInt64IntV(*vp, true, d)
33615 func (_ fastpathT) DecMapInt64IntV(v map[int64]int, canChange bool,
33616 d *Decoder) (_ map[int64]int, changed bool) {
33617 dd, esep := d.d, d.hh.hasElemSeparators()
33618 containerLen := dd.ReadMapStart()
33619 if canChange && v == nil {
33620 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
33621 v = make(map[int64]int, xlen)
33624 if containerLen == 0 {
33631 hasLen := containerLen > 0
33632 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33634 dd.ReadMapElemKey()
33636 mk = dd.DecodeInt64()
33638 dd.ReadMapElemValue()
33640 if dd.TryDecodeAsNil() {
33642 } else if d.h.DeleteOnNilMapValue {
33649 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
33659 func (d *Decoder) fastpathDecMapInt64Int8R(f *codecFnInfo, rv reflect.Value) {
33660 if rv.Kind() == reflect.Ptr {
33661 vp := rv2i(rv).(*map[int64]int8)
33662 v, changed := fastpathTV.DecMapInt64Int8V(*vp, true, d)
33667 fastpathTV.DecMapInt64Int8V(rv2i(rv).(map[int64]int8), false, d)
33670 func (f fastpathT) DecMapInt64Int8X(vp *map[int64]int8, d *Decoder) {
33671 v, changed := f.DecMapInt64Int8V(*vp, true, d)
33676 func (_ fastpathT) DecMapInt64Int8V(v map[int64]int8, canChange bool,
33677 d *Decoder) (_ map[int64]int8, changed bool) {
33678 dd, esep := d.d, d.hh.hasElemSeparators()
33679 containerLen := dd.ReadMapStart()
33680 if canChange && v == nil {
33681 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
33682 v = make(map[int64]int8, xlen)
33685 if containerLen == 0 {
33692 hasLen := containerLen > 0
33693 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33695 dd.ReadMapElemKey()
33697 mk = dd.DecodeInt64()
33699 dd.ReadMapElemValue()
33701 if dd.TryDecodeAsNil() {
33703 } else if d.h.DeleteOnNilMapValue {
33710 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
33720 func (d *Decoder) fastpathDecMapInt64Int16R(f *codecFnInfo, rv reflect.Value) {
33721 if rv.Kind() == reflect.Ptr {
33722 vp := rv2i(rv).(*map[int64]int16)
33723 v, changed := fastpathTV.DecMapInt64Int16V(*vp, true, d)
33728 fastpathTV.DecMapInt64Int16V(rv2i(rv).(map[int64]int16), false, d)
33731 func (f fastpathT) DecMapInt64Int16X(vp *map[int64]int16, d *Decoder) {
33732 v, changed := f.DecMapInt64Int16V(*vp, true, d)
33737 func (_ fastpathT) DecMapInt64Int16V(v map[int64]int16, canChange bool,
33738 d *Decoder) (_ map[int64]int16, changed bool) {
33739 dd, esep := d.d, d.hh.hasElemSeparators()
33740 containerLen := dd.ReadMapStart()
33741 if canChange && v == nil {
33742 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
33743 v = make(map[int64]int16, xlen)
33746 if containerLen == 0 {
33753 hasLen := containerLen > 0
33754 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33756 dd.ReadMapElemKey()
33758 mk = dd.DecodeInt64()
33760 dd.ReadMapElemValue()
33762 if dd.TryDecodeAsNil() {
33764 } else if d.h.DeleteOnNilMapValue {
33771 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
33781 func (d *Decoder) fastpathDecMapInt64Int32R(f *codecFnInfo, rv reflect.Value) {
33782 if rv.Kind() == reflect.Ptr {
33783 vp := rv2i(rv).(*map[int64]int32)
33784 v, changed := fastpathTV.DecMapInt64Int32V(*vp, true, d)
33789 fastpathTV.DecMapInt64Int32V(rv2i(rv).(map[int64]int32), false, d)
33792 func (f fastpathT) DecMapInt64Int32X(vp *map[int64]int32, d *Decoder) {
33793 v, changed := f.DecMapInt64Int32V(*vp, true, d)
33798 func (_ fastpathT) DecMapInt64Int32V(v map[int64]int32, canChange bool,
33799 d *Decoder) (_ map[int64]int32, changed bool) {
33800 dd, esep := d.d, d.hh.hasElemSeparators()
33801 containerLen := dd.ReadMapStart()
33802 if canChange && v == nil {
33803 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
33804 v = make(map[int64]int32, xlen)
33807 if containerLen == 0 {
33814 hasLen := containerLen > 0
33815 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33817 dd.ReadMapElemKey()
33819 mk = dd.DecodeInt64()
33821 dd.ReadMapElemValue()
33823 if dd.TryDecodeAsNil() {
33825 } else if d.h.DeleteOnNilMapValue {
33832 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
33842 func (d *Decoder) fastpathDecMapInt64Int64R(f *codecFnInfo, rv reflect.Value) {
33843 if rv.Kind() == reflect.Ptr {
33844 vp := rv2i(rv).(*map[int64]int64)
33845 v, changed := fastpathTV.DecMapInt64Int64V(*vp, true, d)
33850 fastpathTV.DecMapInt64Int64V(rv2i(rv).(map[int64]int64), false, d)
33853 func (f fastpathT) DecMapInt64Int64X(vp *map[int64]int64, d *Decoder) {
33854 v, changed := f.DecMapInt64Int64V(*vp, true, d)
33859 func (_ fastpathT) DecMapInt64Int64V(v map[int64]int64, canChange bool,
33860 d *Decoder) (_ map[int64]int64, changed bool) {
33861 dd, esep := d.d, d.hh.hasElemSeparators()
33862 containerLen := dd.ReadMapStart()
33863 if canChange && v == nil {
33864 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
33865 v = make(map[int64]int64, xlen)
33868 if containerLen == 0 {
33875 hasLen := containerLen > 0
33876 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33878 dd.ReadMapElemKey()
33880 mk = dd.DecodeInt64()
33882 dd.ReadMapElemValue()
33884 if dd.TryDecodeAsNil() {
33886 } else if d.h.DeleteOnNilMapValue {
33893 mv = dd.DecodeInt64()
33903 func (d *Decoder) fastpathDecMapInt64Float32R(f *codecFnInfo, rv reflect.Value) {
33904 if rv.Kind() == reflect.Ptr {
33905 vp := rv2i(rv).(*map[int64]float32)
33906 v, changed := fastpathTV.DecMapInt64Float32V(*vp, true, d)
33911 fastpathTV.DecMapInt64Float32V(rv2i(rv).(map[int64]float32), false, d)
33914 func (f fastpathT) DecMapInt64Float32X(vp *map[int64]float32, d *Decoder) {
33915 v, changed := f.DecMapInt64Float32V(*vp, true, d)
33920 func (_ fastpathT) DecMapInt64Float32V(v map[int64]float32, canChange bool,
33921 d *Decoder) (_ map[int64]float32, changed bool) {
33922 dd, esep := d.d, d.hh.hasElemSeparators()
33923 containerLen := dd.ReadMapStart()
33924 if canChange && v == nil {
33925 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
33926 v = make(map[int64]float32, xlen)
33929 if containerLen == 0 {
33936 hasLen := containerLen > 0
33937 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33939 dd.ReadMapElemKey()
33941 mk = dd.DecodeInt64()
33943 dd.ReadMapElemValue()
33945 if dd.TryDecodeAsNil() {
33947 } else if d.h.DeleteOnNilMapValue {
33954 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
33964 func (d *Decoder) fastpathDecMapInt64Float64R(f *codecFnInfo, rv reflect.Value) {
33965 if rv.Kind() == reflect.Ptr {
33966 vp := rv2i(rv).(*map[int64]float64)
33967 v, changed := fastpathTV.DecMapInt64Float64V(*vp, true, d)
33972 fastpathTV.DecMapInt64Float64V(rv2i(rv).(map[int64]float64), false, d)
33975 func (f fastpathT) DecMapInt64Float64X(vp *map[int64]float64, d *Decoder) {
33976 v, changed := f.DecMapInt64Float64V(*vp, true, d)
33981 func (_ fastpathT) DecMapInt64Float64V(v map[int64]float64, canChange bool,
33982 d *Decoder) (_ map[int64]float64, changed bool) {
33983 dd, esep := d.d, d.hh.hasElemSeparators()
33984 containerLen := dd.ReadMapStart()
33985 if canChange && v == nil {
33986 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
33987 v = make(map[int64]float64, xlen)
33990 if containerLen == 0 {
33997 hasLen := containerLen > 0
33998 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34000 dd.ReadMapElemKey()
34002 mk = dd.DecodeInt64()
34004 dd.ReadMapElemValue()
34006 if dd.TryDecodeAsNil() {
34008 } else if d.h.DeleteOnNilMapValue {
34015 mv = dd.DecodeFloat64()
34025 func (d *Decoder) fastpathDecMapInt64BoolR(f *codecFnInfo, rv reflect.Value) {
34026 if rv.Kind() == reflect.Ptr {
34027 vp := rv2i(rv).(*map[int64]bool)
34028 v, changed := fastpathTV.DecMapInt64BoolV(*vp, true, d)
34033 fastpathTV.DecMapInt64BoolV(rv2i(rv).(map[int64]bool), false, d)
34036 func (f fastpathT) DecMapInt64BoolX(vp *map[int64]bool, d *Decoder) {
34037 v, changed := f.DecMapInt64BoolV(*vp, true, d)
34042 func (_ fastpathT) DecMapInt64BoolV(v map[int64]bool, canChange bool,
34043 d *Decoder) (_ map[int64]bool, changed bool) {
34044 dd, esep := d.d, d.hh.hasElemSeparators()
34045 containerLen := dd.ReadMapStart()
34046 if canChange && v == nil {
34047 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
34048 v = make(map[int64]bool, xlen)
34051 if containerLen == 0 {
34058 hasLen := containerLen > 0
34059 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34061 dd.ReadMapElemKey()
34063 mk = dd.DecodeInt64()
34065 dd.ReadMapElemValue()
34067 if dd.TryDecodeAsNil() {
34069 } else if d.h.DeleteOnNilMapValue {
34076 mv = dd.DecodeBool()
34086 func (d *Decoder) fastpathDecMapBoolIntfR(f *codecFnInfo, rv reflect.Value) {
34087 if rv.Kind() == reflect.Ptr {
34088 vp := rv2i(rv).(*map[bool]interface{})
34089 v, changed := fastpathTV.DecMapBoolIntfV(*vp, true, d)
34094 fastpathTV.DecMapBoolIntfV(rv2i(rv).(map[bool]interface{}), false, d)
34097 func (f fastpathT) DecMapBoolIntfX(vp *map[bool]interface{}, d *Decoder) {
34098 v, changed := f.DecMapBoolIntfV(*vp, true, d)
34103 func (_ fastpathT) DecMapBoolIntfV(v map[bool]interface{}, canChange bool,
34104 d *Decoder) (_ map[bool]interface{}, changed bool) {
34105 dd, esep := d.d, d.hh.hasElemSeparators()
34106 containerLen := dd.ReadMapStart()
34107 if canChange && v == nil {
34108 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
34109 v = make(map[bool]interface{}, xlen)
34112 if containerLen == 0 {
34117 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
34120 hasLen := containerLen > 0
34121 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34123 dd.ReadMapElemKey()
34125 mk = dd.DecodeBool()
34127 dd.ReadMapElemValue()
34129 if dd.TryDecodeAsNil() {
34131 } else if d.h.DeleteOnNilMapValue {
34153 func (d *Decoder) fastpathDecMapBoolStringR(f *codecFnInfo, rv reflect.Value) {
34154 if rv.Kind() == reflect.Ptr {
34155 vp := rv2i(rv).(*map[bool]string)
34156 v, changed := fastpathTV.DecMapBoolStringV(*vp, true, d)
34161 fastpathTV.DecMapBoolStringV(rv2i(rv).(map[bool]string), false, d)
34164 func (f fastpathT) DecMapBoolStringX(vp *map[bool]string, d *Decoder) {
34165 v, changed := f.DecMapBoolStringV(*vp, true, d)
34170 func (_ fastpathT) DecMapBoolStringV(v map[bool]string, canChange bool,
34171 d *Decoder) (_ map[bool]string, changed bool) {
34172 dd, esep := d.d, d.hh.hasElemSeparators()
34173 containerLen := dd.ReadMapStart()
34174 if canChange && v == nil {
34175 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
34176 v = make(map[bool]string, xlen)
34179 if containerLen == 0 {
34186 hasLen := containerLen > 0
34187 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34189 dd.ReadMapElemKey()
34191 mk = dd.DecodeBool()
34193 dd.ReadMapElemValue()
34195 if dd.TryDecodeAsNil() {
34197 } else if d.h.DeleteOnNilMapValue {
34204 mv = dd.DecodeString()
34214 func (d *Decoder) fastpathDecMapBoolUintR(f *codecFnInfo, rv reflect.Value) {
34215 if rv.Kind() == reflect.Ptr {
34216 vp := rv2i(rv).(*map[bool]uint)
34217 v, changed := fastpathTV.DecMapBoolUintV(*vp, true, d)
34222 fastpathTV.DecMapBoolUintV(rv2i(rv).(map[bool]uint), false, d)
34225 func (f fastpathT) DecMapBoolUintX(vp *map[bool]uint, d *Decoder) {
34226 v, changed := f.DecMapBoolUintV(*vp, true, d)
34231 func (_ fastpathT) DecMapBoolUintV(v map[bool]uint, canChange bool,
34232 d *Decoder) (_ map[bool]uint, changed bool) {
34233 dd, esep := d.d, d.hh.hasElemSeparators()
34234 containerLen := dd.ReadMapStart()
34235 if canChange && v == nil {
34236 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
34237 v = make(map[bool]uint, xlen)
34240 if containerLen == 0 {
34247 hasLen := containerLen > 0
34248 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34250 dd.ReadMapElemKey()
34252 mk = dd.DecodeBool()
34254 dd.ReadMapElemValue()
34256 if dd.TryDecodeAsNil() {
34258 } else if d.h.DeleteOnNilMapValue {
34265 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
34275 func (d *Decoder) fastpathDecMapBoolUint8R(f *codecFnInfo, rv reflect.Value) {
34276 if rv.Kind() == reflect.Ptr {
34277 vp := rv2i(rv).(*map[bool]uint8)
34278 v, changed := fastpathTV.DecMapBoolUint8V(*vp, true, d)
34283 fastpathTV.DecMapBoolUint8V(rv2i(rv).(map[bool]uint8), false, d)
34286 func (f fastpathT) DecMapBoolUint8X(vp *map[bool]uint8, d *Decoder) {
34287 v, changed := f.DecMapBoolUint8V(*vp, true, d)
34292 func (_ fastpathT) DecMapBoolUint8V(v map[bool]uint8, canChange bool,
34293 d *Decoder) (_ map[bool]uint8, changed bool) {
34294 dd, esep := d.d, d.hh.hasElemSeparators()
34295 containerLen := dd.ReadMapStart()
34296 if canChange && v == nil {
34297 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
34298 v = make(map[bool]uint8, xlen)
34301 if containerLen == 0 {
34308 hasLen := containerLen > 0
34309 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34311 dd.ReadMapElemKey()
34313 mk = dd.DecodeBool()
34315 dd.ReadMapElemValue()
34317 if dd.TryDecodeAsNil() {
34319 } else if d.h.DeleteOnNilMapValue {
34326 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
34336 func (d *Decoder) fastpathDecMapBoolUint16R(f *codecFnInfo, rv reflect.Value) {
34337 if rv.Kind() == reflect.Ptr {
34338 vp := rv2i(rv).(*map[bool]uint16)
34339 v, changed := fastpathTV.DecMapBoolUint16V(*vp, true, d)
34344 fastpathTV.DecMapBoolUint16V(rv2i(rv).(map[bool]uint16), false, d)
34347 func (f fastpathT) DecMapBoolUint16X(vp *map[bool]uint16, d *Decoder) {
34348 v, changed := f.DecMapBoolUint16V(*vp, true, d)
34353 func (_ fastpathT) DecMapBoolUint16V(v map[bool]uint16, canChange bool,
34354 d *Decoder) (_ map[bool]uint16, changed bool) {
34355 dd, esep := d.d, d.hh.hasElemSeparators()
34356 containerLen := dd.ReadMapStart()
34357 if canChange && v == nil {
34358 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
34359 v = make(map[bool]uint16, xlen)
34362 if containerLen == 0 {
34369 hasLen := containerLen > 0
34370 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34372 dd.ReadMapElemKey()
34374 mk = dd.DecodeBool()
34376 dd.ReadMapElemValue()
34378 if dd.TryDecodeAsNil() {
34380 } else if d.h.DeleteOnNilMapValue {
34387 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
34397 func (d *Decoder) fastpathDecMapBoolUint32R(f *codecFnInfo, rv reflect.Value) {
34398 if rv.Kind() == reflect.Ptr {
34399 vp := rv2i(rv).(*map[bool]uint32)
34400 v, changed := fastpathTV.DecMapBoolUint32V(*vp, true, d)
34405 fastpathTV.DecMapBoolUint32V(rv2i(rv).(map[bool]uint32), false, d)
34408 func (f fastpathT) DecMapBoolUint32X(vp *map[bool]uint32, d *Decoder) {
34409 v, changed := f.DecMapBoolUint32V(*vp, true, d)
34414 func (_ fastpathT) DecMapBoolUint32V(v map[bool]uint32, canChange bool,
34415 d *Decoder) (_ map[bool]uint32, changed bool) {
34416 dd, esep := d.d, d.hh.hasElemSeparators()
34417 containerLen := dd.ReadMapStart()
34418 if canChange && v == nil {
34419 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
34420 v = make(map[bool]uint32, xlen)
34423 if containerLen == 0 {
34430 hasLen := containerLen > 0
34431 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34433 dd.ReadMapElemKey()
34435 mk = dd.DecodeBool()
34437 dd.ReadMapElemValue()
34439 if dd.TryDecodeAsNil() {
34441 } else if d.h.DeleteOnNilMapValue {
34448 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
34458 func (d *Decoder) fastpathDecMapBoolUint64R(f *codecFnInfo, rv reflect.Value) {
34459 if rv.Kind() == reflect.Ptr {
34460 vp := rv2i(rv).(*map[bool]uint64)
34461 v, changed := fastpathTV.DecMapBoolUint64V(*vp, true, d)
34466 fastpathTV.DecMapBoolUint64V(rv2i(rv).(map[bool]uint64), false, d)
34469 func (f fastpathT) DecMapBoolUint64X(vp *map[bool]uint64, d *Decoder) {
34470 v, changed := f.DecMapBoolUint64V(*vp, true, d)
34475 func (_ fastpathT) DecMapBoolUint64V(v map[bool]uint64, canChange bool,
34476 d *Decoder) (_ map[bool]uint64, changed bool) {
34477 dd, esep := d.d, d.hh.hasElemSeparators()
34478 containerLen := dd.ReadMapStart()
34479 if canChange && v == nil {
34480 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
34481 v = make(map[bool]uint64, xlen)
34484 if containerLen == 0 {
34491 hasLen := containerLen > 0
34492 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34494 dd.ReadMapElemKey()
34496 mk = dd.DecodeBool()
34498 dd.ReadMapElemValue()
34500 if dd.TryDecodeAsNil() {
34502 } else if d.h.DeleteOnNilMapValue {
34509 mv = dd.DecodeUint64()
34519 func (d *Decoder) fastpathDecMapBoolUintptrR(f *codecFnInfo, rv reflect.Value) {
34520 if rv.Kind() == reflect.Ptr {
34521 vp := rv2i(rv).(*map[bool]uintptr)
34522 v, changed := fastpathTV.DecMapBoolUintptrV(*vp, true, d)
34527 fastpathTV.DecMapBoolUintptrV(rv2i(rv).(map[bool]uintptr), false, d)
34530 func (f fastpathT) DecMapBoolUintptrX(vp *map[bool]uintptr, d *Decoder) {
34531 v, changed := f.DecMapBoolUintptrV(*vp, true, d)
34536 func (_ fastpathT) DecMapBoolUintptrV(v map[bool]uintptr, canChange bool,
34537 d *Decoder) (_ map[bool]uintptr, changed bool) {
34538 dd, esep := d.d, d.hh.hasElemSeparators()
34539 containerLen := dd.ReadMapStart()
34540 if canChange && v == nil {
34541 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
34542 v = make(map[bool]uintptr, xlen)
34545 if containerLen == 0 {
34552 hasLen := containerLen > 0
34553 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34555 dd.ReadMapElemKey()
34557 mk = dd.DecodeBool()
34559 dd.ReadMapElemValue()
34561 if dd.TryDecodeAsNil() {
34563 } else if d.h.DeleteOnNilMapValue {
34570 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
34580 func (d *Decoder) fastpathDecMapBoolIntR(f *codecFnInfo, rv reflect.Value) {
34581 if rv.Kind() == reflect.Ptr {
34582 vp := rv2i(rv).(*map[bool]int)
34583 v, changed := fastpathTV.DecMapBoolIntV(*vp, true, d)
34588 fastpathTV.DecMapBoolIntV(rv2i(rv).(map[bool]int), false, d)
34591 func (f fastpathT) DecMapBoolIntX(vp *map[bool]int, d *Decoder) {
34592 v, changed := f.DecMapBoolIntV(*vp, true, d)
34597 func (_ fastpathT) DecMapBoolIntV(v map[bool]int, canChange bool,
34598 d *Decoder) (_ map[bool]int, changed bool) {
34599 dd, esep := d.d, d.hh.hasElemSeparators()
34600 containerLen := dd.ReadMapStart()
34601 if canChange && v == nil {
34602 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
34603 v = make(map[bool]int, xlen)
34606 if containerLen == 0 {
34613 hasLen := containerLen > 0
34614 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34616 dd.ReadMapElemKey()
34618 mk = dd.DecodeBool()
34620 dd.ReadMapElemValue()
34622 if dd.TryDecodeAsNil() {
34624 } else if d.h.DeleteOnNilMapValue {
34631 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
34641 func (d *Decoder) fastpathDecMapBoolInt8R(f *codecFnInfo, rv reflect.Value) {
34642 if rv.Kind() == reflect.Ptr {
34643 vp := rv2i(rv).(*map[bool]int8)
34644 v, changed := fastpathTV.DecMapBoolInt8V(*vp, true, d)
34649 fastpathTV.DecMapBoolInt8V(rv2i(rv).(map[bool]int8), false, d)
34652 func (f fastpathT) DecMapBoolInt8X(vp *map[bool]int8, d *Decoder) {
34653 v, changed := f.DecMapBoolInt8V(*vp, true, d)
34658 func (_ fastpathT) DecMapBoolInt8V(v map[bool]int8, canChange bool,
34659 d *Decoder) (_ map[bool]int8, changed bool) {
34660 dd, esep := d.d, d.hh.hasElemSeparators()
34661 containerLen := dd.ReadMapStart()
34662 if canChange && v == nil {
34663 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
34664 v = make(map[bool]int8, xlen)
34667 if containerLen == 0 {
34674 hasLen := containerLen > 0
34675 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34677 dd.ReadMapElemKey()
34679 mk = dd.DecodeBool()
34681 dd.ReadMapElemValue()
34683 if dd.TryDecodeAsNil() {
34685 } else if d.h.DeleteOnNilMapValue {
34692 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
34702 func (d *Decoder) fastpathDecMapBoolInt16R(f *codecFnInfo, rv reflect.Value) {
34703 if rv.Kind() == reflect.Ptr {
34704 vp := rv2i(rv).(*map[bool]int16)
34705 v, changed := fastpathTV.DecMapBoolInt16V(*vp, true, d)
34710 fastpathTV.DecMapBoolInt16V(rv2i(rv).(map[bool]int16), false, d)
34713 func (f fastpathT) DecMapBoolInt16X(vp *map[bool]int16, d *Decoder) {
34714 v, changed := f.DecMapBoolInt16V(*vp, true, d)
34719 func (_ fastpathT) DecMapBoolInt16V(v map[bool]int16, canChange bool,
34720 d *Decoder) (_ map[bool]int16, changed bool) {
34721 dd, esep := d.d, d.hh.hasElemSeparators()
34722 containerLen := dd.ReadMapStart()
34723 if canChange && v == nil {
34724 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
34725 v = make(map[bool]int16, xlen)
34728 if containerLen == 0 {
34735 hasLen := containerLen > 0
34736 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34738 dd.ReadMapElemKey()
34740 mk = dd.DecodeBool()
34742 dd.ReadMapElemValue()
34744 if dd.TryDecodeAsNil() {
34746 } else if d.h.DeleteOnNilMapValue {
34753 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
34763 func (d *Decoder) fastpathDecMapBoolInt32R(f *codecFnInfo, rv reflect.Value) {
34764 if rv.Kind() == reflect.Ptr {
34765 vp := rv2i(rv).(*map[bool]int32)
34766 v, changed := fastpathTV.DecMapBoolInt32V(*vp, true, d)
34771 fastpathTV.DecMapBoolInt32V(rv2i(rv).(map[bool]int32), false, d)
34774 func (f fastpathT) DecMapBoolInt32X(vp *map[bool]int32, d *Decoder) {
34775 v, changed := f.DecMapBoolInt32V(*vp, true, d)
34780 func (_ fastpathT) DecMapBoolInt32V(v map[bool]int32, canChange bool,
34781 d *Decoder) (_ map[bool]int32, changed bool) {
34782 dd, esep := d.d, d.hh.hasElemSeparators()
34783 containerLen := dd.ReadMapStart()
34784 if canChange && v == nil {
34785 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
34786 v = make(map[bool]int32, xlen)
34789 if containerLen == 0 {
34796 hasLen := containerLen > 0
34797 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34799 dd.ReadMapElemKey()
34801 mk = dd.DecodeBool()
34803 dd.ReadMapElemValue()
34805 if dd.TryDecodeAsNil() {
34807 } else if d.h.DeleteOnNilMapValue {
34814 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
34824 func (d *Decoder) fastpathDecMapBoolInt64R(f *codecFnInfo, rv reflect.Value) {
34825 if rv.Kind() == reflect.Ptr {
34826 vp := rv2i(rv).(*map[bool]int64)
34827 v, changed := fastpathTV.DecMapBoolInt64V(*vp, true, d)
34832 fastpathTV.DecMapBoolInt64V(rv2i(rv).(map[bool]int64), false, d)
34835 func (f fastpathT) DecMapBoolInt64X(vp *map[bool]int64, d *Decoder) {
34836 v, changed := f.DecMapBoolInt64V(*vp, true, d)
34841 func (_ fastpathT) DecMapBoolInt64V(v map[bool]int64, canChange bool,
34842 d *Decoder) (_ map[bool]int64, changed bool) {
34843 dd, esep := d.d, d.hh.hasElemSeparators()
34844 containerLen := dd.ReadMapStart()
34845 if canChange && v == nil {
34846 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
34847 v = make(map[bool]int64, xlen)
34850 if containerLen == 0 {
34857 hasLen := containerLen > 0
34858 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34860 dd.ReadMapElemKey()
34862 mk = dd.DecodeBool()
34864 dd.ReadMapElemValue()
34866 if dd.TryDecodeAsNil() {
34868 } else if d.h.DeleteOnNilMapValue {
34875 mv = dd.DecodeInt64()
34885 func (d *Decoder) fastpathDecMapBoolFloat32R(f *codecFnInfo, rv reflect.Value) {
34886 if rv.Kind() == reflect.Ptr {
34887 vp := rv2i(rv).(*map[bool]float32)
34888 v, changed := fastpathTV.DecMapBoolFloat32V(*vp, true, d)
34893 fastpathTV.DecMapBoolFloat32V(rv2i(rv).(map[bool]float32), false, d)
34896 func (f fastpathT) DecMapBoolFloat32X(vp *map[bool]float32, d *Decoder) {
34897 v, changed := f.DecMapBoolFloat32V(*vp, true, d)
34902 func (_ fastpathT) DecMapBoolFloat32V(v map[bool]float32, canChange bool,
34903 d *Decoder) (_ map[bool]float32, changed bool) {
34904 dd, esep := d.d, d.hh.hasElemSeparators()
34905 containerLen := dd.ReadMapStart()
34906 if canChange && v == nil {
34907 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
34908 v = make(map[bool]float32, xlen)
34911 if containerLen == 0 {
34918 hasLen := containerLen > 0
34919 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34921 dd.ReadMapElemKey()
34923 mk = dd.DecodeBool()
34925 dd.ReadMapElemValue()
34927 if dd.TryDecodeAsNil() {
34929 } else if d.h.DeleteOnNilMapValue {
34936 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
34946 func (d *Decoder) fastpathDecMapBoolFloat64R(f *codecFnInfo, rv reflect.Value) {
34947 if rv.Kind() == reflect.Ptr {
34948 vp := rv2i(rv).(*map[bool]float64)
34949 v, changed := fastpathTV.DecMapBoolFloat64V(*vp, true, d)
34954 fastpathTV.DecMapBoolFloat64V(rv2i(rv).(map[bool]float64), false, d)
34957 func (f fastpathT) DecMapBoolFloat64X(vp *map[bool]float64, d *Decoder) {
34958 v, changed := f.DecMapBoolFloat64V(*vp, true, d)
34963 func (_ fastpathT) DecMapBoolFloat64V(v map[bool]float64, canChange bool,
34964 d *Decoder) (_ map[bool]float64, changed bool) {
34965 dd, esep := d.d, d.hh.hasElemSeparators()
34966 containerLen := dd.ReadMapStart()
34967 if canChange && v == nil {
34968 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
34969 v = make(map[bool]float64, xlen)
34972 if containerLen == 0 {
34979 hasLen := containerLen > 0
34980 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34982 dd.ReadMapElemKey()
34984 mk = dd.DecodeBool()
34986 dd.ReadMapElemValue()
34988 if dd.TryDecodeAsNil() {
34990 } else if d.h.DeleteOnNilMapValue {
34997 mv = dd.DecodeFloat64()
35007 func (d *Decoder) fastpathDecMapBoolBoolR(f *codecFnInfo, rv reflect.Value) {
35008 if rv.Kind() == reflect.Ptr {
35009 vp := rv2i(rv).(*map[bool]bool)
35010 v, changed := fastpathTV.DecMapBoolBoolV(*vp, true, d)
35015 fastpathTV.DecMapBoolBoolV(rv2i(rv).(map[bool]bool), false, d)
35018 func (f fastpathT) DecMapBoolBoolX(vp *map[bool]bool, d *Decoder) {
35019 v, changed := f.DecMapBoolBoolV(*vp, true, d)
35024 func (_ fastpathT) DecMapBoolBoolV(v map[bool]bool, canChange bool,
35025 d *Decoder) (_ map[bool]bool, changed bool) {
35026 dd, esep := d.d, d.hh.hasElemSeparators()
35027 containerLen := dd.ReadMapStart()
35028 if canChange && v == nil {
35029 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
35030 v = make(map[bool]bool, xlen)
35033 if containerLen == 0 {
35040 hasLen := containerLen > 0
35041 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
35043 dd.ReadMapElemKey()
35045 mk = dd.DecodeBool()
35047 dd.ReadMapElemValue()
35049 if dd.TryDecodeAsNil() {
35051 } else if d.h.DeleteOnNilMapValue {
35058 mv = dd.DecodeBool()