// ./demo/basic/main.go for more detail

server, err := wk.NewDefaultServer()

if err != nil {
	fmt.Println("NewDefaultServer error", err)
	return
}

server.RouteTable.Get("/data/top/{count}").To(...)
server.RouteTable.Path("/basic#/{action}/{id}").ToController(...)

server.Start()

cd ./demo/basic  
go run main.go  

// url: /demo/xxx/xxx
// route to controller
server.RouteTable.Path("/demo/{action}/{id}").ToController(controller)

// url: /data/top/10
// func: DataTopHandle(ctx *wk.HttpContext) (result wk.HttpResult, err error)
// route to func (*wk.HttpContext) (wk.HttpResult, error)
server.RouteTable.Get("/data/top/{count}").To(DataTopHandle)

// url: /data/int/1
// func: DataByInt(i int) *Data
// route to a function, convert parameter by index(p0,p1,p2...)
server.RouteTable.Get("/data/int/{p0}?").ToFunc(model.DataByInt)

// url: /data/range/1-9
// func: DataByIntRange(start, end int) []*Data
// route to a function, convert parameter by index(p0,p1,p2...)
server.RouteTable.Get("/data/range/{p0}-{p1}").ToFunc(model.DataByIntRange)

// url: /data/int/1/xml
// func: DataByInt(i int) *Data
// return xml
server.RouteTable.Get("/data/int/{p0}/xml").ToFunc(model.DataByInt).ReturnXml()

// url: /data/int/1/json
// func: DataByInt(i int) *Data
// return json
server.RouteTable.Get("/data/int/{p0}/json").ToFunc(model.DataByInt).ReturnJson()

// url: /data/int/1/kson
// func: DataByInt(i int) *Data
// return custome formatted data
server.RouteTable.Get("/data/int/{p0}/kson").ToFunc(model.DataByInt).Return(formatKson)

// url: /data/name/1
// func: DataByInt(i int) *Data
// route to a function, convert parameter by name
server.RouteTable.Get("/data/name/{id}").ToFunc(model.DataByInt).
	BindByNames("id")

// url: /data/namerange/1-9
// func: DataByIntRange(start, end int) []*Data
// route to a function, convert parameter by name
server.RouteTable.Get("/data/namerange/{start}-{end}").ToFunc(model.DataByIntRange).
	BindByNames("start", "end")

// url: /data/namerange/?start=1&end=9
// func: DataByIntRange(start, end int) []*Data
// route to a function, convert parameter by name
server.RouteTable.Get("/data/namerange/").ToFunc(model.DataByIntRange).
	BindByNames("start", "end")

// url: post /data/post?
// form:{"str": {"string"}, "uint": {"1024"}, "int": {"32"}, "float": {"1.1"}, "byte": {"64"}}
// func: DataPost(data Data) string 
// route http post to function, build struct parameter from form  
server.RouteTable.Post("/data/post?").ToFunc(model.DataPost).BindToStruct()

// url: post /data/postptr?
// form:{"str": {"string"}, "uint": {"1024"}, "int": {"32"}, "float": {"1.1"}, "byte": {"64"}}
// func DataPostPtr(data *Data) string
// route http post to function, build struct parameter from form
server.RouteTable.Post("/data/postptr?").ToFunc(model.DataPostPtr).BindToStruct()

// url: delete /data/delete/1
// func: DataDelete(i int) string 
// route http delete to function
server.RouteTable.Delete("/data/delete/{p0}").ToFunc(model.DataDelete)

// url: get /data/set?str=string&uint=1024&int=32&float=3.14&byte=64
// func: DataSet(s string, u uint64, i int, f float32, b byte) *Data 
// test diffrent parameter type
server.RouteTable.Get("/data/set?").ToFunc(model.DataSet).
	BindByNames("str", "uint", "int", "float", "byte")

// url: /demo/int/32
func (c *DemoController) Int(ctx *wk.HttpContext) (result wk.HttpResult, err error) {
	if id, ok := ctx.RouteData.Int("id"); ok {
		return wk.Json(c.getByInt(id)), nil
	}
	return wk.Data(""), nil
}

// return formatted (HttpResult, true) or return (nil, false) if doesn't format it
type FormatFunc func(*HttpContext, interface{}) (HttpResult, bool)

#app config file demo

#string
key_string: demo

#string
key_int: 	101

#bool
key_bool: 	true

#float
key_float:	3.14

#map
key_map:	{
	key1:	key1 value
	key2:	key2 value
}

#array
key_array:	[
	item 1		
	item 2
]

#struct
key_struct:	{
	Driver:		mysql			
	Host: 		127.0.0.1
	User:		user
	Password:	password			
}

#composite
key_config:	{	
	Log_Level:	debug
	Listen:		8000

	Roles: [
		{
			Name:	user
			Allow:	[
				/user		
				/order
			]
		} 
		{
			Name:	*				
			Deny: 	[
				/user
				/order
			]
		} 
	]

	Db_Log:	{
		Driver:		mysql			
		Host: 		127.0.0.1
		User:		user
		Password:	password
		Database:	log
	}

	Env:	{
		auth:		http://auth.io
		browser:	ie, chrome, firefox, safari
	}
}

type HttpProcessor interface {
	Execute(ctx *HttpContext)

	// Register is called once when server init  
	Register(server *HttpServer)
}

type HttpResult interface {
	Execute(ctx *HttpContext)
}

type ProcessTable []*Process

func (pt *ProcessTable) Append(p *Process)

func (pt *ProcessTable) Remove(name string)

func (pt *ProcessTable) Insert(p *Process, index int) 

Fire(moudle, name string, source, data interface{}, context *HttpContext) 

On(moudle, name string, handler Subscriber)