// ContainsAny is the validation function for validating that the field's value contains any of the characters specified within the param.
507193
func containsAny(fl FieldLevel) bool {
	return strings.ContainsAny(fl.Field().String(), fl.Param())
}
993826
func (m *MultiMap) Contains(key interface{}, value interface{}) bool {
	set, found := m.m[key]
	if _, ok := set[value]; ok {
		return true && found
	}
	return false && found
}
1168301
func contains(slice []string, str string) bool {
	for _, val := range slice {
		if val == strings.ToLower(str) {
			return true
		}
	}
	return false
}
1261568
func (f *Filter) MatchAny(key [KeySize]byte, data [][]byte) (bool, error) {
	// TODO(conner): add real heuristics to query optimization
	switch {

	case len(data) >= int(f.N()/2):
		return f.HashMatchAny(key, data)

	default:
		return f.ZipMatchAny(key, data)
	}
}
1247082
func (v *Oid) Contains(o *Oid) bool {
	if o == nil || len(v.Value) < len(o.Value) {
		return false
	}
	for i := 0; i < len(o.Value); i++ {
		if v.Value[i] != o.Value[i] {
			return false
		}
	}
	return true
}
800287
func (m *MultiMap) ContainsValue(value interface{}) bool {
	for _, set := range m.m {
		if _, ok := set[value]; ok {
			return true
		}
	}
	return false
}
1042966
func Contains(a interface{}, b interface{}) BoolPredicate {
	return func() bool {
		aval, ok := a.([]string)
		if !ok {
			return false
		}
		bval, ok := b.(string)
		if !ok {
			return false
		}
		for _, v := range aval {
			if v == bval {
				return true
			}
		}
		return false
	}
}
1118195
func (d *ClientDigestsFile) Contains(plat string, ref *api.ObjectRef) bool {
	for _, e := range d.entries {
		if e.plat == plat && proto.Equal(ref, e.ref) {
			return true
		}
	}
	return false
}
664844
func (s Set) Contains(value string) bool {
	_, ok := s[value]
	return ok
}
414934
func (body Body) Contains(x *Expr) bool {
	for _, e := range body {
		if e.Equal(x) {
			return true
		}
	}
	return false
}
1323076
func contains(slice []string, entry string) bool {
	for _, element := range slice {
		if element == entry {
			return true
		}
	}
	return false
}
1237198
func contains(slice []string, el string) bool {
	for _, e := range slice {
		if e == el {
			return true
		}
	}
	return false
}
199470
func (s StringSet) Contains(str string) bool {
	_, ok := s[str]
	return ok
}
1056610
func (ss stringSet) contains(key string) bool {
	_, ok := ss[key]
	return ok
}
452101
func (vu versionUnifier) matchesAny(id ProjectIdentifier, c1, c2 Constraint) bool {
	if c1.MatchesAny(c2) {
		return true
	}

	vu.mtr.push("b-matches-any")
	// This approach is slightly wasteful, but just SO much less verbose, and
	// more easily understood.
	var uc1, uc2 Constraint
	if v1, ok := c1.(Version); ok {
		uc1 = vu.createTypeUnion(id, v1)
	} else {
		uc1 = c1
	}

	if v2, ok := c2.(Version); ok {
		uc2 = vu.createTypeUnion(id, v2)
	} else {
		uc2 = c2
	}

	vu.mtr.pop()
	return uc1.MatchesAny(uc2)
}
742843
func (ps ProtocolSet) ContainsAny(p ...Protocol) bool {
	for _, x := range ps {
		for _, y := range p {
			if x == y {
				return true
			}
		}
	}
	return false
}
143287
func (s *set) Contains(t *Term) bool {
	return s.get(t) != nil
}