// List the ip forwarding rules
320264
func (c *Client) ListIpForwardingRules(p *ListIpForwardingRulesParameter) ([]*IpForwardingRule, error) {
	obj, err := c.Request("listIpForwardingRules", convertParamToMap(p))
	if err != nil {
		return nil, err
	}
	return obj.([]*IpForwardingRule), err
}
1238257
func (c *Client) ListNetworkOfferings(p *ListNetworkOfferingsParameter) ([]*NetworkOffering, error) {
	obj, err := c.Request("listNetworkOfferings", convertParamToMap(p))
	if err != nil {
		return nil, err
	}
	return obj.([]*NetworkOffering), err
}
873318
func ListIPServices(client *TwilioIPMessagingClient) (*IPServiceList, error) {
	var serviceList *IPServiceList

	body, err := client.get(nil, "/Services.json")

	if err != nil {
		return serviceList, err
	}

	serviceList = new(IPServiceList)
	serviceList.Client = client
	err = json.Unmarshal(body, serviceList)

	return serviceList, err
}
112051
func (f Firewall) getSecRules(seclist string) ([]response.SecRule, error) {
	// we only care about ingress rules
	name := fmt.Sprintf("seclist:%s", seclist)
	rulesFilter := []api.Filter{
		{
			Arg:   "dst_list",
			Value: name,
		},
	}
	rules, err := f.client.AllSecRules(rulesFilter)
	if err != nil {
		return nil, errors.Trace(err)
	}
	// gsamfira: the oracle compute API does not allow filtering by action
	ret := []response.SecRule{}
	for _, val := range rules.Result {
		// gsamfira: We set a default policy of DENY. No use in worrying about
		// DENY rules (if by any chance someone add one manually for some reason)
		if val.Action != common.SecRulePermit {
			continue
		}
		// We only care about rules that have a destination set
		// to a security list. Those lists get attached to VMs
		// NOTE: someone decided, when writing the oracle API
		// that some fields should be bool, some should be string.
		// never mind they both are boolean values...but hey.
		// I swear...some people like to watch the world burn
		if val.Dst_is_ip == "true" {
			continue
		}
		// We only care about rules that have an IP list as source
		if val.Src_is_ip == "false" {
			continue
		}
		ret = append(ret, val)
	}
	return ret, nil
}
322227
func (c *Client) LinodeIPList(linodeID *int, ipID *int) ([]LinodeIP, error) {
	args := make(map[string]interface{})
	args["LinodeID"] = linodeID
	args["IPAddressID"] = ipID

	data, err := c.apiCall("linode.ip.list", args)
	if err != nil {
		return nil, err
	}

	var out []LinodeIP
	err = unmarshalMultiMap(data, &out)
	if err != nil {
		return nil, err
	}

	return out, nil
}
138344
func (s *Service) PeeringList(ctx context.Context, spaceIdentity string, lr *ListRange) (PeeringListResult, error) {
	var peering PeeringListResult
	return peering, s.Get(ctx, &peering, fmt.Sprintf("/spaces/%v/peerings", spaceIdentity), nil, lr)
}
1113261
func (p *parserMixin) IPList() (target *[]net.IP) {
	target = new([]net.IP)
	p.IPListVar(target)
	return
}
276585
func (s ingressRouteNamespaceLister) List(selector labels.Selector) (ret []*v1alpha1.IngressRoute, err error) {
	err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
		ret = append(ret, m.(*v1alpha1.IngressRoute))
	})
	return ret, err
}
605881
func List(setname string) (*IPSet, error) {
	list, err := list(setname)
	if err != nil {
		return nil, err
	}
	return &list[0], nil
}
1258858
func (c *FakeIngresses) List(opts v1.ListOptions) (result *v1beta1.IngressList, err error) {
	obj, err := c.Fake.
		Invokes(testing.NewListAction(ingressesResource, ingressesKind, c.ns, opts), &v1beta1.IngressList{})

	if obj == nil {
		return nil, err
	}

	label, _, _ := testing.ExtractFromListOptions(opts)
	if label == nil {
		label = labels.Everything()
	}
	list := &v1beta1.IngressList{ListMeta: obj.(*v1beta1.IngressList).ListMeta}
	for _, item := range obj.(*v1beta1.IngressList).Items {
		if label.Matches(labels.Set(item.Labels)) {
			list.Items = append(list.Items, item)
		}
	}
	return list, err
}
901511
func ListIPUsers(client *TwilioIPMessagingClient, serviceSid string) (*IPUserList, error) {
	var userList *IPUserList

	body, err := client.get(nil, "/Services/"+serviceSid+"/Users.json")

	if err != nil {
		return userList, err
	}

	userList = new(IPUserList)
	userList.Client = client
	err = json.Unmarshal(body, userList)

	return userList, err
}
583756
func (api *API) ListPrivateNetworkServers(pn_id string) ([]Identity, error) {
	result := []Identity{}
	url := createUrl(api, privateNetworkPathSegment, pn_id, "servers")
	err := api.Client.Get(url, &result, http.StatusOK)
	if err != nil {
		return nil, err
	}
	return result, nil
}
1197115
func (s *NetworkACLService) ListNetworkACLs(p *ListNetworkACLsParams) (*ListNetworkACLsResponse, error) {
	resp, err := s.cs.newRequest("listNetworkACLs", p.toURLValues())
	if err != nil {
		return nil, err
	}

	var r ListNetworkACLsResponse
	if err := json.Unmarshal(resp, &r); err != nil {
		return nil, err
	}

	return &r, nil
}
619400
func ListIPRoles(client *TwilioIPMessagingClient, serviceSid string) (*IPRoleList, error) {
	var roleList *IPRoleList

	body, err := client.get(nil, "/Services/"+serviceSid+"/Roles.json")

	if err != nil {
		return roleList, err
	}

	roleList = new(IPRoleList)
	roleList.Client = client
	err = json.Unmarshal(body, roleList)

	return roleList, err
}
818660
func (s *NetworkACLService) ListNetworkACLLists(p *ListNetworkACLListsParams) (*ListNetworkACLListsResponse, error) {
	resp, err := s.cs.newRequest("listNetworkACLLists", p.toURLValues())
	if err != nil {
		return nil, err
	}

	var r ListNetworkACLListsResponse
	if err := json.Unmarshal(resp, &r); err != nil {
		return nil, err
	}

	return &r, nil
}
619867
func (api *API) ListPrivateNetworks(args ...interface{}) ([]PrivateNetwork, error) {
	url, err := processQueryParams(createUrl(api, privateNetworkPathSegment), args...)
	if err != nil {
		return nil, err
	}
	result := []PrivateNetwork{}
	err = api.Client.Get(url, &result, http.StatusOK)
	if err != nil {
		return nil, err
	}
	for index, _ := range result {
		result[index].api = api
	}
	return result, nil
}
1048953
func ListIPMessages(client *TwilioIPMessagingClient, serviceSid, channelSid string) (*IPMessageList, error) {
	var messageList *IPMessageList

	body, err := client.get(nil, "/Services/"+serviceSid+"/Channels/"+channelSid+"/Messages.json")

	if err != nil {
		return messageList, err
	}

	messageList = new(IPMessageList)
	messageList.Client = client
	err = json.Unmarshal(body, messageList)

	return messageList, err
}