// All verifies that all elements of units return true for the passed func. See: http://clipperhouse.github.io/gen/#All
423147
func (rcv units) All(fn func(*unit) bool) bool {
	for _, v := range rcv {
		if !fn(v) {
			return false
		}
	}
	return true
}
4777
func (s *stringSet) All() []string {
	all := []string{}
	for v := range s.values {
		all = append(all, v)
	}
	return all
}
926770
func (n *node) All(to interface{}, options ...func(*index.Options)) error {
	opts := index.NewOptions()
	for _, fn := range options {
		fn(opts)
	}

	query := newQuery(n, nil).Limit(opts.Limit).Skip(opts.Skip)
	if opts.Reverse {
		query.Reverse()
	}

	err := query.Find(to)
	if err != nil && err != ErrNotFound {
		return err
	}

	if err == ErrNotFound {
		ref := reflect.ValueOf(to)
		results := reflect.MakeSlice(reflect.Indirect(ref).Type(), 0, 0)
		reflect.Indirect(ref).Set(results)
	}
	return nil
}
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}
}
215777
func (s *OrganizationsStore) All(ctx context.Context) ([]chronograf.Organization, error) {
	err := validOrganization(ctx)
	if err != nil {
		return nil, err
	}

	ds, err := s.store.All(ctx)
	if err != nil {
		return nil, err
	}

	defaultOrg, err := s.store.DefaultOrganization(ctx)
	if err != nil {
		return nil, err
	}

	defaultOrgID := defaultOrg.ID

	// This filters organizations without allocating
	// https://github.com/golang/go/wiki/SliceTricks#filtering-without-allocating
	organizations := ds[:0]
	for _, d := range ds {
		id := d.ID
		switch id {
		case s.organization, defaultOrgID:
			organizations = append(organizations, d)
		default:
			continue
		}
	}

	return organizations, nil
}
52918
func (p *PullRequestsService) All() (pulls []PullRequest, result *Result) {
	result = p.client.get(p.URL, &pulls)
	return
}
224356
func Every(in interface{}, elements ...interface{}) bool {
	for _, elem := range elements {
		if !Contains(in, elem) {
			return false
		}
	}
	return true
}
316927
func (s Shrink) All() []interface{} {
	result := []interface{}{}
	value, ok := s()
	for ok {
		result = append(result, value)
		value, ok = s()
	}
	return result
}
916013
func All(wait time.Duration, stoppers ...Stopper) <-chan Signal {
	all := Make()
	go func() {
		var allChans []<-chan Signal
		for _, stopper := range stoppers {
			go stopper.Stop(wait)
			allChans = append(allChans, stopper.StopChan())
		}
		for _, ch := range allChans {
			<-ch
		}
		close(all)
	}()
	return all
}
373450
func (c *ServiceConfigs) All() map[string]*ServiceConfig {
	c.mu.RLock()
	defer c.mu.RUnlock()
	return c.m
}
1323894
func all(r bounds) uint64 {
	return getBits(r.min, r.max, 1) | starBit
}
285603
func (i *Index) All() []*Result {
	res := make([]*Result, len(i.charts))
	j := 0
	for name, ch := range i.charts {
		parts := strings.Split(name, verSep)
		res[j] = &Result{
			Name:  parts[0],
			Chart: ch,
		}
		j++
	}
	return res
}
506981
func (t *TeamsService) All(uri *Hyperlink, uriParams M) (
	teams []Team, result *Result) {
	url, err := ExpandWithDefault(uri, &OrganizationTeamsURL, uriParams)
	if err != nil {
		return []Team(nil), &Result{Err: err}
	}
	result = t.client.get(url, &teams)
	return
}
610271
func (s *set) Each(f func(item interface{}) bool) {
	for item := range s.m {
		if !f(item) {
			break
		}
	}
}
333199
func (s *StatsService) All(pair string, period, volume string) ([]Stats, error) {
	pair = strings.ToUpper(pair)

	params := url.Values{}
	if period != "" {
		params.Add("period", period)
	}
	if volume != "" {
		params.Add("volume", volume)
	}
	req, err := s.client.newRequest("GET", "stats/"+strings.ToUpper(pair), params)

	if err != nil {
		return nil, err
	}

	var stats []Stats
	_, err = s.client.do(req, &stats)

	if err != nil {
		return nil, err
	}

	return stats, nil
}
989582
func (c *Container) All() (o []rproc.Process) {
	c.mu.Lock()
	defer c.mu.Unlock()

	for _, p := range c.processes {
		o = append(o, p)
	}
	if c.process != nil {
		o = append(o, c.process)
	}
	return o
}
436694
func (o *Organizations) All(ctx context.Context) ([]chronograf.Organization, error) {
	files, err := o.ReadDir(o.Dir)
	if err != nil {
		return nil, err
	}

	orgs := []chronograf.Organization{}
	for _, file := range files {
		if path.Ext(file.Name()) != OrgExt {
			continue
		}
		var org chronograf.Organization
		if err := o.Load(path.Join(o.Dir, file.Name()), &org); err != nil {
			continue // We want to load all files we can.
		} else {
			orgs = append(orgs, org)
		}
	}
	return orgs, nil
}