// All returns a SchemaValidateFunc which tests if the provided value
// passes all provided SchemaValidateFunc
189840
func All(validators ...schema.SchemaValidateFunc) schema.SchemaValidateFunc {
	return func(i interface{}, k string) ([]string, []error) {
		var allErrors []error
		var allWarnings []string
		for _, validator := range validators {
			validatorWarnings, validatorErrors := validator(i, k)
			allWarnings = append(allWarnings, validatorWarnings...)
			allErrors = append(allErrors, validatorErrors...)
		}
		return allWarnings, allErrors
	}
}
553062
func (t *keyStringValueTree) DoAll(f func(k, v string) error) error {
	return t.container.root.doAll(func(dn *node) error {
		return f(dn.content.key().(string), dn.content.value().(string))
	})
}
662681
func (set *Set) All(items ...interface{}) bool {
	set.lock.RLock()
	defer set.lock.RUnlock()

	for _, item := range items {
		if _, ok := set.items[item]; !ok {
			return false
		}
	}

	return true
}
722698
func (t *keyStringValueTree) DoAllDeep(f func(ks []string, v string) error) error {
	return t.container.root.doAll(func(dn *node) error {
		keys := []string{}
		cn := dn
		for cn != nil {
			keys = append([]string{cn.content.key().(string)}, keys...)
			cn = cn.parent
		}
		return f(keys, dn.content.value().(string))
	})
}
1084381
func (t *Table) All() ValExprBuilder {
	list := make([]interface{}, len(t.Columns))
	for i, col := range t.Columns {
		list[i] = &ColName{Name: col.Name, Qualifier: t.aliasOrName()}
	}
	return ValExprBuilder{makeValTuple(list)}
}
1092912
func (a *AnnotationStore) All(ctx context.Context, start, stop time.Time) ([]chronograf.Annotation, error) {
	return a.queryAnnotations(ctx, fmt.Sprintf(AllAnnotations, start.UnixNano(), stop.UnixNano()))
}
754591
func (r *Router) All(path string, fn http.HandlerFunc) *Router {
	r.Route(path).All(fn)
	return r
}
738087
func (v *Schema) Validate(l JSONLoader) (*Result, error) {
	root, err := l.LoadJSON()
	if err != nil {
		return nil, err
	}
	return v.validateDocument(root), nil
}
432735
func (v *Value_Str) Check(schema *Schema) error {
	switch s := schema.Schema.(type) {
	case *Schema_Str:
		maxLen := s.Str.MaxLength
		if maxLen > 0 && uint32(len(v.Str)) > maxLen {
			return fmt.Errorf("value is too large: %d > %d", len(v.Str), maxLen)
		}

	case *Schema_Enum:
		if !s.Enum.Has(v.Str) {
			return fmt.Errorf("value does not match enum: %q", v.Str)
		}

	default:
		panic(fmt.Errorf("for Value_Str: unknown schema %T", s))
	}

	return nil
}
104566
func containsAllKeyValues(actualKVs []*v1alpha.KeyValue, requiredKVs []*v1alpha.KeyValue) bool {
	for _, requiredKV := range requiredKVs {
		actualValue, ok := findInKeyValues(actualKVs, requiredKV.Key)
		if !ok || actualValue != requiredKV.Value {
			return false
		}
	}
	return true
}
847789
func (q Query) All(predicate func(interface{}) bool) bool {
	next := q.Iterate()

	for item, ok := next(); ok; item, ok = next() {
		if !predicate(item) {
			return false
		}
	}

	return true
}
818449
func (s *set) DoAll(f func(v interface{}) error) error {
	for v := range s.values {
		if err := f(v); err != nil {
			return errors.Annotate(err, ErrDoAll, errorMessages)
		}
	}
	return nil
}
397774
func (b *Boolean) Schema(schema interface{}) *Boolean {
	checkSchema(&b.chain, b.value, schema)
	return b
}
1046912
func (pd *DocumentIterator) All(document Document) (interface{}, error) {
	pd.loadInternal()

	documents := slice(document)
	err := pd.iterator.All(documents)
	if err != nil {
		return nil, err
	}

	return results(documents)
}
855277
func (p *PhysicalProperty) AllColsFromSchema(schema *expression.Schema) bool {
	for _, col := range p.Items {
		if schema.ColumnIndex(col.Col) == -1 {
			return false
		}
	}
	return true
}
385003
func (s *Spec) SchemasWithAllOf() (result []SchemaRef) {
	for _, v := range s.allOfs {
		result = append(result, v)
	}
	return
}
1041101
func All(err error) []error {
	if ec, ok := err.(*errorCollection); ok {
		all := make([]error, len(ec.errs))
		copy(all, ec.errs)
		return all
	}
	return []error{err}
}