// Use adds a variable amount of Checkers onto the stack.
502637
func (c *Configure) Use(checkers ...Checker) {
	c.stack = append(c.stack, checkers...)
}
1019008
func (p *Prometheus) Use(e *gin.Engine) {
	e.Use(p.HandlerFunc())
	p.SetMetricsPath(e)
}
750484
func usage(errorMessage string) {
	appName := filepath.Base(os.Args[0])
	appName = strings.TrimSuffix(appName, filepath.Ext(appName))
	fmt.Fprintln(os.Stderr, errorMessage)
	fmt.Fprintln(os.Stderr, "Usage:")
	fmt.Fprintf(os.Stderr, "  %s [OPTIONS] <command> <args...>\n\n",
		appName)
	fmt.Fprintln(os.Stderr, showHelpMessage)
	fmt.Fprintln(os.Stderr, listCmdMessage)
}
501189
func (r *Router) Use(middlewares ...Middleware) {
	r.middlewares = append(r.middlewares, middlewares...)
}
1227357
func (p *IDPool) Use(id ID) bool {
	p.mutex.Lock()
	defer p.mutex.Unlock()

	return p.idCache.use(id)
}
597280
func (c *idCache) use(id ID) bool {
	if _, exists := c.leased[id]; !exists {
		return false
	}

	delete(c.leased, id)
	return true
}
36354
func Use(handler http.Handler, middleware ...func(http.Handler) http.Handler) http.Handler {
	for _, m := range middleware {
		handler = m(handler)
	}
	return handler
}
1262894
func (s *Server) Use(filters ...Filter) {
	s.filters = append(s.filters, filters...)
}
876228
func (fs CacheableFS) Use() (*libfs.FS, error) {
	return fs.fs.ChrootAsLibFS(fs.subdir)
}
490929
func (r *PortAllocator) Used() int {
	return r.portRange.Size - r.alloc.Free()
}
625046
func (o *Output) Used() bool {
	o.Lock()
	defer o.Unlock()
	return o.used
}
947001
func usage(out io.Writer, a Application, includeAdvanced bool) {
	usageTemplate := `{{.Title}}

Usage:  {{.Name}} [command] [arguments]

Commands:{{range .Commands}}
  {{.Name | printf "%%-%ds"}}  {{.ShortDesc}}{{end}}

{{if .EnvVars}}Environment Variables:{{range .EnvVars}}
  {{.Name | printf "%%-%ds"}}  {{.ShortDesc}}{{if .Default}} (Default: {{.Default | printf "%%q"}}){{end}}{{end}}

{{end}}
Use "{{.Name}} help [command]" for more information about a command.{{if .ShowAdvancedTip}}
Use "{{.Name}} help -advanced" to display all commands.{{end}}

`

	widestCmd := 0
	allCmds := a.GetCommands()
	cmds := make([]*Command, 0, len(allCmds))
	hasAdvanced := false
	for _, c := range allCmds {
		hasAdvanced = hasAdvanced || c.Advanced

		if !c.Advanced || includeAdvanced {
			// We need to include this command
			if namLen := len(c.Name()); namLen > widestCmd {
				widestCmd = namLen
			}
			cmds = append(cmds, c)
		}
	}

	type envVarEntry struct {
		Name      string
		ShortDesc string
		Default   string
	}
	widestEnvVar := 0
	envVars := []envVarEntry(nil)
	if envVarMap := a.GetEnvVars(); len(envVarMap) > 0 {
		envVarKeys := make(sort.StringSlice, 0, len(envVarMap))
		for k, v := range envVarMap {
			if v.Advanced {
				hasAdvanced = true
			}
			if !v.Advanced || includeAdvanced {
				if keyLen := len(k); keyLen > widestEnvVar {
					widestEnvVar = keyLen
				}
				envVarKeys = append(envVarKeys, k)
			}
		}
		envVarKeys.Sort()
		envVars = make([]envVarEntry, 0, len(envVarKeys))
		for _, k := range envVarKeys {
			v := envVarMap[k]
			envVars = append(envVars, envVarEntry{k, v.ShortDesc, v.Default})
		}
	}
	data := map[string]interface{}{
		"Title":           a.GetTitle(),
		"Name":            a.GetName(),
		"Commands":        cmds,
		"EnvVars":         envVars,
		"ShowAdvancedTip": (hasAdvanced && !includeAdvanced),
	}
	tmpl(out, fmt.Sprintf(usageTemplate, widestCmd, widestEnvVar), data)
}
891176
func (f *Fibre) Use(m MiddlewareFunc) MiddlewareFunc {
	f.middleware = append(f.middleware, m)
	return m
}
346791
func (b *JoinBuilder) Using(cols ...interface{}) *JoinBuilder {
	var vals Columns
	for _, c := range cols {
		var name string
		switch t := c.(type) {
		case string:
			name = t
		case ValExprBuilder:
			if n, ok := t.ValExpr.(*ColName); ok {
				name = n.Name
				break
			}
		}
		var v ValExpr
		if len(name) == 0 {
			v = makeErrVal("unsupported type %T: %v", c, c)
		} else if b.leftTable.column(name) == nil ||
			b.rightTable.column(name) == nil {
			v = makeErrVal("invalid join column: %s", name)
		} else {
			v = &ColName{Name: name}
		}
		vals = append(vals, &NonStarExpr{Expr: v})
	}
	b.Cond = &UsingJoinCond{Cols: vals}
	return b
}
860084
func (nap *NapNap) Use(mHandler MiddlewareHandler) {
	nap.handlers = append(nap.handlers, mHandler)
	nap.middleware = build(nap.handlers)
}
829196
func (e *Echo) Use(middleware ...interface{}) {
	for _, m := range middleware {
		e.ValidMiddleware(m)
		e.middleware = append(e.middleware, m)
		if e.MiddlewareDebug {
			e.logger.Debugf(`Middleware[Use](%p): [] -> %s `, m, HandlerName(m))
		}
	}
}
687830
func (s *Server) UseFunc(filters ...FilterFunc) {
	for _, f := range filters {
		s.filters = append(s.filters, f)
	}
}