Checks whether the given input object passes the cql filter.

@param input The object to evaluate
@return True if the given object passes the cql filter, false otherwise.
970969
public Boolean transform(T input) throws TransformationException {

        try {
            
            return cqlFilter.evaluate(input);
        }
        catch (ParseException e) {

            throw new TransformationException(e, input);
        }

    }
40275
private boolean acceptValue(int row, Map<Integer, Object> filter) {
		boolean accept = true;
		Set<Integer> keys = filter.keySet();
		for (int index : keys) {
			if (!filter.get(index).equals(dataSource.getValueAt(row, fields.get(index)))) {
				// System.out.println(" + " + filter.get(j));
				// System.out.println(" - " + dataSource.getValueAt(i,
				// fields.get(j)));
				return false;
			}
		}

		return accept;
	}
559927
private boolean hasInputWithValue() {

		// Visit all children of the fieldset of type Input
		AbstractVisitorWithResult<Boolean> visitor = new AbstractVisitorWithResult<Boolean>() {
			@Override
			public WComponentTreeVisitor.VisitorResult visit(final WComponent comp) {
				// Check if the component is an Input and has a value
				if (comp instanceof Input && !((Input) comp).isEmpty()) {
					setResult(true);
					return VisitorResult.ABORT;
				}
				return VisitorResult.CONTINUE;
			}
		};
		visitor.setResult(false);

		TreeUtil.traverseVisible(this, visitor);

		return visitor.getResult();
	}
648328
private Iterable<String> validate(final String input) {
        if (optional && input.isEmpty()) return Lists.newArrayList();
        return FluentIterable
                .from(validators)
                .filter(new Predicate<Validator>() {
                    @Override
                    public boolean apply(Validator validator) {
                        try {
                            return !validator.valid(input);
                        } catch (Exception e) {
                            return true;
                        }
                    }
                })
                .transform(new Function<Validator, String>() {
                    @Override
                    public String apply(Validator input) {
                        return input.message();
                    }
                });
    }
248539
public boolean has(String value) {
		addToDefaults(value, null);
		unrequestedParameters.remove(value);
		return data.containsKey(value);
	}
686166
@Override
	public boolean contains(String str) {
		for (BloomFilter filter : filters) {
			if (filter.contains(str) == false) {
				return false;
			}
		}
		return true;
	}
530878
public boolean is(String query) {
        Evaluator eval = QueryParser.parse(query);
        for (Element e : this) {
            if (e.is(eval))
                return true;
        }
        return false;
    }
136401
@Override
    public boolean contains(Object arg0) {
        checkUnsupportedOperationForIterationOnlyMode("contains(Object arg0)");
        
        if ( allResults.contains(arg0) )
            return true;
        
        while ( nextResultsAvailable() ) {
            boolean found = nextResults.contains(arg0);
            moveNextResults(false);
            if ( found )
                return true;
        }

        return false;
    }
853771
@Override
    public boolean condition(Object input) {
        return op.apply(input.toString(), value, set);
    }
304421
private boolean querySupported(Query<Entity> q) {
    return !containsAnyOperator(q, unsupportedOperators)
        && !containsComputedAttribute(q, getEntityType())
        && !containsNestedQueryRuleField(q);
  }
645282
@Override
    public boolean checkCondition(IValue test) throws FilterException {
        Iterator iter = values.iterator();
        while (iter.hasNext()) {
            IValue value = (IValue) iter.next();
            if (value.containedBy(test)) {
                return true;
            }
        }
        return false;
    }
1238776
public boolean hasInputVariable(String name) {
        for (InputVariable inputVariable : this.inputVariables) {
            if (inputVariable.getName().equals(name)) {
                return true;
            }
        }
        return false;
    }
610715
public static boolean hasQObject(final Reader reader) throws IOException {
    final MetaObjectParser parser = new MetaObjectParser();
    parser.parse(reader);
    return parser.hasQObject;

  }
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() + "]");
    }
15753
public static boolean isParseable(Object input) {
		return (null != input) && (isWrapperType(input.getClass())
				|| allPrimitiveTypes().contains(input.getClass())
				|| (String.class.isInstance(input) && ( Strs.inRange('0', '9').matchesAllOf(
				        MINUS_STRING.matcher((String) input).replaceFirst(Strs.EMPTY)) ) ) );
	}
735413
public boolean isNumeralPunctuation(final String input) {
        for (int i = 0; i < input.length(); i++) {
            if (!isNumeralPunctuation(input.charAt(i))) {
                return false;
            }
        }
        return true;
    }
698996
private boolean validate(ConsoleReaderWrapper consoleReaderWrapper, String input) {
        Iterable<String> errors = validate(input);
        if (!Iterables.isEmpty(errors)) {
            consoleReaderWrapper.beep();
            for (String error : errors) {
                consoleReaderWrapper.print(error);
            }
            return false;
        } else {
            return true;
        }
    }