...
Run Format

Source file src/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	}
   415	

View as plain text