Throws an exception when the specified filter name is not registered in this chain.

@return An filter entry with the specified name.
435058
private EntryImpl checkOldName(String baseName) {
        EntryImpl e = (EntryImpl) name2entry.get(baseName);
        if (e == null) {
            throw new IllegalArgumentException("Filter not found:" + baseName);
        }
        return e;
    }
768495
@Bean
	@ConditionalOnProperty(value = "spring.sleuth.web.exception-logging-filter-enabled",
			matchIfMissing = true)
	public FilterRegistrationBean exceptionThrowingFilter(
			SleuthWebProperties webProperties) {
		FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(
				new ExceptionLoggingFilter());
		filterRegistrationBean.setDispatcherTypes(DispatcherType.ASYNC,
				DispatcherType.ERROR, DispatcherType.FORWARD, DispatcherType.INCLUDE,
				DispatcherType.REQUEST);
		filterRegistrationBean.setOrder(webProperties.getFilterOrder());
		return filterRegistrationBean;
	}
948567
public boolean search(String base, String filter) throws NamingException {
    return search(base, filter, scopeSub);
  }
397149
public FilterRegistration.Dynamic addFilter(String name, Class<? extends Filter> klass) {
        return addFilter(name, new FilterHolder(requireNonNull(klass)));
    }
395019
function getFilter(name) {
    if (name in this._filters) {
      return this._filters[name];
    }
    else if (this._parent) {
      return this._parent.getFilter(name);
    }

    throw new Error("Missing filter " + name);
  }
466112
public <E extends Exception> boolean allMatch(Try.ShortPredicate<E> filter) throws E {
        return allMatch(0, size(), filter);
    }
1197856
public <E extends Exception> boolean allMatch(Try.LongPredicate<E> filter) throws E {
        return allMatch(0, size(), filter);
    }
38506
public static dnscnamerec[] get_filtered(nitro_service service, String filter) throws Exception{
		dnscnamerec obj = new dnscnamerec();
		options option = new options();
		option.set_filter(filter);
		dnscnamerec[] response = (dnscnamerec[]) obj.getfiltered(service, option);
		return response;
	}
247245
public AerospikeDeepJobConfig<T> filterQuery(Filter[] filters) {
        if (filters.length > 1) {
            throw new UnsupportedOperationException("Aerospike currently accepts only one filter operations");
        } else if (filters.length > 0) {
            Filter deepFilter = filters[0];
            if (!isValidAerospikeFilter(deepFilter)) {
                throw new UnsupportedOperationException(
                        "Aerospike currently supports only equality and range filter operations");
            } else if (!deepFilter.getFilterType().equals(FilterType.EQ)) {
                operation("numrange");
                setAerospikeNumrange(deepFilter);
            } else {
                operation("scan");
                setAerospikeEqualsFilter(deepFilter);
            }
        }
        return this;
    }
361158
public <E extends Exception> boolean noneMatch(Try.BooleanPredicate<E> filter) throws E {
        return noneMatch(0, size(), filter);
    }
193770
protected Example doFilter(Example example)
    {
        Example result = example;

        while ( !isBeginTag(result) && !isEndTag(result) )
        {
            if (result.nextSibling() == null)
            {
                return getNextEndTag(example) == null ? null : example;
            }
            result = result.nextSibling();
        }

        return filter(result.nextSibling());
    }
565418
@Override
	public Filter getFilter() {
		Filter filter = new Filter() {
			@Override
			protected FilterResults performFiltering(CharSequence constraint) {
				ArrayList<Pair<String, ?>> filteredPrefs = new ArrayList<Pair<String, ?>>();
				FilterResults filterFriends = new FilterResults();
				if (!SharedPreferenceUtils.isEmptyString(constraint)) {
					for (Pair<String, ?> keyValue : keyValSet) {
						String constraintString = constraint.toString();
						String prefixKey = "key: ";
						String prefixValue = "value: ";
						String first = keyValue.first;
						Object second = keyValue.second;
						if (constraintString.toLowerCase().startsWith(prefixKey)) {
							if (first.toLowerCase().contains(constraintString.toLowerCase().substring(prefixKey.length()))) {
								filteredPrefs.add(keyValue);
							}
						} else if (constraintString.toLowerCase().startsWith(prefixValue)) {
							if (second != null) {
								if (second.toString().contains(constraintString.toLowerCase().substring(prefixValue.length()))) {
									filteredPrefs.add(keyValue);
								}
							}
						} else {
							if (first.equalsIgnoreCase(constraintString) || (second != null && second.toString()
							                                                                         .equalsIgnoreCase(constraintString))) {
								filteredPrefs.add(keyValue);
							}
						}
					}
				} else {
					filteredPrefs = keyValSet;
				}
				filterFriends.count = filteredPrefs.size();
				filterFriends.values = filteredPrefs;
				return filterFriends;
			}

			@Override
			protected void publishResults(CharSequence constraint, FilterResults results) {
				filteredCollection = (ArrayList<Pair<String, ?>>) results.values;

				notifyDataSetChanged();
			}
		};
		return filter;
	}
590252
public static <E> Filter<E> notFilter(Filter<E> filter) {
    return (new NegatedFilter<E>(filter));
  }
943894
public static filteraction[] get_filtered(nitro_service service, String filter) throws Exception{
		filteraction obj = new filteraction();
		options option = new options();
		option.set_filter(filter);
		filteraction[] response = (filteraction[]) obj.getfiltered(service, option);
		return response;
	}
1137422
public OverpassFilterQuery tagNot(String name, String value) {
        builder.notEquals(name, value);

        return this;
    }
566092
public <E extends Exception> boolean anyMatch(Try.LongPredicate<E> filter) throws E {
        return anyMatch(0, size(), filter);
    }
910157
protected function getFilter($name)
    {
        // filters must exists in configured filters
        if (!array_key_exists($name, $this->filters)) {
            throw new Exception('Invalid filter '.$name.'. Check your mapping configuration');
        }

        return $this->filters[$name];
    }