Vendor temporarily
This commit is contained in:
1 parent
dd8e532d18
commit
1c02ed9115
4708 files changed
+1226392
-12
No files matched your search
+546
@@ -0,0 +1,546 @@
|
||||
package msgpack
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"bytes"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"reflect"
|
||||
"time"
|
||||
|
||||
"github.com/vmihailenco/msgpack/codes"
|
||||
)
|
||||
|
||||
const bytesAllocLimit = 1024 * 1024 // 1mb
|
||||
|
||||
type bufReader interface {
|
||||
io.Reader
|
||||
io.ByteScanner
|
||||
}
|
||||
|
||||
func newBufReader(r io.Reader) bufReader {
|
||||
if br, ok := r.(bufReader); ok {
|
||||
return br
|
||||
}
|
||||
return bufio.NewReader(r)
|
||||
}
|
||||
|
||||
func makeBuffer() []byte {
|
||||
return make([]byte, 0, 64)
|
||||
}
|
||||
|
||||
// Unmarshal decodes the MessagePack-encoded data and stores the result
|
||||
// in the value pointed to by v.
|
||||
func Unmarshal(data []byte, v interface{}) error {
|
||||
return NewDecoder(bytes.NewReader(data)).Decode(v)
|
||||
}
|
||||
|
||||
type Decoder struct {
|
||||
r io.Reader
|
||||
s io.ByteScanner
|
||||
buf []byte
|
||||
|
||||
extLen int
|
||||
rec []byte // accumulates read data if not nil
|
||||
|
||||
useLoose bool
|
||||
useJSONTag bool
|
||||
|
||||
decodeMapFunc func(*Decoder) (interface{}, error)
|
||||
}
|
||||
|
||||
// NewDecoder returns a new decoder that reads from r.
|
||||
//
|
||||
// The decoder introduces its own buffering and may read data from r
|
||||
// beyond the MessagePack values requested. Buffering can be disabled
|
||||
// by passing a reader that implements io.ByteScanner interface.
|
||||
func NewDecoder(r io.Reader) *Decoder {
|
||||
d := &Decoder{
|
||||
buf: makeBuffer(),
|
||||
}
|
||||
d.resetReader(r)
|
||||
return d
|
||||
}
|
||||
|
||||
func (d *Decoder) SetDecodeMapFunc(fn func(*Decoder) (interface{}, error)) {
|
||||
d.decodeMapFunc = fn
|
||||
}
|
||||
|
||||
// UseDecodeInterfaceLoose causes decoder to use DecodeInterfaceLoose
|
||||
// to decode msgpack value into Go interface{}.
|
||||
func (d *Decoder) UseDecodeInterfaceLoose(flag bool) {
|
||||
d.useLoose = flag
|
||||
}
|
||||
|
||||
// UseJSONTag causes the Decoder to use json struct tag as fallback option
|
||||
// if there is no msgpack tag.
|
||||
func (d *Decoder) UseJSONTag(v bool) *Decoder {
|
||||
d.useJSONTag = v
|
||||
return d
|
||||
}
|
||||
|
||||
func (d *Decoder) Reset(r io.Reader) error {
|
||||
d.resetReader(r)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (d *Decoder) resetReader(r io.Reader) {
|
||||
reader := newBufReader(r)
|
||||
d.r = reader
|
||||
d.s = reader
|
||||
}
|
||||
|
||||
func (d *Decoder) Decode(v interface{}) error {
|
||||
var err error
|
||||
switch v := v.(type) {
|
||||
case *string:
|
||||
if v != nil {
|
||||
*v, err = d.DecodeString()
|
||||
return err
|
||||
}
|
||||
case *[]byte:
|
||||
if v != nil {
|
||||
return d.decodeBytesPtr(v)
|
||||
}
|
||||
case *int:
|
||||
if v != nil {
|
||||
*v, err = d.DecodeInt()
|
||||
return err
|
||||
}
|
||||
case *int8:
|
||||
if v != nil {
|
||||
*v, err = d.DecodeInt8()
|
||||
return err
|
||||
}
|
||||
case *int16:
|
||||
if v != nil {
|
||||
*v, err = d.DecodeInt16()
|
||||
return err
|
||||
}
|
||||
case *int32:
|
||||
if v != nil {
|
||||
*v, err = d.DecodeInt32()
|
||||
return err
|
||||
}
|
||||
case *int64:
|
||||
if v != nil {
|
||||
*v, err = d.DecodeInt64()
|
||||
return err
|
||||
}
|
||||
case *uint:
|
||||
if v != nil {
|
||||
*v, err = d.DecodeUint()
|
||||
return err
|
||||
}
|
||||
case *uint8:
|
||||
if v != nil {
|
||||
*v, err = d.DecodeUint8()
|
||||
return err
|
||||
}
|
||||
case *uint16:
|
||||
if v != nil {
|
||||
*v, err = d.DecodeUint16()
|
||||
return err
|
||||
}
|
||||
case *uint32:
|
||||
if v != nil {
|
||||
*v, err = d.DecodeUint32()
|
||||
return err
|
||||
}
|
||||
case *uint64:
|
||||
if v != nil {
|
||||
*v, err = d.DecodeUint64()
|
||||
return err
|
||||
}
|
||||
case *bool:
|
||||
if v != nil {
|
||||
*v, err = d.DecodeBool()
|
||||
return err
|
||||
}
|
||||
case *float32:
|
||||
if v != nil {
|
||||
*v, err = d.DecodeFloat32()
|
||||
return err
|
||||
}
|
||||
case *float64:
|
||||
if v != nil {
|
||||
*v, err = d.DecodeFloat64()
|
||||
return err
|
||||
}
|
||||
case *[]string:
|
||||
return d.decodeStringSlicePtr(v)
|
||||
case *map[string]string:
|
||||
return d.decodeMapStringStringPtr(v)
|
||||
case *map[string]interface{}:
|
||||
return d.decodeMapStringInterfacePtr(v)
|
||||
case *time.Duration:
|
||||
if v != nil {
|
||||
vv, err := d.DecodeInt64()
|
||||
*v = time.Duration(vv)
|
||||
return err
|
||||
}
|
||||
case *time.Time:
|
||||
if v != nil {
|
||||
*v, err = d.DecodeTime()
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
vv := reflect.ValueOf(v)
|
||||
if !vv.IsValid() {
|
||||
return errors.New("msgpack: Decode(nil)")
|
||||
}
|
||||
if vv.Kind() != reflect.Ptr {
|
||||
return fmt.Errorf("msgpack: Decode(nonsettable %T)", v)
|
||||
}
|
||||
vv = vv.Elem()
|
||||
if !vv.IsValid() {
|
||||
return fmt.Errorf("msgpack: Decode(nonsettable %T)", v)
|
||||
}
|
||||
return d.DecodeValue(vv)
|
||||
}
|
||||
|
||||
func (d *Decoder) DecodeMulti(v ...interface{}) error {
|
||||
for _, vv := range v {
|
||||
if err := d.Decode(vv); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (d *Decoder) decodeInterfaceCond() (interface{}, error) {
|
||||
if d.useLoose {
|
||||
return d.DecodeInterfaceLoose()
|
||||
}
|
||||
return d.DecodeInterface()
|
||||
}
|
||||
|
||||
func (d *Decoder) DecodeValue(v reflect.Value) error {
|
||||
decode := getDecoder(v.Type())
|
||||
return decode(d, v)
|
||||
}
|
||||
|
||||
func (d *Decoder) DecodeNil() error {
|
||||
c, err := d.readCode()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if c != codes.Nil {
|
||||
return fmt.Errorf("msgpack: invalid code=%x decoding nil", c)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (d *Decoder) decodeNilValue(v reflect.Value) error {
|
||||
err := d.DecodeNil()
|
||||
if v.IsNil() {
|
||||
return err
|
||||
}
|
||||
if v.Kind() == reflect.Ptr {
|
||||
v = v.Elem()
|
||||
}
|
||||
v.Set(reflect.Zero(v.Type()))
|
||||
return err
|
||||
}
|
||||
|
||||
func (d *Decoder) DecodeBool() (bool, error) {
|
||||
c, err := d.readCode()
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
return d.bool(c)
|
||||
}
|
||||
|
||||
func (d *Decoder) bool(c codes.Code) (bool, error) {
|
||||
if c == codes.False {
|
||||
return false, nil
|
||||
}
|
||||
if c == codes.True {
|
||||
return true, nil
|
||||
}
|
||||
return false, fmt.Errorf("msgpack: invalid code=%x decoding bool", c)
|
||||
}
|
||||
|
||||
// DecodeInterface decodes value into interface. It returns following types:
|
||||
// - nil,
|
||||
// - bool,
|
||||
// - int8, int16, int32, int64,
|
||||
// - uint8, uint16, uint32, uint64,
|
||||
// - float32 and float64,
|
||||
// - string,
|
||||
// - []byte,
|
||||
// - slices of any of the above,
|
||||
// - maps of any of the above.
|
||||
//
|
||||
// DecodeInterface should be used only when you don't know the type of value
|
||||
// you are decoding. For example, if you are decoding number it is better to use
|
||||
// DecodeInt64 for negative numbers and DecodeUint64 for positive numbers.
|
||||
func (d *Decoder) DecodeInterface() (interface{}, error) {
|
||||
c, err := d.readCode()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if codes.IsFixedNum(c) {
|
||||
return int8(c), nil
|
||||
}
|
||||
if codes.IsFixedMap(c) {
|
||||
err = d.s.UnreadByte()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return d.DecodeMap()
|
||||
}
|
||||
if codes.IsFixedArray(c) {
|
||||
return d.decodeSlice(c)
|
||||
}
|
||||
if codes.IsFixedString(c) {
|
||||
return d.string(c)
|
||||
}
|
||||
|
||||
switch c {
|
||||
case codes.Nil:
|
||||
return nil, nil
|
||||
case codes.False, codes.True:
|
||||
return d.bool(c)
|
||||
case codes.Float:
|
||||
return d.float32(c)
|
||||
case codes.Double:
|
||||
return d.float64(c)
|
||||
case codes.Uint8:
|
||||
return d.uint8()
|
||||
case codes.Uint16:
|
||||
return d.uint16()
|
||||
case codes.Uint32:
|
||||
return d.uint32()
|
||||
case codes.Uint64:
|
||||
return d.uint64()
|
||||
case codes.Int8:
|
||||
return d.int8()
|
||||
case codes.Int16:
|
||||
return d.int16()
|
||||
case codes.Int32:
|
||||
return d.int32()
|
||||
case codes.Int64:
|
||||
return d.int64()
|
||||
case codes.Bin8, codes.Bin16, codes.Bin32:
|
||||
return d.bytes(c, nil)
|
||||
case codes.Str8, codes.Str16, codes.Str32:
|
||||
return d.string(c)
|
||||
case codes.Array16, codes.Array32:
|
||||
return d.decodeSlice(c)
|
||||
case codes.Map16, codes.Map32:
|
||||
err = d.s.UnreadByte()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return d.DecodeMap()
|
||||
case codes.FixExt1, codes.FixExt2, codes.FixExt4, codes.FixExt8, codes.FixExt16,
|
||||
codes.Ext8, codes.Ext16, codes.Ext32:
|
||||
return d.extInterface(c)
|
||||
}
|
||||
|
||||
return 0, fmt.Errorf("msgpack: unknown code %x decoding interface{}", c)
|
||||
}
|
||||
|
||||
// DecodeInterfaceLoose is like DecodeInterface except that:
|
||||
// - int8, int16, and int32 are converted to int64,
|
||||
// - uint8, uint16, and uint32 are converted to uint64,
|
||||
// - float32 is converted to float64.
|
||||
func (d *Decoder) DecodeInterfaceLoose() (interface{}, error) {
|
||||
c, err := d.readCode()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if codes.IsFixedNum(c) {
|
||||
return int64(c), nil
|
||||
}
|
||||
if codes.IsFixedMap(c) {
|
||||
err = d.s.UnreadByte()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return d.DecodeMap()
|
||||
}
|
||||
if codes.IsFixedArray(c) {
|
||||
return d.decodeSlice(c)
|
||||
}
|
||||
if codes.IsFixedString(c) {
|
||||
return d.string(c)
|
||||
}
|
||||
|
||||
switch c {
|
||||
case codes.Nil:
|
||||
return nil, nil
|
||||
case codes.False, codes.True:
|
||||
return d.bool(c)
|
||||
case codes.Float, codes.Double:
|
||||
return d.float64(c)
|
||||
case codes.Uint8, codes.Uint16, codes.Uint32, codes.Uint64:
|
||||
return d.uint(c)
|
||||
case codes.Int8, codes.Int16, codes.Int32, codes.Int64:
|
||||
return d.int(c)
|
||||
case codes.Bin8, codes.Bin16, codes.Bin32:
|
||||
return d.bytes(c, nil)
|
||||
case codes.Str8, codes.Str16, codes.Str32:
|
||||
return d.string(c)
|
||||
case codes.Array16, codes.Array32:
|
||||
return d.decodeSlice(c)
|
||||
case codes.Map16, codes.Map32:
|
||||
err = d.s.UnreadByte()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return d.DecodeMap()
|
||||
case codes.FixExt1, codes.FixExt2, codes.FixExt4, codes.FixExt8, codes.FixExt16,
|
||||
codes.Ext8, codes.Ext16, codes.Ext32:
|
||||
return d.extInterface(c)
|
||||
}
|
||||
|
||||
return 0, fmt.Errorf("msgpack: unknown code %x decoding interface{}", c)
|
||||
}
|
||||
|
||||
// Skip skips next value.
|
||||
func (d *Decoder) Skip() error {
|
||||
c, err := d.readCode()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if codes.IsFixedNum(c) {
|
||||
return nil
|
||||
} else if codes.IsFixedMap(c) {
|
||||
return d.skipMap(c)
|
||||
} else if codes.IsFixedArray(c) {
|
||||
return d.skipSlice(c)
|
||||
} else if codes.IsFixedString(c) {
|
||||
return d.skipBytes(c)
|
||||
}
|
||||
|
||||
switch c {
|
||||
case codes.Nil, codes.False, codes.True:
|
||||
return nil
|
||||
case codes.Uint8, codes.Int8:
|
||||
return d.skipN(1)
|
||||
case codes.Uint16, codes.Int16:
|
||||
return d.skipN(2)
|
||||
case codes.Uint32, codes.Int32, codes.Float:
|
||||
return d.skipN(4)
|
||||
case codes.Uint64, codes.Int64, codes.Double:
|
||||
return d.skipN(8)
|
||||
case codes.Bin8, codes.Bin16, codes.Bin32:
|
||||
return d.skipBytes(c)
|
||||
case codes.Str8, codes.Str16, codes.Str32:
|
||||
return d.skipBytes(c)
|
||||
case codes.Array16, codes.Array32:
|
||||
return d.skipSlice(c)
|
||||
case codes.Map16, codes.Map32:
|
||||
return d.skipMap(c)
|
||||
case codes.FixExt1, codes.FixExt2, codes.FixExt4, codes.FixExt8, codes.FixExt16,
|
||||
codes.Ext8, codes.Ext16, codes.Ext32:
|
||||
return d.skipExt(c)
|
||||
}
|
||||
|
||||
return fmt.Errorf("msgpack: unknown code %x", c)
|
||||
}
|
||||
|
||||
// PeekCode returns the next MessagePack code without advancing the reader.
|
||||
// Subpackage msgpack/codes contains list of available codes.
|
||||
func (d *Decoder) PeekCode() (codes.Code, error) {
|
||||
c, err := d.s.ReadByte()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return codes.Code(c), d.s.UnreadByte()
|
||||
}
|
||||
|
||||
func (d *Decoder) hasNilCode() bool {
|
||||
code, err := d.PeekCode()
|
||||
return err == nil && code == codes.Nil
|
||||
}
|
||||
|
||||
func (d *Decoder) readCode() (codes.Code, error) {
|
||||
d.extLen = 0
|
||||
c, err := d.s.ReadByte()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if d.rec != nil {
|
||||
d.rec = append(d.rec, c)
|
||||
}
|
||||
return codes.Code(c), nil
|
||||
}
|
||||
|
||||
func (d *Decoder) readFull(b []byte) error {
|
||||
_, err := io.ReadFull(d.r, b)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if d.rec != nil {
|
||||
d.rec = append(d.rec, b...)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (d *Decoder) readN(n int) ([]byte, error) {
|
||||
buf, err := readN(d.r, d.buf, n)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
d.buf = buf
|
||||
if d.rec != nil {
|
||||
d.rec = append(d.rec, buf...)
|
||||
}
|
||||
return buf, nil
|
||||
}
|
||||
|
||||
func readN(r io.Reader, b []byte, n int) ([]byte, error) {
|
||||
if b == nil {
|
||||
if n == 0 {
|
||||
return make([]byte, 0), nil
|
||||
}
|
||||
if n <= bytesAllocLimit {
|
||||
b = make([]byte, n)
|
||||
} else {
|
||||
b = make([]byte, bytesAllocLimit)
|
||||
}
|
||||
}
|
||||
|
||||
if n <= cap(b) {
|
||||
b = b[:n]
|
||||
_, err := io.ReadFull(r, b)
|
||||
return b, err
|
||||
}
|
||||
b = b[:cap(b)]
|
||||
|
||||
var pos int
|
||||
for {
|
||||
alloc := n - len(b)
|
||||
if alloc > bytesAllocLimit {
|
||||
alloc = bytesAllocLimit
|
||||
}
|
||||
b = append(b, make([]byte, alloc)...)
|
||||
|
||||
_, err := io.ReadFull(r, b[pos:])
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if len(b) == n {
|
||||
break
|
||||
}
|
||||
pos = len(b)
|
||||
}
|
||||
|
||||
return b, nil
|
||||
}
|
||||
|
||||
func min(a, b int) int {
|
||||
if a <= b {
|
||||
return a
|
||||
}
|
||||
return b
|
||||
}
|
||||
Reference in new issue
Block a user