Movatterモバイル変換

[0]ホーム
URL:

msgpack

packagemodule
v5.4.1Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest Published: Oct 26, 2023 License:BSD-2-ClauseImports:18Imported by:1,605

Details

Repository

github.com/vmihailenco/msgpack

Links

README

MessagePack encoding for Golang

Build StatusPkgGoDevDocumentationChat

msgpack is brought to you by ⭐uptrace/uptrace.Uptrace is anopen source APM and blazingly fastdistributed tracing tool poweredby OpenTelemetry and ClickHouse. Give it a star as well!

Resources

Features

Installation

msgpack supports 2 last Go versions and requires support forGo modules. So make sure to initialize a Go module:

go mod init github.com/my/repo

And then install msgpack/v5 (notev5 in the import; omitting it is a popular mistake):

go get github.com/vmihailenco/msgpack/v5

Quickstart

import "github.com/vmihailenco/msgpack/v5"func ExampleMarshal() {    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}

See also

Contributors

Thanks to all the people who already contributed!

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

funcMarshal

func Marshal(v interface{}) ([]byte,error)

Marshal returns the MessagePack encoding of v.

Example
type Item struct {Foo string}b, err := msgpack.Marshal(&Item{Foo: "bar"})if err != nil {panic(err)}var item Itemerr = msgpack.Unmarshal(b, &item)if err != nil {panic(err)}fmt.Println(item.Foo)
Output:bar
Example (AsArray)
type Item struct {_msgpack struct{} `msgpack:",as_array"`Foo      stringBar      string}var buf bytes.Bufferenc := 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)
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 Itemif 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)
var t1 Traw, err := msgpack.Marshal(t1)if err != nil {panic(err)}var t2 Tif 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 fieldraw, err = msgpack.Marshal(t2)if err != nil {panic(err)}var t3 Tif 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)
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 = 1hello = world
Example (OmitEmpty)
type Item struct {Foo stringBar 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      stringBar      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"

funcPutDecoder

func PutDecoder(dec *Decoder)

funcPutEncoder

func PutEncoder(enc *Encoder)

funcRegister

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 implementingCustomEncoder/CustomDecoder or Marshaler/Unmarshaler interfaces.

funcRegisterExt

func RegisterExt(extIDint8, valueMarshalerUnmarshaler)
Example
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 extmsgpack.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 extmsgpack.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 UTC1973-11-29 21:33:09.000000123 +0000 UTC1973-11-29 21:33:10.000000123 +0000 UTC1973-11-29 21:33:10.000000123 +0000 UTC

funcRegisterExtDecoder

func RegisterExtDecoder(extIDint8,value interface{},decoder func(dec *Decoder, vreflect.Value, extLenint)error,)

funcRegisterExtEncoder

func RegisterExtEncoder(extIDint8,value interface{},encoder func(enc *Encoder, vreflect.Value) ([]byte,error),)

funcUnmarshal

func Unmarshal(data []byte, v interface{})error

Unmarshal decodes the MessagePack-encoded data and stores the resultin the value pointed to by v.

funcUnregisterExtadded inv5.1.0

func UnregisterExt(extIDint8)
Example
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 UTC1973-11-29 21:33:10.000000123 +0000 UTC

funcVersionadded inv5.3.5

func Version()string

Version is the current release version.

Types

typeCustomDecoder

type CustomDecoder interface {DecodeMsgpack(*Decoder)error}

typeCustomEncoder

type CustomEncoder interface {EncodeMsgpack(*Encoder)error}
Example
package mainimport ("fmt""github.com/vmihailenco/msgpack/v5")type customStruct struct {S stringN 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 customStructerr = msgpack.Unmarshal(b, &v)if err != nil {panic(err)}fmt.Printf("%#v", v)}
Output:msgpack_test.customStruct{S:"hello", N:42}

typeDecoder

type Decoder struct {// contains filtered or unexported fields}

A Decoder reads and decodes MessagePack values from an input stream.

funcGetDecoder

func GetDecoder() *Decoder

funcNewDecoder

func NewDecoder(rio.Reader) *Decoder

NewDecoder returns a new decoder that reads from r.

The decoder introduces its own buffering and may read data from rbeyond the requested msgpack values. Buffering can be disabledby passing a reader that implements io.ByteScanner interface.

func (*Decoder)Buffered

func (d *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.

func (*Decoder)Decode

func (d *Decoder) Decode(v interface{})error

func (*Decoder)DecodeArrayLen

func (d *Decoder) DecodeArrayLen() (int,error)

DecodeArrayLen decodes array length. Length is -1 when array is nil.

func (*Decoder)DecodeBool

func (d *Decoder) DecodeBool() (bool,error)

func (*Decoder)DecodeBytes

func (d *Decoder) DecodeBytes() ([]byte,error)

func (*Decoder)DecodeBytesLen

func (d *Decoder) DecodeBytesLen() (int,error)

func (*Decoder)DecodeDuration

func (d *Decoder) DecodeDuration() (time.Duration,error)

func (*Decoder)DecodeExtHeader

func (d *Decoder) DecodeExtHeader() (extIDint8, extLenint, errerror)

func (*Decoder)DecodeFloat32

func (d *Decoder) DecodeFloat32() (float32,error)

func (*Decoder)DecodeFloat64

func (d *Decoder) DecodeFloat64() (float64,error)

DecodeFloat64 decodes msgpack float32/64 into Go float64.

func (*Decoder)DecodeInt

func (d *Decoder) DecodeInt() (int,error)

func (*Decoder)DecodeInt16

func (d *Decoder) DecodeInt16() (int16,error)

func (*Decoder)DecodeInt32

func (d *Decoder) DecodeInt32() (int32,error)

func (*Decoder)DecodeInt64

func (d *Decoder) DecodeInt64() (int64,error)

DecodeInt64 decodes msgpack int8/16/32/64 and uint8/16/32/64into Go int64.

func (*Decoder)DecodeInt8

func (d *Decoder) DecodeInt8() (int8,error)

func (*Decoder)DecodeInterface

func (d *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 valueyou are decoding. For example, if you are decoding number it is better to useDecodeInt64 for negative numbers and DecodeUint64 for positive numbers.

func (*Decoder)DecodeInterfaceLoose

func (d *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.

func (*Decoder)DecodeMap

func (d *Decoder) DecodeMap() (map[string]interface{},error)

func (*Decoder)DecodeMapLen

func (d *Decoder) DecodeMapLen() (int,error)

DecodeMapLen decodes map length. Length is -1 when map is nil.

func (*Decoder)DecodeMulti

func (d *Decoder) DecodeMulti(v ...interface{})error

func (*Decoder)DecodeNil

func (d *Decoder) DecodeNil()error

func (*Decoder)DecodeRaw

func (d *Decoder) DecodeRaw() (RawMessage,error)

func (*Decoder)DecodeSlice

func (d *Decoder) DecodeSlice() ([]interface{},error)

func (*Decoder)DecodeString

func (d *Decoder) DecodeString() (string,error)

func (*Decoder)DecodeTime

func (d *Decoder) DecodeTime() (time.Time,error)

func (*Decoder)DecodeTypedMap

func (d *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.

func (*Decoder)DecodeUint

func (d *Decoder) DecodeUint() (uint,error)

func (*Decoder)DecodeUint16

func (d *Decoder) DecodeUint16() (uint16,error)

func (*Decoder)DecodeUint32

func (d *Decoder) DecodeUint32() (uint32,error)

func (*Decoder)DecodeUint64

func (d *Decoder) DecodeUint64() (uint64,error)

DecodeUint64 decodes msgpack int8/16/32/64 and uint8/16/32/64into Go uint64.

func (*Decoder)DecodeUint8

func (d *Decoder) DecodeUint8() (uint8,error)

func (*Decoder)DecodeUntypedMap

func (d *Decoder) DecodeUntypedMap() (map[interface{}]interface{},error)

func (*Decoder)DecodeValue

func (d *Decoder) DecodeValue(vreflect.Value)error

func (*Decoder)DisableAllocLimitadded inv5.4.0

func (d *Decoder) DisableAllocLimit(onbool)

DisableAllocLimit enables fully allocating slices/maps when the size is known

func (*Decoder)DisallowUnknownFields

func (d *Decoder) DisallowUnknownFields(onbool)

DisallowUnknownFields causes the Decoder to return an error when the destinationis a struct and the input contains object keys which do not match anynon-ignored, exported fields in the destination.

func (*Decoder)PeekCode

func (d *Decoder) PeekCode() (byte,error)

PeekCode returns the next MessagePack code without advancing the reader.Subpackage msgpack/codes defines the list of available msgpcode.

func (*Decoder)Query

func (d *Decoder) Query(querystring) ([]interface{},error)

Query extracts data specified by the query from the msgpack stream skippingany other data. Query 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

func (*Decoder)ReadFull

func (d *Decoder) ReadFull(buf []byte)error

ReadFull reads exactly len(buf) bytes into the buf.

func (*Decoder)Reset

func (d *Decoder) Reset(rio.Reader)

Reset discards any buffered data, resets all state, and switches the bufferedreader to read from r.

func (*Decoder)ResetDict

func (d *Decoder) ResetDict(rio.Reader, dict []string)

ResetDict is like Reset, but also resets the dict.

func (*Decoder)ResetReaderadded inv5.4.0

func (d *Decoder) ResetReader(rio.Reader)

func (*Decoder)SetCustomStructTag

func (d *Decoder) SetCustomStructTag(tagstring)

SetCustomStructTag causes the decoder to use the supplied tag as a fallback optionif there is no msgpack tag.

func (*Decoder)SetMapDecoder

func (d *Decoder) SetMapDecoder(fn func(*Decoder) (interface{},error))
Example
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)Skip

func (d *Decoder) Skip()error

Skip skips next value.

func (*Decoder)UseInternedStrings

func (d *Decoder) UseInternedStrings(onbool)

UseInternedStrings enables support for decoding interned strings.

func (*Decoder)UseLooseInterfaceDecoding

func (d *Decoder) UseLooseInterfaceDecoding(onbool)

UseLooseInterfaceDecoding causes decoder to use DecodeInterfaceLooseto decode msgpack value into Go interface{}.

func (*Decoder)UsePreallocateValuesadded inv5.4.0

func (d *Decoder) UsePreallocateValues(onbool)

UsePreallocateValues enables preallocating values in chunks

func (*Decoder)WithDictadded inv5.1.3

func (d *Decoder) WithDict(dict []string, fn func(*Decoder)error)error

typeEncoder

type Encoder struct {// contains filtered or unexported fields}

funcGetEncoder

func GetEncoder() *Encoder

funcNewEncoder

func NewEncoder(wio.Writer) *Encoder

NewEncoder returns a new encoder that writes to w.

func (*Encoder)Encode

func (e *Encoder) Encode(v interface{})error

func (*Encoder)EncodeArrayLen

func (e *Encoder) EncodeArrayLen(lint)error

func (*Encoder)EncodeBool

func (e *Encoder) EncodeBool(valuebool)error

func (*Encoder)EncodeBytes

func (e *Encoder) EncodeBytes(v []byte)error

func (*Encoder)EncodeBytesLen

func (e *Encoder) EncodeBytesLen(lint)error

func (*Encoder)EncodeDuration

func (e *Encoder) EncodeDuration(dtime.Duration)error

func (*Encoder)EncodeExtHeader

func (e *Encoder) EncodeExtHeader(extIDint8, extLenint)error

func (*Encoder)EncodeFloat32

func (e *Encoder) EncodeFloat32(nfloat32)error

func (*Encoder)EncodeFloat64

func (e *Encoder) EncodeFloat64(nfloat64)error

func (*Encoder)EncodeInt

func (e *Encoder) EncodeInt(nint64)error

EncodeNumber encodes an int64 in 1, 2, 3, 5, or 9 bytes.Type of the number is lost during encoding.

func (*Encoder)EncodeInt16

func (e *Encoder) EncodeInt16(nint16)error

EncodeInt16 encodes an int16 in 3 bytes preserving type of the number.

func (*Encoder)EncodeInt32

func (e *Encoder) EncodeInt32(nint32)error

EncodeInt32 encodes an int32 in 5 bytes preserving type of the number.

func (*Encoder)EncodeInt64

func (e *Encoder) EncodeInt64(nint64)error

EncodeInt64 encodes an int64 in 9 bytes preserving type of the number.

func (*Encoder)EncodeInt8

func (e *Encoder) EncodeInt8(nint8)error

EncodeInt8 encodes an int8 in 2 bytes preserving type of the number.

func (*Encoder)EncodeMap

func (e *Encoder) EncodeMap(m map[string]interface{})error

func (*Encoder)EncodeMapLen

func (e *Encoder) EncodeMapLen(lint)error

func (*Encoder)EncodeMapSorted

func (e *Encoder) EncodeMapSorted(m map[string]interface{})error

func (*Encoder)EncodeMulti

func (e *Encoder) EncodeMulti(v ...interface{})error

func (*Encoder)EncodeNil

func (e *Encoder) EncodeNil()error

func (*Encoder)EncodeString

func (e *Encoder) EncodeString(vstring)error

func (*Encoder)EncodeTime

func (e *Encoder) EncodeTime(tmtime.Time)error

func (*Encoder)EncodeUint

func (e *Encoder) EncodeUint(nuint64)error

EncodeUnsignedNumber encodes an uint64 in 1, 2, 3, 5, or 9 bytes.Type of the number is lost during encoding.

func (*Encoder)EncodeUint16

func (e *Encoder) EncodeUint16(nuint16)error

EncodeUint16 encodes an uint16 in 3 bytes preserving type of the number.

func (*Encoder)EncodeUint32

func (e *Encoder) EncodeUint32(nuint32)error

EncodeUint32 encodes an uint16 in 5 bytes preserving type of the number.

func (*Encoder)EncodeUint64

func (e *Encoder) EncodeUint64(nuint64)error

EncodeUint64 encodes an uint16 in 9 bytes preserving type of the number.

func (*Encoder)EncodeUint8

func (e *Encoder) EncodeUint8(nuint8)error

EncodeUint8 encodes an uint8 in 2 bytes preserving type of the number.

func (*Encoder)EncodeValue

func (e *Encoder) EncodeValue(vreflect.Value)error

func (*Encoder)Reset

func (e *Encoder) Reset(wio.Writer)

Reset discards any buffered data, resets all state, and switches the writer to write to w.

func (*Encoder)ResetDict

func (e *Encoder) ResetDict(wio.Writer, dict map[string]int)

ResetDict is like Reset, but also resets the dict.

func (*Encoder)ResetWriteradded inv5.4.0

func (e *Encoder) ResetWriter(wio.Writer)

func (*Encoder)SetCustomStructTag

func (e *Encoder) SetCustomStructTag(tagstring)

SetCustomStructTag causes the Encoder to use a custom struct tag asfallback option if there is no msgpack tag.

func (*Encoder)SetOmitEmptyadded inv5.3.2

func (e *Encoder) SetOmitEmpty(onbool)

SetOmitEmpty causes the Encoder to omit empty values by default.

func (*Encoder)SetSortMapKeys

func (e *Encoder) SetSortMapKeys(onbool) *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{}

func (*Encoder)UseArrayEncodedStructs

func (e *Encoder) UseArrayEncodedStructs(onbool)

UseArrayEncodedStructs causes the Encoder to encode Go structs as msgpack arrays.

Example
type Item struct {Foo stringBar string}var buf bytes.Bufferenc := 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

func (e *Encoder) UseCompactFloats(onbool)

UseCompactFloats causes the Encoder to chose a compact integer encodingfor floats that can be represented as integers.

func (*Encoder)UseCompactInts

func (e *Encoder) UseCompactInts(onbool)

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

func (e *Encoder) UseInternedStrings(onbool)

UseInternedStrings causes the Encoder to intern strings.

func (*Encoder)WithDictadded inv5.1.3

func (e *Encoder) WithDict(dict map[string]int, fn func(*Encoder)error)error

func (*Encoder)Writer

func (e *Encoder) Writer()io.Writer

Writer returns the Encoder's writer.

typeMarshaler

type Marshaler interface {MarshalMsgpack() ([]byte,error)}

typeMarshalerUnmarshaler

type MarshalerUnmarshaler interface {MarshalerUnmarshaler}

typeRawMessage

type RawMessage []byte

func (*RawMessage)DecodeMsgpack

func (m *RawMessage) DecodeMsgpack(dec *Decoder)error

func (RawMessage)EncodeMsgpack

func (mRawMessage) EncodeMsgpack(enc *Encoder)error

typeUnmarshaler

type Unmarshaler interface {UnmarshalMsgpack([]byte)error}

Source Files

View all Source files

Directories

PathSynopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f orF : Jump to
y orY : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic.Learn more.
[8]ページ先頭
©2009-2025 Movatter.jp