urit

type FixedMatchOption interface {
	Match(value string, expected string, pathPos int, vars PathVars) bool
}

type Headers interface {
	HeadersOption
	Set(key string, value interface{}) Headers
	Get(key string) (interface{}, bool)
	Has(key string) bool
	Del(key string) Headers
	Clone() Headers
}

type HeadersOption interface {
	GetHeaders() (map[string]string, error)
}

type Host interface {
	HostOption
}

type HostOption interface {
	GetAddress() string
}

type PathVar struct {
	Name          string
	NamedPosition int
	Position      int
	Value         interface{}
}

type PathVars interface {
	GetPositional(position int) (string, bool)
	GetNamed(name string, position int) (string, bool)
	GetNamedFirst(name string) (string, bool)
	GetNamedLast(name string) (string, bool)
	Get(idents ...interface{}) (string, bool)
	GetAll() []PathVar
	Len() int
	Clear()
	// VarsType returns the path vars type (Positions or Names)
	VarsType() PathVarsType
	AddNamedValue(name string, val interface{}) error
	AddPositionalValue(val interface{}) error
}

type PathVarsType int

type QueryParams interface {
	QueryParamsOption
	Get(key string) (interface{}, bool)
	GetIndex(key string, index int) (interface{}, bool)
	Set(key string, value interface{}) QueryParams
	Add(key string, value interface{}) QueryParams
	Del(key string) QueryParams
	Has(key string) bool
	Sorted(on bool) QueryParams
	Clone() QueryParams
}

type QueryParamsOption interface {
	GetQuery() (string, error)
}

type Stringable interface {
	String() string
}

type Template interface {
	// PathFrom generates a path from the template given the specified path vars
	PathFrom(vars PathVars, options ...interface{}) (string, error)
	// RequestFrom generates a http.Request from the template given the specified path vars
	RequestFrom(method string, vars PathVars, body io.Reader, options ...interface{}) (*http.Request, error)
	// Matches checks whether the specified path matches the template -
	// and if a successful match, returns the extracted path vars
	Matches(path string, options ...interface{}) (PathVars, bool)
	// MatchesUrl checks whether the specified URL path matches the template -
	// and if successful match, returns the extracted path vars
	MatchesUrl(u url.URL, options ...interface{}) (PathVars, bool)
	// MatchesRequest checks whether the specified request matches the template -
	// and if a successful match, returns the extracted path vars
	MatchesRequest(req *http.Request, options ...interface{}) (PathVars, bool)
	// Sub generates a new template with added sub-path
	Sub(path string, options ...interface{}) (Template, error)
	// ResolveTo generates a new template, filling in any known path vars from the supplied vars
	ResolveTo(vars PathVars) (Template, error)
	// VarsType returns the path vars type (Positions or Names)
	VarsType() PathVarsType
	// Vars returns the path vars of the template
	Vars() []PathVar
	// OriginalTemplate returns the original (or generated) path template string
	OriginalTemplate() string
	// Template returns the template (optionally with any path var patterns removed)
	Template(removePatterns bool) string
}

type TemplateParseError interface {
	error
	Unwrap() error
	Position() int
}

type VarMatchOption interface {
	Applicable(value string, position int, name string, rx *regexp.Regexp, rxs string, pathPos int, vars PathVars) bool
	Match(value string, position int, name string, rx *regexp.Regexp, rxs string, pathPos int, vars PathVars) (string, bool)
}