libgo/go/encoding/gob/enc_helpers.go

   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 }