private static Class<?>[] getParameterTypes(Expression<?>... args) { Class<?>[] paramTypes = new Class[args.length]; for (int i = 0; i < paramTypes.length; i++) { paramTypes[i] = args[i].getType(); } return paramTypes; }
public NumberConversion(Expression<T> expr) { super(expr.getType()); exprs = Collections.<Expression<?>>singletonList(expr); }
protected void typeMismatch(Class<?> type, Expression<?> expr) { final String msg = expr.getType().getName() + " is not compatible with " + type.getName(); throw new IllegalArgumentException(msg); }
protected AppendingFactoryExpression(Expression<T> base, Expression<?>... rest) { super(base.getType()); this.base = base; ImmutableList.Builder<Expression<?>> builder = ImmutableList.builder(); builder.add(base); builder.add(rest); this.args = builder.build(); }
private <T extends Comparable> Cases<T, DateTimeExpression<T>> thenDateTime(Expression<T> expr) { return new Cases<T, DateTimeExpression<T>>(expr.getType()) { @Override protected DateTimeExpression<T> createResult(Class<? extends T> type, Expression<T> last) { return Expressions.dateTimeOperation(type, Ops.CASE, last); } }.addCase(when, expr); }
private <T extends Comparable> Cases<T, ComparableExpression<T>> thenComparable(Expression<T> expr) { return new Cases<T, ComparableExpression<T>>(expr.getType()) { @Override protected ComparableExpression<T> createResult(Class<? extends T> type, Expression<T> last) { return Expressions.comparableOperation(type, Ops.CASE, last); } }.addCase(when, expr); }
private <T extends Comparable> Cases<T, DateExpression<T>> thenDate(Expression<T> expr) { return new Cases<T, DateExpression<T>>(expr.getType()) { @Override protected DateExpression<T> createResult(Class<? extends T> type, Expression<T> last) { return Expressions.dateOperation(type, Ops.CASE, last); } }.addCase(when, expr); }
@SuppressWarnings("unchecked") private <A extends Number & Comparable<?>> Cases<A, NumberExpression<A>> thenNumber(Expression<A> expr) { return new Cases<A, NumberExpression<A>>(expr.getType()) { @Override protected NumberExpression<A> createResult(Class<? extends A> type, Expression<A> last) { return Expressions.numberOperation(type, Ops.CASE, last); } }.addCase(when, expr); }
@SuppressWarnings("unchecked") private <T extends Enum<T>> Cases<T,EnumExpression<T>> thenEnum(Expression<T> expr) { return new Cases<T,EnumExpression<T>>(expr.getType()) { @Override protected EnumExpression<T> createResult(Class<? extends T> type, Expression<T> last) { return Expressions.enumOperation(type, Ops.CASE, last); } }.addCase(when, expr); }
private <T extends Comparable> Cases<T, TimeExpression<T>> thenTime(Expression<T> expr) { return new Cases<T, TimeExpression<T>>(expr.getType()) { @Override protected TimeExpression<T> createResult(Class<? extends T> type, Expression<T> last) { return Expressions.timeOperation(type, Ops.CASE, last); } }.addCase(when, expr); }
@SuppressWarnings("unchecked") @Override public Class<T> getType() { Expression<?> projection = queryMixin.getMetadata().getProjection(); return (Class) (projection != null ? projection.getType() : Void.class); }
private <T> Cases<T, Expression<T>> thenSimple(Expression<T> expr) { type = expr.getType(); return new Cases<T,Expression<T>>() { @Override protected Expression<T> createResult(Class<T> type, Expression<T> last) { return Expressions.operation(type, Ops.CASE_EQ, base, last); } }.when(other).then(expr); }
private Cases<Boolean, BooleanExpression> thenBoolean(Expression<Boolean> then) { type = then.getType(); return new Cases<Boolean, BooleanExpression>() { @Override protected BooleanExpression createResult(Class<Boolean> type, Expression<Boolean> last) { return Expressions.booleanOperation(Ops.CASE_EQ, base, last); } }.when(other).then(then); }
private Cases<String,StringExpression> thenString(Expression<String> then) { type = then.getType(); return new Cases<String,StringExpression>() { @SuppressWarnings("unchecked") @Override protected StringExpression createResult(Class<String> type, Expression<String> last) { return Expressions.stringOperation(Ops.CASE_EQ, base, last); } }.when(other).then(then); }
/** * Sets the SRID on a geometry to a particular integer value. * * @param expr geometry * @param srid SRID * @param <T> * @return geometry */ public static <T extends Geometry> JTSGeometryExpression<T> setSRID(Expression<T> expr, int srid) { return geometryOperation(expr.getType(), SpatialOps.SET_SRID, expr, ConstantImpl.create(srid)); }
private <T extends Comparable> Cases<T, DateTimeExpression<T>> thenDateTime(Expression<T> then) { type = then.getType(); return new Cases<T, DateTimeExpression<T>>() { @Override protected DateTimeExpression<T> createResult(Class<T> type, Expression<T> last) { return Expressions.dateTimeOperation(type, Ops.CASE_EQ, base, last); } }.when(other).then(then); }
public <T extends Number & Comparable<?>> Cases<T,NumberExpression<T>> thenNumber(Expression<T> then) { type = then.getType(); return new Cases<T,NumberExpression<T>>() { @SuppressWarnings("unchecked") @Override protected NumberExpression<T> createResult(Class<T> type, Expression<T> last) { return Expressions.numberOperation(type, Ops.CASE_EQ, base, last); } }.when(other).then(then); }
private <T extends Comparable> Cases<T, DateExpression<T>> thenDate(Expression<T> then) { type = then.getType(); return new Cases<T, DateExpression<T>>() { @Override protected DateExpression<T> createResult(Class<T> type, Expression<T> last) { return Expressions.dateOperation(type, Ops.CASE_EQ, base, last); } }.when(other).then(then); }
private <T extends Enum<T>> Cases<T, EnumExpression<T>> thenEnum(Expression<T> then) { type = then.getType(); return new Cases<T, EnumExpression<T>>() { @Override protected EnumExpression<T> createResult(Class<T> type, Expression<T> last) { return Expressions.enumOperation(type, Ops.CASE_EQ, base, last); } }.when(other).then(then); }
private <T extends Comparable> Cases<T, TimeExpression<T>> thenTime(Expression<T> then) { type = then.getType(); return new Cases<T, TimeExpression<T>>() { @Override protected TimeExpression<T> createResult(Class<T> type, Expression<T> last) { return Expressions.timeOperation(type, Ops.CASE_EQ, base, last); } }.when(other).then(then); }