protected final Template getTemplate(Operator<?> op) { return templates.getTemplate(op); }
protected final void add(Map<Operator<?>, String> ops) { for (Map.Entry<Operator<?>, String> entry : ops.entrySet()) { add(entry.getKey(), entry.getValue()); } }
public String escapeForLike(String str) { return Templates.this.escapeForLike(str); } };
@Override public String visit(Operation<?> o, Templates templates) { final Template template = templates.getTemplate(o.getOperator()); if (template != null) { final int precedence = templates.getPrecedence(o.getOperator()); final StringBuilder builder = new StringBuilder(); for (Template.Element element : template.getElements()) { final Object rv = element.convert(o.getArgs()); if (rv instanceof Expression) { if (precedence > -1 && rv instanceof Operation) { if (precedence < templates.getPrecedence(((Operation<?>)rv).getOperator())) { builder.append("("); builder.append(((Expression)rv).accept(this, templates)); builder.append(")"); continue; } } builder.append(((Expression)rv).accept(this, templates)); } else { builder.append(rv.toString()); } } return builder.toString(); } else { return "unknown operation with operator " + o.getOperator().getId() + " and args " + o.getArgs(); } }
public SerializerBase(Templates templates) { this.templates = templates; this.escape = templates.getEscapeChar(); }
protected void setPrecedence(int p, Operator<?>... ops) { setPrecedence(p, Arrays.asList(ops)); }
protected void visitOperation(Class<?> type, Operator<?> operator, final List<? extends Expression<?>> args) { final Template template = templates.getTemplate(operator); if (template != null) { final int precedence = templates.getPrecedence(operator); boolean first = true; for (final Template.Element element : template.getElements()) { if (precedence > -1 && expr instanceof Operation) { Operator op = ((Operation<?>) expr).getOperator(); int opPrecedence = templates.getPrecedence(op); if (precedence < opPrecedence) { append("(").handle(expr).append(")");
@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(); } }
add(Ops.LIST, "{0}, {1}", Precedence.LIST); add(Ops.SINGLETON, "{0}", Precedence.LIST); add(Ops.WRAPPED, "({0})"); add(Ops.ORDER, "order()"); add(Ops.AND, "{0} && {1}", Precedence.AND); add(Ops.NOT, "!{0}", Precedence.NOT_HIGH); add(Ops.OR, "{0} || {1}", Precedence.OR); add(Ops.XNOR, "{0} xnor {1}", Precedence.XNOR); add(Ops.XOR, "{0} xor {1}", Precedence.XOR); add(Ops.COL_IS_EMPTY, "empty({0})"); add(Ops.COL_SIZE, "size({0})"); add(Ops.ARRAY_SIZE, "size({0})"); add(Ops.MAP_SIZE, "size({0})"); add(Ops.MAP_IS_EMPTY, "empty({0})"); add(Ops.CONTAINS_KEY, "containsKey({0},{1})"); add(Ops.CONTAINS_VALUE, "containsValue({0},{1})"); add(Ops.BETWEEN, "{0} between {1} and {2}", Precedence.COMPARISON); add(Ops.GOE, "{0} >= {1}", Precedence.COMPARISON); add(Ops.GT, "{0} > {1}", Precedence.COMPARISON); add(Ops.LOE, "{0} <= {1}", Precedence.COMPARISON); add(Ops.LT, "{0} < {1}", Precedence.COMPARISON); add(Ops.NEGATE, "-{0}", Precedence.NEGATE); add(Ops.ADD, "{0} + {1}", Precedence.ARITH_LOW);
@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; }
@Test public void Escape() { List<Templates> templates = Arrays.<Templates>asList( new JPQLTemplates(), new HQLTemplates(), new EclipseLinkTemplates(), new OpenJPATemplates() ); for (Templates t : templates) { assertEquals("{0} like {1} escape '!'", t.getTemplate(Ops.LIKE).toString()); } }
@Test public void Custom_Escape() { List<Templates> templates = Arrays.<Templates>asList( new JPQLTemplates('X'), new HQLTemplates('X'), new EclipseLinkTemplates('X'), new OpenJPATemplates('X') ); for (Templates t : templates) { assertEquals("{0} like {1} escape 'X'", t.getTemplate(Ops.LIKE).toString()); } }