Retrieve installed trap, drop and bypass policies.

        :param filters: retrieve only matching policies (optional)
        :type filters: dict
        :return: list of installed trap, drop and bypass policies
        :rtype: list
963841
def list_policies(self, filters=None):
        
        _, policy_list = self.handler.streamed_request("list-policies",
                                                       "list-policy", filters)
        return policy_list
436060
public static appflowpolicylabel[] get_filtered(nitro_service service, String filter) throws Exception{
		appflowpolicylabel obj = new appflowpolicylabel();
		options option = new options();
		option.set_filter(filter);
		appflowpolicylabel[] response = (appflowpolicylabel[]) obj.getfiltered(service, option);
		return response;
	}
585803
public static pqpolicy[] get_filtered(nitro_service service, String filter) throws Exception{
		pqpolicy obj = new pqpolicy();
		options option = new options();
		option.set_filter(filter);
		pqpolicy[] response = (pqpolicy[]) obj.getfiltered(service, option);
		return response;
	}
363130
public static transformpolicy[] get_filtered(nitro_service service, String filter) throws Exception{
		transformpolicy obj = new transformpolicy();
		options option = new options();
		option.set_filter(filter);
		transformpolicy[] response = (transformpolicy[]) obj.getfiltered(service, option);
		return response;
	}
677718
def filters(self):
        
        params = {}
        for _filter in self._filters:
            params.update(_filter)

        return params
554266
public static vpnurl[] get_filtered(nitro_service service, String filter) throws Exception{
		vpnurl obj = new vpnurl();
		options option = new options();
		option.set_filter(filter);
		vpnurl[] response = (vpnurl[]) obj.getfiltered(service, option);
		return response;
	}
891845
def logging_list_filters(**kwargs):
    
    ctx = Context(**kwargs)
    ctx.execute_action('logging:list_filters', **{
        'logging_service': ctx.repo.create_secure_service('logging'),
    })
1020048
async def ListFilesystems(self, filters):
        '''
        
        '''
        # map input types to rpc msg
        _params = dict()
        msg = dict(type='Storage',
                   request='ListFilesystems',
                   version=4,
                   params=_params)
        _params['filters'] = filters
        reply = await self.rpc(msg)
        return reply
396497
def allow_filtering(self):
        
        clone = copy.deepcopy(self)
        clone._allow_filtering = True
        return clone
1337345
public static systemuser[] get_filtered(nitro_service service, String filter) throws Exception{
		systemuser obj = new systemuser();
		options option = new options();
		option.set_filter(filter);
		systemuser[] response = (systemuser[]) obj.getfiltered(service, option);
		return response;
	}
982442
public static transformpolicylabel[] get_filtered(nitro_service service, String filter) throws Exception{
		transformpolicylabel obj = new transformpolicylabel();
		options option = new options();
		option.set_filter(filter);
		transformpolicylabel[] response = (transformpolicylabel[]) obj.getfiltered(service, option);
		return response;
	}
605224
def readFILTERLIST(self):
        
        number = self.readUI8()
        return [self.readFILTER() for _ in range(number)]
167840
def _get_policy_object(platform,
                       filters=None,
                       pillar_key='acl',
                       pillarenv=None,
                       saltenv=None,
                       merge_pillar=True):
    '''
    
    '''
    policy = _Policy()
    policy_filters = []
    if not filters:
        filters = []
    for filter_ in filters:
        if not filter_ or not isinstance(filter_, dict):
            continue  # go to the next filter
        filter_name = filter_.keys()[0]
        filter_config = filter_.values()[0]
        header = capirca.lib.policy.Header()  # same header everywhere
        target_opts = [
            platform,
            filter_name
        ]
        filter_options = filter_config.pop('options', None)
        if filter_options:
            filter_options = _make_it_list({}, filter_name, filter_options)
            # make sure the filter options are sent as list
            target_opts.extend(filter_options)
        target = capirca.lib.policy.Target(target_opts)
        header.AddObject(target)
        filter_terms = []
        for term_ in filter_config.get('terms', []):
            if term_ and isinstance(term_, dict):
                term_name = term_.keys()[0]
                term_fields = term_.values()[0]
                term = _get_term_object(filter_name,
                                        term_name,
                                        pillar_key=pillar_key,
                                        pillarenv=pillarenv,
                                        saltenv=saltenv,
                                        merge_pillar=merge_pillar,
                                        **term_fields)
            filter_terms.append(term)
        policy_filters.append(
            (header, filter_terms)
        )
    policy.filters = policy_filters
    log.debug('Policy config:')
    log.debug(six.text_type(policy))
    platform_generator = _import_platform_generator(platform)
    policy_config = platform_generator(policy, 2)
    log.debug('Generating policy config for %s:', platform)
    log.debug(six.text_type(policy_config))
    return policy_config
1347436
public static prune_policy[] get_filtered(nitro_service service, String filter) throws Exception
	{
		prune_policy obj = new prune_policy();
		options option = new options();
		option.set_filter(filter);
		prune_policy[] response = (prune_policy[]) obj.getfiltered(service, option);
		return response;
	}
804964
def get_default_filters(self, **resources):
        
        return dict((k, (v, False)) for k, v in resources.items()
                    if k in self._meta.fields)
658080
public static ipset[] get_filtered(nitro_service service, String filter) throws Exception{
		ipset obj = new ipset();
		options option = new options();
		option.set_filter(filter);
		ipset[] response = (ipset[]) obj.getfiltered(service, option);
		return response;
	}
496413
def get_filters(self, request, **resources):
        
        filters = dict()

        if not self._meta.fields:
            return filters

        for field in request.GET.iterkeys():
            tokens = field.split(LOOKUP_SEP)
            field_name = tokens[0]

            if field_name not in self._meta.fields:
                continue

            exclude = False
            if tokens[-1] == 'not':
                exclude = True
                tokens.pop()

            value = request.GET.getlist(field)
            if len(tokens) == 1:
                value = map(self._meta.model._meta.get_field(field_name).to_python, value)

            if len(value) > 1:
                tokens.append('in')
            else:
                value = value.pop()

            filters[LOOKUP_SEP.join(tokens)] = (value, exclude)

        return filters