@Override public List<Expression<?>> getArgs() { return expr.getArgs(); }
@Override public boolean equals(Object o) { if (o == this) { return true; } else if (o instanceof FactoryExpression) { return getClass().equals(o.getClass()) && getArgs().equals(((FactoryExpression) o).getArgs()); } else { return false; } }
@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(FactoryExpression<?> expr, List<Path<?>> paths) { visit(expr.getArgs(), paths); return null; }
@Override public Integer visit(FactoryExpression<?> expr, Void context) { int result = expr.getType().hashCode(); return 31 * result + expr.getArgs().hashCode(); }
FactoryExpressionAdapter(FactoryExpression<T> inner) { super(inner.getType()); this.inner = inner; this.args = expand(inner.getArgs()); }
@Override public Void visit(FactoryExpression<?> expr, Void context) { handle(", ", expr.getArgs()); return null; }
@Override public Void visit(FactoryExpression<?> expr, QueryMetadata context) { visit(expr.getArgs(), context); return null; }
protected static FactoryExpression<Tuple> withoutGroupExpressions(final FactoryExpression<Tuple> expr) { List<Expression<?>> args = new ArrayList<Expression<?>>(expr.getArgs().size()); for (Expression<?> arg : expr.getArgs()) { if (arg instanceof GroupExpression) { args.add(((GroupExpression) arg).getExpression()); } else { args.add(arg); } } return new FactoryExpressionAdapter<Tuple>(expr, args); }
@Override public Path<?> visit(FactoryExpression<?> expr, Void context) { return visit(expr.getArgs()); }
@Override public boolean equals(Object obj) { if (obj == this) { return true; } else if (obj instanceof FactoryExpression<?>) { FactoryExpression<?> c = (FactoryExpression<?>) obj; return args.equals(c.getArgs()) && getType().equals(c.getType()); } else { return false; } }
@Override public boolean equals(Object o) { if (o == this) { return true; } else if (o instanceof FactoryExpression) { FactoryExpression<?> e = (FactoryExpression<?>) o; return args.equals(e.getArgs()) && getType().equals(e.getType()); } else { return false; } }
private DBObject createProjection(Expression<?> projection) { if (projection instanceof FactoryExpression) { DBObject obj = new BasicDBObject(); for (Object expr : ((FactoryExpression) projection).getArgs()) { if (expr instanceof Expression) { obj.put((String) serializer.handle((Expression) expr), 1); } } return obj; } return null; }
public static <T> FactoryExpression<T> wrap(FactoryExpression<T> expr) { for (Expression<?> arg : expr.getArgs()) { if (arg instanceof ProjectionRole) { arg = ((ProjectionRole) arg).getProjection(); } if (arg instanceof FactoryExpression<?>) { return new FactoryExpressionAdapter<T>(expr); } } return expr; }
@Override public Void visit(FactoryExpression<?> expr, Void context) { visitConstant(expr); append(".newInstance("); handle(", ", expr.getArgs()); append(")"); return null; }
@Test public void wrapped_projection_has_right_arguments() { FactoryExpression<String> wrapped = FactoryExpressionUtils.wrap(concat1); assertEquals(Arrays.asList(str1, str2, str3), wrapped.getArgs()); }
@Test public void factoryExpression_has_right_args() { FactoryExpression<ProjectionExample> constructor = Projections.constructor(ProjectionExample.class, concat); constructor = FactoryExpressionUtils.wrap(constructor); assertEquals(Arrays.asList(str1, str2), constructor.getArgs()); }
@Test public void nestedProjection_getArgs2() { assertEquals(Arrays.asList(str1, str2, str3), FactoryExpressionUtils.wrap(new QMap(concat, str3)).getArgs()); }
@Test public void nestedProjection_getArgs() { assertEquals(Arrays.asList(str1, str2), FactoryExpressionUtils.wrap(new QTuple(concat)).getArgs()); }