1 // Created by encgen --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 7 package gob 8 9 import ( 10 "reflect" 11 ) 12 13 var 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 32 var 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 51 func 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 59 func 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 77 func 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 85 func 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 102 func 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 110 func 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 127 func 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 135 func 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 150 func 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 158 func 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 173 func 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 181 func 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 195 func 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 203 func 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 217 func 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 225 func 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 239 func 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 247 func 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 261 func 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 269 func 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 283 func 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 291 func 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 306 func 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 314 func 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 328 func 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 336 func 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 350 func 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 358 func 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 372 func 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 380 func 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 394 func 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 402 func 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
