func (ctx *Context) Bind(v interface{}) error {
	msg := ctx.Message
	if msg.IsError() {
		return msg.Error()
	}
	if v != nil {
		data := msg.Data()
		switch vt := v.(type) {
		case *[]byte:
			*vt = data
		case *string:
			*vt = string(data)
		default:
			return ctx.Client.Codec.Unmarshal(data, v)
		}
	}
	return nil
}
Bind parses the body data and stores the result
in the value pointed to by v.
package arpc
import (
	"math"
	"sync"
	"time"
)
var (
	contextPool = sync.Pool{
		New: func() interface{} {
			return &Context{}
		},
	}
	emptyContext = Context{}
)
type Context struct {
	Client  *Client
	Message *Message
	index    int
	handlers []HandlerFunc
}
func (ctx *Context) Release() {
	ctx.Message.Release()
	*ctx = emptyContext
	contextPool.Put(ctx)
}
func (ctx *Context) Get(key interface{}) (interface{}, bool) {
	if len(ctx.Message.values) == 0 {
		return nil, false
	}
	value, ok := ctx.Message.values[key]
	return value, ok
}
func (ctx *Context) Set(key interface{}, value interface{}) {
	if key == nil || value == nil {
		return
	}
	if ctx.Message.values == nil {
		ctx.Message.values = map[interface{}]interface{}{}
	}
	ctx.Message.values[key] = value
}
func (ctx *Context) Values() map[interface{}]interface{} {
	if ctx.Message == nil {
		return nil
	}
	return ctx.Message.values
}
func (ctx *Context) Body() []byte {
	return ctx.Message.Data()
}