// Each triggers the callback for each, valid answer or any non 404 issue
518082
func (ListNics) Each(resp interface{}, callback IterateItemFunc) {
	items, ok := resp.(*ListNicsResponse)
	if !ok {
		callback(nil, fmt.Errorf("wrong type, ListNicsResponse was expected, got %T", resp))
		return
	}

	for i := range items.Nic {
		if !callback(&items.Nic[i], nil) {
			break
		}
	}
}
612539
func (f *FunctionStack) Each(d ...interface{}) {
	if f.Size() <= 0 {
		return
	}

	f.lock.RLock()
	for _, fx := range f.listeners {
		fx(d...)
	}
	f.lock.RUnlock()
}
744602
func (c *Client) All(ctx context.Context) ([]chronograf.User, error) {
	users, err := c.showUsers(ctx)
	if err != nil {
		return nil, err
	}

	// For all users we need to look up permissions to add to the user.
	for i, user := range users {
		perms, err := c.userPermissions(ctx, user.Name)
		if err != nil {
			return nil, err
		}

		user.Permissions = append(user.Permissions, perms...)
		users[i] = user
	}
	return users, nil
}
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)
}
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
}
733569
func (c Collector) Each(fx StringEachfunc) {
	var state bool
	for k, v := range c {
		if state {
			break
		}

		fx(v, k, func() {
			state = true
		})
	}
}
1205553
func (v *Value) EachObjxMap(callback func(int, Map) bool) *Value {
	for index, val := range v.MustObjxMapSlice() {
		carryon := callback(index, val)
		if !carryon {
			break
		}
	}
	return v
}
46051
func (u *URLQueryParameters) All() []URLQueryParameter {
	all := make([]URLQueryParameter, len(u.params))
	copy(all, u.params)
	return all
}
1108247
func (s *Set) Each(f func(item interface{}) bool) {
	s.l.RLock()
	defer s.l.RUnlock()

	for item := range s.m {
		if !f(item) {
			break
		}
	}
}
47866
func (s *Sublist) All(subs *[]*subscription) {
	s.RLock()
	s.collectAllSubs(s.root, subs)
	s.RUnlock()
}
324873
func (t *Pot) eachFrom(f func(Val) bool, po int) bool {
	if t == nil || t.size == 0 {
		return false
	}
	_, beg := t.getPos(po)
	for i := beg; i < len(t.bins); i++ {
		if !t.bins[i].each(f) {
			return false
		}
	}
	return f(t.pin)
}
116235
func (l *subCommandList) Each(fn func(string, *SubCommand)) {
	for _, item := range *l {
		if item.command.Hidden() {
			continue
		}
		fn(item.name, item.command)
	}
}
203077
func (ListTemplates) Each(resp interface{}, callback IterateItemFunc) {
	items, ok := resp.(*ListTemplatesResponse)
	if !ok {
		callback(nil, fmt.Errorf("wrong type, ListTemplatesResponse was expected, got %T", resp))
		return
	}

	for i := range items.Template {
		if !callback(&items.Template[i], nil) {
			break
		}
	}
}
1226218
func (ListServiceOfferings) Each(resp interface{}, callback IterateItemFunc) {
	items, ok := resp.(*ListServiceOfferingsResponse)
	if !ok {
		callback(nil, fmt.Errorf("wrong type, ListServiceOfferingsResponse was expected, got %T", resp))
		return
	}

	for i := range items.ServiceOffering {
		if !callback(&items.ServiceOffering[i], nil) {
			break
		}
	}
}
1324922
func (this Collection) Each(f func(*Context)) Collection {
    for _, c := range this {
        f(c)
    }

    return this
}
1204257
func (em *EventManager) EachManager(fx EventManagerHandler) {
	em.wo.Lock()
	for eo := range em.attaches {
		fx(eo)
	}
	em.wo.Unlock()
}
807190
func (ListNetworkOfferings) Each(resp interface{}, callback IterateItemFunc) {
	items, ok := resp.(*ListNetworkOfferingsResponse)
	if !ok {
		callback(nil, fmt.Errorf("wrong type, ListNetworkOfferingsResponse was expected, got %T", resp))
		return
	}

	for i := range items.NetworkOffering {
		if !callback(&items.NetworkOffering[i], nil) {
			break
		}
	}
}