msgpack-go

Message Pack Encoder/Decoder for Golang
git clone git://git.lair.cx/msgpack-go
Log | Files | Refs | LICENSE

decode.go (2445B)

      1 package msgpack
      2 
      3 import (
      4 	"io"
      5 )
      6 
      7 func Unmarshal(p []byte, v interface{}) error {
      8 	return NewDecoder(nil, p).Decode(v)
      9 }
     10 
     11 type Decoder struct {
     12 	r      io.Reader
     13 	buf    []byte
     14 	length int
     15 	cursor int
     16 	err    error
     17 }
     18 
     19 // NewDecoder returns a new decoder instance.
     20 //
     21 // Decoder takes reader and buffer.
     22 // r can be nil. when r is nil, decoder uses buf as data source.
     23 //
     24 // It panics when both r and buf are nil.
     25 func NewDecoder(r io.Reader, buf []byte) *Decoder {
     26 	d := &Decoder{}
     27 	d.Reset(r, buf)
     28 	return d
     29 }
     30 
     31 // Reset resets the decoder. if both r and buf are nil, it panics.
     32 func (d *Decoder) Reset(r io.Reader, buf []byte) {
     33 	if r == nil && len(buf) == 0 {
     34 		panic("core/msgpack: decoder: no source is provided")
     35 	}
     36 
     37 	if len(buf) == 0 {
     38 		buf = make([]byte, 512)
     39 	}
     40 
     41 	*d = Decoder{
     42 		r:   r,
     43 		buf: buf,
     44 	}
     45 
     46 	if r == nil {
     47 		d.length = len(buf)
     48 	}
     49 }
     50 
     51 // Decode decodes input from reader or buffer to value.
     52 func (d *Decoder) Decode(v interface{}) error {
     53 	return d.decode(v)
     54 }
     55 
     56 func (d *Decoder) decode(v interface{}) error {
     57 	switch v := v.(type) {
     58 	case *bool:
     59 		return d.Bool(v)
     60 	case *int:
     61 		return d.Int(v)
     62 	case *int8:
     63 		return d.Int8(v)
     64 	case *int16:
     65 		return d.Int16(v)
     66 	case *int32:
     67 		return d.Int32(v)
     68 	case *int64:
     69 		return d.Int64(v)
     70 	case *uint:
     71 		return d.Uint(v)
     72 	case *uint8:
     73 		return d.Uint8(v)
     74 	case *uint16:
     75 		return d.Uint16(v)
     76 	case *uint32:
     77 		return d.Uint32(v)
     78 	case *uint64:
     79 		return d.Uint64(v)
     80 	case *float32:
     81 		return d.Float32(v)
     82 	case *float64:
     83 		return d.Float64(v)
     84 	case *string:
     85 		return d.String(v)
     86 	case *[]byte:
     87 		return d.Binary(v)
     88 	case Array:
     89 		return d.Array(v)
     90 	case Map:
     91 		return d.Map(v)
     92 	case Extension:
     93 		return d.Ext(v)
     94 	default:
     95 		panic("unsupported value")
     96 	}
     97 }
     98 
     99 func (d *Decoder) read(p []byte) (int, error) {
    100 	if len(p) == 0 {
    101 		return 0, nil
    102 	}
    103 
    104 	// no empty space in buffer
    105 	if d.length == d.cursor {
    106 		if d.r == nil {
    107 			return 0, io.EOF
    108 		}
    109 
    110 		if len(p) >= len(d.buf) {
    111 			return d.r.Read(p)
    112 		}
    113 
    114 		n, err := d.r.Read(d.buf)
    115 		if err != nil {
    116 			return 0, err
    117 		}
    118 
    119 		d.cursor = 0
    120 		d.length = n
    121 	}
    122 
    123 	n := copy(p, d.buf[d.cursor:d.length])
    124 	d.cursor += n
    125 
    126 	if d.r != nil && n < len(p) {
    127 		n2, err := d.read(p[n:])
    128 		if err != nil && err != io.EOF {
    129 			return n, err
    130 		}
    131 		n += n2
    132 	}
    133 
    134 	return n, nil
    135 }
    136 
    137 func (d *Decoder) readByte() (byte, error) {
    138 	buf := make([]byte, 1)
    139 	n, err := d.read(buf)
    140 	if err != nil {
    141 		return 0, err
    142 	}
    143 	if n == 0 {
    144 		return 0, io.EOF
    145 	}
    146 	return buf[0], nil
    147 }