// All gets a list of all repositories associated with the url of the service
//
// https://developer.github.com/v3/repos/#list-your-repositories
979508
func (r *RepositoriesService) All(uri *Hyperlink, params M) (repos []Repository,
	result *Result) {
	if uri == nil && len(params) == 0 {
		uri = &UserRepositoriesURL
	} else if uri == nil {
		uri = &AllRepositoriesURL
	}
	url, err := uri.Expand(params)
	if err != nil {
		return nil, &Result{Err: err}
	}
	result = r.client.get(url, &repos)
	return
}
931046
func (e *Elem) All() []dns.RR {
	list := []dns.RR{}
	for _, rrs := range e.m {
		list = append(list, rrs...)
	}
	return list
}
374837
func (s *UsersStore) All(ctx context.Context) ([]chronograf.User, error) {
	return s.AllF(ctx)
}
398505
func (service *ProjectService) List() ([]*Project, *http.Response, error) {
	req, err := service.client.NewRequest("GET", "projects", nil)
	if err != nil {
		return nil, nil, err
	}

	var projects []*Project
	resp, err := service.client.Do(req, &projects)
	if err != nil {
		return nil, resp, err
	}

	return projects, resp, err
}
1091033
func All(settings environment.EnvSettings) Providers {
	result := Providers{
		{
			Schemes: []string{"http", "https"},
			New:     newHTTPGetter,
		},
	}
	pluginDownloaders, _ := collectPlugins(settings)
	result = append(result, pluginDownloaders...)
	return result
}
4467
func (crs *ConfigRepoService) List(ctx context.Context) (repos []*ConfigRepo, resp *APIResponse, err error) {
	r := &ConfigReposListResponse{}
	_, resp, err = crs.client.getAction(ctx, &APIClientRequest{
		Path:         "admin/config_repos",
		ResponseBody: r,
		APIVersion:   apiV1,
	})

	for _, repos := range r.Embedded.Repos {
		repos.client = crs.client
	}
	repos = r.Embedded.Repos

	return
}
1217908
func (r *Repo) FindAll(ctx context.Context) ([]eh.Entity, error) {
	r.FindAllCalled = true
	if r.LoadErr != nil {
		return nil, r.LoadErr
	}
	return r.Entities, nil
}
673107
func (sp statePersistence) All(collName string, query, docs interface{}) error {
	coll, closeColl := sp.st.db().GetCollection(collName)
	defer closeColl()

	if err := coll.Find(query).All(docs); err != nil {
		return errors.Trace(err)
	}
	return nil
}
46051
func (u *URLQueryParameters) All() []URLQueryParameter {
	all := make([]URLQueryParameter, len(u.params))
	copy(all, u.params)
	return all
}
754591
func (r *Router) All(path string, fn http.HandlerFunc) *Router {
	r.Route(path).All(fn)
	return r
}
292582
func (mp ModelPayloads) ListAll() ([]payload.FullPayloadInfo, error) {
	coll, closer := mp.db.GetCollection(payloadsC)
	defer closer()

	var docs []payloadDoc
	if err := coll.Find(nil).All(&docs); err != nil {
		return nil, errors.Trace(err)
	}
	return nsPayloads.asPayloads(docs), nil
}
1288015
func (c *ClientOperations) All(fn string, args ...interface{}) {
	c.e.callGroupMethod(c.relay, "Global", fn, args...)
}
269611
func (be *Backend) GetAll(c context.Context, t backend.GetAllTarget, path string, p backend.Params) (
	[]*config.Config, error) {

	svc := be.GetConfigInterface(c, p.Authority)

	var fn func(context.Context, string, bool) ([]config.Config, error)
	switch t {
	case backend.GetAllProject:
		fn = svc.GetProjectConfigs
	case backend.GetAllRef:
		fn = svc.GetRefConfigs
	default:
		return nil, errors.Reason("unknown GetAllType: %q", t).Err()
	}

	cfgs, err := fn(c, path, !p.Content)
	if err != nil || len(cfgs) == 0 {
		return nil, translateConfigErr(err)
	}

	items := make([]*config.Config, len(cfgs))
	for i := range cfgs {
		items[i] = makeItem(&cfgs[i])
	}
	return items, nil
}
137668
func (s *ServicesService) List(options *ListServicesOptions) ([]*Service, *http.Response, error) {
	return s.ListWithContext(context.TODO(), options)
}
978611
func (s *PacketStore) All() []packet.Generic {
	s.mutex.RLock()
	defer s.mutex.RUnlock()

	var all []packet.Generic

	for _, pkt := range s.packets {
		all = append(all, pkt)
	}

	return all
}
183731
func (reg *registry) Repositories(ctx context.Context, repos []string, last string) (n int, err error) {
	var finishedWalk bool
	var foundRepos []string

	if len(repos) == 0 {
		return 0, errors.New("no space in slice")
	}

	root, err := pathFor(repositoriesRootPathSpec{})
	if err != nil {
		return 0, err
	}

	err = reg.blobStore.driver.Walk(ctx, root, func(fileInfo driver.FileInfo) error {
		err := handleRepository(fileInfo, root, last, func(repoPath string) error {
			foundRepos = append(foundRepos, repoPath)
			return nil
		})
		if err != nil {
			return err
		}

		// if we've filled our array, no need to walk any further
		if len(foundRepos) == len(repos) {
			finishedWalk = true
			return driver.ErrSkipDir
		}

		return nil
	})

	n = copy(repos, foundRepos)

	if err != nil {
		return n, err
	} else if !finishedWalk {
		// We didn't fill buffer. No more records are available.
		return n, io.EOF
	}

	return n, err
}
560722
func (a *AuthorizationsService) All() (auths []Authorization, result *Result) {
	result = a.client.get(a.URL, &auths)
	return
}