ctx

type AbortI interface {
	// GetMessage return the abort response bytes
	GetAbortMessage() []byte
	NewAbort(status int16, message interface{}) *abortContext
}

type ControlStrategy interface {
	Do() bool
}

type GroupI interface {
	Register(method, path string, handlerFuncs ...handlerFunc)
	Group(path string, handlerFuncs ...handlerFunc) GroupI
}

type ReqCxtI interface {
	RspCtxI
	AbortI
	StrategyI

	// Abort response with status
	// setAbort can make the current flow stop.
	// set the stop time & set the finished flag true
	Abort(status int16, message interface{})
	// Set into sync.map
	Set(key string, val interface{})
	// Get from sync.map
	Get(key string) interface{}
	// Push calling push when execute a HandlerFunc and push the next Handler
	// to execute or jump to anther HandlerFunc to deal with the request.
	Next(handlerFunc handlerFunc)

	GetQuery(key, dft string) string
	// ParseBody turn the body bytes to dst
	ParseBody(dst interface{}) error

	// RegisterStrategy register the customized strategy
	RegisterStrategy(strategy *StrategyContext)

	SaveLocalFile(dst string)
}

type RequestContext struct {
	*StrategyContext
	// contains filtered or unexported fields
}

type RspCtxI interface {
	// JSON response
	JSON(status int16, response interface{})
}

type StrategyContext struct {
	// time to live, stack execute profundity.
	Ttl int32

	// set Async identification to inform program to execute
	// the method by asynchronous. TimeOut option is an async true
	Timeout time.Duration

	Async bool

	// fusing resistor to protect the third part dependency.
	// or other purpose that you made.
	Fusing ControlStrategy

	// for security reason, attack recognition or any other optional
	// functions can be made && check here.
	Security ControlStrategy
	// contains filtered or unexported fields
}

type StrategyI interface {
	SetTimeOut(t time.Duration)
	SetTTL(t int32)
}