func (c *Context) JSONMap(data map[string]interface{}, err error) {
	code := http.StatusOK
	c.Error = err
	bcode := ecode.Cause(err)
	writeStatusCode(c.Writer, bcode.Code())
	data["code"] = bcode.Code()
	if _, ok := data["message"]; !ok {
		data["message"] = bcode.Message()
	}
	c.Render(code, render.MapJSON(data))
}
JSONMap serializes the given map as map JSON into the response body.
It also sets the Content-Type as "application/json".
package blademaster
import (
	"context"
	"math"
	"net/http"
	"strconv"
	"text/template"
	"github.com/mapgoo-lab/atreus/pkg/ecode"
	"github.com/mapgoo-lab/atreus/pkg/net/http/blademaster/binding"
	"github.com/mapgoo-lab/atreus/pkg/net/http/blademaster/render"
	"github.com/gogo/protobuf/proto"
	"github.com/gogo/protobuf/types"
	"github.com/pkg/errors"
)
const (
	_abortIndex int8 = math.MaxInt8 / 2
)
var (
	_openParen  = []byte("(")
	_closeParen = []byte(")")
)
type Context struct {
	context.Context
	Request *http.Request
	Writer  http.ResponseWriter
	index    int8
	handlers []HandlerFunc
	Keys map[string]interface{}
	Error error
	method string
	engine *Engine
	RoutePath string
	Params Params
}
func (c *Context) Next() {
	c.index++
	for c.index < int8(len(c.handlers)) {
		c.handlers[c.index](c)
		c.index++
	}
}
func (c *Context) Abort() {
	c.index = _abortIndex
}
func (c *Context) AbortWithStatus(code int) {
	c.Status(code)
	c.Abort()
}
func (c *Context) IsAborted() bool {
	return c.index >= _abortIndex
}
func (c *Context) Set(key string, value interface{}) {
	if c.Keys == nil {
		c.Keys = make(map[string]interface{})
	}
	c.Keys[key] = value
}
func (c *Context) Get(key string) (value interface{}, exists bool) {
	value, exists = c.Keys[key]
	return
}
func bodyAllowedForStatus(status int) bool {
	switch {
	case status >= 100 && status <= 199:
		return false
	case status == 204:
		return false
	case status == 304:
		return false
	}
	return true
}
func (c *Context) Status(code int) {
	c.Writer.WriteHeader(code)
}
func (c *Context) Render(code int, r render.Render) {
	r.WriteContentType(c.Writer)
	if code > 0 {
		c.Status(code)
	}
	if !bodyAllowedForStatus(code) {
		return
	}
	params := c.Request.Form
	cb := template.JSEscapeString(params.Get("callback"))
	jsonp := cb != ""
	if jsonp {
		c.Writer.Write([]byte(cb))
		c.Writer.Write(_openParen)
	}
	if err := r.Render(c.Writer); err != nil {
		c.Error = err
		return
	}
	if jsonp {
		if _, err := c.Writer.Write(_closeParen); err != nil {
			c.Error = errors.WithStack(err)
		}
	}
}
func (c *Context) JSON(data interface{}, err error) {
	code := http.StatusOK
	c.Error = err
	bcode := ecode.Cause(err)
	isSimple := c.engine.conf.UseSimpleJson
	if isSimple == false {
		useSimplejson := c.Request.Form.Get("useSimpleJson")
		if useSimplejson == "1" || useSimplejson == "true" {
			isSimple = true
		}
	}
	writeStatusCode(c.Writer, bcode.Code())
	c.Render(code, render.JSON{
		Code:    bcode.Code(),
		Message: bcode.Message(),
		Data:    data,
		IsSimple: isSimple,
	})
}