These are the built-in filter params that define this report. They are merged at a later
 step with the runtime params entered by the user for a specific report run.
 nb. the sorter column here may be overridden by a runtime sort if requested by the user.
332796
def report_filter_params
      Hash[*viable_report_filters.map{|filter| filter.filter_match_params}.flatten].
        merge(order: self.sorter)
    end
85262
public static snmp_view[] get_filtered(nitro_service service, String filter) throws Exception
	{
		snmp_view obj = new snmp_view();
		options option = new options();
		option.set_filter(filter);
		snmp_view[] response = (snmp_view[]) obj.getfiltered(service, option);
		return response;
	}
593688
function initSortMethod() {
        var sortMethod = PreferencesManager.getViewState(_WORKING_SET_SORT_PREF);

        if (!sortMethod) {
            sortMethod = _convertSortPref(PreferencesManager.getViewState(_LEGACY_SORT_PREF));
        }

        if (!sortMethod) {
            sortMethod = Commands.CMD_WORKINGSET_SORT_BY_ADDED;
        }
        return sortMethod;
    }
485118
public static Link filterLinkParams(final Link link, final boolean filter) {
        // from and until parameters can cause problems with downstream applications because they contain commas. This
        // method makes it possible to filter out those params, if desired. By default, they are not filtered out.
        if (filter) {
            if (TIMEMAP.equals(link.getRel())) {
                return Link.fromUri(link.getUri()).rel(TIMEMAP).type(APPLICATION_LINK_FORMAT).build();
            } else if (MEMENTO.equals(link.getRel())) {
                return Link.fromUri(link.getUri()).rel(MEMENTO).build();
            }
        }
        return link;
    }
96795
def valued_parameters
      @valued_parameters ||= filter_parameters.select do |key,value|
        # :order is special, it must always be excluded
        key.to_sym != :order && valued_parameter?(key,value)
      end
    end
45359
function  collectFilterColumns(dftTable, filter, col)  {
	var  isLogical = false;
	if (filter.op === 'AND' || filter.op === 'and' || filter.op === 'OR' || filter.op === 'or')  {
		filter.op = filter.op.toLowerCase();
		isLogical = true;
	}

	if (isLogical)  {
		filter.filters.forEach(function(f) {
			collectFilterColumns(dftTable, f, col);
		});
	}
	else  {
		var  colName = filter.field || filter.name,
			 fc = {tbName: dftTable, col: colName, orig: colName},
			 idx = colName.indexOf('.');

		if (idx > 0)  {
			fc.tbName = colName.substring(0, idx);
			fc.col = colName.substring(idx+1);
		}

		if (_.findIndex(col, fc) < 0)
			col.push(fc);
	}
}
469856
def _input_as_parameters(self, data):
        
        # The list of values which can be passed on a per-run basis
        allowed_values = ['--input', '--uc', '--fastapairs',
                          '--uc2clstr', '--output', '--mergesort']

        unsupported_parameters = set(data.keys()) - set(allowed_values)
        if unsupported_parameters:
            raise ApplicationError(
                "Unsupported parameter(s) passed when calling uclust: %s" %
                ' '.join(unsupported_parameters))

        for v in allowed_values:
            # turn the parameter off so subsequent runs are not
            # affected by parameter settings from previous runs
            self.Parameters[v].off()
            if v in data:
                # turn the parameter on if specified by the user
                self.Parameters[v].on(data[v])

        return ''
655994
function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {

	var inspected = {},
		seekingTransport = ( structure === transports );

	function inspect( dataType ) {
		var selected;
		inspected[ dataType ] = true;
		jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
			var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
			if ( typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[ dataTypeOrTransport ] ) {
				options.dataTypes.unshift( dataTypeOrTransport );
				inspect( dataTypeOrTransport );
				return false;
			} else if ( seekingTransport ) {
				return !( selected = dataTypeOrTransport );
			}
		});
		return selected;
	}

	return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
}
986653
@SuppressWarnings("checkstyle:npathcomplexity")
    @Override
    public int doFilter(EventFilter filter, Data dataKey, Object oldValue, Object dataValue, EntryEventType eventType,
                        String mapNameOrNull) {
        if (filter instanceof MapPartitionLostEventFilter) {
            return FILTER_DOES_NOT_MATCH;
        }

        // the order of the following ifs is important!
        // QueryEventFilter is instance of EntryEventFilter
        if (filter instanceof EventListenerFilter) {
            if (!filter.eval(eventType.getType())) {
                return FILTER_DOES_NOT_MATCH;
            } else {
                filter = ((EventListenerFilter) filter).getEventFilter();
            }
        }
        if (filter instanceof TrueEventFilter) {
            return eventType.getType();
        }
        if (filter instanceof QueryEventFilter) {
            return processQueryEventFilter(filter, eventType, dataKey, oldValue, dataValue, mapNameOrNull)
                    ? eventType.getType() : FILTER_DOES_NOT_MATCH;
        }
        if (filter instanceof EntryEventFilter) {
            return processEntryEventFilter(filter, dataKey) ? eventType.getType() : FILTER_DOES_NOT_MATCH;
        }
        throw new IllegalArgumentException("Unknown EventFilter type = [" + filter.getClass().getCanonicalName() + "]");
    }
1123246
public void traverseAndFilter(final TreeWalker walker, final String indent, final Metadata metadata,
        final StringBuilder sb) {

        final Node parend = walker.getCurrentNode();

        final boolean isLogged = appendText(indent, (Element) parend, sb);

        for (final Filter filter : filterList) {
            if (filter.filter(metadata, walker)) {
                appendText(" catched by: " + filter.getClass().getSimpleName(), sb);
                break;
            }
        }

        if (isLogged) {
            appendText("\n", sb);
        }

        for (Node n = walker.firstChild(); n != null; n = walker.nextSibling()) {
            traverseAndFilter(walker, indent + "  ", metadata, sb);
        }

        walker.setCurrentNode(parend);
    }
751867
def cleanup_parameter_values
        abandoned_parameter_values = Discerner::ParameterValue.order(:id).to_a - updated_parameter_values - blank_parameter_values

        if self.options[:prune_dictionaries].blank?
          notification_message "if option --prune_dictionaries is not specified, parameter values for dictionaries that are not in parsed definition file should be deleted manually. Use `rake discerner:delete_dictionary' NAME='My dictionary name'"
          abandoned_parameter_values = abandoned_parameter_values.reject{|v| abandoned_dictionaries.include?(v.parameter.parameter_category.dictionary)}
        end

        used_parameter_values      = abandoned_parameter_values.select{|p| p.used_in_search?}
        not_used_parameter_values  = abandoned_parameter_values - used_parameter_values

        used_parameter_values.each do |r|
          notification_message("marking parameter value #{r.name} as deleted");
          r.deleted_at = Time.now
          error_message "parameter value could not be marked as deleted: #{r.errors.full_messages}", r.name unless r.save
        end

        unless not_used_parameter_values.blank?
          notification_message("permanently deleting parameter values #{not_used_parameter_values.map{|r| r.name}.join(', ')}");
          not_used_parameter_values.each{|r| r.destroy}
        end
      end
1299738
static DumpWriter addFilter(DumpWriter sink, String filter, String param) throws IOException, ParseException {
		if (filter.equals("latest"))
			return new LatestFilter(sink);
		else if (filter.equals("namespace"))
			return new NamespaceFilter(sink, param);
		else if (filter.equals("notalk"))
			return new NotalkFilter(sink);
		else if (filter.equals("titlematch"))
			return new TitleMatchFilter(sink, param);
		else if (filter.equals("list"))
			return new ListFilter(sink, param);
		else if (filter.equals("exactlist"))
			return new ExactListFilter(sink, param);
		else if (filter.equals("revlist"))
			return new RevisionListFilter(sink, param);
		else if (filter.equals("before"))
			return new BeforeTimeStampFilter(sink, param);
		else if (filter.equals("after"))
			return new AfterTimeStampFilter(sink, param);
		else
			throw new IllegalArgumentException("Filter unknown: " + filter);
	}
969398
def custom_filters
      self.resource_class.report_filter_options.select{|filter| viable_report_filters.map(&:filter_name).exclude? filter.param}
    end
465911
def _getParameters(self):
        """"""
        param = self.query._getParameters()        
        sortingNames = []
        for outputCol in self.__columns:
            sort_dictionary={"field" : outputCol, "direction" : "ASC"}
            sortingNames.append(sort_dictionary)            
        param.update({'sort' : {"ordersList" : sortingNames}})
        return param
720211
private String getFilterValues(final TableDataModel dataModel, final int rowIndex) {
		List<String> filterValues = dataModel.getFilterValues(rowIndex);

		if (filterValues == null || filterValues.isEmpty()) {
			return null;
		}

		StringBuffer buf = new StringBuffer(filterValues.get(0));

		for (int i = 1; i < filterValues.size(); i++) {
			buf.append(", ");
			buf.append(filterValues.get(i));
		}

		return buf.toString();
	}
506687
@Override
    public Iterable<TableReportEntry> getReportEntries(String reportId, final AllTablesReportQuery query) {
        checkNotNull(reportId, "reportId");

        final String reportTable = getTableName(reportId);

        // Set up several filters based on the query attributes

        final Predicate<String> placementFilter = query.getPlacements().isEmpty()
                ? Predicates.<String>alwaysTrue()
                : Predicates.in(query.getPlacements());

        final Predicate<Boolean> droppedFilter = query.isIncludeDropped()
                ? Predicates.<Boolean>alwaysTrue()
                : Predicates.equalTo(false);

        final Predicate<Boolean> facadeFilter = query.isIncludeFacades()
                ? Predicates.<Boolean>alwaysTrue()
                : Predicates.equalTo(false);

        return new Iterable<TableReportEntry>() {
            @Override
            public Iterator<TableReportEntry> iterator() {
                return Iterators.limit(
                        Iterators.filter(
                                Iterators.transform(
                                        queryDataStoreForTableReportResults(reportTable, query),
                                        new Function<Map<String, Object>, TableReportEntry>() {
                                            @Nullable
                                            @Override
                                            public TableReportEntry apply(Map<String, Object> map) {
                                                if (Intrinsic.getId(map).startsWith("~")) {
                                                    // Skip this row, it's the metadata
                                                    return null;
                                                }
                                                return convertToTableReportEntry(
                                                        map, placementFilter, droppedFilter, facadeFilter);
                                            }
                                        }),
                                Predicates.notNull()
                        ),
                        query.getLimit()
                );
            }
        };
    }
692531
def merge_parameter_lists(*parameter_definitions):
    
    merged_parameters = {}
    for parameter_list in parameter_definitions:
        for parameter in parameter_list:
            key = (parameter['name'], parameter['in'])
            merged_parameters[key] = parameter
    return merged_parameters.values()