roboot

type Codec interface {
	ContentType() string
	Marshal(interface{}) ([]byte, error)
	NewEncoder(io.Writer) Encoder
	Encode(io.Writer, interface{}) error
	Unmarshal([]byte, interface{}) error
	NewDecoder(io.Reader) Decoder
	Decode(io.Reader, interface{}) error
}

type Context struct {
	Req   *http.Request
	Resp  ResponseWriter
	Codec Codec
	// contains filtered or unexported fields
}

type Decoder interface {
	Decode(interface{}) error
}

type Encoder interface {
	Encode(interface{}) error
}

type Env struct {
	// cant't be nil
	Codec Codec
	Error ErrorHandler

	FileUpload struct {
		MaxMemory int64
	}
	Renderer Renderer
}

type ErrType uint8

type ErrorHandler interface {
	Log(ctx *Context, errType ErrType, err error)
	Handle(ctx *Context, callerDepth, status int, err error)
}

type Filter interface {
	Filter(ctx *Context, chain Handler)
}

type FilterFunc func(ctx *Context, chain Handler)

type Handler interface {
	Handle(*Context)
}

type HandlerFunc func(*Context)

type MatchedFilter struct {
	Filter
	Params
}

type MatchedHandler struct {
	Handler
	Params
}

type Params interface {
	Len() int
	Get(name string) string
}

type Renderer interface {
	Render(io.Writer, string, interface{}) error
}

type ResponseWriter interface {
	StatusCode() int
	http.ResponseWriter
}

type Router interface {
	Handle(path string, handler Handler) error
	Filter(path string, filters ...Filter) error
	Group(prefix string) Router
	Merge(prefix string, r Router) error

	MatchHandler(path string) MatchedHandler
	MatchFilters(path string) []MatchedFilter
	MatchHandlerAndFilters(path string) (MatchedHandler, []MatchedFilter)
}

type Server interface {
	Env() *Env
	Router(h string) Router
	Host(h string, r Router)
	http.Handler
}