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; }
@SuppressWarnings("unchecked") public GMin(Expression<T> expr) { super((Class) expr.getType(), expr); }
private Path<?> visit(List<?> exprs) { for (Object e : exprs) { if (e instanceof Expression) { Path<?> path = ((Expression<?>) e).accept(this, null); if (path != null) { return path; } } } return null; }
@Override public final Class<? extends T> getType() { return mixin.getType(); }
public Path<?> visit(Collection<?> exprs, List<Path<?>> paths) { for (Object e : exprs) { if (e instanceof Expression) { ((Expression<?>) e).accept(this, paths); } } return null; }
@SuppressWarnings("unchecked") public GOne(Expression<T> expr) { super((Class) expr.getType(), expr); }
private void visit(Expression<?> expr, QueryMetadata context) { if (expr != null) { expr.accept(this, context); } }
@SuppressWarnings("unchecked") public GMax(Expression<T> expr) { super((Class) expr.getType(), expr); }
private void visit(List<Expression<?>> exprs, QueryMetadata context) { for (Expression<?> arg : exprs) { arg.accept(this, context); } }
public Coalesce(Expression... exprs) { // NOTE : type parameters for the varargs, would result in compiler warnings this((exprs.length > 0 ? exprs[0].getType() : Object.class), exprs); }
@Override public <R, C> R accept(Visitor<R, C> v, C context) { return this.mixin.accept(v, context); }
@SuppressWarnings("unchecked") public GSum(Expression<T> expr) { super((Class) expr.getType(), expr); }
@Override public <R, C> R accept(Visitor<R, C> v, C context) { return this.mixin.accept(v, context); }
public GAvg(Expression<T> expr) { super((Class) expr.getType(), expr); }
@Override public <R, C> R accept(Visitor<R, C> v, C context) { return this.mixin.accept(v, context); }
public NumberConversion(Expression<T> expr) { super(expr.getType()); exprs = Collections.<Expression<?>>singletonList(expr); }
@Override public <R, C> R accept(Visitor<R, C> v, C context) { return this.mixin.accept(v, context); }
protected void typeMismatch(Class<?> type, Expression<?> expr) { final String msg = expr.getType().getName() + " is not compatible with " + type.getName(); throw new IllegalArgumentException(msg); }
@Override public <R, C> R accept(Visitor<R, C> v, C context) { return this.mixin.accept(v, context); }