opm

type Context interface {
	// Request returns `*http.Request`
	Request() *http.Request

	// SetRequest sets `*http.Request`
	SetRequest(*http.Request)

	// Response returns `http.ResponseWriter`
	Response() http.ResponseWriter

	// SetResponse sets `http.ResponseWriter`
	SetResponse(http.ResponseWriter)

	// Logger returns the Looger instance
	Logger() Logger

	// SetLogger set the logger
	SetLogger(l Logger)

	// SetValue saves data in body response
	SetValue(string, interface{})

	// GetValue data in body response
	GetValue(string) interface{}

	// GetValues data in body response
	GetValues() map[string]interface{}

	// Param returns path parameter by name.
	Param(name string) string

	// ParamNames sets path parameter names.
	SetParamNames(names ...string)

	// ParamNames returns path parameter names.
	ParamNames() []string

	// ParamNames sets path parameter values.
	SetParamValues(values ...string)

	// ParamNames returns path parameter values.
	ParamValues() []string

	// QueryParam returns the query param for the provided.
	QueryParam(name string) string

	// QueryParams returns the query parameters as `url.Values`.
	QueryParams() url.Values

	// QueryString returns the URL query string.
	QueryString() string

	// FormValue returns the form field value for the provided name.
	FormValue(name string) string

	// FormFile returns the multipart form file for the provided name.
	FormFile(name string) (*multipart.FileHeader, error)

	// HTML sends a blod response with  content type and status code
	Blob(code int, contentType string, b []byte) (err error)

	// Decode reads the next JSON-encoded value from request
	Decode(interface{}) error

	// Stream sends a streaming response with status code and content type.
	Stream(code int, contentType string, r io.Reader) error

	// HTML sends a HTTP response with status code
	HTML(code int, html string) (err error)

	// HTMLBlob sends a HTTP blod response with status code
	HTMLBlob(code int, b []byte) (err error)

	// Render renders a template with data and sends a text/html response with
	// status code.
	Render(code int, filename string) error

	// JSON sends a JSON response with status code
	JSON(code int, data interface{}) error

	// JSON sends a JSON response with status code
	String(code int, data string) error

	// Redirect Redirects the request to provider URL with status code
	Redirect(code int, url string) error

	// File sends a file response
	File(file string) error

	// NoContent sends a response with no body anh a status code
	NoContent(code int) error

	// Get retrieves data from the body response.
	Get(key string) interface{}

	// Set saves data in the body response.
	Set(key string, val interface{})

	// Get data in the body response.
	Body() map[string]interface{}

	Reset(w http.ResponseWriter, r *http.Request)

	// Cookie returns the named cookie provided in the request.
	Cookie(name string) (*http.Cookie, error)

	// SetCookie adds a `Set-Cookie` header in HTTP response.
	SetCookie(cookie *http.Cookie)

	// Cookies returns the HTTP cookies sent with the request.
	Cookies() []*http.Cookie

	// Renderer sets service provide response HTML.
	SetRenderer(Renderer)

	// Renderer returns service provide response HTML.
	Renderer() Renderer

	// SetRoute sets `*Route`
	SetRoute(*Route)

	// Route returns `*Route`
	Route() *Route

	// Domain returns site domain
	Domain() string

	// RealIP return real ip
	RealIP() string
}

type Core struct {
	sync.Mutex

	Logger   Logger
	Renderer Renderer

	NotFoundHandler         Handler
	SystemErrorHandler      Handler
	MethodNotAllowedHandler Handler
	// contains filtered or unexported fields
}

type Group struct {
	// contains filtered or unexported fields
}

type HTTPError struct {
	Code    int         `json:"-"`
	Message interface{} `json:"message"`
}

type Handler func(Context) error

type Logger interface {
	Debugf(format string, args ...interface{})
	Info(i ...interface{})
	Infof(format string, args ...interface{})
	Warn(i ...interface{})
	Warnf(format string, args ...interface{})
	Error(i ...interface{})
	Errorf(format string, args ...interface{})
	Fatal(i ...interface{})
	Fatalf(format string, args ...interface{})
	Panic(i ...interface{})
	Panicf(format string, args ...interface{})
}

type Map map[string]interface{}

type MiddlewareFunc func(Handler) Handler

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

type Route struct {
	// contains filtered or unexported fields
}

type RouteList []*Route

type RouteMatch struct {
	Route    *Route
	Handler  Handler
	PNames   []string
	PValues  []string
	MatchErr error
}

type RouteNames map[string]*Route

type Server struct {
	Name         string
	Host         string
	Port         int
	Addr         string
	Handler      http.Handler
	WriteTimeout time.Duration
	ReadTimeout  time.Duration
}