public Path<?> visit(Collection<?> exprs, List<Path<?>> paths) { for (Object e : exprs) { if (e instanceof Expression) { ((Expression<?>) e).accept(this, paths); } } return null; }
private void visit(Expression<?> expr, QueryMetadata context) { if (expr != null) { expr.accept(this, context); } }
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; }
private void visit(List<Expression<?>> exprs, QueryMetadata context) { for (Expression<?> arg : exprs) { arg.accept(this, context); } }
@Override public <R, C> R accept(Visitor<R, C> v, C context) { return this.mixin.accept(v, context); }
@Override public <R, C> R accept(Visitor<R, C> v, C context) { return this.mixin.accept(v, context); }
@Override public <R, C> R accept(Visitor<R, C> v, C context) { return this.mixin.accept(v, context); }
@Nullable @Override public <R, C> R accept(Visitor<R, C> v, @Nullable C context) { return base.accept(v, context); } }
private ImmutableList<Expression<?>> visit(List<Expression<?>> args, C context) { ImmutableList.Builder<Expression<?>> builder = ImmutableList.builder(); for (Expression<?> arg : args) { builder.add(arg.accept(this, context)); } return builder.build(); } }
@Override public Set<Expression<?>> visit(TemplateExpression<?> expr, Set<Expression<?>> known) { for (Object arg : expr.getArgs()) { if (arg instanceof Expression<?>) { known = ((Expression<?>) arg).accept(this, known); } } return known; }
public final S handle(Object arg) { if (arg instanceof Expression) { ((Expression<?>) arg).accept(this, null); } else { visitConstant(arg); } return self; }
@Override public Set<Expression<?>> visit(FactoryExpression<?> expr, Set<Expression<?>> known) { for (Expression<?> arg : expr.getArgs()) { known = arg.accept(this, known); } return known; }
@Override public Void visit(TemplateExpression<?> expr, QueryMetadata context) { for (Object arg : expr.getArgs()) { if (arg instanceof Expression<?>) { ((Expression<?>) arg).accept(this, context); } } return null; }
public DBObject toSort(List<OrderSpecifier<?>> orderBys) { BasicDBObject sort = new BasicDBObject(); for (OrderSpecifier<?> orderBy : orderBys) { Object key = orderBy.getTarget().accept(this, null); sort.append(key.toString(), orderBy.getOrder() == Order.ASC ? 1 : -1); } return sort; }
protected void handleTemplate(final Template template, final List<?> args) { for (final Template.Element element : template.getElements()) { final Object rv = element.convert(args); if (rv instanceof Expression) { ((Expression<?>) rv).accept(this, null); } else if (element.isString()) { builder.append(rv.toString()); } else { visitConstant(rv); } } }
@Override public Set<Expression<?>> visit(Operation<?> expr, Set<Expression<?>> known) { if (expr.getOperator() == Ops.ALIAS) { known = add(known, expr.getArg(1)); } for (Expression<?> arg : expr.getArgs()) { known = arg.accept(this, known); } return known; }
@Test public void template() { Expression<Boolean> template = ExpressionUtils.template(Boolean.class, "{0} is not null", QCat.cat.name); assertEquals("cat_name is not null", template.accept(ToStringVisitor.DEFAULT, templates)); }
@Test public void operation() { Expression<String> str = Expressions.stringPath(ExpressionUtils.path(Object.class, "customer"), "name"); Expression<String> str2 = Expressions.stringPath("str"); Expression<String> concat = Expressions.stringOperation(Ops.CONCAT, str, str2); assertEquals("customer.name + str", concat.toString()); assertEquals("customer_.name + str_", concat.accept(visitor, null).toString()); }
@Test public void templateExpression() { Expression<String> str = Expressions.stringPath(ExpressionUtils.path(Object.class, "customer"), "name"); Expression<String> str2 = Expressions.stringPath("str"); Expression<String> concat = Expressions.stringTemplate("{0} + {1}", str, str2); assertEquals("customer.name + str", concat.toString()); assertEquals("customer_.name + str_", concat.accept(visitor, null).toString()); } }