Returns the composite handled filter, or null if no matches at all.
165231
public Filter<S> getHandledFilter() {
        Filter<S> identity = getIdentityFilter();
        Filter<S> rangeStart = buildCompositeFilter(getRangeStartFilters());
        Filter<S> rangeEnd = buildCompositeFilter(getRangeEndFilters());

        return and(and(identity, rangeStart), rangeEnd);
    }
1072012
function getCombination (dateFilter, resolutionFilter, dataTypeFilter) {
  var c = {
    date: getFilter(date, dateFilter),
    resolution: getFilter(resolution, resolutionFilter),
    dataType: getFilter(dataType, dataTypeFilter),
    searchParameters: getSearchParameters(dateFilter, resolutionFilter, dataTypeFilter)
  };
  c.key = [c.date.key, c.resolution.key, c.dataType.key].join('_');

  return c;
}
633272
@Override
    public FilterAction handleClientRequest(User user, ISFSObject params) throws SFSException {
        try {
            handler.handleClientRequest(user, params);
        }
        catch(Exception e) { 
            return FilterAction.HALT; 
        }
        return FilterAction.CONTINUE;
    }
865765
public static SingleColumnFilterFactory getOperator(String condition, boolean idPresent, boolean useFilter)
    {
        if (condition.equals("="))
        {
            return SingleColumnFilterFactory.EQUAL;
        }
        else if (condition.equals(">"))
        {
            return SingleColumnFilterFactory.GREATER;
        }
        else if (condition.equals("<"))
        {
            return SingleColumnFilterFactory.LESS;
        }
        else if (condition.equals(">="))
        {
            return SingleColumnFilterFactory.GREATER_OR_EQUAL;
        }
        else if (condition.equals("<="))
        {
            return SingleColumnFilterFactory.LESS_OR_EQUAL;
        }
        else if (condition.equals("<>"))
        {
            return SingleColumnFilterFactory.NOT_EQUAL;
        }
        else if (condition.equals("LIKE"))
        {
            return SingleColumnFilterFactory.LIKE;
        }
        else if (condition.equals("REGEXP"))
        {
            return SingleColumnFilterFactory.REGEXP;
        }
        else if (useFilter)
        {
            if (!idPresent)
            {
                throw new UnsupportedOperationException(" Condition " + condition + " is not suported in  hbase!");
            }
            else
            {
                throw new UnsupportedOperationException(" Condition " + condition
                        + " is not suported for query on row key!");

            }
        }
        return null;
    }
732412
@Nullable
  public static Filter toFilter(@Nullable DimFilter dimFilter)
  {
    return dimFilter == null ? null : dimFilter.toFilter();
  }
297945
def _match_filters(parameter, filters=None):
        """"""
        for filter_obj in (filters or []):
            key = filter_obj['Key']
            option = filter_obj.get('Option', 'Equals')
            values = filter_obj.get('Values', [])

            what = None
            if key == 'Type':
                what = parameter.type
            elif key == 'KeyId':
                what = parameter.keyid

            if option == 'Equals'\
                    and not any(what == value for value in values):
                return False
            elif option == 'BeginsWith'\
                    and not any(what.startswith(value) for value in values):
                return False
        # True if no false match (or no filters at all)
        return True
613900
public CompositeHandler withQueryHandler(final QueryHandler handler) {
        if (handler == null) {
            throw new IllegalArgumentException();
        } // end of if

        // ---

        return new CompositeHandler(this.queryDetection,
                                    handler,
                                    this.updateHandler);
        
    }
1271983
public int filterObject(CaptureSearchResult r) {
		String captureDate = r.getCaptureTimestamp();
		
		int captureDateLength = Math.min(captureDate.length(), endDate.length());

		return (endDate.substring(0, captureDateLength).compareTo(
				captureDate) < 0) ? 
				FILTER_ABORT : FILTER_INCLUDE; 
	}
751118
public int filterObject(E o) {

		int size = filters.size();
		int result = FILTER_ABORT;
		for (int i = 0; i < size; i++) {
			result = filters.get(i).filterObject(o);
			if (result == FILTER_ABORT) {
				break;
			} else if (result == FILTER_EXCLUDE) {
				break;
			}
		}
		return result;
	}
1290326
public static transformprofile[] get_filtered(nitro_service service, String filter) throws Exception{
		transformprofile obj = new transformprofile();
		options option = new options();
		option.set_filter(filter);
		transformprofile[] response = (transformprofile[]) obj.getfiltered(service, option);
		return response;
	}
825976
@Override
    public T findOne(EntityFilter<T> filter) {
        for (T object : findAll()) {
            if (filter.accept(object)) {
                return object;
            }
        }
        return null;
    }
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;
	}
805571
@Override
    public RequestCtx handleResponse(SOAPMessageContext context)
            throws OperationHandlerException {
        try {
            Object response = getSOAPResponseObject(context);
            org.fcrepo.server.types.gen.FieldSearchResult result =
                (org.fcrepo.server.types.gen.FieldSearchResult) callGetter("getResult",response);
            result =
                filter(context, result);
            Method setter = response.getClass().getDeclaredMethod("setResult",
                    org.fcrepo.server.types.gen.FieldSearchResult.class);
            setter.invoke(response, result);
            setSOAPResponseObject(context, response);
        } catch (Exception e) {
            logger.error("Error filtering Objects", e);
            throw new OperationHandlerException("Error filtering Objects", e);
        }

        return null;
    }
944296
public <E extends Exception> boolean noneMatch(Try.LongPredicate<E> filter) throws E {
        return noneMatch(0, size(), filter);
    }
384031
public Filter<S> getCoveringRemainderFilter() {
        if (mCoveringRemainderFilter == null) {
            List<? extends Filter<S>> remainderFilters = mRemainderFilters;
            List<? extends Filter<S>> coveringFilters = mCoveringFilters;
            if (coveringFilters.size() < remainderFilters.size()) {
                Filter<S> composite = null;
                for (int i=0; i<remainderFilters.size(); i++) {
                    Filter<S> subFilter = remainderFilters.get(i);
                    if (!coveringFilters.contains(subFilter)) {
                        if (composite == null) {
                            composite = subFilter;
                        } else {
                            composite = composite.and(subFilter);
                        }
                    }
                }
                mCoveringRemainderFilter = composite;
            }
        }
        return mCoveringRemainderFilter;
    }
710699
def Filter(self, match=None, **_):
    """"""
    arg = self.stack.pop(-1)

    # Filters can be specified as a comma separated list.
    for filter_name in match.group(1).split(","):
      filter_object = ConfigFilter.classes_by_name.get(filter_name)
      if filter_object is None:
        raise FilterError("Unknown filter function %r" % filter_name)

      if not filter_object.sensitive_arg:
        logging.debug("Applying filter %s for %s.", filter_name, arg)
      arg = filter_object().Filter(arg)
      precondition.AssertType(arg, Text)

    self.stack[-1] += arg
1123307
public <E extends Exception> boolean anyMatch(Try.DoublePredicate<E> filter) throws E {
        return anyMatch(0, size(), filter);
    }