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

   1 package msgpack
   2
   3 import (
   4         "reflect"
   5         "sort"
   6
   7         "github.com/vmihailenco/msgpack/codes"
   8 )
   9
  10 func encodeMapValue(e *Encoder, v reflect.Value) error {
  11         if v.IsNil() {
  12                 return e.EncodeNil()
  13         }
  14
  15         if err := e.EncodeMapLen(v.Len()); err != nil {
  16                 return err
  17         }
  18
  19         for _, key := range v.MapKeys() {
  20                 if err := e.EncodeValue(key); err != nil {
  21                         return err
  22                 }
  23                 if err := e.EncodeValue(v.MapIndex(key)); err != nil {
  24                         return err
  25                 }
  26         }
  27
  28         return nil
  29 }
  30
  31 func encodeMapStringStringValue(e *Encoder, v reflect.Value) error {
  32         if v.IsNil() {
  33                 return e.EncodeNil()
  34         }
  35
  36         if err := e.EncodeMapLen(v.Len()); err != nil {
  37                 return err
  38         }
  39
  40         m := v.Convert(mapStringStringType).Interface().(map[string]string)
  41         if e.sortMapKeys {
  42                 return e.encodeSortedMapStringString(m)
  43         }
  44
  45         for mk, mv := range m {
  46                 if err := e.EncodeString(mk); err != nil {
  47                         return err
  48                 }
  49                 if err := e.EncodeString(mv); err != nil {
  50                         return err
  51                 }
  52         }
  53
  54         return nil
  55 }
  56
  57 func encodeMapStringInterfaceValue(e *Encoder, v reflect.Value) error {
  58         if v.IsNil() {
  59                 return e.EncodeNil()
  60         }
  61
  62         if err := e.EncodeMapLen(v.Len()); err != nil {
  63                 return err
  64         }
  65
  66         m := v.Convert(mapStringInterfaceType).Interface().(map[string]interface{})
  67         if e.sortMapKeys {
  68                 return e.encodeSortedMapStringInterface(m)
  69         }
  70
  71         for mk, mv := range m {
  72                 if err := e.EncodeString(mk); err != nil {
  73                         return err
  74                 }
  75                 if err := e.Encode(mv); err != nil {
  76                         return err
  77                 }
  78         }
  79
  80         return nil
  81 }
  82
  83 func (e *Encoder) encodeSortedMapStringString(m map[string]string) error {
  84         keys := make([]string, 0, len(m))
  85         for k, _ := range m {
  86                 keys = append(keys, k)
  87         }
  88         sort.Strings(keys)
  89
  90         for _, k := range keys {
  91                 err := e.EncodeString(k)
  92                 if err != nil {
  93                         return err
  94                 }
  95                 if err = e.EncodeString(m[k]); err != nil {
  96                         return err
  97                 }
  98         }
  99
 100         return nil
 101 }
 102
 103 func (e *Encoder) encodeSortedMapStringInterface(m map[string]interface{}) error {
 104         keys := make([]string, 0, len(m))
 105         for k, _ := range m {
 106                 keys = append(keys, k)
 107         }
 108         sort.Strings(keys)
 109
 110         for _, k := range keys {
 111                 err := e.EncodeString(k)
 112                 if err != nil {
 113                         return err
 114                 }
 115                 if err = e.Encode(m[k]); err != nil {
 116                         return err
 117                 }
 118         }
 119
 120         return nil
 121 }
 122
 123 func (e *Encoder) EncodeMapLen(l int) error {
 124         if l < 16 {
 125                 return e.writeCode(codes.FixedMapLow | codes.Code(l))
 126         }
 127         if l < 65536 {
 128                 return e.write2(codes.Map16, uint16(l))
 129         }
 130         return e.write4(codes.Map32, uint32(l))
 131 }
 132
 133 func encodeStructValue(e *Encoder, strct reflect.Value) error {
 134         var structFields *fields
 135         if e.useJSONTag {
 136                 structFields = jsonStructs.Fields(strct.Type())
 137         } else {
 138                 structFields = structs.Fields(strct.Type())
 139         }
 140
 141         if e.structAsArray || structFields.AsArray {
 142                 return encodeStructValueAsArray(e, strct, structFields.List)
 143         }
 144         fields := structFields.OmitEmpty(strct)
 145
 146         if err := e.EncodeMapLen(len(fields)); err != nil {
 147                 return err
 148         }
 149
 150         for _, f := range fields {
 151                 if err := e.EncodeString(f.name); err != nil {
 152                         return err
 153                 }
 154                 if err := f.EncodeValue(e, strct); err != nil {
 155                         return err
 156                 }
 157         }
 158
 159         return nil
 160 }
 161
 162 func encodeStructValueAsArray(e *Encoder, strct reflect.Value, fields []*field) error {
 163         if err := e.EncodeArrayLen(len(fields)); err != nil {
 164                 return err
 165         }
 166         for _, f := range fields {
 167                 if err := f.EncodeValue(e, strct); err != nil {
 168                         return err
 169                 }
 170         }
 171         return nil
 172 }