// ANY registers the provided contextual Handler for all of the allowed http methods: GET, HEAD, POST, PUT, DELETE, TRACE, OPTIONS, CONNECT, PATCH
430264
func (r *Router) ANY(pattern string, handler func(Context)) Route {
	rt := r.Handle(allowedHTTPMethods[0], pattern, wrap(handler)).(*route)
	rt.withMethods(r.middlewares.BuildHandler(wrap(handler)), allowedHTTPMethods[1:]...)
	return rt
}
671749
func (s *Server) Any(path string, handler HandlerFunc, opts ...HandlerOption) {
	s.Match(methods[:], path, handler, opts...)
}
1226303
func (s *Server) Patch(path string, h HandlerFunc, opts ...HandlerOption) {
	s.register(http.MethodPatch, path, h, opts...)
}
15133
func (cg *ContextGroup) Handle(method, path string, handler http.HandlerFunc) {
	cg.group.Handle(method, path, func(w http.ResponseWriter, r *http.Request, params map[string]string) {
		if params != nil {
			r = r.WithContext(AddParamsToContext(r.Context(), params))
		}
		handler(w, r)
	})
}
457846
func (h *Handler) Handle(err error) {
	// Get HTTP request (if any)
	req, _ := httperr.HTTPRequest(err)

	notice := h.notifier.Notice(emperror.ExposeStackTrace(err), req, 1)

	// Extract context from the error and attach it to the notice
	notice.Params = keyvals.ToMap(emperror.Context(err))

	if h.sendSynchronously {
		_, _ = h.notifier.SendNotice(notice)
	} else {
		h.notifier.SendNoticeAsync(notice)
	}
}
1105936
func (d *SUIData3) Handler(notFound http.Handler, defaultDef string) http.Handler {
	return suihttp.Handler(d.as, notFound, d.index, d.def, defaultDef)
}
1187025
func (rcv groups) Any(fn func(group) bool) bool {
	for _, v := range rcv {
		if fn(v) {
			return true
		}
	}
	return false
}
1154436
func (f FuncRespHandler) Handle(resp *http.Response, ctx *ProxyCtx) *http.Response {
	return f(resp, ctx)
}
926303
func (r *Router) AnyFunc(pattern string, handler http.HandlerFunc) Route {
	return r.Any(pattern, http.HandlerFunc(handler))
}
602638
func Any(slice []string, handler func(string) bool) bool {
	for _, element := range slice {
		if handler(element) {
			return true
		}
	}
	return false
}
947664
func isContextHandler(handler interface{}) (context.Handler, bool) {
	h, is := handler.(context.Handler)
	if !is {
		fh, is := handler.(func(context.Context))
		if is {
			return fh, is
		}
	}
	return h, is
}
1081510
func anyMatch() regexpInfo {
	return regexpInfo{
		canEmpty: true,
		prefix:   []string{""},
		suffix:   []string{""},
		match:    allQuery,
	}
}
553209
func (t *Tango) Any(url string, c interface{}, middlewares ...Handler) {
	t.Route(SupportMethods, url, c, middlewares...)
	t.Route([]string{"HEAD:Get"}, url, c, middlewares...)
}
1270574
func (g *Group) Any(path string, handler HandlerFunc, middleware ...MiddlewareFunc) []*Route {
	routes := make([]*Route, len(methods))
	for i, m := range methods {
		routes[i] = g.Add(m, path, handler, middleware...)
	}
	return routes
}
1134682
func HTTPHandler(opts ...HandlerOption) Handler {
	h := &httpHandler{}
	h.Init(opts...)
	return h
}
750288
func (rg *RouteGroup) Any(path string, handlers ...Handler) *Route {
	return rg.To(strings.Join(Methods, ","), path, handlers...)
}
901715
func (p *Attempt_Partial) Any() bool {
	return (p.BackDeps || p.Data || p.Executions || p.FwdDeps ||
		p.Result == Attempt_Partial_NOT_LOADED)
}