// Not checks if the value matches not expected matcher
351344
func Not(expectedValue Matcher) *notValueMatcher {
	m := new(notValueMatcher)
	m.expectedValue = expectedValue
	return m
}
574884
func (bc *bitmapContainer) not(firstOfRange, endx int) container {
	answer := bc.clone()
	return answer.inot(firstOfRange, endx)
}
584789
func NotLike(col I, pattern string) Condition {
	return Condition{
		Type:  ConditionNotLike,
		Left:  NewOperand(col),
		Right: NewOperand(pattern),
	}
}
200399
func NotMatchHandler(key string, value interface{}, h LogHandler) LogHandler {
	return FilterHandler(func(r *Record) (pass bool) {
		return r.Context[key] != value
	}, h)
}
291604
func (api *NFSAPI) Exclude(key string) *NFSAPI {
	api.exclude(key)
	return api
}
371375
func NOT(p Predicate) Predicate {
	return func(r request.Request) bool {
		return !p(r)
	}
}
421078
func (gosec *Analyzer) ignore(n ast.Node) ([]string, bool) {
	if groups, ok := gosec.context.Comments[n]; ok && !gosec.ignoreNosec {
		for _, group := range groups {
			if strings.Contains(group.Text(), "#nosec") {
				gosec.stats.NumNosec++

				// Pull out the specific rules that are listed to be ignored.
				re := regexp.MustCompile(`(G\d{3})`)
				matches := re.FindAllStringSubmatch(group.Text(), -1)

				// If no specific rules were given, ignore everything.
				if len(matches) == 0 {
					return nil, true
				}

				// Find the rule IDs to ignore.
				var ignores []string
				for _, v := range matches {
					ignores = append(ignores, v[1])
				}
				return ignores, false
			}
		}
	}
	return nil, false
}
792368
func (b ValExprBuilder) NotLike(val interface{}) BoolExprBuilder {
	return b.makeComparisonExpr(astNotLike, makeValExpr(val))
}
685033
func (l *lex) matchNoConsume(m string) bool {
	return strings.HasPrefix(l.s[l.p:], m)
}
954906
func (p *parser) negation(t *Token) (Pattern, Error) {
	// a negation appears before a path specification, so
	// skip the negation token
	_next, _err := p.next()
	if _err != nil {
		return nil, _err
	}

	// extract the sequence of tokens for this path
	_tokens, _err := p.sequence(_next)
	if _err != nil {
		return nil, _err
	}

	// include the "negation" token at the front of the sequence
	_tokens = append([]*Token{t}, _tokens...)

	// return the Pattern instance
	return NewPattern(_tokens), nil
}
1139576
func NotLike(column, value string, escape ...string) Builder {
	return BuildFunc(func(d Dialect, buf Buffer) error {
		return buildLike(d, buf, column, value, true, escape)
	})
}
194433
func Is(expectedValue interface{}) *isMatcher {
	matcher := new(isMatcher)
	matcher.expectedValue = expectedValue
	return matcher
}
539263
func NotBlank(fl validator.FieldLevel) bool {
	field := fl.Field()

	switch field.Kind() {
	case reflect.String:
		return len(strings.TrimSpace(field.String())) > 0
	case reflect.Chan, reflect.Map, reflect.Slice, reflect.Array:
		return field.Len() > 0
	case reflect.Ptr, reflect.Interface, reflect.Func:
		return !field.IsNil()
	default:
		return field.IsValid() && field.Interface() != reflect.Zero(field.Type()).Interface()
	}
}
1225498
func notFunc(q query, t iterator) interface{} {
	switch v := q.Evaluate(t).(type) {
	case bool:
		return !v
	case query:
		node := v.Select(t)
		return node == nil
	default:
		return false
	}
}
607669
func Not(checker Checker) Checker {

	return func() (passed bool, errorMessage string) {
		if passed, errorMessage = checker(); passed {
			return false, fmt.Sprintf("Not(%s)", errorMessage)
		}

		return true, ""
	}
}
599548
func ignore(s string, blacklist []string) bool {
	for _, bad := range blacklist {
		if s == bad {
			return true
		}
	}
	return false
}
975797
func (self *Query) Skip(skip int) *Query {

	self.skip = skip

	return self
}