Documentation ¶
Index ¶
- Variables
- func Marshal(v interface{}) ([]byte, error)
- func PutDecoder(dec *Decoder)
- func PutEncoder(enc *Encoder)
- func Register(value interface{}, enc encoderFunc, dec decoderFunc)
- func RegisterBinaryExt[T encoding.BinaryMarshaler, _ interface{ ... }](extID int8)
- func RegisterExt(extID int8, value MarshalerUnmarshaler)
- func RegisterExtDecoder(extID int8, value interface{}, ...)
- func RegisterExtEncoder(extID int8, value interface{}, ...)
- func Unmarshal(data []byte, v interface{}) error
- func UnregisterExt(extID int8)
- func Version() string
- type CustomDecoder
- type CustomEncoder
- type Decoder
- func (d *Decoder) Buffered() io.Reader
- 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) DecodeDuration() (time.Duration, error)
- func (d *Decoder) DecodeExtHeader() (extID int8, extLen int, err 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) DecodeInterfaceLoose() (interface{}, error)
- func (d *Decoder) DecodeMap() (map[string]interface{}, error)
- func (d *Decoder) DecodeMapLen() (int, error)
- func (d *Decoder) DecodeMulti(v ...interface{}) error
- func (d *Decoder) DecodeNil() error
- func (d *Decoder) DecodeRaw() (RawMessage, error)
- func (d *Decoder) DecodeSlice() ([]interface{}, error)
- func (d *Decoder) DecodeString() (string, error)
- func (d *Decoder) DecodeTime() (time.Time, error)
- func (d *Decoder) DecodeTypedMap() (interface{}, 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) DecodeUntypedMap() (map[interface{}]interface{}, error)
- func (d *Decoder) DecodeValue(v reflect.Value) error
- func (d *Decoder) DisableAllocLimit(on bool)
- func (d *Decoder) DisallowUnknownFields(on bool)
- func (d *Decoder) IgnoreMismatchedArrayFields(on bool)
- func (d *Decoder) PeekCode() (byte, error)
- func (d *Decoder) Query(query string) ([]interface{}, error)
- func (d *Decoder) ReadFull(buf []byte) error
- func (d *Decoder) Reset(r io.Reader)
- func (d *Decoder) ResetDict(r io.Reader, dict []string)
- func (d *Decoder) ResetReader(r io.Reader)
- func (d *Decoder) SetCustomStructTag(tag string)
- func (d *Decoder) SetMapDecoder(fn func(*Decoder) (interface{}, error))
- func (d *Decoder) Skip() error
- func (d *Decoder) UseInternedStrings(on bool)
- func (d *Decoder) UseLooseInterfaceDecoding(on bool)
- func (d *Decoder) UsePreallocateValues(on bool)
- func (d *Decoder) WithDict(dict []string, fn func(*Decoder) error) 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) EncodeBytesLen(l int) error
- func (e *Encoder) EncodeDuration(d time.Duration) error
- func (e *Encoder) EncodeExtHeader(extID int8, extLen int) error
- func (e *Encoder) EncodeFloat32(n float32) error
- func (e *Encoder) EncodeFloat64(n float64) error
- func (e *Encoder) EncodeInt(n int64) error
- func (e *Encoder) EncodeInt16(n int16) error
- func (e *Encoder) EncodeInt32(n int32) error
- func (e *Encoder) EncodeInt64(n int64) error
- func (e *Encoder) EncodeInt8(n int8) error
- func (e *Encoder) EncodeMap(m map[string]interface{}) error
- func (e *Encoder) EncodeMapLen(l int) error
- func (e *Encoder) EncodeMapSorted(m map[string]interface{}) error
- func (e *Encoder) EncodeMulti(v ...interface{}) error
- func (e *Encoder) EncodeNil() error
- func (e *Encoder) EncodeString(v string) error
- func (e *Encoder) EncodeTime(tm time.Time) error
- func (e *Encoder) EncodeUint(n uint64) error
- func (e *Encoder) EncodeUint16(n uint16) error
- func (e *Encoder) EncodeUint32(n uint32) error
- func (e *Encoder) EncodeUint64(n uint64) error
- func (e *Encoder) EncodeUint8(n uint8) error
- func (e *Encoder) EncodeValue(v reflect.Value) error
- func (e *Encoder) Reset(w io.Writer)
- func (e *Encoder) ResetDict(w io.Writer, dict map[string]int)
- func (e *Encoder) ResetWriter(w io.Writer)
- func (e *Encoder) SetCustomStructTag(tag string)
- func (e *Encoder) SetOmitEmpty(on bool)
- func (e *Encoder) SetSortMapKeys(on bool) *Encoder
- func (e *Encoder) UseArrayEncodedStructs(on bool)
- func (e *Encoder) UseCompactFloats(on bool)
- func (e *Encoder) UseCompactInts(on bool)
- func (e *Encoder) UseInternedStrings(on bool)
- func (e *Encoder) WithDict(dict map[string]int, fn func(*Encoder) error) error
- func (e *Encoder) Writer() io.Writer
- type Marshaler
- type MarshalerUnmarshaler
- type RawMessage
- type Unmarshaler
Examples ¶
- CustomEncoder
- Decoder (IgnoreMismatchedArrayFields2)
- Decoder.IgnoreMismatchedArrayFields
- Decoder.Query
- Decoder.SetMapDecoder
- Encoder.UseArrayEncodedStructs
- Marshal
- Marshal (AsArray)
- Marshal (EscapedNames)
- Marshal (Ignore_simple_zero_structs_when_tagged_with_omitempty)
- Marshal (MapStringInterface)
- Marshal (OmitEmpty)
- RegisterExt
- UnregisterExt
Constants ¶
This section is empty.
Variables ¶
var ErrArrayStruct = errors.New("msgpack: number of fields in array-encoded struct has changed")
Functions ¶
func Marshal ¶
Marshal returns the MessagePack encoding of v.
Example ¶
package main import ( "fmt" "github.com/Alexander-r/msgpack" ) func main() { 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
Example (AsArray) ¶
package main import ( "bytes" "fmt" "github.com/Alexander-r/msgpack" ) func main() { type Item struct { _msgpack struct{} `msgpack:",as_array"` Foo string Bar string } var buf bytes.Buffer enc := msgpack.NewEncoder(&buf) err := enc.Encode(&Item{Foo: "foo", Bar: "bar"}) if err != nil { panic(err) } dec := msgpack.NewDecoder(&buf) v, err := dec.DecodeInterface() if err != nil { panic(err) } fmt.Println(v) }
Output: [foo bar]
Example (EscapedNames) ¶
package main import ( "fmt" "github.com/Alexander-r/msgpack" ) func main() { og := map[string]interface{}{ "something:special": uint(123), "hello, world": "hello!", } raw, err := msgpack.Marshal(og) if err != nil { panic(err) } type Item struct { SomethingSpecial uint `msgpack:"'something:special'"` HelloWorld string `msgpack:"'hello, world'"` } var item Item if err := msgpack.Unmarshal(raw, &item); err != nil { panic(err) } fmt.Printf("%#v\n", item) }
Output: msgpack_test.Item{SomethingSpecial:0x7b, HelloWorld:"hello!"}
Example (Ignore_simple_zero_structs_when_tagged_with_omitempty) ¶
package main import ( "fmt" "github.com/Alexander-r/msgpack" ) type NullInt struct { Valid bool Int int } func (i *NullInt) Set(j int) { i.Int = j i.Valid = true } func (i NullInt) IsZero() bool { return !i.Valid } func (i NullInt) MarshalMsgpack() ([]byte, error) { return msgpack.Marshal(i.Int) } func (i *NullInt) UnmarshalMsgpack(b []byte) error { if err := msgpack.Unmarshal(b, &i.Int); err != nil { return err } i.Valid = true return nil } type Secretive struct { Visible bool hidden bool } type T struct { I NullInt `msgpack:",omitempty"` J NullInt S Secretive `msgpack:",omitempty"` } func main() { var t1 T raw, err := msgpack.Marshal(t1) if err != nil { panic(err) } var t2 T if err = msgpack.Unmarshal(raw, &t2); err != nil { panic(err) } fmt.Printf("%#v\n", t2) t2.I.Set(42) t2.S.hidden = true // won't be included because it is a hidden field raw, err = msgpack.Marshal(t2) if err != nil { panic(err) } var t3 T if err = msgpack.Unmarshal(raw, &t3); err != nil { panic(err) } fmt.Printf("%#v\n", t3) }
Output: msgpack_test.T{I:msgpack_test.NullInt{Valid:false, Int:0}, J:msgpack_test.NullInt{Valid:true, Int:0}, S:msgpack_test.Secretive{Visible:false, hidden:false}} msgpack_test.T{I:msgpack_test.NullInt{Valid:true, Int:42}, J:msgpack_test.NullInt{Valid:true, Int:0}, S:msgpack_test.Secretive{Visible:false, hidden:false}}
Example (MapStringInterface) ¶
package main import ( "fmt" "github.com/Alexander-r/msgpack" ) func main() { 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 (OmitEmpty) ¶
package main import ( "fmt" "github.com/Alexander-r/msgpack" ) func main() { type Item struct { Foo string Bar string } item := &Item{ Foo: "hello", } b, err := msgpack.Marshal(item) if err != nil { panic(err) } fmt.Printf("item: %q\n", b) type ItemOmitEmpty struct { _msgpack struct{} `msgpack:",omitempty"` Foo string Bar string } itemOmitEmpty := &ItemOmitEmpty{ Foo: "hello", } b, err = msgpack.Marshal(itemOmitEmpty) if err != nil { panic(err) } fmt.Printf("item2: %q\n", b) }
Output: item: "\x82\xa3Foo\xa5hello\xa3Bar\xa0" item2: "\x81\xa3Foo\xa5hello"
func PutDecoder ¶
func PutDecoder(dec *Decoder)
func PutEncoder ¶
func PutEncoder(enc *Encoder)
func Register ¶
func Register(value interface{}, enc encoderFunc, dec decoderFunc)
Register registers encoder and decoder functions for a value. This is low level API and in most cases you should prefer implementing CustomEncoder/CustomDecoder or Marshaler/Unmarshaler interfaces.
func RegisterBinaryExt ¶
func RegisterBinaryExt[T encoding.BinaryMarshaler, _ interface { encoding.BinaryUnmarshaler *T }](extID int8)
RegisterBinaryExt registers a binary marshaler/unmarshaler for the given type. The type must be implemented both interfaces.
func RegisterExt ¶
func RegisterExt(extID int8, value MarshalerUnmarshaler)
Example ¶
package main import ( "encoding/binary" "fmt" "time" "github.com/Alexander-r/msgpack" ) // https://github.com/fluent/fluentd/wiki/Forward-Protocol-Specification-v1#eventtime-ext-format type EventTime struct { time.Time } type OneMoreSecondEventTime struct { EventTime } func (tm *EventTime) MarshalMsgpack() ([]byte, error) { b := make([]byte, 8) binary.BigEndian.PutUint32(b, uint32(tm.Unix())) binary.BigEndian.PutUint32(b[4:], uint32(tm.Nanosecond())) return b, nil } func (tm *EventTime) UnmarshalMsgpack(b []byte) error { if len(b) != 8 { return fmt.Errorf("invalid data length: got %d, wanted 8", len(b)) } sec := binary.BigEndian.Uint32(b) usec := binary.BigEndian.Uint32(b[4:]) tm.Time = time.Unix(int64(sec), int64(usec)) return nil } func (tm *OneMoreSecondEventTime) MarshalMsgpack() ([]byte, error) { b := make([]byte, 8) binary.BigEndian.PutUint32(b, uint32(tm.Unix()+1)) binary.BigEndian.PutUint32(b[4:], uint32(tm.Nanosecond())) return b, nil } func (tm *OneMoreSecondEventTime) UnmarshalMsgpack(b []byte) error { if len(b) != 8 { return fmt.Errorf("invalid data length: got %d, wanted 8", len(b)) } sec := binary.BigEndian.Uint32(b) usec := binary.BigEndian.Uint32(b[4:]) tm.Time = time.Unix(int64(sec+1), int64(usec)) return nil } func main() { t := time.Unix(123456789, 123) { msgpack.RegisterExt(1, (*EventTime)(nil)) b, err := msgpack.Marshal(&EventTime{t}) if err != nil { panic(err) } var v interface{} err = msgpack.Unmarshal(b, &v) if err != nil { panic(err) } fmt.Println(v.(*EventTime).UTC()) tm := new(EventTime) err = msgpack.Unmarshal(b, &tm) if err != nil { panic(err) } fmt.Println(tm.UTC()) } { msgpack.RegisterExt(1, (*EventTime)(nil)) b, err := msgpack.Marshal(&EventTime{t}) if err != nil { panic(err) } // override ext msgpack.RegisterExt(1, (*OneMoreSecondEventTime)(nil)) var v interface{} err = msgpack.Unmarshal(b, &v) if err != nil { panic(err) } fmt.Println(v.(*OneMoreSecondEventTime).UTC()) } { msgpack.RegisterExt(1, (*OneMoreSecondEventTime)(nil)) b, err := msgpack.Marshal(&OneMoreSecondEventTime{ EventTime{t}, }) if err != nil { panic(err) } // override ext msgpack.RegisterExt(1, (*EventTime)(nil)) var v interface{} err = msgpack.Unmarshal(b, &v) if err != nil { panic(err) } fmt.Println(v.(*EventTime).UTC()) } }
Output: 1973-11-29 21:33:09.000000123 +0000 UTC 1973-11-29 21:33:09.000000123 +0000 UTC 1973-11-29 21:33:10.000000123 +0000 UTC 1973-11-29 21:33:10.000000123 +0000 UTC
func RegisterExtDecoder ¶
func RegisterExtEncoder ¶
func Unmarshal ¶
Unmarshal decodes the MessagePack-encoded data and stores the result in the value pointed to by v.
func UnregisterExt ¶
func UnregisterExt(extID int8)
Example ¶
package main import ( "encoding/binary" "fmt" "time" "github.com/Alexander-r/msgpack" ) // https://github.com/fluent/fluentd/wiki/Forward-Protocol-Specification-v1#eventtime-ext-format type EventTime struct { time.Time } type OneMoreSecondEventTime struct { EventTime } func (tm *EventTime) MarshalMsgpack() ([]byte, error) { b := make([]byte, 8) binary.BigEndian.PutUint32(b, uint32(tm.Unix())) binary.BigEndian.PutUint32(b[4:], uint32(tm.Nanosecond())) return b, nil } func (tm *EventTime) UnmarshalMsgpack(b []byte) error { if len(b) != 8 { return fmt.Errorf("invalid data length: got %d, wanted 8", len(b)) } sec := binary.BigEndian.Uint32(b) usec := binary.BigEndian.Uint32(b[4:]) tm.Time = time.Unix(int64(sec), int64(usec)) return nil } func (tm *OneMoreSecondEventTime) MarshalMsgpack() ([]byte, error) { b := make([]byte, 8) binary.BigEndian.PutUint32(b, uint32(tm.Unix()+1)) binary.BigEndian.PutUint32(b[4:], uint32(tm.Nanosecond())) return b, nil } func (tm *OneMoreSecondEventTime) UnmarshalMsgpack(b []byte) error { if len(b) != 8 { return fmt.Errorf("invalid data length: got %d, wanted 8", len(b)) } sec := binary.BigEndian.Uint32(b) usec := binary.BigEndian.Uint32(b[4:]) tm.Time = time.Unix(int64(sec+1), int64(usec)) return nil } func main() { t := time.Unix(123456789, 123) { msgpack.RegisterExt(1, (*EventTime)(nil)) b, err := msgpack.Marshal(&EventTime{t}) if err != nil { panic(err) } msgpack.UnregisterExt(1) var v interface{} err = msgpack.Unmarshal(b, &v) wanted := "msgpack: unknown ext id=1" if err.Error() != wanted { panic(err) } msgpack.RegisterExt(1, (*OneMoreSecondEventTime)(nil)) err = msgpack.Unmarshal(b, &v) if err != nil { panic(err) } fmt.Println(v.(*OneMoreSecondEventTime).UTC()) } { msgpack.RegisterExt(1, (*OneMoreSecondEventTime)(nil)) b, err := msgpack.Marshal(&OneMoreSecondEventTime{ EventTime{t}, }) if err != nil { panic(err) } msgpack.UnregisterExt(1) var v interface{} err = msgpack.Unmarshal(b, &v) wanted := "msgpack: unknown ext id=1" if err.Error() != wanted { panic(err) } msgpack.RegisterExt(1, (*EventTime)(nil)) err = msgpack.Unmarshal(b, &v) if err != nil { panic(err) } fmt.Println(v.(*EventTime).UTC()) } }
Output: 1973-11-29 21:33:10.000000123 +0000 UTC 1973-11-29 21:33:10.000000123 +0000 UTC
Types ¶
type CustomDecoder ¶
type CustomEncoder ¶
Example ¶
package main import ( "fmt" "github.com/Alexander-r/msgpack" ) type customStruct struct { S string N int } var _ msgpack.CustomEncoder = (*customStruct)(nil) var _ msgpack.CustomDecoder = (*customStruct)(nil) func (s *customStruct) EncodeMsgpack(enc *msgpack.Encoder) error { return enc.EncodeMulti(s.S, s.N) } func (s *customStruct) DecodeMsgpack(dec *msgpack.Decoder) error { return dec.DecodeMulti(&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 {
// contains filtered or unexported fields
}
A Decoder reads and decodes MessagePack values from an input stream.
Example (IgnoreMismatchedArrayFields2) ¶
package main import ( "bytes" "fmt" "github.com/Alexander-r/msgpack" ) func main() { type Item struct { Foo string Bar string } type ItemLong struct { Foo string Bar string Baz string } var buf bytes.Buffer enc := msgpack.NewEncoder(&buf) enc.UseArrayEncodedStructs(true) err := enc.Encode(&ItemLong{Foo: "foo", Bar: "bar", Baz: "baz"}) if err != nil { panic(err) } dec := msgpack.NewDecoder(&buf) dec.IgnoreMismatchedArrayFields(true) var item Item err = dec.Decode(&item) if err != nil { panic(err) } fmt.Println(item) }
Output: {foo bar}
func GetDecoder ¶
func GetDecoder() *Decoder
func NewDecoder ¶
NewDecoder returns a new decoder that reads from r.
The decoder introduces its own buffering and may read data from r beyond the requested msgpack values. Buffering can be disabled by passing a reader that implements io.ByteScanner interface.
func (*Decoder) Buffered ¶
Buffered returns a reader of the data remaining in the Decoder's buffer. The reader is valid until the next call to Decode.
func (*Decoder) DecodeArrayLen ¶
DecodeArrayLen decodes array length. Length is -1 when array is nil.
func (*Decoder) DecodeBool ¶
func (*Decoder) DecodeBytes ¶
func (*Decoder) DecodeBytesLen ¶
func (*Decoder) DecodeExtHeader ¶
func (*Decoder) DecodeFloat32 ¶
func (*Decoder) DecodeFloat64 ¶
DecodeFloat64 decodes msgpack float32/64 into Go float64.
func (*Decoder) DecodeInt16 ¶
func (*Decoder) DecodeInt32 ¶
func (*Decoder) DecodeInt64 ¶
DecodeInt64 decodes msgpack int8/16/32/64 and uint8/16/32/64 into Go int64.
func (*Decoder) DecodeInt8 ¶
func (*Decoder) DecodeInterface ¶
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 (*Decoder) DecodeInterfaceLoose ¶
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.
- []byte is converted to string.
func (*Decoder) DecodeMapLen ¶
DecodeMapLen decodes map length. Length is -1 when map is nil.
func (*Decoder) DecodeMulti ¶
func (*Decoder) DecodeRaw ¶
func (d *Decoder) DecodeRaw() (RawMessage, error)
func (*Decoder) DecodeSlice ¶
func (*Decoder) DecodeString ¶
func (*Decoder) DecodeTypedMap ¶
DecodeTypedMap decodes a typed map. Typed map is a map that has a fixed type for keys and values. Key and value types may be different.
func (*Decoder) DecodeUint ¶
func (*Decoder) DecodeUint16 ¶
func (*Decoder) DecodeUint32 ¶
func (*Decoder) DecodeUint64 ¶
DecodeUint64 decodes msgpack int8/16/32/64 and uint8/16/32/64 into Go uint64.
func (*Decoder) DecodeUint8 ¶
func (*Decoder) DecodeUntypedMap ¶
func (*Decoder) DisableAllocLimit ¶
DisableAllocLimit enables fully allocating slices/maps when the size is known
func (*Decoder) DisallowUnknownFields ¶
DisallowUnknownFields causes the Decoder to return an error when the destination is a struct and the input contains object keys which do not match any non-ignored, exported fields in the destination.
func (*Decoder) IgnoreMismatchedArrayFields ¶
IgnoreMismatchedArrayFields causes the Decoder to ignore mismatch fields number in the array and struct.
Example ¶
package main import ( "bytes" "fmt" "github.com/Alexander-r/msgpack" ) func main() { type Item struct { Foo string Bar string } type ItemLong struct { Foo string Bar string Baz string } var buf bytes.Buffer enc := msgpack.NewEncoder(&buf) enc.UseArrayEncodedStructs(true) err := enc.Encode(&Item{Foo: "foo", Bar: "bar"}) if err != nil { panic(err) } dec := msgpack.NewDecoder(&buf) dec.IgnoreMismatchedArrayFields(true) var itemLong ItemLong err = dec.Decode(&itemLong) if err != nil { panic(err) } fmt.Println(itemLong) }
Output: {foo bar }
func (*Decoder) PeekCode ¶
PeekCode returns the next MessagePack code without advancing the reader. Subpackage msgpack/codes defines the list of available msgpcode.
func (*Decoder) Query ¶
Query extracts data specified by the query from the msgpack stream skipping any other data. Query consists of map keys and array indexes separated with dot, e.g. key1.0.key2.
Example ¶
package main import ( "bytes" "fmt" "github.com/Alexander-r/msgpack" ) func main() { 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
func (*Decoder) Reset ¶
Reset discards any buffered data, resets all state, and switches the buffered reader to read from r.
func (*Decoder) ResetReader ¶
func (*Decoder) SetCustomStructTag ¶
SetCustomStructTag causes the decoder to use the supplied tag as a fallback option if there is no msgpack tag.
func (*Decoder) SetMapDecoder ¶
Example ¶
package main import ( "bytes" "fmt" "github.com/Alexander-r/msgpack" ) func main() { buf := new(bytes.Buffer) enc := msgpack.NewEncoder(buf) in := map[string]string{"hello": "world"} err := enc.Encode(in) if err != nil { panic(err) } dec := msgpack.NewDecoder(buf) // Causes decoder to produce map[string]string instead of map[string]interface{}. dec.SetMapDecoder(func(d *msgpack.Decoder) (interface{}, error) { n, err := d.DecodeMapLen() if err != nil { return nil, err } m := make(map[string]string, n) for i := 0; i < n; i++ { mk, err := d.DecodeString() if err != nil { return nil, err } mv, err := d.DecodeString() if err != nil { return nil, err } m[mk] = mv } return m, nil }) out, err := dec.DecodeInterface() if err != nil { panic(err) } fmt.Printf("%#v", out) }
Output: map[string]string{"hello":"world"}
func (*Decoder) UseInternedStrings ¶
UseInternedStrings enables support for decoding interned strings.
func (*Decoder) UseLooseInterfaceDecoding ¶
UseLooseInterfaceDecoding causes decoder to use DecodeInterfaceLoose to decode msgpack value into Go interface{}.
func (*Decoder) UsePreallocateValues ¶
UsePreallocateValues enables preallocating values in chunks
type Encoder ¶
type Encoder struct {
// contains filtered or unexported fields
}
func GetEncoder ¶
func GetEncoder() *Encoder
func NewEncoder ¶
NewEncoder returns a new encoder that writes to w.
func (*Encoder) EncodeArrayLen ¶
func (*Encoder) EncodeBool ¶
func (*Encoder) EncodeBytes ¶
func (*Encoder) EncodeBytesLen ¶
func (*Encoder) EncodeFloat32 ¶
func (*Encoder) EncodeFloat64 ¶
func (*Encoder) EncodeInt ¶
EncodeNumber encodes an int64 in 1, 2, 3, 5, or 9 bytes. Type of the number is lost during encoding.
func (*Encoder) EncodeInt16 ¶
EncodeInt16 encodes an int16 in 3 bytes preserving type of the number.
func (*Encoder) EncodeInt32 ¶
EncodeInt32 encodes an int32 in 5 bytes preserving type of the number.
func (*Encoder) EncodeInt64 ¶
EncodeInt64 encodes an int64 in 9 bytes preserving type of the number.
func (*Encoder) EncodeInt8 ¶
EncodeInt8 encodes an int8 in 2 bytes preserving type of the number.
func (*Encoder) EncodeMapLen ¶
func (*Encoder) EncodeMapSorted ¶
func (*Encoder) EncodeMulti ¶
func (*Encoder) EncodeString ¶
func (*Encoder) EncodeUint ¶
EncodeUnsignedNumber encodes an uint64 in 1, 2, 3, 5, or 9 bytes. Type of the number is lost during encoding.
func (*Encoder) EncodeUint16 ¶
EncodeUint16 encodes an uint16 in 3 bytes preserving type of the number.
func (*Encoder) EncodeUint32 ¶
EncodeUint32 encodes an uint16 in 5 bytes preserving type of the number.
func (*Encoder) EncodeUint64 ¶
EncodeUint64 encodes an uint16 in 9 bytes preserving type of the number.
func (*Encoder) EncodeUint8 ¶
EncodeUint8 encodes an uint8 in 2 bytes preserving type of the number.
func (*Encoder) Reset ¶
Reset discards any buffered data, resets all state, and switches the writer to write to w.
func (*Encoder) ResetWriter ¶
func (*Encoder) SetCustomStructTag ¶
SetCustomStructTag causes the Encoder to use a custom struct tag as fallback option if there is no msgpack tag.
func (*Encoder) SetOmitEmpty ¶
SetOmitEmpty causes the Encoder to omit empty values by default.
func (*Encoder) SetSortMapKeys ¶
SetSortMapKeys causes the Encoder to encode map keys in increasing order. Supported map types are:
- map[string]string
- map[string]bool
- map[string]interface{}
func (*Encoder) UseArrayEncodedStructs ¶
UseArrayEncodedStructs causes the Encoder to encode Go structs as msgpack arrays.
Example ¶
package main import ( "bytes" "fmt" "github.com/Alexander-r/msgpack" ) func main() { type Item struct { Foo string Bar string } var buf bytes.Buffer enc := msgpack.NewEncoder(&buf) enc.UseArrayEncodedStructs(true) err := enc.Encode(&Item{Foo: "foo", Bar: "bar"}) if err != nil { panic(err) } dec := msgpack.NewDecoder(&buf) v, err := dec.DecodeInterface() if err != nil { panic(err) } fmt.Println(v) }
Output: [foo bar]
func (*Encoder) UseCompactFloats ¶
UseCompactFloats causes the Encoder to chose a compact integer encoding for floats that can be represented as integers.
func (*Encoder) UseCompactInts ¶
UseCompactEncoding causes the Encoder to chose the most compact encoding. For example, it allows to encode small Go int64 as msgpack int8 saving 7 bytes.
func (*Encoder) UseInternedStrings ¶
UseInternedStrings causes the Encoder to intern strings.
type MarshalerUnmarshaler ¶
type MarshalerUnmarshaler interface { Marshaler Unmarshaler }
type RawMessage ¶
type RawMessage []byte
func (*RawMessage) DecodeMsgpack ¶
func (m *RawMessage) DecodeMsgpack(dec *Decoder) error
func (RawMessage) EncodeMsgpack ¶
func (m RawMessage) EncodeMsgpack(enc *Encoder) error