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

   1 package msgpack
   2
   3 import (
   4         "fmt"
   5         "reflect"
   6 )
   7
   8 var valueEncoders []encoderFunc
   9
  10 func init() {
  11         valueEncoders = []encoderFunc{
  12                 reflect.Bool:          encodeBoolValue,
  13                 reflect.Int:           encodeInt64CondValue,
  14                 reflect.Int8:          encodeInt8CondValue,
  15                 reflect.Int16:         encodeInt16CondValue,
  16                 reflect.Int32:         encodeInt32CondValue,
  17                 reflect.Int64:         encodeInt64CondValue,
  18                 reflect.Uint:          encodeUint64CondValue,
  19                 reflect.Uint8:         encodeUint8CondValue,
  20                 reflect.Uint16:        encodeUint16CondValue,
  21                 reflect.Uint32:        encodeUint32CondValue,
  22                 reflect.Uint64:        encodeUint64CondValue,
  23                 reflect.Float32:       encodeFloat32Value,
  24                 reflect.Float64:       encodeFloat64Value,
  25                 reflect.Complex64:     encodeUnsupportedValue,
  26                 reflect.Complex128:    encodeUnsupportedValue,
  27                 reflect.Array:         encodeArrayValue,
  28                 reflect.Chan:          encodeUnsupportedValue,
  29                 reflect.Func:          encodeUnsupportedValue,
  30                 reflect.Interface:     encodeInterfaceValue,
  31                 reflect.Map:           encodeMapValue,
  32                 reflect.Ptr:           encodeUnsupportedValue,
  33                 reflect.Slice:         encodeSliceValue,
  34                 reflect.String:        encodeStringValue,
  35                 reflect.Struct:        encodeStructValue,
  36                 reflect.UnsafePointer: encodeUnsupportedValue,
  37         }
  38 }
  39
  40 func getEncoder(typ reflect.Type) encoderFunc {
  41         if encoder, ok := typEncMap[typ]; ok {
  42                 return encoder
  43         }
  44
  45         if typ.Implements(customEncoderType) {
  46                 return encodeCustomValue
  47         }
  48         if typ.Implements(marshalerType) {
  49                 return marshalValue
  50         }
  51
  52         kind := typ.Kind()
  53
  54         // Addressable struct field value.
  55         if kind != reflect.Ptr {
  56                 ptr := reflect.PtrTo(typ)
  57                 if ptr.Implements(customEncoderType) {
  58                         return encodeCustomValuePtr
  59                 }
  60                 if ptr.Implements(marshalerType) {
  61                         return marshalValuePtr
  62                 }
  63         }
  64
  65         if typ == errorType {
  66                 return encodeErrorValue
  67         }
  68
  69         switch kind {
  70         case reflect.Ptr:
  71                 return ptrEncoderFunc(typ)
  72         case reflect.Slice:
  73                 if typ.Elem().Kind() == reflect.Uint8 {
  74                         return encodeByteSliceValue
  75                 }
  76         case reflect.Array:
  77                 if typ.Elem().Kind() == reflect.Uint8 {
  78                         return encodeByteArrayValue
  79                 }
  80         case reflect.Map:
  81                 if typ.Key() == stringType {
  82                         switch typ.Elem() {
  83                         case stringType:
  84                                 return encodeMapStringStringValue
  85                         case interfaceType:
  86                                 return encodeMapStringInterfaceValue
  87                         }
  88                 }
  89         }
  90         return valueEncoders[kind]
  91 }
  92
  93 func ptrEncoderFunc(typ reflect.Type) encoderFunc {
  94         encoder := getEncoder(typ.Elem())
  95         return func(e *Encoder, v reflect.Value) error {
  96                 if v.IsNil() {
  97                         return e.EncodeNil()
  98                 }
  99                 return encoder(e, v.Elem())
 100         }
 101 }
 102
 103 func encodeCustomValuePtr(e *Encoder, v reflect.Value) error {
 104         if !v.CanAddr() {
 105                 return fmt.Errorf("msgpack: Encode(non-addressable %T)", v.Interface())
 106         }
 107         encoder := v.Addr().Interface().(CustomEncoder)
 108         return encoder.EncodeMsgpack(e)
 109 }
 110
 111 func encodeCustomValue(e *Encoder, v reflect.Value) error {
 112         switch v.Kind() {
 113         case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
 114                 if v.IsNil() {
 115                         return e.EncodeNil()
 116                 }
 117         }
 118
 119         encoder := v.Interface().(CustomEncoder)
 120         return encoder.EncodeMsgpack(e)
 121 }
 122
 123 func marshalValuePtr(e *Encoder, v reflect.Value) error {
 124         if !v.CanAddr() {
 125                 return fmt.Errorf("msgpack: Encode(non-addressable %T)", v.Interface())
 126         }
 127         return marshalValue(e, v.Addr())
 128 }
 129
 130 func marshalValue(e *Encoder, v reflect.Value) error {
 131         switch v.Kind() {
 132         case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
 133                 if v.IsNil() {
 134                         return e.EncodeNil()
 135                 }
 136         }
 137
 138         marshaler := v.Interface().(Marshaler)
 139         b, err := marshaler.MarshalMsgpack()
 140         if err != nil {
 141                 return err
 142         }
 143         _, err = e.w.Write(b)
 144         return err
 145 }
 146
 147 func encodeBoolValue(e *Encoder, v reflect.Value) error {
 148         return e.EncodeBool(v.Bool())
 149 }
 150
 151 func encodeInterfaceValue(e *Encoder, v reflect.Value) error {
 152         if v.IsNil() {
 153                 return e.EncodeNil()
 154         }
 155         return e.EncodeValue(v.Elem())
 156 }
 157
 158 func encodeErrorValue(e *Encoder, v reflect.Value) error {
 159         if v.IsNil() {
 160                 return e.EncodeNil()
 161         }
 162         return e.EncodeString(v.Interface().(error).Error())
 163 }
 164
 165 func encodeUnsupportedValue(e *Encoder, v reflect.Value) error {
 166         return fmt.Errorf("msgpack: Encode(unsupported %s)", v.Type())
 167 }