binary.go

Documentation: encoding/binary

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Package binary implements simple translation between numbers and byte
     6  // sequences and encoding and decoding of varints.
     7  //
     8  // Numbers are translated by reading and writing fixed-size values.
     9  // A fixed-size value is either a fixed-size arithmetic
    10  // type (bool, int8, uint8, int16, float32, complex64, ...)
    11  // or an array or struct containing only fixed-size values.
    12  //
    13  // The varint functions encode and decode single integer values using
    14  // a variable-length encoding; smaller values require fewer bytes.
    15  // For a specification, see
    16  // https://developers.google.com/protocol-buffers/docs/encoding.
    17  //
    18  // This package favors simplicity over efficiency. Clients that require
    19  // high-performance serialization, especially for large data structures,
    20  // should look at more advanced solutions such as the encoding/gob
    21  // package or protocol buffers.
    22  package binary
    23  
    24  import (
    25  	"errors"
    26  	"io"
    27  	"math"
    28  	"reflect"
    29  	"sync"
    30  )
    31  
    32  // A ByteOrder specifies how to convert byte sequences into
    33  // 16-, 32-, or 64-bit unsigned integers.
    34  type ByteOrder interface {
    35  	Uint16([]byte) uint16
    36  	Uint32([]byte) uint32
    37  	Uint64([]byte) uint64
    38  	PutUint16([]byte, uint16)
    39  	PutUint32([]byte, uint32)
    40  	PutUint64([]byte, uint64)
    41  	String() string
    42  }
    43  
    44  // LittleEndian is the little-endian implementation of ByteOrder.
    45  var LittleEndian littleEndian
    46  
    47  // BigEndian is the big-endian implementation of ByteOrder.
    48  var BigEndian bigEndian
    49  
    50  type littleEndian struct{}
    51  
    52  func (littleEndian) Uint16(b []byte) uint16 {
    53  	_ = b[1] // bounds check hint to compiler; see golang.org/issue/14808
    54  	return uint16(b[0]) | uint16(b[1])<<8
    55  }
    56  
    57  func (littleEndian) PutUint16(b []byte, v uint16) {
    58  	_ = b[1] // early bounds check to guarantee safety of writes below
    59  	b[0] = byte(v)
    60  	b[1] = byte(v >> 8)
    61  }
    62  
    63  func (littleEndian) Uint32(b []byte) uint32 {
    64  	_ = b[3] // bounds check hint to compiler; see golang.org/issue/14808
    65  	return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
    66  }
    67  
    68  func (littleEndian) PutUint32(b []byte, v uint32) {
    69  	_ = b[3] // early bounds check to guarantee safety of writes below
    70  	b[0] = byte(v)
    71  	b[1] = byte(v >> 8)
    72  	b[2] = byte(v >> 16)
    73  	b[3] = byte(v >> 24)
    74  }
    75  
    76  func (littleEndian) Uint64(b []byte) uint64 {
    77  	_ = b[7] // bounds check hint to compiler; see golang.org/issue/14808
    78  	return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 |
    79  		uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
    80  }
    81  
    82  func (littleEndian) PutUint64(b []byte, v uint64) {
    83  	_ = b[7] // early bounds check to guarantee safety of writes below
    84  	b[0] = byte(v)
    85  	b[1] = byte(v >> 8)
    86  	b[2] = byte(v >> 16)
    87  	b[3] = byte(v >> 24)
    88  	b[4] = byte(v >> 32)
    89  	b[5] = byte(v >> 40)
    90  	b[6] = byte(v >> 48)
    91  	b[7] = byte(v >> 56)
    92  }
    93  
    94  func (littleEndian) String() string { return "LittleEndian" }
    95  
    96  func (littleEndian) GoString() string { return "binary.LittleEndian" }
    97  
    98  type bigEndian struct{}
    99  
   100  func (bigEndian) Uint16(b []byte) uint16 {
   101  	_ = b[1] // bounds check hint to compiler; see golang.org/issue/14808
   102  	return uint16(b[1]) | uint16(b[0])<<8
   103  }
   104  
   105  func (bigEndian) PutUint16(b []byte, v uint16) {
   106  	_ = b[1] // early bounds check to guarantee safety of writes below
   107  	b[0] = byte(v >> 8)
   108  	b[1] = byte(v)
   109  }
   110  
   111  func (bigEndian) Uint32(b []byte) uint32 {
   112  	_ = b[3] // bounds check hint to compiler; see golang.org/issue/14808
   113  	return uint32(b[3]) | uint32(b[2])<<8 | uint32(b[1])<<16 | uint32(b[0])<<24
   114  }
   115  
   116  func (bigEndian) PutUint32(b []byte, v uint32) {
   117  	_ = b[3] // early bounds check to guarantee safety of writes below
   118  	b[0] = byte(v >> 24)
   119  	b[1] = byte(v >> 16)
   120  	b[2] = byte(v >> 8)
   121  	b[3] = byte(v)
   122  }
   123  
   124  func (bigEndian) Uint64(b []byte) uint64 {
   125  	_ = b[7] // bounds check hint to compiler; see golang.org/issue/14808
   126  	return uint64(b[7]) | uint64(b[6])<<8 | uint64(b[5])<<16 | uint64(b[4])<<24 |
   127  		uint64(b[3])<<32 | uint64(b[2])<<40 | uint64(b[1])<<48 | uint64(b[0])<<56
   128  }
   129  
   130  func (bigEndian) PutUint64(b []byte, v uint64) {
   131  	_ = b[7] // early bounds check to guarantee safety of writes below
   132  	b[0] = byte(v >> 56)
   133  	b[1] = byte(v >> 48)
   134  	b[2] = byte(v >> 40)
   135  	b[3] = byte(v >> 32)
   136  	b[4] = byte(v >> 24)
   137  	b[5] = byte(v >> 16)
   138  	b[6] = byte(v >> 8)
   139  	b[7] = byte(v)
   140  }
   141  
   142  func (bigEndian) String() string { return "BigEndian" }
   143  
   144  func (bigEndian) GoString() string { return "binary.BigEndian" }
   145  
   146  // Read reads structured binary data from r into data.
   147  // Data must be a pointer to a fixed-size value or a slice
   148  // of fixed-size values.
   149  // Bytes read from r are decoded using the specified byte order
   150  // and written to successive fields of the data.
   151  // When decoding boolean values, a zero byte is decoded as false, and
   152  // any other non-zero byte is decoded as true.
   153  // When reading into structs, the field data for fields with
   154  // blank (_) field names is skipped; i.e., blank field names
   155  // may be used for padding.
   156  // When reading into a struct, all non-blank fields must be exported
   157  // or Read may panic.
   158  //
   159  // The error is EOF only if no bytes were read.
   160  // If an EOF happens after reading some but not all the bytes,
   161  // Read returns ErrUnexpectedEOF.
   162  func Read(r io.Reader, order ByteOrder, data interface{}) error {
   163  	// Fast path for basic types and slices.
   164  	if n := intDataSize(data); n != 0 {
   165  		bs := make([]byte, n)
   166  		if _, err := io.ReadFull(r, bs); err != nil {
   167  			return err
   168  		}
   169  		switch data := data.(type) {
   170  		case *bool:
   171  			*data = bs[0] != 0
   172  		case *int8:
   173  			*data = int8(bs[0])
   174  		case *uint8:
   175  			*data = bs[0]
   176  		case *int16:
   177  			*data = int16(order.Uint16(bs))
   178  		case *uint16:
   179  			*data = order.Uint16(bs)
   180  		case *int32:
   181  			*data = int32(order.Uint32(bs))
   182  		case *uint32:
   183  			*data = order.Uint32(bs)
   184  		case *int64:
   185  			*data = int64(order.Uint64(bs))
   186  		case *uint64:
   187  			*data = order.Uint64(bs)
   188  		case *float32:
   189  			*data = math.Float32frombits(order.Uint32(bs))
   190  		case *float64:
   191  			*data = math.Float64frombits(order.Uint64(bs))
   192  		case []bool:
   193  			for i, x := range bs { // Easier to loop over the input for 8-bit values.
   194  				data[i] = x != 0
   195  			}
   196  		case []int8:
   197  			for i, x := range bs {
   198  				data[i] = int8(x)
   199  			}
   200  		case []uint8:
   201  			copy(data, bs)
   202  		case []int16:
   203  			for i := range data {
   204  				data[i] = int16(order.Uint16(bs[2*i:]))
   205  			}
   206  		case []uint16:
   207  			for i := range data {
   208  				data[i] = order.Uint16(bs[2*i:])
   209  			}
   210  		case []int32:
   211  			for i := range data {
   212  				data[i] = int32(order.Uint32(bs[4*i:]))
   213  			}
   214  		case []uint32:
   215  			for i := range data {
   216  				data[i] = order.Uint32(bs[4*i:])
   217  			}
   218  		case []int64:
   219  			for i := range data {
   220  				data[i] = int64(order.Uint64(bs[8*i:]))
   221  			}
   222  		case []uint64:
   223  			for i := range data {
   224  				data[i] = order.Uint64(bs[8*i:])
   225  			}
   226  		case []float32:
   227  			for i := range data {
   228  				data[i] = math.Float32frombits(order.Uint32(bs[4*i:]))
   229  			}
   230  		case []float64:
   231  			for i := range data {
   232  				data[i] = math.Float64frombits(order.Uint64(bs[8*i:]))
   233  			}
   234  		default:
   235  			n = 0 // fast path doesn't apply
   236  		}
   237  		if n != 0 {
   238  			return nil
   239  		}
   240  	}
   241  
   242  	// Fallback to reflect-based decoding.
   243  	v := reflect.ValueOf(data)
   244  	size := -1
   245  	switch v.Kind() {
   246  	case reflect.Ptr:
   247  		v = v.Elem()
   248  		size = dataSize(v)
   249  	case reflect.Slice:
   250  		size = dataSize(v)
   251  	}
   252  	if size < 0 {
   253  		return errors.New("binary.Read: invalid type " + reflect.TypeOf(data).String())
   254  	}
   255  	d := &decoder{order: order, buf: make([]byte, size)}
   256  	if _, err := io.ReadFull(r, d.buf); err != nil {
   257  		return err
   258  	}
   259  	d.value(v)
   260  	return nil
   261  }
   262  
   263  // Write writes the binary representation of data into w.
   264  // Data must be a fixed-size value or a slice of fixed-size
   265  // values, or a pointer to such data.
   266  // Boolean values encode as one byte: 1 for true, and 0 for false.
   267  // Bytes written to w are encoded using the specified byte order
   268  // and read from successive fields of the data.
   269  // When writing structs, zero values are written for fields
   270  // with blank (_) field names.
   271  func Write(w io.Writer, order ByteOrder, data interface{}) error {
   272  	// Fast path for basic types and slices.
   273  	if n := intDataSize(data); n != 0 {
   274  		bs := make([]byte, n)
   275  		switch v := data.(type) {
   276  		case *bool:
   277  			if *v {
   278  				bs[0] = 1
   279  			} else {
   280  				bs[0] = 0
   281  			}
   282  		case bool:
   283  			if v {
   284  				bs[0] = 1
   285  			} else {
   286  				bs[0] = 0
   287  			}
   288  		case []bool:
   289  			for i, x := range v {
   290  				if x {
   291  					bs[i] = 1
   292  				} else {
   293  					bs[i] = 0
   294  				}
   295  			}
   296  		case *int8:
   297  			bs[0] = byte(*v)
   298  		case int8:
   299  			bs[0] = byte(v)
   300  		case []int8:
   301  			for i, x := range v {
   302  				bs[i] = byte(x)
   303  			}
   304  		case *uint8:
   305  			bs[0] = *v
   306  		case uint8:
   307  			bs[0] = v
   308  		case []uint8:
   309  			bs = v // TODO(josharian): avoid allocating bs in this case?
   310  		case *int16:
   311  			order.PutUint16(bs, uint16(*v))
   312  		case int16:
   313  			order.PutUint16(bs, uint16(v))
   314  		case []int16:
   315  			for i, x := range v {
   316  				order.PutUint16(bs[2*i:], uint16(x))
   317  			}
   318  		case *uint16:
   319  			order.PutUint16(bs, *v)
   320  		case uint16:
   321  			order.PutUint16(bs, v)
   322  		case []uint16:
   323  			for i, x := range v {
   324  				order.PutUint16(bs[2*i:], x)
   325  			}
   326  		case *int32:
   327  			order.PutUint32(bs, uint32(*v))
   328  		case int32:
   329  			order.PutUint32(bs, uint32(v))
   330  		case []int32:
   331  			for i, x := range v {
   332  				order.PutUint32(bs[4*i:], uint32(x))
   333  			}
   334  		case *uint32:
   335  			order.PutUint32(bs, *v)
   336  		case uint32:
   337  			order.PutUint32(bs, v)
   338  		case []uint32:
   339  			for i, x := range v {
   340  				order.PutUint32(bs[4*i:], x)
   341  			}
   342  		case *int64:
   343  			order.PutUint64(bs, uint64(*v))
   344  		case int64:
   345  			order.PutUint64(bs, uint64(v))
   346  		case []int64:
   347  			for i, x := range v {
   348  				order.PutUint64(bs[8*i:], uint64(x))
   349  			}
   350  		case *uint64:
   351  			order.PutUint64(bs, *v)
   352  		case uint64:
   353  			order.PutUint64(bs, v)
   354  		case []uint64:
   355  			for i, x := range v {
   356  				order.PutUint64(bs[8*i:], x)
   357  			}
   358  		case *float32:
   359  			order.PutUint32(bs, math.Float32bits(*v))
   360  		case float32:
   361  			order.PutUint32(bs, math.Float32bits(v))
   362  		case []float32:
   363  			for i, x := range v {
   364  				order.PutUint32(bs[4*i:], math.Float32bits(x))
   365  			}
   366  		case *float64:
   367  			order.PutUint64(bs, math.Float64bits(*v))
   368  		case float64:
   369  			order.PutUint64(bs, math.Float64bits(v))
   370  		case []float64:
   371  			for i, x := range v {
   372  				order.PutUint64(bs[8*i:], math.Float64bits(x))
   373  			}
   374  		}
   375  		_, err := w.Write(bs)
   376  		return err
   377  	}
   378  
   379  	// Fallback to reflect-based encoding.
   380  	v := reflect.Indirect(reflect.ValueOf(data))
   381  	size := dataSize(v)
   382  	if size < 0 {
   383  		return errors.New("binary.Write: invalid type " + reflect.TypeOf(data).String())
   384  	}
   385  	buf := make([]byte, size)
   386  	e := &encoder{order: order, buf: buf}
   387  	e.value(v)
   388  	_, err := w.Write(buf)
   389  	return err
   390  }
   391  
   392  // Size returns how many bytes Write would generate to encode the value v, which
   393  // must be a fixed-size value or a slice of fixed-size values, or a pointer to such data.
   394  // If v is neither of these, Size returns -1.
   395  func Size(v interface{}) int {
   396  	return dataSize(reflect.Indirect(reflect.ValueOf(v)))
   397  }
   398  
   399  var structSize sync.Map // map[reflect.Type]int
   400  
   401  // dataSize returns the number of bytes the actual data represented by v occupies in memory.
   402  // For compound structures, it sums the sizes of the elements. Thus, for instance, for a slice
   403  // it returns the length of the slice times the element size and does not count the memory
   404  // occupied by the header. If the type of v is not acceptable, dataSize returns -1.
   405  func dataSize(v reflect.Value) int {
   406  	switch v.Kind() {
   407  	case reflect.Slice:
   408  		if s := sizeof(v.Type().Elem()); s >= 0 {
   409  			return s * v.Len()
   410  		}
   411  		return -1
   412  
   413  	case reflect.Struct:
   414  		t := v.Type()
   415  		if size, ok := structSize.Load(t); ok {
   416  			return size.(int)
   417  		}
   418  		size := sizeof(t)
   419  		structSize.Store(t, size)
   420  		return size
   421  
   422  	default:
   423  		return sizeof(v.Type())
   424  	}
   425  }
   426  
   427  // sizeof returns the size >= 0 of variables for the given type or -1 if the type is not acceptable.
   428  func sizeof(t reflect.Type) int {
   429  	switch t.Kind() {
   430  	case reflect.Array:
   431  		if s := sizeof(t.Elem()); s >= 0 {
   432  			return s * t.Len()
   433  		}
   434  
   435  	case reflect.Struct:
   436  		sum := 0
   437  		for i, n := 0, t.NumField(); i < n; i++ {
   438  			s := sizeof(t.Field(i).Type)
   439  			if s < 0 {
   440  				return -1
   441  			}
   442  			sum += s
   443  		}
   444  		return sum
   445  
   446  	case reflect.Bool,
   447  		reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
   448  		reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
   449  		reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128:
   450  		return int(t.Size())
   451  	}
   452  
   453  	return -1
   454  }
   455  
   456  type coder struct {
   457  	order  ByteOrder
   458  	buf    []byte
   459  	offset int
   460  }
   461  
   462  type decoder coder
   463  type encoder coder
   464  
   465  func (d *decoder) bool() bool {
   466  	x := d.buf[d.offset]
   467  	d.offset++
   468  	return x != 0
   469  }
   470  
   471  func (e *encoder) bool(x bool) {
   472  	if x {
   473  		e.buf[e.offset] = 1
   474  	} else {
   475  		e.buf[e.offset] = 0
   476  	}
   477  	e.offset++
   478  }
   479  
   480  func (d *decoder) uint8() uint8 {
   481  	x := d.buf[d.offset]
   482  	d.offset++
   483  	return x
   484  }
   485  
   486  func (e *encoder) uint8(x uint8) {
   487  	e.buf[e.offset] = x
   488  	e.offset++
   489  }
   490  
   491  func (d *decoder) uint16() uint16 {
   492  	x := d.order.Uint16(d.buf[d.offset : d.offset+2])
   493  	d.offset += 2
   494  	return x
   495  }
   496  
   497  func (e *encoder) uint16(x uint16) {
   498  	e.order.PutUint16(e.buf[e.offset:e.offset+2], x)
   499  	e.offset += 2
   500  }
   501  
   502  func (d *decoder) uint32() uint32 {
   503  	x := d.order.Uint32(d.buf[d.offset : d.offset+4])
   504  	d.offset += 4
   505  	return x
   506  }
   507  
   508  func (e *encoder) uint32(x uint32) {
   509  	e.order.PutUint32(e.buf[e.offset:e.offset+4], x)
   510  	e.offset += 4
   511  }
   512  
   513  func (d *decoder) uint64() uint64 {
   514  	x := d.order.Uint64(d.buf[d.offset : d.offset+8])
   515  	d.offset += 8
   516  	return x
   517  }
   518  
   519  func (e *encoder) uint64(x uint64) {
   520  	e.order.PutUint64(e.buf[e.offset:e.offset+8], x)
   521  	e.offset += 8
   522  }
   523  
   524  func (d *decoder) int8() int8 { return int8(d.uint8()) }
   525  
   526  func (e *encoder) int8(x int8) { e.uint8(uint8(x)) }
   527  
   528  func (d *decoder) int16() int16 { return int16(d.uint16()) }
   529  
   530  func (e *encoder) int16(x int16) { e.uint16(uint16(x)) }
   531  
   532  func (d *decoder) int32() int32 { return int32(d.uint32()) }
   533  
   534  func (e *encoder) int32(x int32) { e.uint32(uint32(x)) }
   535  
   536  func (d *decoder) int64() int64 { return int64(d.uint64()) }
   537  
   538  func (e *encoder) int64(x int64) { e.uint64(uint64(x)) }
   539  
   540  func (d *decoder) value(v reflect.Value) {
   541  	switch v.Kind() {
   542  	case reflect.Array:
   543  		l := v.Len()
   544  		for i := 0; i < l; i++ {
   545  			d.value(v.Index(i))
   546  		}
   547  
   548  	case reflect.Struct:
   549  		t := v.Type()
   550  		l := v.NumField()
   551  		for i := 0; i < l; i++ {
   552  			// Note: Calling v.CanSet() below is an optimization.
   553  			// It would be sufficient to check the field name,
   554  			// but creating the StructField info for each field is
   555  			// costly (run "go test -bench=ReadStruct" and compare
   556  			// results when making changes to this code).
   557  			if v := v.Field(i); v.CanSet() || t.Field(i).Name != "_" {
   558  				d.value(v)
   559  			} else {
   560  				d.skip(v)
   561  			}
   562  		}
   563  
   564  	case reflect.Slice:
   565  		l := v.Len()
   566  		for i := 0; i < l; i++ {
   567  			d.value(v.Index(i))
   568  		}
   569  
   570  	case reflect.Bool:
   571  		v.SetBool(d.bool())
   572  
   573  	case reflect.Int8:
   574  		v.SetInt(int64(d.int8()))
   575  	case reflect.Int16:
   576  		v.SetInt(int64(d.int16()))
   577  	case reflect.Int32:
   578  		v.SetInt(int64(d.int32()))
   579  	case reflect.Int64:
   580  		v.SetInt(d.int64())
   581  
   582  	case reflect.Uint8:
   583  		v.SetUint(uint64(d.uint8()))
   584  	case reflect.Uint16:
   585  		v.SetUint(uint64(d.uint16()))
   586  	case reflect.Uint32:
   587  		v.SetUint(uint64(d.uint32()))
   588  	case reflect.Uint64:
   589  		v.SetUint(d.uint64())
   590  
   591  	case reflect.Float32:
   592  		v.SetFloat(float64(math.Float32frombits(d.uint32())))
   593  	case reflect.Float64:
   594  		v.SetFloat(math.Float64frombits(d.uint64()))
   595  
   596  	case reflect.Complex64:
   597  		v.SetComplex(complex(
   598  			float64(math.Float32frombits(d.uint32())),
   599  			float64(math.Float32frombits(d.uint32())),
   600  		))
   601  	case reflect.Complex128:
   602  		v.SetComplex(complex(
   603  			math.Float64frombits(d.uint64()),
   604  			math.Float64frombits(d.uint64()),
   605  		))
   606  	}
   607  }
   608  
   609  func (e *encoder) value(v reflect.Value) {
   610  	switch v.Kind() {
   611  	case reflect.Array:
   612  		l := v.Len()
   613  		for i := 0; i < l; i++ {
   614  			e.value(v.Index(i))
   615  		}
   616  
   617  	case reflect.Struct:
   618  		t := v.Type()
   619  		l := v.NumField()
   620  		for i := 0; i < l; i++ {
   621  			// see comment for corresponding code in decoder.value()
   622  			if v := v.Field(i); v.CanSet() || t.Field(i).Name != "_" {
   623  				e.value(v)
   624  			} else {
   625  				e.skip(v)
   626  			}
   627  		}
   628  
   629  	case reflect.Slice:
   630  		l := v.Len()
   631  		for i := 0; i < l; i++ {
   632  			e.value(v.Index(i))
   633  		}
   634  
   635  	case reflect.Bool:
   636  		e.bool(v.Bool())
   637  
   638  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   639  		switch v.Type().Kind() {
   640  		case reflect.Int8:
   641  			e.int8(int8(v.Int()))
   642  		case reflect.Int16:
   643  			e.int16(int16(v.Int()))
   644  		case reflect.Int32:
   645  			e.int32(int32(v.Int()))
   646  		case reflect.Int64:
   647  			e.int64(v.Int())
   648  		}
   649  
   650  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   651  		switch v.Type().Kind() {
   652  		case reflect.Uint8:
   653  			e.uint8(uint8(v.Uint()))
   654  		case reflect.Uint16:
   655  			e.uint16(uint16(v.Uint()))
   656  		case reflect.Uint32:
   657  			e.uint32(uint32(v.Uint()))
   658  		case reflect.Uint64:
   659  			e.uint64(v.Uint())
   660  		}
   661  
   662  	case reflect.Float32, reflect.Float64:
   663  		switch v.Type().Kind() {
   664  		case reflect.Float32:
   665  			e.uint32(math.Float32bits(float32(v.Float())))
   666  		case reflect.Float64:
   667  			e.uint64(math.Float64bits(v.Float()))
   668  		}
   669  
   670  	case reflect.Complex64, reflect.Complex128:
   671  		switch v.Type().Kind() {
   672  		case reflect.Complex64:
   673  			x := v.Complex()
   674  			e.uint32(math.Float32bits(float32(real(x))))
   675  			e.uint32(math.Float32bits(float32(imag(x))))
   676  		case reflect.Complex128:
   677  			x := v.Complex()
   678  			e.uint64(math.Float64bits(real(x)))
   679  			e.uint64(math.Float64bits(imag(x)))
   680  		}
   681  	}
   682  }
   683  
   684  func (d *decoder) skip(v reflect.Value) {
   685  	d.offset += dataSize(v)
   686  }
   687  
   688  func (e *encoder) skip(v reflect.Value) {
   689  	n := dataSize(v)
   690  	zero := e.buf[e.offset : e.offset+n]
   691  	for i := range zero {
   692  		zero[i] = 0
   693  	}
   694  	e.offset += n
   695  }
   696  
   697  // intDataSize returns the size of the data required to represent the data when encoded.
   698  // It returns zero if the type cannot be implemented by the fast path in Read or Write.
   699  func intDataSize(data interface{}) int {
   700  	switch data := data.(type) {
   701  	case bool, int8, uint8, *bool, *int8, *uint8:
   702  		return 1
   703  	case []bool:
   704  		return len(data)
   705  	case []int8:
   706  		return len(data)
   707  	case []uint8:
   708  		return len(data)
   709  	case int16, uint16, *int16, *uint16:
   710  		return 2
   711  	case []int16:
   712  		return 2 * len(data)
   713  	case []uint16:
   714  		return 2 * len(data)
   715  	case int32, uint32, *int32, *uint32:
   716  		return 4
   717  	case []int32:
   718  		return 4 * len(data)
   719  	case []uint32:
   720  		return 4 * len(data)
   721  	case int64, uint64, *int64, *uint64:
   722  		return 8
   723  	case []int64:
   724  		return 8 * len(data)
   725  	case []uint64:
   726  		return 8 * len(data)
   727  	case float32, *float32:
   728  		return 4
   729  	case float64, *float64:
   730  		return 8
   731  	case []float32:
   732  		return 4 * len(data)
   733  	case []float64:
   734  		return 8 * len(data)
   735  	}
   736  	return 0
   737  }
   738
View as plain text