/** * Create a new Predicate operation * * @param operation * @param args * @return */ public static BooleanExpression predicate(Operator<Boolean> operation, Expression<?>... args) { return BooleanOperation.create(operation, args); }
public static BooleanExpression create(Operator<? super Boolean> op, Expression<?> one) { return new BooleanOperation(op, ImmutableList.<Expression<?>>of(one)); }
public static BooleanExpression create(Operator<? super Boolean> op, Expression<?> one, Expression<?> two) { return new BooleanOperation(op, ImmutableList.of(one, two)); }
/** * @param str * @return */ public BooleanExpression startsWithIgnoreCase(Expression<String> str) { return BooleanOperation.create(Ops.STARTS_WITH_IC, mixin, str); }
@Override public BooleanExpression exists() { if (exists == null) { exists = BooleanOperation.create(Ops.EXISTS, mixin); } return exists; }
@Override public BooleanExpression exists() { if (exists == null) { exists = BooleanOperation.create(Ops.EXISTS, mixin); } return exists; } @Override
/** * Create a {@code this is not null} expression * * @return */ public BooleanExpression isNotNull() { if (isnotnull == null) { isnotnull = BooleanOperation.create(Ops.IS_NOT_NULL, mixin); } return isnotnull; }
/** * Create a {@code this is null} expression * * @return */ public BooleanExpression isNull() { if (isnull == null) { isnull = BooleanOperation.create(Ops.IS_NULL, mixin); } return isnull; }
/** * Get a {@code this in right} expression * * @param right rhs of the comparison * @return */ public BooleanExpression in(CollectionExpression<?,? extends T> right) { return BooleanOperation.create(Ops.IN, mixin, right); }
@Override public BooleanExpression exists() { if (exists == null) { exists = BooleanOperation.create(Ops.EXISTS, mixin); } return exists; }
/** * @param str * @return */ public BooleanExpression endsWithIgnoreCase(Expression<String> str) { return BooleanOperation.create(Ops.ENDS_WITH_IC, mixin, str); }
/** * Compares this {@code StringExpression} to another {@code StringExpression}, ignoring case * considerations. * * @param str * @return this.equalsIgnoreCase(str) * @see java.lang.String#equalsIgnoreCase(String) */ public BooleanExpression equalsIgnoreCase(Expression<String> str) { return BooleanOperation.create(Ops.EQ_IGNORE_CASE, mixin, str); }
/** * Return true if this starts with str * * @param str * @return this.startsWith(str) * @see java.lang.String#startsWith(String) */ public BooleanExpression startsWith(Expression<String> str) { return BooleanOperation.create(Ops.STARTS_WITH, mixin, str); }
/** * Get a {@code this > right} expression * * @param right rhs of the comparison * @return * @see java.lang.Comparable#compareTo(Object) */ public BooleanExpression gt(Expression<T> right) { return BooleanOperation.create(Ops.GT, mixin, right); }
/** * Get a {@code this <= right} expression * * @param right rhs of the comparison * @return * @see java.lang.Comparable#compareTo(Object) */ public final BooleanExpression loe(Expression<T> right) { return BooleanOperation.create(Ops.LOE, mixin, right); }
@Override public BooleanExpression exists() { if (exists == null) { exists = BooleanOperation.create(Ops.EXISTS, mixin); } return exists; }
/** * Get a {@code this not in right} expression * * @param right rhs of the comparison * @return */ public final BooleanExpression notIn(CollectionExpression<?,? extends T> right) { return BooleanOperation.create(Ops.NOT_IN, mixin, right); }
/** * Get an aggregate all expression for the given boolean expression */ public static BooleanExpression all(BooleanExpression expr) { return BooleanOperation.create(Ops.AggOps.BOOLEAN_ALL, expr); }
@Override public BooleanExpression exists() { if (exists == null) { exists = BooleanOperation.create(Ops.EXISTS, mixin); } return exists; }
@Override public BooleanExpression exists() { if (exists == null) { exists = BooleanOperation.create(Ops.EXISTS, mixin); } return exists; }