// Not reverses the results of its given child matcher.
//
// Example usage:
//   Not(Eq(5)).Matches(4) // returns true
//   Not(Eq(5)).Matches(5) // returns false
389
func Not(x interface{}) Matcher {
	if m, ok := x.(Matcher); ok {
		return notMatcher{m}
	}
	return notMatcher{Eq(x)}
}
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()
	}
}
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, ""
	}
}
733994
func match(a, b string) bool {
	if wildcard(a) {
		return true
	}
	if wildcard(b) {
		return true
	}
	return strings.EqualFold(a, b)
}
113753
func (e BoolExprBuilder) Not() BoolExprBuilder {
	return BoolExprBuilder{
		&NotExpr{
			Op:   astNotExpr,
			Expr: &ParenBoolExpr{Expr: e.BoolExpr},
		}}
}
223288
func (f Filter) NotLike(val interface{}) Filter {
	f.Op = "!~"
	f.Val = val
	return f
}
579012
func Not(r ReqCondition) ReqConditionFunc {
	return func(req *http.Request, ctx *ProxyCtx) bool {
		return !r.HandleReq(req, ctx)
	}
}
62480
func (o querySet) Exclude(expr string, args ...interface{}) QuerySeter {
	if o.cond == nil {
		o.cond = NewCondition()
	}
	o.cond = o.cond.AndNot(expr, args...)
	return &o
}
164204
func (session *Session) NotIn(column string, args ...interface{}) *Session {
	session.Statement.NotIn(column, args...)
	return session
}
574029
func (s *Suite) Not(result *Assertion, messages ...string) *Assertion {
	assertion := s.setup(fmt.Sprintf("Expected assertion to fail"), messages)
	if result.Passed {
		assertion.fail()
	} else {
		result.Passed = true
		assertion.testFunc.resetLastError()
	}
	return assertion
}
1241871
func (c Condition) None() bool {
	return (c.Type == ConditionAnd ||
		c.Type == ConditionOr ||
		c.Type == ConditionNot) &&
		len(c.Inner) == 0
}
227698
func (r *Range) Contains(other Version) bool {
	return other.Compare(&r.Begin) >= 0 && other.Compare(&r.End) < 0
}
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)
	})
}
1024009
func (s *DB) Not(query interface{}, args ...interface{}) *DB {
	return s.clone().search.Not(query, args...).db
}
632698
func (q Query) Except(q2 Query) Query {
	return Query{
		Iterate: func() Iterator {
			next := q.Iterate()

			next2 := q2.Iterate()
			set := make(map[interface{}]bool)
			for i, ok := next2(); ok; i, ok = next2() {
				set[i] = true
			}

			return func() (item interface{}, ok bool) {
				for item, ok = next(); ok; item, ok = next() {
					if _, has := set[item]; !has {
						return
					}
				}

				return
			}
		},
	}
}
107102
func not(arg interface{}) (truth bool) {
	truth, _ = isTrue(reflect.ValueOf(arg))
	return !truth
}
1046688
func (m *Mux) Match(ctx *c.Context) bool {
	for _, matcher := range m.Matchers {
		if !matcher(ctx) {
			return false
		}
	}
	return true
}