// StreamsOnlineList 获取在线流
// @appname 应用名 为空时，忽略此参数
// @link  https://help.aliyun.com/document_detail/27192.html?spm=0.0.0.0.7uWhjM
774151
func (l *Live) StreamsOnlineList(resp interface{}) (err error) {
	req := l.cloneRequest(DescribeLiveStreamsOnlineListAction)
	err = l.rpc.Query(req, resp)
	return
}
918961
func (s *ChannelsService) List() *ChannelsListCall {
	var call ChannelsListCall
	call.service = s
	return &call
}
476545
func (c *Client) ProviderList() ([]*ct.Provider, error) {
	var providers []*ct.Provider
	return providers, c.Get("/providers", &providers)
}
412571
func (r *UpstreamService) List() *UpstreamListCall {
	c := &UpstreamListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	return c
}
219495
func (c *Client) ListPools(providers, names []string) ([]params.StoragePool, error) {
	args := params.StoragePoolFilters{
		Filters: []params.StoragePoolFilter{{
			Names:     names,
			Providers: providers,
		}},
	}
	var results params.StoragePoolsResults
	if err := c.facade.FacadeCall("ListPools", args, &results); err != nil {
		return nil, errors.Trace(err)
	}
	if len(results.Results) != 1 {
		return nil, errors.Errorf("expected 1 result, got %d", len(results.Results))
	}
	if err := results.Results[0].Error; err != nil {
		return nil, err
	}
	return results.Results[0].Result, nil
}
1267440
func List(c *deis.Client, appID string, results int) ([]api.Build, int, error) {
	u := fmt.Sprintf("/v2/apps/%s/builds/", appID)
	body, count, reqErr := c.LimitedRequest(u, results)

	if reqErr != nil && !deis.IsErrAPIMismatch(reqErr) {
		return []api.Build{}, -1, reqErr
	}

	var builds []api.Build
	if err := json.Unmarshal([]byte(body), &builds); err != nil {
		return []api.Build{}, -1, err
	}

	return builds, count, reqErr
}
1100807
func (s *Server) List(ctx context.Context, q *ApplicationQuery) (*appv1.ApplicationList, error) {
	appList, err := s.appclientset.ArgoprojV1alpha1().Applications(s.ns).List(metav1.ListOptions{})
	if err != nil {
		return nil, err
	}
	newItems := make([]appv1.Application, 0)
	for _, a := range appList.Items {
		if s.enf.Enforce(ctx.Value("claims"), rbacpolicy.ResourceApplications, rbacpolicy.ActionGet, appRBACName(a)) {
			newItems = append(newItems, a)
		}
	}
	newItems = argoutil.FilterByProjects(newItems, q.Projects)
	for i := range newItems {
		app := newItems[i]
		newItems[i] = app
	}
	appList.Items = newItems
	return appList, nil
}
1277316
func InStream(pattern string, stream io.Reader) *list.List {
	var (
		scanner = bufio.NewScanner(stream)
		sp      = NewShellPattern("*" + pattern + "*")
		line    string
		lineNo  int
		result  = list.New()
	)

	for scanner.Scan() {
		line = scanner.Text()
		if sp.Match(line) {
			result.PushBack(&Ref{lineNo, line})
		}
		lineNo++
	}
	return result
}
831704
func (r *ChannelService) PublicList() *ChannelPublicListCall {
	c := &ChannelPublicListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	return c
}
483050
func (c *Client) LogDrainList(appIdentity string, lr *ListRange) ([]LogDrain, error) {
	req, err := c.NewRequest("GET", "/apps/"+appIdentity+"/log-drains", nil, nil)
	if err != nil {
		return nil, err
	}

	if lr != nil {
		lr.SetHeader(req)
	}

	var logDrainsRes []LogDrain
	return logDrainsRes, c.DoReq(req, &logDrainsRes)
}
1061746
func (c *ContivClient) AppProfileList() (*[]*AppProfile, error) {
	// build key and URL
	url := c.baseURL + "/api/v1/appProfiles/"

	// http get the object
	var objList []*AppProfile
	err := c.httpGet(url, &objList)
	if err != nil {
		log.Debugf("Error getting appProfiles. Err: %v", err)
		return nil, err
	}

	return &objList, nil
}
823195
func (r *AppService) List() *AppListCall {
	c := &AppListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	return c
}
562767
func (c *Client) StreamAppLog(appID string, opts *logagg.LogOpts, output chan<- *ct.SSELogChunk) (stream.Stream, error) {
	path := fmt.Sprintf("/apps/%s/log", appID)
	if opts != nil {
		if encodedQuery := opts.EncodedQuery(); encodedQuery != "" {
			path = fmt.Sprintf("%s?%s", path, encodedQuery)
		}
	}
	return c.Stream("GET", path, nil, output)
}
1124195
func (r *AppPackageService) PublicList() *AppPackagePublicListCall {
	c := &AppPackagePublicListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	return c
}
916525
func (c *Client) List(name string) ([]os.FileInfo, error) {
	return c.ListN(name, 0)
}
220536
func (s *Stream) List() (size uint64, err error) {
	kind, size, err := s.Kind()
	if err != nil {
		return 0, err
	}
	if kind != List {
		return 0, ErrExpectedList
	}
	s.stack = append(s.stack, listpos{0, size})
	s.kind = -1
	s.size = 0
	return size, nil
}
1085522
func (r *AppRepo) List() ([]App, error) {
	apps := []App{}

	if err := r.DB.Select(&apps, "SELECT * FROM apps ORDER BY name ASC"); err != nil {
		return apps, err
	}

	return apps, nil
}