Upgrade to 0.12

1 files changed, 170 insertions, 0 deletions

diff --git a/vendor/github.com/vmihailenco/msgpack/encode.go b/vendor/github.com/vmihailenco/msgpack/encode.go
new file mode 100644
index 0000000..c2bb23c
--- /dev/null
+++ b/vendor/github.com/vmihailenco/msgpack/encode.go
@@ -0,0 +1,170 @@
+package msgpack
+
+import (
+        "bytes"
+        "io"
+        "reflect"
+        "time"
+
+        "github.com/vmihailenco/msgpack/codes"
+)
+
+type writer interface {
+        io.Writer
+        WriteByte(byte) error
+        WriteString(string) (int, error)
+}
+
+type byteWriter struct {
+        io.Writer
+
+        buf       []byte
+        bootstrap [64]byte
+}
+
+func newByteWriter(w io.Writer) *byteWriter {
+        bw := &byteWriter{
+                Writer: w,
+        }
+        bw.buf = bw.bootstrap[:]
+        return bw
+}
+
+func (w *byteWriter) WriteByte(c byte) error {
+        w.buf = w.buf[:1]
+        w.buf[0] = c
+        _, err := w.Write(w.buf)
+        return err
+}
+
+func (w *byteWriter) WriteString(s string) (int, error) {
+        w.buf = append(w.buf[:0], s...)
+        return w.Write(w.buf)
+}
+
+// Marshal returns the MessagePack encoding of v.
+func Marshal(v interface{}) ([]byte, error) {
+        var buf bytes.Buffer
+        err := NewEncoder(&buf).Encode(v)
+        return buf.Bytes(), err
+}
+
+type Encoder struct {
+        w   writer
+        buf []byte
+
+        sortMapKeys   bool
+        structAsArray bool
+        useJSONTag    bool
+        useCompact    bool
+}
+
+// NewEncoder returns a new encoder that writes to w.
+func NewEncoder(w io.Writer) *Encoder {
+        bw, ok := w.(writer)
+        if !ok {
+                bw = newByteWriter(w)
+        }
+        return &Encoder{
+                w:   bw,
+                buf: make([]byte, 9),
+        }
+}
+
+// SortMapKeys causes the Encoder to encode map keys in increasing order.
+// Supported map types are:
+//   - map[string]string
+//   - map[string]interface{}
+func (e *Encoder) SortMapKeys(flag bool) *Encoder {
+        e.sortMapKeys = flag
+        return e
+}
+
+// StructAsArray causes the Encoder to encode Go structs as MessagePack arrays.
+func (e *Encoder) StructAsArray(flag bool) *Encoder {
+        e.structAsArray = flag
+        return e
+}
+
+// UseJSONTag causes the Encoder to use json struct tag as fallback option
+// if there is no msgpack tag.
+func (e *Encoder) UseJSONTag(flag bool) *Encoder {
+        e.useJSONTag = flag
+        return e
+}
+
+// UseCompactEncoding causes the Encoder to chose the most compact encoding.
+// For example, it allows to encode Go int64 as msgpack int8 saving 7 bytes.
+func (e *Encoder) UseCompactEncoding(flag bool) *Encoder {
+        e.useCompact = flag
+        return e
+}
+
+func (e *Encoder) Encode(v interface{}) error {
+        switch v := v.(type) {
+        case nil:
+                return e.EncodeNil()
+        case string:
+                return e.EncodeString(v)
+        case []byte:
+                return e.EncodeBytes(v)
+        case int:
+                return e.encodeInt64Cond(int64(v))
+        case int64:
+                return e.encodeInt64Cond(v)
+        case uint:
+                return e.encodeUint64Cond(uint64(v))
+        case uint64:
+                return e.encodeUint64Cond(v)
+        case bool:
+                return e.EncodeBool(v)
+        case float32:
+                return e.EncodeFloat32(v)
+        case float64:
+                return e.EncodeFloat64(v)
+        case time.Duration:
+                return e.encodeInt64Cond(int64(v))
+        case time.Time:
+                return e.EncodeTime(v)
+        }
+        return e.EncodeValue(reflect.ValueOf(v))
+}
+
+func (e *Encoder) EncodeMulti(v ...interface{}) error {
+        for _, vv := range v {
+                if err := e.Encode(vv); err != nil {
+                        return err
+                }
+        }
+        return nil
+}
+
+func (e *Encoder) EncodeValue(v reflect.Value) error {
+        fn := getEncoder(v.Type())
+        return fn(e, v)
+}
+
+func (e *Encoder) EncodeNil() error {
+        return e.writeCode(codes.Nil)
+}
+
+func (e *Encoder) EncodeBool(value bool) error {
+        if value {
+                return e.writeCode(codes.True)
+        }
+        return e.writeCode(codes.False)
+}
+
+func (e *Encoder) writeCode(c codes.Code) error {
+        return e.w.WriteByte(byte(c))
+}
+
+func (e *Encoder) write(b []byte) error {
+        _, err := e.w.Write(b)
+        return err
+}
+
+func (e *Encoder) writeString(s string) error {
+        _, err := e.w.WriteString(s)
+        return err
+}