// Route defines a customerize route to this group
322690
func (g *Group) Route(methods interface{}, url string, c interface{}, middlewares ...Handler) {
	g.routers = append(g.routers, groupRouter{methods, url, c, middlewares})
}
41294
func Convert_route_Route_To_v1_Route(in *route.Route, out *v1.Route, s conversion.Scope) error {
	return autoConvert_route_Route_To_v1_Route(in, out, s)
}
1099118
func (g *Group) Group(p string, o interface{}) {
	gr := getGroup(o)
	for _, gchild := range gr.routers {
		g.Route(gchild.methods, joinRoute(p, gchild.url), gchild.c, append(gr.handlers, gchild.handlers...)...)
	}
}
750288
func (rg *RouteGroup) Any(path string, handlers ...Handler) *Route {
	return rg.To(strings.Join(Methods, ","), path, handlers...)
}
163444
func (r *RouteGroup) To(methods, path string, handlers ...Handler) *Route {
	route := newRoute(path, r)
	for _, method := range strings.Split(methods, ",") {
		route.add(method, handlers)
	}
	return route
}
939858
func (g *Group) GET(path string, h HandlerFunc, m ...MiddlewareFunc) *Route {
	return g.Add(http.MethodGet, path, h, m...)
}
602161
func (g *routeGroup) Use(m ...Middleware) {
	g.middleware = append(g.middleware, m...)
}
985467
func (c *Clientset) Route() routeinternalversion.RouteInterface {
	return &fakerouteinternalversion.FakeRoute{Fake: &c.Fake}
}
304576
func (g *Group) Add(method, path string, handler HandlerFunc, middleware ...MiddlewareFunc) *Route {
	// Combine into a new slice to avoid accidentally passing the same slice for
	// multiple routes, which would lead to later add() calls overwriting the
	// middleware from earlier calls.
	m := make([]MiddlewareFunc, 0, len(g.middleware)+len(middleware))
	m = append(m, g.middleware...)
	m = append(m, middleware...)
	return g.echo.add(g.host, method, g.prefix+path, handler, m...)
}
901321
func (rm *RouteManager) Route(route *Route, logstream chan *Message) {
	for _, router := range LogRouters.All() {
		go router.Route(route, logstream)
	}
}
979450
func (r *router) POST(path string, handler Route) {
	r.group.POST(path, handler)
}
633585
func (s *Switch) route(packet *htlcPacket) error {
	command := &plexPacket{
		pkt: packet,
		err: make(chan error, 1),
	}

	select {
	case s.htlcPlex <- command:
	case <-s.quit:
		return ErrSwitchExiting
	}

	select {
	case err := <-command.err:
		return err
	case <-s.quit:
		return ErrSwitchExiting
	}
}
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
}
300620
func newRoute(path string, group *RouteGroup) *Route {
	path = group.prefix + path
	name := path

	// an asterisk at the end matches any number of characters
	if strings.HasSuffix(path, "*") {
		path = path[:len(path)-1] + "<:.*>"
	}

	route := &Route{
		group:    group,
		name:     name,
		path:     path,
		template: buildURLTemplate(path),
	}
	group.router.routes[name] = route

	return route
}
209489
func (cmd *Command) Route(router []string) *Command {
	child, end := cmd.SubRoute(router)
	if end != len(router) {
		return nil
	}
	return child
}
1180279
func (r *Router) Route(path string, h Handler, methods ...Method) {
	if path[0] != '/' {
		panic("path must begin with '/'")
	}
	if r.trees == nil {
		r.trees = make(map[Method]*node)
	}
	for _, method := range methods {
		root := r.trees[method]
		if root == nil {
			root = new(node)
			r.trees[method] = root
		}
		root.addRoute(path, h)
	}
}
302906
func (b *UpdateService) Routing(routing string) *UpdateService {
	b.routing = routing
	return b
}