// DoAll implements the KeyStringValueTree interface.
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))
	})
}
1066802
func (h *RevelHeader) GetAll(key string) (values []string) {
	if h.Server != nil {
		values = h.Server.Get(key)
	}
	return
}
1220299
func (s *stringSet) FindAll(f func(v string) (bool, error)) ([]string, error) {
	found := []string{}
	for v := range s.values {
		ok, err := f(v)
		if err != nil {
			return nil, errors.Annotate(err, ErrFindAll, errorMessages)
		}
		if ok {
			found = append(found, v)
		}
	}
	return found, nil
}
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
}
1208039
func (n *node) doAll(f func(dn *node) error) error {
	if err := f(n); err != nil {
		return errors.Annotate(err, ErrNodeDoAll, errorMessages)
	}
	for _, child := range n.children {
		if err := child.doAll(f); err != nil {
			return errors.Annotate(err, ErrNodeDoAll, errorMessages)
		}
	}
	return nil
}
1350014
func All(asyncs ...Async) Async {
	return &asyncImpl{
		cancel: func() {
			for _, a := range asyncs {
				a.Cancel()
			}
		},
		promise: Promise(func() error {
			errs := make([]error, 0)
			for _, a := range asyncs {
				err := <-a.Result()
				if err != nil {
					errs = append(errs, err)
				}
			}
			if len(errs) > 0 {
				return &GroupError{Errs: errs}
			}
			return nil
		}),
	}
}
128074
func all(thread *Thread, _ *Builtin, args Tuple, kwargs []Tuple) (Value, error) {
	var iterable Iterable
	if err := UnpackPositionalArgs("all", args, kwargs, 1, &iterable); err != nil {
		return nil, err
	}
	iter := iterable.Iterate()
	defer iter.Done()
	var x Value
	for iter.Next(&x) {
		if !x.Truth() {
			return False, nil
		}
	}
	return True, nil
}
644705
func (t *stringTree) FindAll(f func(v string) (bool, error)) []StringChanger {
	ns, err := t.container.root.findAll(func(fn *node) (bool, error) {
		return f(fn.content.value().(string))
	})
	if err != nil {
		return []StringChanger{&stringChanger{nil, err}}
	}
	var cs []StringChanger
	for _, n := range ns {
		cs = append(cs, &stringChanger{n, nil})
	}
	return cs
}
824374
func (s *stringStack) All() []string {
	sl := len(s.values)
	all := make([]string, sl)
	copy(all, s.values)
	return all
}
1258051
func replaceAll(s string, args ...string) string {
	switch len(args) {
	case 0:
		return s
	case 1:
		return strings.Replace(s, args[0], "", -1)
	default:
		return strings.Replace(s, args[0], args[1], -1)
	}
}
1183681
func (exp *TernaryIfExpr) All() []Node {
	return []Node{exp.Cond, exp.TrueX, exp.FalseX}
}
878811
func (b *SampleJSONBuilder) AddAll() *SampleJSONBuilder {
	b._properties["Str"] = b.Str
	b._properties["Foo"] = b.Foo
	return b
}
731703
func (e *etc) Do(path string, f func(p string) error) error {
	fullPath := makeFullPath(path)
	changer := e.values.At(fullPath...)
	if changer.Error() != nil {
		return changer.Error()
	}
	kvs, err := changer.List()
	if err != nil {
		return err
	}
	for _, kv := range kvs {
		p := pathToString(append(fullPath, kv.Key))
		err := f(p)
		if err != nil {
			return err
		}
	}
	return nil
}
878183
func (m *SortedMap) Each(prefix string, handle func(key string, value interface{}) bool) bool {
	return m.trie.Allprefixed([]byte(prefix), func(k []byte, v interface{}) bool {
		return handle(string(k), v)
	})
}
854270
func (m *MemoryStorer) All() ([]string, error) {
	m.mut.RLock()
	defer m.mut.RUnlock()

	sessions := make([]string, len(m.sessions))

	i := 0
	for id := range m.sessions {
		sessions[i] = id
		i++
	}

	return sessions, nil
}
169464
func (store *MemoryStore) All() []string {
	store.RLock()
	defer store.RUnlock()
	if !store.opened {
		ERROR.Println(STR, "Trying to use memory store, but not open")
		return nil
	}
	keys := []string{}
	for k := range store.messages {
		keys = append(keys, k)
	}
	return keys
}
498087
func (mod Mod) All() []string {
	all := make(map[string]bool)
	for _, p := range mod.Changed {
		all[p] = true
	}
	for _, p := range mod.Added {
		all[p] = true
	}
	return _keys(all)
}