@Override protected String getKeyForPath(Path<?> expr, PathMetadata<?> metadata) { if (expr.getAnnotatedElement().isAnnotationPresent(Id.class)) { return "_id"; } else if (metadata.getPathType() == PathType.PROPERTY && expr.getAnnotatedElement().isAnnotationPresent(Property.class)) { return expr.getAnnotatedElement().getAnnotation(Property.class).value(); } else { return metadata.getElement().toString(); } }
private static String getName(Expression<?> expression) { if (expression instanceof Path<?>) { @SuppressWarnings("rawtypes") PathMetadata<?> metadata = ((Path) expression).getMetadata(); if (metadata.getPathType() == PathType.PROPERTY) { return metadata.getElement().toString(); } else { throw new MappingException("Unexpected expression " + expression); } } else { throw new MappingException("Unexpected expression " + expression); } }
if (!casts.containsKey(clazz)) { PathMetadata<T> metadata; if (pathMixin.getMetadata().getPathType() != PathType.COLLECTION_ANY) { metadata = PathMetadataFactory.forDelegate(pathMixin); } else { if (inits != null && pathMixin.getMetadata().getPathType() != PathType.VARIABLE) { rv = clazz.getConstructor(PathMetadata.class, PathInits.class).newInstance(metadata, inits); } else {
@Override public String visit(Path<?> p, Templates templates) { final Path<?> parent = p.getMetadata().getParent(); final Object elem = p.getMetadata().getElement(); if (parent != null) { Template pattern = templates.getTemplate(p.getMetadata().getPathType()); if (pattern != null) { final List<?> args = Arrays.asList(parent, elem); final StringBuilder builder = new StringBuilder(); for (Template.Element element : pattern.getElements()) { Object rv = element.convert(args); if (rv instanceof Expression) { builder.append(((Expression)rv).accept(this, templates)); } else { builder.append(rv.toString()); } } return builder.toString(); } else { throw new IllegalArgumentException("No pattern for " + p.getMetadata().getPathType()); } } else { return elem.toString(); } }
@Override public String visit(Path<?> expr, Void context) { PathMetadata<?> metadata = expr.getMetadata(); if (metadata.getParent() != null) { Path<?> parent = metadata.getParent(); if (parent.getMetadata().getPathType() == PathType.DELEGATE) { parent = parent.getMetadata().getParent(); } if (metadata.getPathType() == PathType.COLLECTION_ANY) { return visit(parent, context); } else if (parent.getMetadata().getPathType() != PathType.VARIABLE) { String rv = getKeyForPath(expr, metadata); String parentStr = visit(parent, context); return rv != null ? parentStr + "." + rv : parentStr; } } return getKeyForPath(expr, metadata); }
@Override public Void visit(Path<?> expr, Void context){ // only wrap a PathCollection, if it the pathType is PROPERTY boolean wrap = wrapElements && (Collection.class.isAssignableFrom(expr.getType()) || Map.class.isAssignableFrom(expr.getType())) && expr.getMetadata().getPathType().equals(PathType.PROPERTY); if (wrap) { append("elements("); } super.visit(expr, context); if (wrap) { append(")"); } return null; }
@Override public Void visit(Path<?> path, Void context) { final PathType pathType = path.getMetadata().getPathType(); final Template template = templates.getTemplate(pathType); final Object element = path.getMetadata().getElement(); List<Object> args; if (path.getMetadata().getParent() != null) { args = ImmutableList.of(path.getMetadata().getParent(), element); } else { args = ImmutableList.of(element); } handleTemplate(template, args); return null; }
@SuppressWarnings("unchecked") private static <T> Path<T> replaceParent(Path<T> path, Path<?> parent) { PathMetadata<?> metadata = new PathMetadata(parent, path.getMetadata().getElement(), path.getMetadata().getPathType()); return new PathImpl<T>(path.getType(), metadata); }
private MappedPath getMappedPath(Path<?> path) { PathMetadata<?> md = path.getMetadata(); if (path.getMetadata().getPathType() != PathType.PROPERTY) { md = md.getParent().getMetadata(); } MappedClass mc = configuration.getMappedClass(md.getParent().getType()); return mc.getMappedPath(md.getElement().toString()); }
@Override public final AnnotatedElement getAnnotatedElement() { if (annotatedElement == null) { if (metadata.getPathType() == PathType.PROPERTY) { Class<?> beanClass = metadata.getParent().getType(); String propertyName = metadata.getName(); annotatedElement = ReflectionUtils.getAnnotatedElement(beanClass, propertyName, getType()); } else { annotatedElement = getType(); } } return annotatedElement; }
@Override public Expression<?> visit(Path<?> expr, @Nullable Void context) { if (expr.getMetadata().isRoot()) { return expr; } else { PathMetadata metadata = expr.getMetadata(); Path<?> parent = (Path)metadata.getParent().accept(this, null); Object element = metadata.getElement(); if (element instanceof Expression<?>) { element = ((Expression) element).accept(this, null); } if (parent.equals(metadata.getParent()) && Objects.equal(element, metadata.getElement())) { return expr; } else { metadata = new PathMetadata(parent, element, metadata.getPathType()); return new PathImpl(expr.getType(), metadata); } } }
@SuppressWarnings("rawtypes") private static <T> Path<T> replaceParent(Path<T> path, Path<?> parent) { PathMetadata<?> metadata = new PathMetadata<Object>(parent, path.getMetadata().getElement(), path.getMetadata().getPathType()); if (path instanceof CollectionExpression) { CollectionExpression<?,?> col = (CollectionExpression<?,?>)path; return new ListPath(col.getParameter(0), SimplePath.class, metadata); } else { return new PathImpl<T>(path.getType(), metadata); } }
@SuppressWarnings("unchecked") private Operation<?> transformPathEqNeConstant(Operation<?> operation) { Path<?> path = (Path<?>) operation.getArg(0); Constant<?> constant = (Constant<?>) operation.getArg(1); MappedPath mappedPath = getMappedPath(path); // id property if (path.getMetadata().getPathType() == PathType.PROPERTY && constant.getType().equals(String.class) && mappedPath.getPredicatePath().isEmpty()) { operation = PredicateOperation.create((Operator) operation.getOperator(), path, new ConstantImpl<ID>(session.getId(new LID(constant.toString())))); // localized property } else if (mappedPath.getMappedProperty().isLocalized()) { Locale locale; if (path.getMetadata().getPathType() == PathType.PROPERTY) { locale = session.getCurrentLocale(); } else { locale = (Locale) path.getMetadata().getElement(); } operation = PredicateOperation.create((Operator) operation.getOperator(), path, new ConstantImpl<LIT>(new LIT(constant.toString(), locale))); } return operation; }
/** * template method, override to customize * * @param path * @return */ protected String toField(Path<?> path) { String rv = path.getMetadata().getName(); if (path.getMetadata().getParent() != null) { Path<?> parent = path.getMetadata().getParent(); if (parent.getMetadata().getPathType() != PathType.VARIABLE) { rv = toField(parent) + "." + rv; } } return rv; }
@SuppressWarnings("unchecked") @Override public Expression<?> visit(Path<?> expr, Context context) { final PathType pathType = expr.getMetadata().getPathType(); if (pathType == PathType.LISTVALUE_CONSTANT || pathType == PathType.LISTVALUE) { final String variable = expr.accept(ToStringVisitor.DEFAULT, TEMPLATE).replace('.', '_'); final EntityPath<?> replacement = new EntityPathBase(expr.getType(), variable); context.add(expr, replacement); return replacement; } else if (expr.getMetadata().getParent() != null) { Context c = new Context(); final Path<?> parent = (Path<?>) expr.getMetadata().getParent().accept(this, c); if (c.replace) { context.add(c); return replaceParent(expr, parent); } } return expr; }
@Override public Void visit(Path<?> path, Void context) { final PathType pathType = path.getMetadata().getPathType(); if (pathType == PathType.PROPERTY) { final Path<?> parent = path.getMetadata().getParent();
PathType pathType = md.getPathType(); ParamExpression<?> parent = (ParamExpression<?>) visit(md.getParent(), filters); ParamExpression<?> pathNode = null;
@Override public Expression<?> visit(Path<?> expr, Context context) { if (expr.getMetadata().getPathType() == PathType.COLLECTION_ANY) { Path<?> parent = (Path<?>) expr.getMetadata().getParent().accept(this, context); expr = new PathImpl<Object>(expr.getType(), PathMetadataFactory.forCollectionAny(parent)); EntityPath<?> replacement = new EntityPathBase<Object>(expr.getType(), ExpressionUtils.createRootVariable(expr)); context.add(expr, replacement); return replacement; } else if (expr.getMetadata().getParent() != null) { Context c = new Context(); Path<?> parent = (Path<?>) expr.getMetadata().getParent().accept(this, c); if (c.replace) { context.add(c); return replaceParent(expr, parent); } } return expr; }
&& ((Path) expr.getArg(0)).getMetadata().getPathType() != PathType.VARIABLE) { expr = transformPathEqNeConstant(expr);