protected ComparablePath(Class<? extends T> type, PathMetadata metadata) { super(ExpressionUtils.path(type, metadata)); this.pathMixin = (PathImpl<T>) mixin; }
public BeanPath(Class<? extends T> type, PathMetadata metadata, @Nullable PathInits inits) { super(ExpressionUtils.path(type, metadata)); this.pathMixin = (PathImpl<T>) mixin; this.inits = inits; }
@SuppressWarnings("unchecked") protected ArrayPath(Class<? super A> type, PathMetadata metadata) { super(ExpressionUtils.path((Class) type, metadata)); this.pathMixin = (PathImpl<A>) mixin; this.componentType = Primitives.wrap((Class<E>) type.getComponentType()); }
/** * Create an alias expression with the given source and alias * * @param <D> type of expression * @param source source * @param alias alias * @return source as alias */ public static <D> Expression<D> as(Expression<D> source, String alias) { return as(source, path(source.getType(), alias)); }
/** * Create an alias for the expression * * @return alias expression */ public DslExpression<R> as(String alias) { return as(ExpressionUtils.path(getType(), alias)); }
/** * Create an alias for the expression * * @return alias expression */ @Override public SimpleExpression<T> as(String alias) { return as(ExpressionUtils.path(getType(), alias)); }
/** * Create an alias for the expression * * @return alias expression */ public Expression<T> as(String alias) { return as(ExpressionUtils.path(getType(), alias)); }
/** * Create an alias for the expression * * @return this as alias */ public Expression<T> as(String alias) { return as(ExpressionUtils.path(getType(), alias)); }
/** * Create a {@code source as alias} expression * * @param source source * @param alias alias * @return source as alias */ public static <D> SimpleExpression<D> as(Expression<D> source, String alias) { return as(source, ExpressionUtils.path(source.getType(), alias)); }
/** * Create an alias for the expression * * @return this as alias */ public DslExpression<T> as(String alias) { return as(ExpressionUtils.path(getType(), alias)); }
/** * Create an alias for the expression * * @return this as alias */ public DslExpression<T> as(String alias) { return as(ExpressionUtils.path(getType(), alias)); }
@Override public DateExpression<T> as(String alias) { return as(ExpressionUtils.path(getType(), alias)); }
@SuppressWarnings("rawtypes") private static <T> Path<T> replaceParent(Path<T> path, Path<?> parent) { PathMetadata metadata = new PathMetadata(parent, path.getMetadata().getElement(), path.getMetadata().getPathType()); if (path instanceof CollectionExpression) { CollectionExpression<?,?> col = (CollectionExpression<?,?>) path; return (Path<T>) Expressions.listPath(col.getParameter(0), SimplePath.class, metadata); } else { return ExpressionUtils.path(path.getType(), metadata); } }
@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()); } }
public Expression<?> visit(Path<?> expr, @Nullable Void context) { if (expr.getMetadata().isRoot()) { return ExpressionUtils.path(expr.getType(), expr.getMetadata().getName() + "_"); } else { return super.visit(expr, context); } } };
@Test public void roundtrip() throws Exception { Path<?> path = ExpressionUtils.path(Object.class, "entity"); SimplePath<?> path2 = Expressions.path(Object.class, "entity"); assertEquals(path, serialize(path)); assertEquals(path2, serialize(path2)); assertEquals(path2.isNull(), serialize(path2.isNull())); assertEquals(path.hashCode(), serialize(path).hashCode()); assertEquals(path2.hashCode(), serialize(path2).hashCode()); assertEquals(path2.isNull().hashCode(), serialize(path2.isNull()).hashCode()); }