1// Code generated by go run encgen.go -output enc_helpers.go; DO NOT EDIT.
2
3// Copyright 2014 The Go Authors. All rights reserved.
4// Use of this source code is governed by a BSD-style
5// license that can be found in the LICENSE file.
6
7package gob
8
9import (
10	"reflect"
11)
12
13var encArrayHelper = map[reflect.Kind]encHelper{
14	reflect.Bool:       encBoolArray,
15	reflect.Complex64:  encComplex64Array,
16	reflect.Complex128: encComplex128Array,
17	reflect.Float32:    encFloat32Array,
18	reflect.Float64:    encFloat64Array,
19	reflect.Int:        encIntArray,
20	reflect.Int16:      encInt16Array,
21	reflect.Int32:      encInt32Array,
22	reflect.Int64:      encInt64Array,
23	reflect.Int8:       encInt8Array,
24	reflect.String:     encStringArray,
25	reflect.Uint:       encUintArray,
26	reflect.Uint16:     encUint16Array,
27	reflect.Uint32:     encUint32Array,
28	reflect.Uint64:     encUint64Array,
29	reflect.Uintptr:    encUintptrArray,
30}
31
32var encSliceHelper = map[reflect.Kind]encHelper{
33	reflect.Bool:       encBoolSlice,
34	reflect.Complex64:  encComplex64Slice,
35	reflect.Complex128: encComplex128Slice,
36	reflect.Float32:    encFloat32Slice,
37	reflect.Float64:    encFloat64Slice,
38	reflect.Int:        encIntSlice,
39	reflect.Int16:      encInt16Slice,
40	reflect.Int32:      encInt32Slice,
41	reflect.Int64:      encInt64Slice,
42	reflect.Int8:       encInt8Slice,
43	reflect.String:     encStringSlice,
44	reflect.Uint:       encUintSlice,
45	reflect.Uint16:     encUint16Slice,
46	reflect.Uint32:     encUint32Slice,
47	reflect.Uint64:     encUint64Slice,
48	reflect.Uintptr:    encUintptrSlice,
49}
50
51func encBoolArray(state *encoderState, v reflect.Value) bool {
52	// Can only slice if it is addressable.
53	if !v.CanAddr() {
54		return false
55	}
56	return encBoolSlice(state, v.Slice(0, v.Len()))
57}
58
59func encBoolSlice(state *encoderState, v reflect.Value) bool {
60	slice, ok := v.Interface().([]bool)
61	if !ok {
62		// It is kind bool but not type bool. TODO: We can handle this unsafely.
63		return false
64	}
65	for _, x := range slice {
66		if x != false || state.sendZero {
67			if x {
68				state.encodeUint(1)
69			} else {
70				state.encodeUint(0)
71			}
72		}
73	}
74	return true
75}
76
77func encComplex64Array(state *encoderState, v reflect.Value) bool {
78	// Can only slice if it is addressable.
79	if !v.CanAddr() {
80		return false
81	}
82	return encComplex64Slice(state, v.Slice(0, v.Len()))
83}
84
85func encComplex64Slice(state *encoderState, v reflect.Value) bool {
86	slice, ok := v.Interface().([]complex64)
87	if !ok {
88		// It is kind complex64 but not type complex64. TODO: We can handle this unsafely.
89		return false
90	}
91	for _, x := range slice {
92		if x != 0+0i || state.sendZero {
93			rpart := floatBits(float64(real(x)))
94			ipart := floatBits(float64(imag(x)))
95			state.encodeUint(rpart)
96			state.encodeUint(ipart)
97		}
98	}
99	return true
100}
101
102func encComplex128Array(state *encoderState, v reflect.Value) bool {
103	// Can only slice if it is addressable.
104	if !v.CanAddr() {
105		return false
106	}
107	return encComplex128Slice(state, v.Slice(0, v.Len()))
108}
109
110func encComplex128Slice(state *encoderState, v reflect.Value) bool {
111	slice, ok := v.Interface().([]complex128)
112	if !ok {
113		// It is kind complex128 but not type complex128. TODO: We can handle this unsafely.
114		return false
115	}
116	for _, x := range slice {
117		if x != 0+0i || state.sendZero {
118			rpart := floatBits(real(x))
119			ipart := floatBits(imag(x))
120			state.encodeUint(rpart)
121			state.encodeUint(ipart)
122		}
123	}
124	return true
125}
126
127func encFloat32Array(state *encoderState, v reflect.Value) bool {
128	// Can only slice if it is addressable.
129	if !v.CanAddr() {
130		return false
131	}
132	return encFloat32Slice(state, v.Slice(0, v.Len()))
133}
134
135func encFloat32Slice(state *encoderState, v reflect.Value) bool {
136	slice, ok := v.Interface().([]float32)
137	if !ok {
138		// It is kind float32 but not type float32. TODO: We can handle this unsafely.
139		return false
140	}
141	for _, x := range slice {
142		if x != 0 || state.sendZero {
143			bits := floatBits(float64(x))
144			state.encodeUint(bits)
145		}
146	}
147	return true
148}
149
150func encFloat64Array(state *encoderState, v reflect.Value) bool {
151	// Can only slice if it is addressable.
152	if !v.CanAddr() {
153		return false
154	}
155	return encFloat64Slice(state, v.Slice(0, v.Len()))
156}
157
158func encFloat64Slice(state *encoderState, v reflect.Value) bool {
159	slice, ok := v.Interface().([]float64)
160	if !ok {
161		// It is kind float64 but not type float64. TODO: We can handle this unsafely.
162		return false
163	}
164	for _, x := range slice {
165		if x != 0 || state.sendZero {
166			bits := floatBits(x)
167			state.encodeUint(bits)
168		}
169	}
170	return true
171}
172
173func encIntArray(state *encoderState, v reflect.Value) bool {
174	// Can only slice if it is addressable.
175	if !v.CanAddr() {
176		return false
177	}
178	return encIntSlice(state, v.Slice(0, v.Len()))
179}
180
181func encIntSlice(state *encoderState, v reflect.Value) bool {
182	slice, ok := v.Interface().([]int)
183	if !ok {
184		// It is kind int but not type int. TODO: We can handle this unsafely.
185		return false
186	}
187	for _, x := range slice {
188		if x != 0 || state.sendZero {
189			state.encodeInt(int64(x))
190		}
191	}
192	return true
193}
194
195func encInt16Array(state *encoderState, v reflect.Value) bool {
196	// Can only slice if it is addressable.
197	if !v.CanAddr() {
198		return false
199	}
200	return encInt16Slice(state, v.Slice(0, v.Len()))
201}
202
203func encInt16Slice(state *encoderState, v reflect.Value) bool {
204	slice, ok := v.Interface().([]int16)
205	if !ok {
206		// It is kind int16 but not type int16. TODO: We can handle this unsafely.
207		return false
208	}
209	for _, x := range slice {
210		if x != 0 || state.sendZero {
211			state.encodeInt(int64(x))
212		}
213	}
214	return true
215}
216
217func encInt32Array(state *encoderState, v reflect.Value) bool {
218	// Can only slice if it is addressable.
219	if !v.CanAddr() {
220		return false
221	}
222	return encInt32Slice(state, v.Slice(0, v.Len()))
223}
224
225func encInt32Slice(state *encoderState, v reflect.Value) bool {
226	slice, ok := v.Interface().([]int32)
227	if !ok {
228		// It is kind int32 but not type int32. TODO: We can handle this unsafely.
229		return false
230	}
231	for _, x := range slice {
232		if x != 0 || state.sendZero {
233			state.encodeInt(int64(x))
234		}
235	}
236	return true
237}
238
239func encInt64Array(state *encoderState, v reflect.Value) bool {
240	// Can only slice if it is addressable.
241	if !v.CanAddr() {
242		return false
243	}
244	return encInt64Slice(state, v.Slice(0, v.Len()))
245}
246
247func encInt64Slice(state *encoderState, v reflect.Value) bool {
248	slice, ok := v.Interface().([]int64)
249	if !ok {
250		// It is kind int64 but not type int64. TODO: We can handle this unsafely.
251		return false
252	}
253	for _, x := range slice {
254		if x != 0 || state.sendZero {
255			state.encodeInt(x)
256		}
257	}
258	return true
259}
260
261func encInt8Array(state *encoderState, v reflect.Value) bool {
262	// Can only slice if it is addressable.
263	if !v.CanAddr() {
264		return false
265	}
266	return encInt8Slice(state, v.Slice(0, v.Len()))
267}
268
269func encInt8Slice(state *encoderState, v reflect.Value) bool {
270	slice, ok := v.Interface().([]int8)
271	if !ok {
272		// It is kind int8 but not type int8. TODO: We can handle this unsafely.
273		return false
274	}
275	for _, x := range slice {
276		if x != 0 || state.sendZero {
277			state.encodeInt(int64(x))
278		}
279	}
280	return true
281}
282
283func encStringArray(state *encoderState, v reflect.Value) bool {
284	// Can only slice if it is addressable.
285	if !v.CanAddr() {
286		return false
287	}
288	return encStringSlice(state, v.Slice(0, v.Len()))
289}
290
291func encStringSlice(state *encoderState, v reflect.Value) bool {
292	slice, ok := v.Interface().([]string)
293	if !ok {
294		// It is kind string but not type string. TODO: We can handle this unsafely.
295		return false
296	}
297	for _, x := range slice {
298		if x != "" || state.sendZero {
299			state.encodeUint(uint64(len(x)))
300			state.b.WriteString(x)
301		}
302	}
303	return true
304}
305
306func encUintArray(state *encoderState, v reflect.Value) bool {
307	// Can only slice if it is addressable.
308	if !v.CanAddr() {
309		return false
310	}
311	return encUintSlice(state, v.Slice(0, v.Len()))
312}
313
314func encUintSlice(state *encoderState, v reflect.Value) bool {
315	slice, ok := v.Interface().([]uint)
316	if !ok {
317		// It is kind uint but not type uint. TODO: We can handle this unsafely.
318		return false
319	}
320	for _, x := range slice {
321		if x != 0 || state.sendZero {
322			state.encodeUint(uint64(x))
323		}
324	}
325	return true
326}
327
328func encUint16Array(state *encoderState, v reflect.Value) bool {
329	// Can only slice if it is addressable.
330	if !v.CanAddr() {
331		return false
332	}
333	return encUint16Slice(state, v.Slice(0, v.Len()))
334}
335
336func encUint16Slice(state *encoderState, v reflect.Value) bool {
337	slice, ok := v.Interface().([]uint16)
338	if !ok {
339		// It is kind uint16 but not type uint16. TODO: We can handle this unsafely.
340		return false
341	}
342	for _, x := range slice {
343		if x != 0 || state.sendZero {
344			state.encodeUint(uint64(x))
345		}
346	}
347	return true
348}
349
350func encUint32Array(state *encoderState, v reflect.Value) bool {
351	// Can only slice if it is addressable.
352	if !v.CanAddr() {
353		return false
354	}
355	return encUint32Slice(state, v.Slice(0, v.Len()))
356}
357
358func encUint32Slice(state *encoderState, v reflect.Value) bool {
359	slice, ok := v.Interface().([]uint32)
360	if !ok {
361		// It is kind uint32 but not type uint32. TODO: We can handle this unsafely.
362		return false
363	}
364	for _, x := range slice {
365		if x != 0 || state.sendZero {
366			state.encodeUint(uint64(x))
367		}
368	}
369	return true
370}
371
372func encUint64Array(state *encoderState, v reflect.Value) bool {
373	// Can only slice if it is addressable.
374	if !v.CanAddr() {
375		return false
376	}
377	return encUint64Slice(state, v.Slice(0, v.Len()))
378}
379
380func encUint64Slice(state *encoderState, v reflect.Value) bool {
381	slice, ok := v.Interface().([]uint64)
382	if !ok {
383		// It is kind uint64 but not type uint64. TODO: We can handle this unsafely.
384		return false
385	}
386	for _, x := range slice {
387		if x != 0 || state.sendZero {
388			state.encodeUint(x)
389		}
390	}
391	return true
392}
393
394func encUintptrArray(state *encoderState, v reflect.Value) bool {
395	// Can only slice if it is addressable.
396	if !v.CanAddr() {
397		return false
398	}
399	return encUintptrSlice(state, v.Slice(0, v.Len()))
400}
401
402func encUintptrSlice(state *encoderState, v reflect.Value) bool {
403	slice, ok := v.Interface().([]uintptr)
404	if !ok {
405		// It is kind uintptr but not type uintptr. TODO: We can handle this unsafely.
406		return false
407	}
408	for _, x := range slice {
409		if x != 0 || state.sendZero {
410			state.encodeUint(uint64(x))
411		}
412	}
413	return true
414}
415