vendor/github.com/vmihailenco/msgpack/encode_slice.go

   1 package msgpack
   2
   3 import (
   4         "reflect"
   5
   6         "github.com/vmihailenco/msgpack/codes"
   7 )
   8
   9 func encodeStringValue(e *Encoder, v reflect.Value) error {
  10         return e.EncodeString(v.String())
  11 }
  12
  13 func encodeByteSliceValue(e *Encoder, v reflect.Value) error {
  14         return e.EncodeBytes(v.Bytes())
  15 }
  16
  17 func encodeByteArrayValue(e *Encoder, v reflect.Value) error {
  18         if err := e.EncodeBytesLen(v.Len()); err != nil {
  19                 return err
  20         }
  21
  22         if v.CanAddr() {
  23                 b := v.Slice(0, v.Len()).Bytes()
  24                 return e.write(b)
  25         }
  26
  27         e.buf = grow(e.buf, v.Len())
  28         reflect.Copy(reflect.ValueOf(e.buf), v)
  29         return e.write(e.buf)
  30 }
  31
  32 func grow(b []byte, n int) []byte {
  33         if cap(b) >= n {
  34                 return b[:n]
  35         }
  36         b = b[:cap(b)]
  37         b = append(b, make([]byte, n-len(b))...)
  38         return b
  39 }
  40
  41 func (e *Encoder) EncodeBytesLen(l int) error {
  42         if l < 256 {
  43                 return e.write1(codes.Bin8, uint8(l))
  44         }
  45         if l < 65536 {
  46                 return e.write2(codes.Bin16, uint16(l))
  47         }
  48         return e.write4(codes.Bin32, uint32(l))
  49 }
  50
  51 func (e *Encoder) encodeStrLen(l int) error {
  52         if l < 32 {
  53                 return e.writeCode(codes.FixedStrLow | codes.Code(l))
  54         }
  55         if l < 256 {
  56                 return e.write1(codes.Str8, uint8(l))
  57         }
  58         if l < 65536 {
  59                 return e.write2(codes.Str16, uint16(l))
  60         }
  61         return e.write4(codes.Str32, uint32(l))
  62 }
  63
  64 func (e *Encoder) EncodeString(v string) error {
  65         if err := e.encodeStrLen(len(v)); err != nil {
  66                 return err
  67         }
  68         return e.writeString(v)
  69 }
  70
  71 func (e *Encoder) EncodeBytes(v []byte) error {
  72         if v == nil {
  73                 return e.EncodeNil()
  74         }
  75         if err := e.EncodeBytesLen(len(v)); err != nil {
  76                 return err
  77         }
  78         return e.write(v)
  79 }
  80
  81 func (e *Encoder) EncodeArrayLen(l int) error {
  82         if l < 16 {
  83                 return e.writeCode(codes.FixedArrayLow | codes.Code(l))
  84         }
  85         if l < 65536 {
  86                 return e.write2(codes.Array16, uint16(l))
  87         }
  88         return e.write4(codes.Array32, uint32(l))
  89 }
  90
  91 func (e *Encoder) encodeStringSlice(s []string) error {
  92         if s == nil {
  93                 return e.EncodeNil()
  94         }
  95         if err := e.EncodeArrayLen(len(s)); err != nil {
  96                 return err
  97         }
  98         for _, v := range s {
  99                 if err := e.EncodeString(v); err != nil {
 100                         return err
 101                 }
 102         }
 103         return nil
 104 }
 105
 106 func encodeSliceValue(e *Encoder, v reflect.Value) error {
 107         if v.IsNil() {
 108                 return e.EncodeNil()
 109         }
 110         return encodeArrayValue(e, v)
 111 }
 112
 113 func encodeArrayValue(e *Encoder, v reflect.Value) error {
 114         l := v.Len()
 115         if err := e.EncodeArrayLen(l); err != nil {
 116                 return err
 117         }
 118         for i := 0; i < l; i++ {
 119                 if err := e.EncodeValue(v.Index(i)); err != nil {
 120                         return err
 121                 }
 122         }
 123         return nil
 124 }