msgpack

func (*Client) Close ¶

func (c *Client) Close()

Close now, dumping any connections

func (*Client) Closed ¶

func (c *Client) Closed() *ClientClosedError

Use this to check if a client has closed and get the underlying error

func (*Client) Send ¶

func (c *Client) Send(method string, params []interface{}) (interface{}, interface{})

Send a request and wait for a response. Under the hood, this uses SendAsync so the client can still be used by other goroutines without blocking @return the result data or error if there is an error

if the error is of type ClientClosedError, then the client has had a fatal error and can no longer be used.

func (*Client) SendAsync ¶

func (c *Client) SendAsync(method string, params []interface{}, replyChan chan ClientResponse) (msgid uint32, err *ClientClosedError)

Send a request but don't wait for the response. This call may block if the in-flight limit is reached

@param replyChan this channel may be new for every request, or a shared channel may be used. Be sure to

use a buffered channel or immediately wait (or have a goroutine already waiting) for the response because
the message will be thrown away if the reply cannot be sent immediately to the channel

@return message id of the request. it is useful for demultiplexing requests if using a single reply channel. err will

always be nil unless the Client has closed due to an error.  If you get a ClientClosedError

func (*Client) ShutdownGracefully ¶

func (c *Client) ShutdownGracefully(timeout time.Duration, done chan int)

This will close the client but attempt to finish all in-flight requests first The client will closed forefully after the timeout expires

func (*Client) String ¶

func (c *Client) String() string

func (*ClientClosedError) Error ¶

func (cce *ClientClosedError) Error() string

func (*ClientClosedError) String ¶

func (cce *ClientClosedError) String() string

func (*Decoder) Decode ¶

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

Decode decodes the stream from reader and stores the result in the value pointed to by v.

If v is a pointer to a non-nil value, we will decode the stream into that value (if the value type and the stream match. For example: integer in stream must go into int type (int8...int64), etc

If you do not know what type of stream it is, pass in a pointer to a nil interface. We will decode and store a value in that nil interface.

time.Time is handled transparently, by (en)decoding (to)from a []int64{Seconds since Epoch, Nanoseconds offset}.

Sample usages:

// Decoding into a non-nil typed value
var f float32
err = msgpack.NewDecoder(r, nil).Decode(&f)

// Decoding into nil interface
var v interface{}
dec := msgpack.NewDecoder(r, nil)
err = dec.Decode(&v)

// To configure default options, see DefaultDecoderContainerResolver usage.
// or write your own DecoderContainerResolver

func (*Decoder) DecodeValue ¶

func (d *Decoder) DecodeValue(rv reflect.Value) (err error)

DecodeValue decodes the stream into a reflect.Value. The reflect.Value must be a pointer. See Decoder.Decode documentation. (Decode internally calls DecodeValue).

func (*Encoder) Encode ¶

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

Encode writes an object into a stream in the MsgPack format.

time.Time is handled transparently, by (en)decoding (to)from a []int64{Seconds since Epoch, Nanoseconds offset}.

Struct values encode as maps. Each exported struct field is encoded unless:

• the field's tag is "-", or
• the field is empty and its tag specifies the "omitempty" option.

The empty values are false, 0, any nil pointer or interface value, and any array, slice, map, or string of length zero.

Anonymous fields are encoded inline if no msgpack tag is present. Else they are encoded as regular fields.

The object's default key string is the struct field name but can be specified in the struct field's tag value. The "msgpack" key in struct field's tag value is the key name, followed by an optional comma and options.

To set an option on all fields (e.g. omitempty on all fields), you can create a field called _struct, and set flags on it.

Examples:

type MyStruct struct {
    _struct bool    `msgpack:",omitempty"`   //set omitempty for every field
    Field1 string   `msgpack:"-"`            //skip this field
    Field2 int      `msgpack:"myName"`       //Use key "myName" in encode stream
    Field3 int32    `msgpack:",omitempty"`   //use key "Field3". Omit if empty.
    Field4 bool     `msgpack:"f4,omitempty"` //use key "f4". Omit if empty.
    ...
}

func (*Encoder) EncodeValue ¶

func (e *Encoder) EncodeValue(rv reflect.Value) (err error)

EncodeValue encodes a reflect.Value.

func (SimpleDecoderContainerResolver) DecoderContainer ¶

func (d SimpleDecoderContainerResolver) DecoderContainer(
	parentcontainer reflect.Value, parentkey interface{},
	length int, ct ContainerType) (rvn reflect.Value)

DecoderContainer supports common cases for decoding into a nil interface{} depending on the context.

When decoding into a nil interface{}, the following rules apply as we have to make assumptions about the specific types you want.

• Maps are decoded as map[interface{}]interface{} unless you provide a default map type when creating your decoder. option: MapType
• Lists are always decoded as []interface{} unless you provide a default slice type when creating your decoder. option: SliceType
• raw bytes are decoded into []byte or string depending on setting of: option: BytesStringMapValue (if within a map value, use this setting) option: BytesStringSliceElement (else if within a slice, use this setting) option: BytesStringLiteral (else use this setting)