private static Template createTemplate(String template) { return TemplateFactory.DEFAULT.create(template); }
@Test public void operation() { TemplateFactory factory = new TemplateFactory('\\'); match("[0 ADD 1]", factory.create("{0+1}")); match("[0 DIV 1]", factory.create("{0/1}")); }
@Override public Object apply(Object arg) { if (arg instanceof Constant<?>) { return ConstantImpl.create(apply(arg.toString()).toString()); } else if (arg instanceof Expression) { return ExpressionUtils.operation(String.class, Ops.CONCAT, (Expression) arg, PERCENT); } else { return escapeForLike(String.valueOf(arg)) + "%"; } } };
protected final void add(Operator op, String pattern, int pre) { templates.put(op, templateFactory.create(pattern)); precedence.put(op, pre); }
@Test public void test() { TemplateFactory factory = new TemplateFactory('\\'); match("[0, ' + ', 1, ' + ', 2]", factory.create("{0} + {1} + {2}")); match("['blah ', 0, ' + ', 1, ' + ', 2, ' XXX']", factory.create("blah {0} + {1} + {2} XXX")); match("['+', 1]", factory.create("+{1}")); match("[1, '.method()']", factory.create("{1}.method()")); match("[0, '.get(', 1, ')']", factory.create("{0}.get({1})")); match("[0, '.', 1s]", factory.create("{0}.{1s}")); }
@Override public Object apply(Object arg) { if (arg instanceof Constant) { return ConstantImpl.create(apply(arg.toString()).toString()); } else if (arg instanceof Expression) { return ExpressionUtils.operation(String.class, Ops.CONCAT, PERCENT, (Expression) arg); } else { return "%" + escapeForLike(String.valueOf(arg)); } } };
protected final void add(Operator op, String pattern) { templates.put(op, templateFactory.create(pattern)); if (!precedence.containsKey(op)) { precedence.put(op, -1); } }
@Test public void like() { TemplateFactory factory = new TemplateFactory('\\'); match("[0]", factory.create("{0%}")); match("[0]", factory.create("{%0}")); match("[0]", factory.create("{%0%}")); match("[0]", factory.create("{0%%}")); match("[0]", factory.create("{%%0}")); match("[0]", factory.create("{%%0%%}")); }
@Override public Object apply(Object arg) { if (arg instanceof Constant<?>) { return ConstantImpl.create(apply(arg.toString()).toString()); } else if (arg instanceof Expression) { Expression<String> concatenated = ExpressionUtils.operation(String.class, Ops.CONCAT, PERCENT, (Expression) arg); return ExpressionUtils.operation(String.class, Ops.LOWER, concatenated); } else { return "%" + escapeForLike(String.valueOf(arg).toLowerCase()); } } };
/** * Create a new Template expression * * @param template template * @param args template parameters * @return template expression */ public static PredicateTemplate predicateTemplate(String template, Object... args) { return predicateTemplate(TemplateFactory.DEFAULT.create(template), ImmutableList.copyOf(args)); }
@Test public void operationConst() { TemplateFactory factory = new TemplateFactory('\\'); match("[0 ADD 1]", factory.create("{0+'1'}")); match("[0 DIV 1.0]", factory.create("{0/'1.0'}")); match("[0 MULT 3.141592653589793, ' / 180.0)']", factory.create("{0*'3.141592653589793'} / 180.0)")); }
@Override public Object apply(Object arg) { if (arg instanceof Constant<?>) { return ConstantImpl.create(apply(arg.toString()).toString()); } else if (arg instanceof Expression) { Expression<String> concatenated = ExpressionUtils.operation(String.class, Ops.CONCAT, (Expression) arg, PERCENT); return ExpressionUtils.operation(String.class, Ops.LOWER, concatenated); } else { return escapeForLike(String.valueOf(arg).toLowerCase()) + "%"; } } };
/** * Create a new Template expression * * @deprecated Use {@link #predicateTemplate(String, List)} instead. * * @param template template * @param args template parameters * @return template expression */ @Deprecated public static PredicateTemplate predicateTemplate(String template, ImmutableList<?> args) { return predicateTemplate(TemplateFactory.DEFAULT.create(template), args); }
@Override public Object apply(Object arg) { if (arg instanceof Constant<?>) { return ConstantImpl.create(apply(arg.toString()).toString()); } else if (arg instanceof Expression) { Expression<String> concatenated = ExpressionUtils.operation(String.class, Ops.CONCAT, PERCENT, (Expression) arg); return ExpressionUtils.operation(String.class, Ops.CONCAT, concatenated, PERCENT); } else { return "%" + escapeForLike(String.valueOf(arg)) + "%"; } } };
/** * Create a new Template expression * * @param template template * @param args template parameters * @return template expression */ public static PredicateTemplate predicateTemplate(String template, List<?> args) { return predicateTemplate(TemplateFactory.DEFAULT.create(template), args); }
@Override public Object apply(Object arg) { if (arg instanceof Constant<?>) { return ConstantImpl.create(apply(arg.toString()).toString()); } else if (arg instanceof Expression) { Expression<String> concatenated = ExpressionUtils.operation(String.class, Ops.CONCAT, PERCENT, (Expression) arg); concatenated = ExpressionUtils.operation(String.class, Ops.CONCAT, concatenated, PERCENT); return ExpressionUtils.operation(String.class, Ops.LOWER, concatenated); } else { return "%" + escapeForLike(String.valueOf(arg).toLowerCase()) + "%"; } } };
/** * Create a new Template expression * * @param cl type of expression * @param template template * @param args template parameters * @return template expression */ public static <T> TemplateExpression<T> template(Class<? extends T> cl, String template, Object... args) { return template(cl, TemplateFactory.DEFAULT.create(template), ImmutableList.copyOf(args)); }
@Override public Object apply(Object arg) { if (arg instanceof Constant<?>) { return ConstantImpl.create(apply(arg.toString()).toString()); } else if (arg instanceof Expression) { return ExpressionUtils.operation(String.class, Ops.CONCAT, (Expression) arg, PERCENT); } else { return escapeForLike(String.valueOf(arg)) + "%"; } } };
/** * Create a new Template expression * * @param cl type of expression * @param template template * @param args template parameters * @return template expression */ public static <T> TemplateExpression<T> template(Class<? extends T> cl, String template, List<?> args) { return template(cl, TemplateFactory.DEFAULT.create(template), args); }
@Override public Object apply(Object arg) { if (arg instanceof Constant) { return ConstantImpl.create(apply(arg.toString()).toString()); } else if (arg instanceof Expression) { return ExpressionUtils.operation(String.class, Ops.CONCAT, PERCENT, (Expression) arg); } else { return "%" + escapeForLike(String.valueOf(arg)); } } };