// V returns whether the current clog verbosity is above the specified level.
352287
func V(level int) bool {
	if logger == nil {
		return false
	}
	return logger.V(level)
}
491512
func (n *notaryCommander) setVerbosityLevel() {
	if n.debug {
		logrus.SetLevel(logrus.DebugLevel)
	} else if n.verbose {
		logrus.SetLevel(logrus.InfoLevel)
	} else {
		logrus.SetLevel(logrus.WarnLevel)
	}
	logrus.SetOutput(os.Stderr)
}
1098705
func (l *logger) Verboseln(vals ...interface{}) {
	s := fmt.Sprintln(vals...)
	l.mut.Lock()
	defer l.mut.Unlock()
	l.logger.Output(2, "VERBOSE: "+s)
	l.callHandlers(LevelVerbose, s)
}
1068884
func (v *vsn) Compare(cv Version) (Precedence, Level) {
	// Standard version parts.
	switch {
	case v.major < cv.Major():
		return Older, Major
	case v.major > cv.Major():
		return Newer, Major
	case v.minor < cv.Minor():
		return Older, Minor
	case v.minor > cv.Minor():
		return Newer, Minor
	case v.patch < cv.Patch():
		return Older, Patch
	case v.patch > cv.Patch():
		return Newer, Patch
	}
	// Now the parts of the pre-release.
	cvpr := []string{}
	for _, cvprPart := range strings.Split(cv.PreRelease(), ".") {
		if cvprPart != "" {
			cvpr = append(cvpr, cvprPart)
		}
	}
	vlen := len(v.preRelease)
	cvlen := len(cvpr)
	count := vlen
	if cvlen < vlen {
		count = cvlen
	}
	for i := 0; i < count; i++ {
		vn, verr := strconv.Atoi(v.preRelease[i])
		cvn, cverr := strconv.Atoi(cvpr[i])
		if verr == nil && cverr == nil {
			// Numerical comparison.
			switch {
			case vn < cvn:
				return Older, PreRelease
			case vn > cvn:
				return Newer, PreRelease
			}
			continue
		}
		// Alphanumerical comparison.
		switch {
		case v.preRelease[i] < cvpr[i]:
			return Older, PreRelease
		case v.preRelease[i] > cvpr[i]:
			return Newer, PreRelease
		}
	}
	// Still no clean result, so the shorter
	// pre-relese is older.
	switch {
	case vlen < cvlen:
		return Newer, PreRelease
	case vlen > cvlen:
		return Older, PreRelease
	}
	// Last but not least: we are equal.
	return Equal, All
}
500874
func GetLevel() string {
	if l, ok := instance.(*log.Logger); ok {
		return l.GetLevel()
	}
	return "UNKNOWN"
}
345956
func (iter *dbCacheIterator) Prev() bool {
	// Nothing to return if cursor is exhausted.
	if iter.currentIter == nil {
		return false
	}

	// Move the current iterator to the previous entry and choose the
	// iterator that is both valid and has the larger key.
	iter.currentIter.Prev()
	return iter.chooseIterator(false)
}
1301876
func (s Semaphore) V(n int) {
	for i := 0; i < n; i++ {
		<-s
	}
}
406137
func SetVerbosity(level int) {
	log.Root().SetHandler(log.LvlFilterHandler(log.Lvl(level), log.StreamHandler(os.Stderr, log.TerminalFormat(false))))
}
913293
func ContainsLogIn(it Iterator, val Value) {
	if clog.V(4) {
		clog.Infof("%s %d CHECK CONTAINS %v", strings.ToUpper(it.Type().String()), it.UID(), val)
	}
}
677272
func LogLevel() string {
	envLevel := os.Getenv(EnvLog)
	if envLevel == "" {
		return ""
	}

	logLevel := "TRACE"
	if isValidLogLevel(envLevel) {
		// allow following for better ux: info, Info or INFO
		logLevel = strings.ToUpper(envLevel)
	} else {
		log.Printf("[WARN] Invalid log level: %q. Defaulting to level: TRACE. Valid levels are: %+v",
			envLevel, ValidLevels)
	}

	return logLevel
}
73430
func (s *XormLogger) Level() core.LogLevel {
	switch s.level {
	case glog.LvlError:
		return core.LOG_ERR
	case glog.LvlWarn:
		return core.LOG_WARNING
	case glog.LvlInfo:
		return core.LOG_INFO
	case glog.LvlDebug:
		return core.LOG_DEBUG
	default:
		return core.LOG_ERR
	}
}
679706
func (h *GlogHandler) Verbosity(level Lvl) {
	atomic.StoreUint32(&h.level, uint32(level))
}
884718
func (g *GRPCLogger) V(l int) bool {
	switch g.level {
	case "TRACE":
		// Enable ALL the verbosity!
		return true
	case "DEBUG":
		return l < 2
	case "INFO":
		return l < 1
	default:
		return false
	}
}
1228086
func (logger *Logger) GetLevel() Level {
	logger.mu.Lock()
	defer logger.mu.Unlock()
	return logger.Level
}
165047
func IsLogging(c context.Context, l Level) bool {
	return l >= GetLevel(c)
}
86871
func (c *ConfigLocal) SetVLogLevel(levelString string) {
	c.lock.Lock()
	defer c.lock.Unlock()
	c.vdebugSetting = levelString
	for _, vlog := range c.vlogs {
		vlog.Configure(levelString)
	}
}
315247
func (g *SimpleGraph) V() int {
	g.mutex.RLock()
	defer g.mutex.RUnlock()

	return g.v
}