@Override public BaseCondition not() { BaseCondition[] reversedConditions = new BaseCondition[conditions.length]; for (int i = 0; i < conditions.length; i++) { reversedConditions[i] = conditions[i].not(); } return new JoinedCondition(logicalOperator.not(), reversedConditions); }
@Override public BaseCondition not() { return new SimpleCondition(field, whereOperator.reverse(), whereValue); }
@Override public boolean evaluate(Object object) { try { Object objectValue = new ConditionReference(field, clazz, object).getValue(); return whereOperator.evaluate(objectValue, whereValue); } catch (ConditionForChildException e) { return true; } }
private void verifyIfConditionIsForChild() throws ConditionForChildException { if (clazz != null && isObjectAcenstor() && isReferenceForChild()) { throw new ConditionForChildException(); } }
public static BaseCondition c(String field, String operator, Object comparison) { return c(field, WhereOperator.toOperator(operator), comparison); }
private boolean evaluateAnd(Object object) { for (BaseCondition condition : conditions) { if (!condition.evaluate(object)) { return false; } } return true; }
public void or(BaseCondition condition) { if (this.condition != null) { this.condition = Condition.or(this.condition, condition); return; } this.condition = condition; }
private boolean isQueryById() { if (condition == null || !(condition instanceof SimpleCondition)) { return false; } SimpleCondition c = (SimpleCondition) condition; return c.isIdField() && c.isEqualOperator(); }
private void initConditions() { if (condition == null) { return; } condition.init(r, endpointClazz); }
@Override public boolean evaluate(Object object) { if (logicalOperator == LogicalOperator.AND) { return evaluateAnd(object); } return evaluateOr(object); }
private static boolean listContainsLessThanOrEqual(List list, Object whereValue) { for (Object value : list) { if (compareObjects(value, whereValue) <= 0) { return true; } } return false; }
public static BaseCondition and(BaseCondition... conditions) { if (conditions.length == 1) { return conditions[0]; } return new JoinedCondition(LogicalOperator.AND, conditions); }
public SimpleCondition(String field, WhereOperator whereOperator, Object value) { this.field = field; this.whereOperator = whereOperator; this.whereValue = value; if (whereOperator == WhereOperator.IN) { assertIsList(value); } }
@Override public boolean hasPostFilter() { return !hasPreFilter(); }
@Override public boolean evaluate(Object object) { return condition.evaluate(object); } }
private static boolean listContainsGreaterThanOrEqual(List list, Object whereValue) { for (Object value : list) { if (compareObjects(value, whereValue) >= 0) { return true; } } return false; }
public static BaseCondition or(BaseCondition... conditions) { if (conditions.length == 1) { return conditions[0]; } return new JoinedCondition(LogicalOperator.OR, conditions); }
private static boolean listContainsGreaterThan(List list, Object whereValue) { for (Object value : list) { if (compareObjects(value, whereValue) > 0) { return true; } } return false; }
private static boolean listContainsLessThan(List list, Object whereValue) { for (Object value : list) { if (compareObjects(value, whereValue) < 0) { return true; } } return false; }