package msgpack

Import Path
	github.com/vmihailenco/msgpack/v5 (on go.dev)

Dependency Relation
	imports 18 packages, and imported by 2 packages

Involved Source Files

	    decode.go
	    decode_map.go
	    decode_number.go
	    decode_query.go
	    decode_slice.go
	    decode_string.go
	    decode_typgen.go
	    decode_value.go
	    encode.go
	    encode_map.go
	    encode_number.go
	    encode_slice.go
	    encode_value.go
	    ext.go
	    intern.go
	    msgpack.go
	    time.go
	    types.go
	    unsafe.go
	    version.go
Code Examples

	CustomEncoder
		package main
		
		import (
			"fmt"
		
			"github.com/vmihailenco/msgpack/v5"
		)
		
		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)
		}

	Decoder_Query
	  {
	  	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])
	  
	  }
	Decoder_SetMapDecoder
	  {
	  	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)
	  
	  	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)
	  
	  }
	Encoder_UseArrayEncodedStructs
	  {
	  	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)
	  
	  }
	Marshal
	  {
	  	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)
	  
	  }
	Marshal_asArray
	  {
	  	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)
	  
	  }
	Marshal_escapedNames
	  {
	  	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)
	  
	  }
	Marshal_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"])
	  
	  }
	Marshal_omitEmpty
	  {
	  	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)
	  
	  }
	RegisterExt
	  {
	  	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)
	  		}
	  
	  		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)
	  		}
	  
	  		msgpack.RegisterExt(1, (*EventTime)(nil))
	  		var v interface{}
	  		err = msgpack.Unmarshal(b, &v)
	  		if err != nil {
	  			panic(err)
	  		}
	  		fmt.Println(v.(*EventTime).UTC())
	  	}
	  
	  }
	UnregisterExt
	  {
	  	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())
	  	}
	  
	  }

Package-Level Type Names (total 8)

	/* sort by: alphabet | popularity */
	 type CustomDecoder (interface)

		Methods (only one)
			( CustomDecoder) DecodeMsgpack(*Decoder) error
		Implemented By (at least one exported)
			*RawMessage

	 type CustomEncoder (interface)

		Methods (only one)
			( CustomEncoder) EncodeMsgpack(*Encoder) error
		Implemented By (at least one exported)
			 RawMessage

	 type Decoder (struct)
		A Decoder reads and decodes MessagePack values from an input stream.

		Methods (total 48)
			(*Decoder) Buffered() io.Reader
				Buffered returns a reader of the data remaining in the Decoder's buffer.
				The reader is valid until the next call to Decode.

			(*Decoder) Decode(v interface{}) error
			(*Decoder) DecodeArrayLen() (int, error)
				DecodeArrayLen decodes array length. Length is -1 when array is nil.

			(*Decoder) DecodeBool() (bool, error)
			(*Decoder) DecodeBytes() ([]byte, error)
			(*Decoder) DecodeBytesLen() (int, error)
			(*Decoder) DecodeDuration() (time.Duration, error)
			(*Decoder) DecodeExtHeader() (extID int8, extLen int, err error)
			(*Decoder) DecodeFloat32() (float32, error)
			(*Decoder) DecodeFloat64() (float64, error)
				DecodeFloat64 decodes msgpack float32/64 into Go float64.

			(*Decoder) DecodeInt() (int, error)
			(*Decoder) DecodeInt16() (int16, error)
			(*Decoder) DecodeInt32() (int32, error)
			(*Decoder) DecodeInt64() (int64, error)
				DecodeInt64 decodes msgpack int8/16/32/64 and uint8/16/32/64
				into Go int64.

			(*Decoder) DecodeInt8() (int8, error)
			(*Decoder) DecodeInterface() (interface{}, error)
				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.

			(*Decoder) DecodeInterfaceLoose() (interface{}, error)
				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.

			(*Decoder) DecodeMap() (map[string]interface{}, error)
			(*Decoder) DecodeMapLen() (int, error)
				DecodeMapLen decodes map length. Length is -1 when map is nil.

			(*Decoder) DecodeMulti(v ...interface{}) error
			(*Decoder) DecodeNil() error
			(*Decoder) DecodeRaw() (RawMessage, error)
			(*Decoder) DecodeSlice() ([]interface{}, error)
			(*Decoder) DecodeString() (string, error)
			(*Decoder) DecodeTime() (time.Time, error)
			(*Decoder) DecodeTypedMap() (interface{}, error)
				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.

			(*Decoder) DecodeUint() (uint, error)
			(*Decoder) DecodeUint16() (uint16, error)
			(*Decoder) DecodeUint32() (uint32, error)
			(*Decoder) DecodeUint64() (uint64, error)
				DecodeUint64 decodes msgpack int8/16/32/64 and uint8/16/32/64
				into Go uint64.

			(*Decoder) DecodeUint8() (uint8, error)
			(*Decoder) DecodeUntypedMap() (map[interface{}]interface{}, error)
			(*Decoder) DecodeValue(v reflect.Value) error
			(*Decoder) DisableAllocLimit(on bool)
				DisableAllocLimit enables fully allocating slices/maps when the size is known

			(*Decoder) DisallowUnknownFields(on bool)
				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.

			(*Decoder) PeekCode() (byte, error)
				PeekCode returns the next MessagePack code without advancing the reader.
				Subpackage msgpack/codes defines the list of available msgpcode.

			(*Decoder) Query(query string) ([]interface{}, error)
				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.

			(*Decoder) ReadFull(buf []byte) error
				ReadFull reads exactly len(buf) bytes into the buf.

			(*Decoder) Reset(r io.Reader)
				Reset discards any buffered data, resets all state, and switches the buffered
				reader to read from r.

			(*Decoder) ResetDict(r io.Reader, dict []string)
				ResetDict is like Reset, but also resets the dict.

			(*Decoder) ResetReader(r io.Reader)
			(*Decoder) SetCustomStructTag(tag string)
				SetCustomStructTag causes the decoder to use the supplied tag as a fallback option
				if there is no msgpack tag.

			(*Decoder) SetMapDecoder(fn func(*Decoder) (interface{}, error))
			(*Decoder) Skip() error
				Skip skips next value.

			(*Decoder) UseInternedStrings(on bool)
				UseInternedStrings enables support for decoding interned strings.

			(*Decoder) UseLooseInterfaceDecoding(on bool)
				UseLooseInterfaceDecoding causes decoder to use DecodeInterfaceLoose
				to decode msgpack value into Go interface{}.

			(*Decoder) UsePreallocateValues(on bool)
				UsePreallocateValues enables preallocating values in chunks

			(*Decoder) WithDict(dict []string, fn func(*Decoder) error) error
		Implements (at least one exported)
			*Decoder : github.com/grpc-ecosystem/grpc-gateway/v2/runtime.Decoder
		As Outputs Of (at least 2)
			func GetDecoder() *Decoder
			func NewDecoder(r io.Reader) *Decoder
		As Inputs Of (at least 3)
			func PutDecoder(dec *Decoder)
			func CustomDecoder.DecodeMsgpack(*Decoder) error
			func (*RawMessage).DecodeMsgpack(dec *Decoder) error

	 type Encoder (struct)

		Methods (total 39)
			(*Encoder) Encode(v interface{}) error
			(*Encoder) EncodeArrayLen(l int) error
			(*Encoder) EncodeBool(value bool) error
			(*Encoder) EncodeBytes(v []byte) error
			(*Encoder) EncodeBytesLen(l int) error
			(*Encoder) EncodeDuration(d time.Duration) error
			(*Encoder) EncodeExtHeader(extID int8, extLen int) error
			(*Encoder) EncodeFloat32(n float32) error
			(*Encoder) EncodeFloat64(n float64) error
			(*Encoder) EncodeInt(n int64) error
				EncodeNumber encodes an int64 in 1, 2, 3, 5, or 9 bytes.
				Type of the number is lost during encoding.

			(*Encoder) EncodeInt16(n int16) error
				EncodeInt16 encodes an int16 in 3 bytes preserving type of the number.

			(*Encoder) EncodeInt32(n int32) error
				EncodeInt32 encodes an int32 in 5 bytes preserving type of the number.

			(*Encoder) EncodeInt64(n int64) error
				EncodeInt64 encodes an int64 in 9 bytes preserving type of the number.

			(*Encoder) EncodeInt8(n int8) error
				EncodeInt8 encodes an int8 in 2 bytes preserving type of the number.

			(*Encoder) EncodeMap(m map[string]interface{}) error
			(*Encoder) EncodeMapLen(l int) error
			(*Encoder) EncodeMapSorted(m map[string]interface{}) error
			(*Encoder) EncodeMulti(v ...interface{}) error
			(*Encoder) EncodeNil() error
			(*Encoder) EncodeString(v string) error
			(*Encoder) EncodeTime(tm time.Time) error
			(*Encoder) EncodeUint(n uint64) error
				EncodeUnsignedNumber encodes an uint64 in 1, 2, 3, 5, or 9 bytes.
				Type of the number is lost during encoding.

			(*Encoder) EncodeUint16(n uint16) error
				EncodeUint16 encodes an uint16 in 3 bytes preserving type of the number.

			(*Encoder) EncodeUint32(n uint32) error
				EncodeUint32 encodes an uint16 in 5 bytes preserving type of the number.

			(*Encoder) EncodeUint64(n uint64) error
				EncodeUint64 encodes an uint16 in 9 bytes preserving type of the number.

			(*Encoder) EncodeUint8(n uint8) error
				EncodeUint8 encodes an uint8 in 2 bytes preserving type of the number.

			(*Encoder) EncodeValue(v reflect.Value) error
			(*Encoder) Reset(w io.Writer)
				Reset discards any buffered data, resets all state, and switches the writer to write to w.

			(*Encoder) ResetDict(w io.Writer, dict map[string]int)
				ResetDict is like Reset, but also resets the dict.

			(*Encoder) ResetWriter(w io.Writer)
			(*Encoder) SetCustomStructTag(tag string)
				SetCustomStructTag causes the Encoder to use a custom struct tag as
				fallback option if there is no msgpack tag.

			(*Encoder) SetOmitEmpty(on bool)
				SetOmitEmpty causes the Encoder to omit empty values by default.

			(*Encoder) SetSortMapKeys(on bool) *Encoder
				SetSortMapKeys causes the Encoder to encode map keys in increasing order.
				Supported map types are:
				  - map[string]string
				  - map[string]bool
				  - map[string]interface{}

			(*Encoder) UseArrayEncodedStructs(on bool)
				UseArrayEncodedStructs causes the Encoder to encode Go structs as msgpack arrays.

			(*Encoder) UseCompactFloats(on bool)
				UseCompactFloats causes the Encoder to chose a compact integer encoding
				for floats that can be represented as integers.

			(*Encoder) UseCompactInts(on bool)
				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.

			(*Encoder) UseInternedStrings(on bool)
				UseInternedStrings causes the Encoder to intern strings.

			(*Encoder) WithDict(dict map[string]int, fn func(*Encoder) error) error
			(*Encoder) Writer() io.Writer
				Writer returns the Encoder's writer.

		Implements (at least 2)
			*Encoder : github.com/grpc-ecosystem/grpc-gateway/v2/runtime.Encoder
			*Encoder : go.uber.org/zap/zapcore.ReflectedEncoder
		As Outputs Of (at least 3)
			func GetEncoder() *Encoder
			func NewEncoder(w io.Writer) *Encoder
			func (*Encoder).SetSortMapKeys(on bool) *Encoder
		As Inputs Of (at least 3)
			func PutEncoder(enc *Encoder)
			func CustomEncoder.EncodeMsgpack(*Encoder) error
			func RawMessage.EncodeMsgpack(enc *Encoder) error

	 type Marshaler (interface)

		Methods (only one)
			( Marshaler) MarshalMsgpack() ([]byte, error)
		Implemented By (at least one exported)
			 MarshalerUnmarshaler (interface)

	 type MarshalerUnmarshaler (interface)

		Methods (total 2)
			( MarshalerUnmarshaler) MarshalMsgpack() ([]byte, error)
			( MarshalerUnmarshaler) UnmarshalMsgpack([]byte) error
		Implements (at least 2)
			 MarshalerUnmarshaler : Marshaler
			 MarshalerUnmarshaler : Unmarshaler
		As Inputs Of (at least one exported)
			func RegisterExt(extID int8, value MarshalerUnmarshaler)

	 type RawMessage ([])

		Methods (total 2)
			(*RawMessage) DecodeMsgpack(dec *Decoder) error
			( RawMessage) EncodeMsgpack(enc *Encoder) error
		Implements (at least 2)
			*RawMessage : CustomDecoder
			 RawMessage : CustomEncoder
		As Outputs Of (at least one exported)
			func (*Decoder).DecodeRaw() (RawMessage, error)

	 type Unmarshaler (interface)

		Methods (only one)
			( Unmarshaler) UnmarshalMsgpack([]byte) error
		Implemented By (at least one exported)
			 MarshalerUnmarshaler (interface)


Package-Level Functions (total 14)

	 func GetDecoder() *Decoder
	 func GetEncoder() *Encoder
	 func Marshal(v interface{}) ([]byte, error)
		Marshal returns the MessagePack encoding of v.

	 func NewDecoder(r io.Reader) *Decoder
		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 NewEncoder(w io.Writer) *Encoder
		NewEncoder returns a new encoder that writes to w.

	 func PutDecoder(dec *Decoder)
	 func PutEncoder(enc *Encoder)
	 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 RegisterExt(extID int8, value MarshalerUnmarshaler)
	 func RegisterExtDecoder(extID int8, value interface{}, decoder func(dec *Decoder, v reflect.Value, extLen int) error)
	 func RegisterExtEncoder(extID int8, value interface{}, encoder func(enc *Encoder, v reflect.Value) ([]byte, error))
	 func Unmarshal(data []byte, v interface{}) error
		Unmarshal decodes the MessagePack-encoded data and stores the result
		in the value pointed to by v.

	 func UnregisterExt(extID int8)
	 func Version() string
		Version is the current release version.

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.