Returns a map of all the meters in the registry and their names which match the given filter.

@param filter the metric filter to match
@return all the meters in the registry
174442
@Override
    public SortedMap<String, Meter> getMeters(MetricFilter filter) {
        return getMetrics(Meter.class, filter);
    }
581830
public static Stream<PrometheusMetric> filteredMetrics(PullProcessorPipeline registry) throws Exception {
        Stream <PrometheusMetric> m = registry.get().stream()
                .flatMap((TimeSeriesValue i) -> {
                    Map<MetricName, MetricValue> metrics = i.getMetrics();
                    GroupName group = i.getGroup();
                    return metrics.entrySet().stream()
                            .filter((kv) -> kv.getValue().value().isPresent())
                            .map((kv) -> {
                                final String metric_group = toPrometheusString_(group.getPath().getPath());
                                final Map<String, String> tags = group.getTags().stream()
                                        .filter(tag -> tag.getValue().asString().isPresent())
                                        .collect(Collectors.toMap(
                                                tag -> escapeprometheus(tag.getKey()),
                                                tag -> escapeLabelValue_(tag.getValue().asString().get())));
                                final String metric_name = toPrometheusString_(kv.getKey().getPath());
                                final Number metric_value = kv.getValue().value().get();
                                return new PrometheusMetric(metric_group, tags, metric_name, metric_value);
                            });
                }
256621
public static autoscaleprofile[] get_filtered(nitro_service service, String filter) throws Exception{
		autoscaleprofile obj = new autoscaleprofile();
		options option = new options();
		option.set_filter(filter);
		autoscaleprofile[] response = (autoscaleprofile[]) obj.getfiltered(service, option);
		return response;
	}
150154
public Collection<Request> getRequests(RequestFilter filter) {
        filter = (filter != null) ? filter : new RequestFilter();

        filter.issues.clear();
        filter.issues.add(this);
        return getInstance().get().requests(filter);
    }
1344111
public MetricFilter metricsFilter() {
        if (id() == null) {
            return (name, metric) -> false;
        }
        return (name, metric) -> metricNames.contains(name);

    }
673106
@Override
    public Set<Field> getDeclaredFields(FieldFilter filter) {
        return FieldUtils.getDeclaredFields(target, filter);
    }
800939
@Override
    public List<Metric> filter(Map<Metric, String> extendedSortedMap, String limit) {
        SystemAssert.requireArgument(extendedSortedMap != null && !extendedSortedMap.isEmpty(), "New map is not constructed successfully!");
        SystemAssert.requireArgument(limit != null && !limit.equals(""), "Limit must be provided!");

        List<Metric> result = new ArrayList<Metric>();

        for (Map.Entry<Metric, String> entry : extendedSortedMap.entrySet()) {
            if (Double.parseDouble(limit) > Double.parseDouble(entry.getValue())) {
                result.add(entry.getKey());
            }
        }
        return result;
    }
890326
public static mps[] get_filtered(nitro_service service, String filter) throws Exception
	{
		mps obj = new mps();
		options option = new options();
		option.set_filter(filter);
		mps[] response = (mps[]) obj.getfiltered(service, option);
		return response;
	}
913670
public List<FilterMappingType<WebAppType<T>>> getAllFilterMapping()
   {
      List<FilterMappingType<WebAppType<T>>> list = new ArrayList<FilterMappingType<WebAppType<T>>>();
      List<Node> nodeList = childNode.get("filter-mapping");
      for(Node node: nodeList)
      {
         FilterMappingType<WebAppType<T>>  type = new FilterMappingTypeImpl<WebAppType<T>>(this, "filter-mapping", childNode, node);
         list.add(type);
      }
      return list;
   }
896848
@Override
	public M filter(BiPredicate<? super K, ? super V> filter) {
		MapBuilder<K, V, M> builder = builder();
		for (java.util.Map.Entry<K, V> entry : entrySet()) {
			if(filter.test(entry.getKey(), entry.getValue())) {
				builder.put(entry.getKey(), entry.getValue());
			}
		}
		return builder.build();
	}
573192
public SortedMap<String, HealthCheck.Result> runHealthChecks(HealthCheckFilter filter) {
        final SortedMap<String, HealthCheck.Result> results = new TreeMap<>();
        for (Map.Entry<String, HealthCheck> entry : healthChecks.entrySet()) {
            final String name = entry.getKey();
            final HealthCheck healthCheck = entry.getValue();
            if (filter.matches(name, healthCheck)) {
                final Result result = entry.getValue().execute();
                results.put(entry.getKey(), result);
            }
        }
        return Collections.unmodifiableSortedMap(results);
    }
634494
public boolean matchesFilter(String filter) {

        filter = filter.toLowerCase();
        return getTitle().toLowerCase().contains(filter) || m_path.toLowerCase().contains(filter);
    }
237090
@SuppressWarnings("unchecked")
  public static <E> E[] filter(E[] elems, Filter<E> filter) {
    List<E> filtered = new ArrayList<E>();
    for (E elem: elems) {
      if (filter.accept(elem)) {
        filtered.add(elem);
      }
    }
    return (filtered.toArray((E[]) Array.newInstance(elems.getClass().getComponentType(), filtered.size())));
  }
429464
private Group[] getRefsFromFilter(GroupFilter groupFilter) {
        checkNotNull(groupFilter, "Group filter must be not null");

        List<Group> groupList = findLazy(groupFilter)
            .map(metadata -> Group.refById(metadata.getId()))
            .collect(toList());

        return groupList.toArray(new Group[groupList.size()]);
    }
1261791
public Predicate<Measurement> getDefaultMeasurementFilter() throws IOException {
    if (defaultMeasurementFilter != null) {
      return defaultMeasurementFilter;
    }

    if (!prototypeFilterPath.isEmpty()) {
      defaultMeasurementFilter = PrototypeMeasurementFilter.loadFromPath(
          prototypeFilterPath);
    } else {
      defaultMeasurementFilter = ALL_MEASUREMENTS_FILTER;
    }

    return defaultMeasurementFilter;
  }
1203600
public static Iterable<Measurement> filter(Iterable<Measurement> ms, Tag t) {
    return filter(ms, t.key(), t.value());
  }
1308111
protected List<CmsTreeItem> getFilteredCategories(String filter) {

        List<CmsTreeItem> result = new ArrayList<CmsTreeItem>();
        if (CmsStringUtil.isNotEmptyOrWhitespaceOnly(filter)) {
            result = new ArrayList<CmsTreeItem>();
            for (CmsTreeItem category : m_categories.values()) {
                if (((CmsDataValue)category.getMainWidget()).matchesFilter(filter, 0, 1)) {
                    result.add(category);
                }
            }
        } else {
            Iterator<CmsTreeItem> it = m_categories.values().iterator();
            while (it.hasNext()) {
                result.add(it.next());
            }

        }
        return result;
    }