<p>
The metric filters.
</p>

@return The metric filters.
339491
public java.util.List<MetricFilter> getMetricFilters() {
        if (metricFilters == null) {
            metricFilters = new com.amazonaws.internal.SdkInternalList<MetricFilter>();
        }
        return metricFilters;
    }
1256204
public List<FilterMappingType<WebFragmentDescriptor>> getAllFilterMapping()
   {
      List<FilterMappingType<WebFragmentDescriptor>> list = new ArrayList<FilterMappingType<WebFragmentDescriptor>>();
      List<Node> nodeList = model.get("filter-mapping");
      for(Node node: nodeList)
      {
         FilterMappingType<WebFragmentDescriptor>  type = new FilterMappingTypeImpl<WebFragmentDescriptor>(this, "filter-mapping", model, node);
         list.add(type);
      }
      return list;
   }
1224327
@Override
    public List<MetricSchemaRecord> filterRecords(SchemaQuery query) {
        requireNotDisposed();
        
        _logger.debug(query.toString());
        
        if(query instanceof MetricSchemaRecordQuery) {
        	long start = System.nanoTime();
        	List<MetricSchemaRecord> result = _schemaService.get(MetricSchemaRecordQuery.class.cast(query));
            _logger.debug("Time to filter records in ms: " + (System.nanoTime() - start) / 1000000);
            return result;
        } else {
        	long start = System.nanoTime();
        	List<MetricSchemaRecord> result = _schemaService.keywordSearch(KeywordQuery.class.cast(query));
            _logger.debug("Time to filter records in ms: " + (System.nanoTime() - start) / 1000000);
            return result;
        }
        
    }
298755
@Override
    public SortedMap<String, Timer> getTimers(MetricFilter filter) {
        return getMetrics(Timer.class, filter);
    }
1304741
@Override
  public SortedMap<String, Counter> getCounters(MetricFilter filter) {
    return getSimplyNamedMetrics(Counter.class, Optional.of(filter));
  }
937239
@Override
  public SortedMap<String, Gauge> getGauges(MetricFilter filter) {
    return this.innerMetricContext.getGauges(filter);
  }
1369156
public java.util.List<DocumentFilter> getDocumentFilterList() {
        if (documentFilterList == null) {
            documentFilterList = new com.amazonaws.internal.SdkInternalList<DocumentFilter>();
        }
        return documentFilterList;
    }
464240
public static Collection<HystrixThreadPoolMetrics> getInstances() {
        List<HystrixThreadPoolMetrics> threadPoolMetrics = new ArrayList<HystrixThreadPoolMetrics>();
        for (HystrixThreadPoolMetrics tpm: metrics.values()) {
            if (hasExecutedCommandsOnThread(tpm)) {
                threadPoolMetrics.add(tpm);
            }
        }

        return Collections.unmodifiableCollection(threadPoolMetrics);
    }
1368448
public List<String> extractMetricNames() {

        List<String> result = new ArrayList<>();
        for (MonitoringRule rule : monitoringRules.getMonitoringRules()) {
            for (Action action : rule.getActions().getActions()) {
                if (action.getName().equalsIgnoreCase("OutputMetric")) {
                    for (Parameter parameter : action.getParameters()) {
                        if (parameter.getName().equalsIgnoreCase("metric")) {
                            result.add(parameter.getValue());
                        }
                    }
                }
            }
        }
        return result;
    }
178792
@Override
  public SortedMap<String, Timer> getTimers(MetricFilter filter) {
    return this.innerMetricContext.getTimers(filter);
  }
1249451
@Nonnull
	static Collection<MetricLocation> prepareGetMetricUrls(List<String> metricMasks, String tableFilter, boolean underscoreAsLiteral) {
		if (WildcardsUtil.isRetrieveAllPattern(tableFilter) || tableFilter.isEmpty()) {
			if (metricMasks.isEmpty()) {
				return Collections.emptyList();
			} else {
				return buildPatternDisjunction(metricMasks, underscoreAsLiteral);
			}
		} else  {
			return Collections.singletonList(buildAtsdPatternUrl(tableFilter, underscoreAsLiteral));
		}
	}
535307
public ObjectName[] getFilters()
    {
        List l=_webappHandler.getFilters();
        return getComponentMBeans(l.toArray(),_filters);  
    }
349147
public static lbmetrictable_metric_binding[] get_filtered(nitro_service service, String metrictable, String filter) throws Exception{
		lbmetrictable_metric_binding obj = new lbmetrictable_metric_binding();
		obj.set_metrictable(metrictable);
		options option = new options();
		option.set_filter(filter);
		lbmetrictable_metric_binding[] response = (lbmetrictable_metric_binding[]) obj.getfiltered(service, option);
		return response;
	}
24070
public List<FilterType<PortletDescriptor>> getAllFilter()
   {
      List<FilterType<PortletDescriptor>> list = new ArrayList<FilterType<PortletDescriptor>>();
      List<Node> nodeList = model.get("filter");
      for(Node node: nodeList)
      {
         FilterType<PortletDescriptor>  type = new FilterTypeImpl<PortletDescriptor>(this, "filter", model, node);
         list.add(type);
      }
      return list;
   }
1260965
public java.util.List<EnhancedMetrics> getEnhancedMonitoring() {
        if (enhancedMonitoring == null) {
            enhancedMonitoring = new com.amazonaws.internal.SdkInternalList<EnhancedMetrics>();
        }
        return enhancedMonitoring;
    }
89668
public static lbmetrictable[] get_filtered(nitro_service service, String filter) throws Exception{
		lbmetrictable obj = new lbmetrictable();
		options option = new options();
		option.set_filter(filter);
		lbmetrictable[] response = (lbmetrictable[]) obj.getfiltered(service, option);
		return response;
	}
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;
    }