Documentation ¶
Overview ¶
Example (DecodeMapStringString) ¶
decodedMap := make(map[string]string) buf := &bytes.Buffer{} m := map[string]string{"foo1": "bar1", "foo2": "bar2", "foo3": "bar3"} keys := []string{"foo1", "foo3", "foo2"} encodedMap, err := encodeMap(m, keys...) if err != nil { panic(err) } _, err = buf.Write(encodedMap) if err != nil { panic(err) } decoder := msgpack.NewDecoder(buf) n, err := decoder.DecodeMapLen() if err != nil { panic(err) } for i := 0; i < n; i++ { key, err := decoder.DecodeString() if err != nil { panic(err) } value, err := decoder.DecodeString() if err != nil { panic(err) } decodedMap[key] = value } for _, key := range keys { fmt.Printf("%#v: %#v, ", key, decodedMap[key]) }
Output: "foo1": "bar1", "foo3": "bar3", "foo2": "bar2",
Example (EncodeMapStringString) ¶
buf := &bytes.Buffer{} m := map[string]string{"foo1": "bar1", "foo2": "bar2", "foo3": "bar3"} keys := []string{"foo1", "foo3"} encodedMap, err := encodeMap(m, keys...) if err != nil { panic(err) } _, err = buf.Write(encodedMap) if err != nil { panic(err) } decoder := msgpack.NewDecoder(buf) value, err := decoder.DecodeMap() if err != nil { panic(err) } decodedMapValue := value.(map[interface{}]interface{}) for _, key := range keys { fmt.Printf("%#v: %#v, ", key, decodedMapValue[key]) }
Output: "foo1": "bar1", "foo3": "bar3",
Example (MapStringInterface) ¶
in := map[string]interface{}{"foo": 1, "hello": "world"} b, err := msgpack.Marshal(in) if err != nil { panic(err) } var out map[string]interface{} err = msgpack.Unmarshal(b, &out) if err != nil { panic(err) } fmt.Println("foo =", out["foo"]) fmt.Println("hello =", out["hello"])
Output: foo = 1 hello = world
Example (RecursiveMapStringInterface) ¶
buf := new(bytes.Buffer) enc := msgpack.NewEncoder(buf) in := map[string]interface{}{"foo": map[string]interface{}{"hello": "world"}} _ = enc.Encode(in) dec := msgpack.NewDecoder(buf) dec.DecodeMapFunc = func(d *msgpack.Decoder) (interface{}, error) { n, err := d.DecodeMapLen() if err != nil { return nil, err } m := make(map[string]interface{}, n) for i := 0; i < n; i++ { mk, err := d.DecodeString() if err != nil { return nil, err } mv, err := d.DecodeInterface() if err != nil { return nil, err } m[mk] = mv } return m, nil } out, err := dec.DecodeInterface() fmt.Printf("%v %#v\n", err, out)
Output: <nil> map[string]interface {}{"foo":map[string]interface {}{"hello":"world"}}
Index ¶
- func Marshal(v ...interface{}) ([]byte, error)
- func Register(typ reflect.Type, enc encoderFunc, dec decoderFunc)
- func RegisterExt(id int8, value interface{})
- func Unmarshal(b []byte, v ...interface{}) error
- type CustomDecoder
- type CustomEncoder
- type Decoder
- func (d *Decoder) Decode(v ...interface{}) error
- func (d *Decoder) DecodeArrayLen() (int, error)
- func (d *Decoder) DecodeBool() (bool, error)
- func (d *Decoder) DecodeBytes() ([]byte, error)
- func (d *Decoder) DecodeBytesLen() (int, error)
- func (d *Decoder) DecodeFloat32() (float32, error)
- func (d *Decoder) DecodeFloat64() (float64, error)
- func (d *Decoder) DecodeInt() (int, error)
- func (d *Decoder) DecodeInt16() (int16, error)
- func (d *Decoder) DecodeInt32() (int32, error)
- func (d *Decoder) DecodeInt64() (int64, error)
- func (d *Decoder) DecodeInt8() (int8, error)
- func (d *Decoder) DecodeInterface() (interface{}, error)
- func (d *Decoder) DecodeMap() (interface{}, error)
- func (d *Decoder) DecodeMapLen() (int, error)
- func (d *Decoder) DecodeNil() error
- func (d *Decoder) DecodeSlice() ([]interface{}, error)
- func (d *Decoder) DecodeSliceLen() (int, error)
- func (d *Decoder) DecodeString() (string, error)
- func (d *Decoder) DecodeTime() (time.Time, error)
- func (d *Decoder) DecodeUint() (uint, error)
- func (d *Decoder) DecodeUint16() (uint16, error)
- func (d *Decoder) DecodeUint32() (uint32, error)
- func (d *Decoder) DecodeUint64() (uint64, error)
- func (d *Decoder) DecodeUint8() (uint8, error)
- func (d *Decoder) DecodeValue(v reflect.Value) error
- func (d *Decoder) PeekCode() (code byte, err error)
- func (d *Decoder) Query(query string) ([]interface{}, error)
- func (d *Decoder) Reset(r io.Reader) error
- func (d *Decoder) Skip() error
- type Encoder
- func (e *Encoder) Encode(v ...interface{}) error
- func (e *Encoder) EncodeArrayLen(l int) error
- func (e *Encoder) EncodeBool(value bool) error
- func (e *Encoder) EncodeBytes(v []byte) error
- func (e *Encoder) EncodeFloat32(n float32) error
- func (e *Encoder) EncodeFloat64(n float64) error
- func (e *Encoder) EncodeInt(v int) error
- func (e *Encoder) EncodeInt16(v int16) error
- func (e *Encoder) EncodeInt32(v int32) error
- func (e *Encoder) EncodeInt64(v int64) error
- func (e *Encoder) EncodeInt8(v int8) error
- func (e *Encoder) EncodeMapLen(l int) error
- func (e *Encoder) EncodeNil() error
- func (e *Encoder) EncodeSliceLen(l int) error
- func (e *Encoder) EncodeString(v string) error
- func (e *Encoder) EncodeTime(tm time.Time) error
- func (e *Encoder) EncodeUint(v uint) error
- func (e *Encoder) EncodeUint16(v uint16) error
- func (e *Encoder) EncodeUint32(v uint32) error
- func (e *Encoder) EncodeUint64(v uint64) error
- func (e *Encoder) EncodeUint8(v uint8) error
- func (e *Encoder) EncodeValue(v reflect.Value) error
- func (e *Encoder) SortMapKeys(v bool) *Encoder
- type Marshaler
- type Unmarshaler
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Marshal ¶
Example ¶
type Item struct { Foo string } b, err := msgpack.Marshal(&Item{Foo: "bar"}) if err != nil { panic(err) } var item Item err = msgpack.Unmarshal(b, &item) if err != nil { panic(err) } fmt.Println(item.Foo)
Output: bar
func Register ¶
Register registers encoder and decoder functions for a type. In most cases you should prefer implementing CustomEncoder and CustomDecoder interfaces.
func RegisterExt ¶ added in v2.4.1
func RegisterExt(id int8, value interface{})
Example ¶
type Item struct { S string } msgpack.RegisterExt(1, Item{}) b, err := msgpack.Marshal(&Item{S: "string"}) if err != nil { panic(err) } var v interface{} err = msgpack.Unmarshal(b, &v) if err != nil { panic(err) } fmt.Printf("%#v", v)
Output: msgpack_test.Item{S:"string"}
Types ¶
type CustomDecoder ¶ added in v2.2.1
type CustomEncoder ¶ added in v2.2.1
Example ¶
package main import ( "fmt" "gopkg.in/vmihailenco/msgpack.v2" ) type customStruct struct { S string N int } var ( _ msgpack.CustomEncoder = &customStruct{} _ msgpack.CustomDecoder = &customStruct{} ) func (s *customStruct) EncodeMsgpack(enc *msgpack.Encoder) error { return enc.Encode(s.S, s.N) } func (s *customStruct) DecodeMsgpack(dec *msgpack.Decoder) error { return dec.Decode(&s.S, &s.N) } func main() { b, err := msgpack.Marshal(&customStruct{S: "hello", N: 42}) if err != nil { panic(err) } var v customStruct err = msgpack.Unmarshal(b, &v) if err != nil { panic(err) } fmt.Printf("%#v", v) }
Output: msgpack_test.customStruct{S:"hello", N:42}
type Decoder ¶
type Decoder struct { DecodeMapFunc func(*Decoder) (interface{}, error) // contains filtered or unexported fields }
func NewDecoder ¶
func (*Decoder) DecodeArrayLen ¶ added in v2.6.1
func (*Decoder) DecodeBool ¶
func (*Decoder) DecodeBytes ¶
func (*Decoder) DecodeBytesLen ¶
func (*Decoder) DecodeFloat32 ¶
func (*Decoder) DecodeFloat64 ¶
func (*Decoder) DecodeInt16 ¶
func (*Decoder) DecodeInt32 ¶
func (*Decoder) DecodeInt64 ¶
func (*Decoder) DecodeInt8 ¶
func (*Decoder) DecodeInterface ¶
DecodeInterface decodes value into interface. Possible value types are:
- nil,
- bool,
- int64 for negative numbers,
- uint64 for positive numbers,
- float32 and float64,
- string,
- slices of any of the above,
- maps of any of the above.
func (*Decoder) DecodeMapLen ¶
func (*Decoder) DecodeSlice ¶
func (*Decoder) DecodeSliceLen ¶
Deprecated. Use DecodeArrayLen instead.
func (*Decoder) DecodeString ¶
func (*Decoder) DecodeUint ¶
func (*Decoder) DecodeUint16 ¶
func (*Decoder) DecodeUint32 ¶
func (*Decoder) DecodeUint64 ¶
func (*Decoder) DecodeUint8 ¶
func (*Decoder) PeekCode ¶ added in v2.5.1
peekCode returns the next Msgpack code. See https://github.com/msgpack/msgpack/blob/master/spec.md#formats for details.
func (*Decoder) Query ¶ added in v2.6.0
Query extracts field specified by the query from the msgpack stream ignoring any other fields. Query string consists of map keys and array indexes separated with dot, e.g. `key1.0.key2`.
Example ¶
b, err := msgpack.Marshal([]map[string]interface{}{ {"id": 1, "attrs": map[string]interface{}{"phone": 12345}}, {"id": 2, "attrs": map[string]interface{}{"phone": 54321}}, }) if err != nil { panic(err) } dec := msgpack.NewDecoder(bytes.NewBuffer(b)) values, err := dec.Query("*.attrs.phone") if err != nil { panic(err) } fmt.Println("phones are", values) dec.Reset(bytes.NewBuffer(b)) values, err = dec.Query("1.attrs.phone") if err != nil { panic(err) } fmt.Println("2nd phone is", values[0])
Output: phones are [12345 54321] 2nd phone is 54321
type Encoder ¶
type Encoder struct {
// contains filtered or unexported fields
}
func NewEncoder ¶
func (*Encoder) EncodeArrayLen ¶ added in v2.4.11
func (*Encoder) EncodeBool ¶
func (*Encoder) EncodeBytes ¶
func (*Encoder) EncodeFloat32 ¶
func (*Encoder) EncodeFloat64 ¶
func (*Encoder) EncodeInt16 ¶
func (*Encoder) EncodeInt32 ¶
func (*Encoder) EncodeInt64 ¶
func (*Encoder) EncodeInt8 ¶
func (*Encoder) EncodeMapLen ¶ added in v2.4.8
func (*Encoder) EncodeSliceLen ¶
Deprecated. Use EncodeArrayLen instead.
func (*Encoder) EncodeString ¶
func (*Encoder) EncodeUint ¶
func (*Encoder) EncodeUint16 ¶
func (*Encoder) EncodeUint32 ¶
func (*Encoder) EncodeUint64 ¶
func (*Encoder) EncodeUint8 ¶
func (*Encoder) SortMapKeys ¶ added in v2.5.3
SortMapKeys causes the Encoder to encode map keys in increasing order. Supported map types are:
- map[string]string
- map[string]interface{}
type Unmarshaler ¶
Deprecated. Use CustomDecoder.