1 files changed, 310 insertions, 0 deletions

diff --git a/vendor/github.com/vmihailenco/msgpack/types.go b/vendor/github.com/vmihailenco/msgpack/types.go
new file mode 100644
index 0000000..6a1bf7f
--- /dev/null
+++ b/vendor/github.com/vmihailenco/msgpack/types.go
@@ -0,0 +1,310 @@
+package msgpack
+
+import (
+        "reflect"
+        "sync"
+)
+
+var errorType = reflect.TypeOf((*error)(nil)).Elem()
+
+var customEncoderType = reflect.TypeOf((*CustomEncoder)(nil)).Elem()
+var customDecoderType = reflect.TypeOf((*CustomDecoder)(nil)).Elem()
+
+var marshalerType = reflect.TypeOf((*Marshaler)(nil)).Elem()
+var unmarshalerType = reflect.TypeOf((*Unmarshaler)(nil)).Elem()
+
+type encoderFunc func(*Encoder, reflect.Value) error
+type decoderFunc func(*Decoder, reflect.Value) error
+
+var typEncMap = make(map[reflect.Type]encoderFunc)
+var typDecMap = make(map[reflect.Type]decoderFunc)
+
+// Register registers encoder and decoder functions for a value.
+// This is low level API and in most cases you should prefer implementing
+// Marshaler/CustomEncoder and Unmarshaler/CustomDecoder interfaces.
+func Register(value interface{}, enc encoderFunc, dec decoderFunc) {
+        typ := reflect.TypeOf(value)
+        if enc != nil {
+                typEncMap[typ] = enc
+        }
+        if dec != nil {
+                typDecMap[typ] = dec
+        }
+}
+
+//------------------------------------------------------------------------------
+
+var structs = newStructCache(false)
+var jsonStructs = newStructCache(true)
+
+type structCache struct {
+        mu sync.RWMutex
+        m  map[reflect.Type]*fields
+
+        useJSONTag bool
+}
+
+func newStructCache(useJSONTag bool) *structCache {
+        return &structCache{
+                m: make(map[reflect.Type]*fields),
+
+                useJSONTag: useJSONTag,
+        }
+}
+
+func (m *structCache) Fields(typ reflect.Type) *fields {
+        m.mu.RLock()
+        fs, ok := m.m[typ]
+        m.mu.RUnlock()
+        if ok {
+                return fs
+        }
+
+        m.mu.Lock()
+        fs, ok = m.m[typ]
+        if !ok {
+                fs = getFields(typ, m.useJSONTag)
+                m.m[typ] = fs
+        }
+        m.mu.Unlock()
+
+        return fs
+}
+
+//------------------------------------------------------------------------------
+
+type field struct {
+        name      string
+        index     []int
+        omitEmpty bool
+        encoder   encoderFunc
+        decoder   decoderFunc
+}
+
+func (f *field) value(v reflect.Value) reflect.Value {
+        return fieldByIndex(v, f.index)
+}
+
+func (f *field) Omit(strct reflect.Value) bool {
+        return f.omitEmpty && isEmptyValue(f.value(strct))
+}
+
+func (f *field) EncodeValue(e *Encoder, strct reflect.Value) error {
+        return f.encoder(e, f.value(strct))
+}
+
+func (f *field) DecodeValue(d *Decoder, strct reflect.Value) error {
+        return f.decoder(d, f.value(strct))
+}
+
+//------------------------------------------------------------------------------
+
+type fields struct {
+        Table   map[string]*field
+        List    []*field
+        AsArray bool
+
+        hasOmitEmpty bool
+}
+
+func newFields(numField int) *fields {
+        return &fields{
+                Table: make(map[string]*field, numField),
+                List:  make([]*field, 0, numField),
+        }
+}
+
+func (fs *fields) Add(field *field) {
+        fs.Table[field.name] = field
+        fs.List = append(fs.List, field)
+        if field.omitEmpty {
+                fs.hasOmitEmpty = true
+        }
+}
+
+func (fs *fields) OmitEmpty(strct reflect.Value) []*field {
+        if !fs.hasOmitEmpty {
+                return fs.List
+        }
+
+        fields := make([]*field, 0, len(fs.List))
+        for _, f := range fs.List {
+                if !f.Omit(strct) {
+                        fields = append(fields, f)
+                }
+        }
+        return fields
+}
+
+func getFields(typ reflect.Type, useJSONTag bool) *fields {
+        numField := typ.NumField()
+        fs := newFields(numField)
+
+        var omitEmpty bool
+        for i := 0; i < numField; i++ {
+                f := typ.Field(i)
+
+                tag := f.Tag.Get("msgpack")
+                if useJSONTag && tag == "" {
+                        tag = f.Tag.Get("json")
+                }
+
+                name, opt := parseTag(tag)
+                if name == "-" {
+                        continue
+                }
+
+                if f.Name == "_msgpack" {
+                        if opt.Contains("asArray") {
+                                fs.AsArray = true
+                        }
+                        if opt.Contains("omitempty") {
+                                omitEmpty = true
+                        }
+                }
+
+                if f.PkgPath != "" && !f.Anonymous {
+                        continue
+                }
+
+                field := &field{
+                        name:      name,
+                        index:     f.Index,
+                        omitEmpty: omitEmpty || opt.Contains("omitempty"),
+                        encoder:   getEncoder(f.Type),
+                        decoder:   getDecoder(f.Type),
+                }
+
+                if field.name == "" {
+                        field.name = f.Name
+                }
+
+                if f.Anonymous && !opt.Contains("noinline") {
+                        inline := opt.Contains("inline")
+                        if inline {
+                                inlineFields(fs, f.Type, field, useJSONTag)
+                        } else {
+                                inline = autoinlineFields(fs, f.Type, field, useJSONTag)
+                        }
+                        if inline {
+                                fs.Table[field.name] = field
+                                continue
+                        }
+                }
+
+                fs.Add(field)
+        }
+        return fs
+}
+
+var encodeStructValuePtr uintptr
+var decodeStructValuePtr uintptr
+
+func init() {
+        encodeStructValuePtr = reflect.ValueOf(encodeStructValue).Pointer()
+        decodeStructValuePtr = reflect.ValueOf(decodeStructValue).Pointer()
+}
+
+func inlineFields(fs *fields, typ reflect.Type, f *field, useJSONTag bool) {
+        inlinedFields := getFields(typ, useJSONTag).List
+        for _, field := range inlinedFields {
+                if _, ok := fs.Table[field.name]; ok {
+                        // Don't inline shadowed fields.
+                        continue
+                }
+                field.index = append(f.index, field.index...)
+                fs.Add(field)
+        }
+}
+
+func autoinlineFields(fs *fields, typ reflect.Type, f *field, useJSONTag bool) bool {
+        var encoder encoderFunc
+        var decoder decoderFunc
+
+        if typ.Kind() == reflect.Struct {
+                encoder = f.encoder
+                decoder = f.decoder
+        } else {
+                for typ.Kind() == reflect.Ptr {
+                        typ = typ.Elem()
+                        encoder = getEncoder(typ)
+                        decoder = getDecoder(typ)
+                }
+                if typ.Kind() != reflect.Struct {
+                        return false
+                }
+        }
+
+        if reflect.ValueOf(encoder).Pointer() != encodeStructValuePtr {
+                return false
+        }
+        if reflect.ValueOf(decoder).Pointer() != decodeStructValuePtr {
+                return false
+        }
+
+        inlinedFields := getFields(typ, useJSONTag).List
+        for _, field := range inlinedFields {
+                if _, ok := fs.Table[field.name]; ok {
+                        // Don't auto inline if there are shadowed fields.
+                        return false
+                }
+        }
+
+        for _, field := range inlinedFields {
+                field.index = append(f.index, field.index...)
+                fs.Add(field)
+        }
+        return true
+}
+
+func isEmptyValue(v reflect.Value) bool {
+        switch v.Kind() {
+        case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
+                return v.Len() == 0
+        case reflect.Bool:
+                return !v.Bool()
+        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                return v.Int() == 0
+        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+                return v.Uint() == 0
+        case reflect.Float32, reflect.Float64:
+                return v.Float() == 0
+        case reflect.Interface, reflect.Ptr:
+                return v.IsNil()
+        }
+        return false
+}
+
+func fieldByIndex(v reflect.Value, index []int) reflect.Value {
+        if len(index) == 1 {
+                return v.Field(index[0])
+        }
+        for i, x := range index {
+                if i > 0 {
+                        var ok bool
+                        v, ok = indirectNew(v)
+                        if !ok {
+                                return v
+                        }
+                }
+                v = v.Field(x)
+        }
+        return v
+}
+
+func indirectNew(v reflect.Value) (reflect.Value, bool) {
+        if v.Kind() == reflect.Ptr {
+                if v.IsNil() {
+                        if !v.CanSet() {
+                                return v, false
+                        }
+                        elemType := v.Type().Elem()
+                        if elemType.Kind() != reflect.Struct {
+                                return v, false
+                        }
+                        v.Set(reflect.New(elemType))
+                }
+                v = v.Elem()
+        }
+        return v, true
+}