private static boolean isNumber(Object o) { return o instanceof Number || o instanceof Constant && ((Constant<?>) o).getConstant() instanceof Number; }
@Override public Object visit(Constant<?> expr, Void context) { if (Enum.class.isAssignableFrom(expr.getType())) { @SuppressWarnings("unchecked") //Guarded by previous check Constant<? extends Enum<?>> expectedExpr = (Constant<? extends Enum<?>>) expr; return expectedExpr.getConstant().name(); } else { return expr.getConstant(); } }
@Override public boolean equals(Object o) { if (o == this) { return true; } else if (o instanceof Constant<?>) { return ((Constant<?>) o).getConstant().equals(constant); } else { return false; } }
@Override public Object visit(Constant<?> expr, Void context) { if (!Enum.class.isAssignableFrom(expr.getType())) { return expr.getConstant(); } @SuppressWarnings("unchecked") // Guarded by previous check Constant<? extends Enum<?>> expectedExpr = (Constant<? extends Enum<?>>) expr; return expectedExpr.getConstant().name(); }
@Override public Integer visit(Constant<?> expr, Void context) { return expr.getConstant().hashCode(); }
protected Query range(Path<?> leftHandSide, String field, @Nullable Expression<?> min, @Nullable Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata) { if (min != null && Number.class.isAssignableFrom(min.getType()) || max != null && Number.class.isAssignableFrom(max.getType())) { @SuppressWarnings("unchecked") //guarded by previous check Constant<? extends Number> minConstant = (Constant<? extends Number>) min; @SuppressWarnings("unchecked") //guarded by previous check Constant<? extends Number> maxConstant = (Constant<? extends Number>) max; Class<? extends Number> numType = minConstant != null ? minConstant.getType() : maxConstant.getType(); //this is not necessarily safe, but compile time checking //on the user side mandates these types to be interchangeable @SuppressWarnings("unchecked") Class<Number> unboundedNumType = (Class<Number>) numType; return numericRange(unboundedNumType, field, minConstant == null ? null : minConstant.getConstant(), maxConstant == null ? null : maxConstant.getConstant(), minInc, maxInc); } return stringRange(leftHandSide, field, min, max, minInc, maxInc, metadata); }
@Override public String visit(Constant<?> e, Templates templates) { return e.getConstant().toString(); }
protected Query range(Path<?> leftHandSide, String field, @Nullable Expression<?> min, @Nullable Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata) { if (min != null && Number.class.isAssignableFrom(min.getType()) || max != null && Number.class.isAssignableFrom(max.getType())) { @SuppressWarnings("unchecked") //guarded by previous check Constant<? extends Number> minConstant = (Constant<? extends Number>) min; @SuppressWarnings("unchecked") //guarded by previous check Constant<? extends Number> maxConstant = (Constant<? extends Number>) max; Class<? extends Number> numType = minConstant != null ? minConstant.getType() : maxConstant.getType(); //this is not necessarily safe, but compile time checking //on the user side mandates these types to be interchangeable @SuppressWarnings("unchecked") Class<Number> unboundedNumType = (Class<Number>) numType; return numericRange(unboundedNumType, field, minConstant == null ? null : minConstant.getConstant(), maxConstant == null ? null : maxConstant.getConstant(), minInc, maxInc); } return stringRange(leftHandSide, field, min, max, minInc, maxInc, metadata); }
private static Number asNumber(Object arg) { if (arg instanceof Number) { return (Number) arg; } else if (arg instanceof Constant) { return (Number) ((Constant) arg).getConstant(); } else { throw new IllegalArgumentException(arg.toString()); } }
@Override public Object visit(Constant<?> expr, Void context) { if (!ClassUtils.isAssignable(Enum.class, expr.getType())) { return super.visit(expr, context); } return converter.convertToMongoType(expr.getConstant()); }
@Override public final Void visit(Constant<?> expr, Void context) { visitConstant(expr.getConstant()); return null; }
protected Query range(Path<?> leftHandSide, String field, @Nullable Expression<?> min, @Nullable Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata) { if (min != null && Number.class.isAssignableFrom(min.getType()) || max != null && Number.class.isAssignableFrom(max.getType())) { @SuppressWarnings("unchecked") // guarded by previous check Constant<? extends Number> minConstant = (Constant<? extends Number>) min; @SuppressWarnings("unchecked") // guarded by previous check Constant<? extends Number> maxConstant = (Constant<? extends Number>) max; Class<? extends Number> numType = minConstant != null ? minConstant .getType() : maxConstant.getType(); // this is not necessarily safe, but compile time checking // on the user side mandates these types to be interchangeable @SuppressWarnings("unchecked") Class<Number> unboundedNumType = (Class<Number>) numType; return numericRange(unboundedNumType, field, minConstant == null ? null : minConstant.getConstant(), maxConstant == null ? null : maxConstant.getConstant(), minInc, maxInc); } return stringRange(leftHandSide, field, min, max, minInc, maxInc, metadata); }
/** * Converts the given expression to lower(expression) * * <p>Constants are lower()ed at creation time</p> * * @param stringExpression the string to lower() * @return lower(stringExpression) */ public static Expression<String> toLower(Expression<String> stringExpression) { if (stringExpression instanceof Constant) { Constant<String> constantExpression = (Constant<String>) stringExpression; return ConstantImpl.create(constantExpression.getConstant().toLowerCase()); } else { return operation(String.class, Ops.LOWER, stringExpression); } }
protected Object convert(Path<?> property, Constant<?> constant) { if (isReference(property)) { return asReference(constant.getConstant()); } else if (isId(property)) { if (isReference(property.getMetadata().getParent())) { return asReferenceKey(property.getMetadata().getParent().getType(), constant.getConstant()); } else if (constant.getType().equals(String.class) && isImplicitObjectIdConversion()) { String id = (String) constant.getConstant(); return ObjectId.isValid(id) ? new ObjectId(id) : id; } } return visit(constant, null); }
public ConstantHidingExpression(FactoryExpression<T> expr) { super(expr.getType()); this.expr = expr; this.args = Lists.newArrayList(); this.template = new Object[expr.getArgs().size()]; for (int i = 0; i < template.length; i++) { Expression<?> arg = expr.getArgs().get(i); Expression<?> unwrapped = unwrap(arg); if (unwrapped instanceof Constant) { template[i] = ((Constant<?>) unwrapped).getConstant(); } else if (unwrapped.equals(Expressions.TRUE)) { template[i] = Boolean.TRUE; } else if (unwrapped.equals(Expressions.FALSE)) { template[i] = Boolean.FALSE; } else { args.add(arg); } } }
protected Object convert(Path<?> property, Constant<?> constant) { if (isReference(property)) { return asReference(constant.getConstant()); } else if (isId(property)) { if (isReference(property.getMetadata().getParent())) { return asReferenceKey(property.getMetadata().getParent().getType(), constant.getConstant()); } else if (constant.getType().equals(String.class) && isImplicitObjectIdConversion()) { String id = (String) constant.getConstant(); return ObjectId.isValid(id) ? new ObjectId(id) : id; } } return visit(constant, null); }
protected Object convert(@Nullable Path<?> path, @Nullable Constant<?> constant) { if (!isReference(path)) { return super.convert(path, constant); } MongoPersistentProperty property = getPropertyFor(path); return property.isIdProperty() ? asReference(constant.getConstant(), path.getMetadata().getParent()) : asReference(constant.getConstant(), path); }
@Override public Object visit(Constant<?> expr, Void context) { if (!Enum.class.isAssignableFrom(expr.getType())) { return expr.getConstant(); } @SuppressWarnings("unchecked") // Guarded by previous check Constant<? extends Enum<?>> expectedExpr = (Constant<? extends Enum<?>>) expr; return expectedExpr.getConstant().name(); }
@Override protected void visitOperation(Class<?> type, Operator operator, List<? extends Expression<?>> args) { if (Ops.aggOps.contains(operator)) { throw new UnsupportedOperationException("Aggregation operators are only supported as single expressions"); } if (args.size() == 2 && OPERATOR_SYMBOLS.containsKey(operator) && isPrimitive(args.get(0).getType()) && isPrimitive(args.get(1).getType())) { handle(args.get(0)); append(OPERATOR_SYMBOLS.get(operator)); handle(args.get(1)); if (args.get(1) instanceof Constant<?>) { append(CAST_SUFFIXES.get(args.get(1).getType())); } return; } if (operator == Ops.STRING_CAST) { visitCast(operator, args.get(0), String.class); } else if (operator == Ops.NUMCAST) { @SuppressWarnings("unchecked") //this is the second argument's type Constant<Class<?>> rightArg = (Constant<Class<?>>) args.get(1); visitCast(operator, args.get(0), rightArg.getConstant()); } else { super.visitOperation(type, operator, args); } }
@Override public Object visit(Constant<?> expr, Void context) { if (!ClassUtils.isAssignable(Enum.class, expr.getType())) { return super.visit(expr, context); } return converter.convertToMongoType(expr.getConstant()); }