private static Template createTemplate(String template) { return TemplateFactory.DEFAULT.create(template); }
protected final void add(Operator op, String pattern, int pre) { templates.put(op, templateFactory.create(pattern)); precedence.put(op, pre); }
protected final void add(Operator op, String pattern) { templates.put(op, templateFactory.create(pattern)); if (!precedence.containsKey(op)) { precedence.put(op, -1); } }
/** * 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)); }
/** * 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); }
/** * 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)); }
/** * 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); }
/** * 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); }
public void run() { for (int i = 0; i < 100000; i++) { TemplateFactory.DEFAULT.create(templates[i % templates.length]); } } }
/** * Create a new Template expression * * @deprecated Use {@link #template(Class, String, List)} instead. * * @param cl type of expression * @param template template * @param args template parameters * @return template expression */ @Deprecated public static <T> TemplateExpression<T> template(Class<? extends T> cl, String template, ImmutableList<?> args) { return template(cl, TemplateFactory.DEFAULT.create(template), args); }
@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}")); }
@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%%}")); }
@Test public void factoryMethods2() { Template template = TemplateFactory.DEFAULT.create(""); Expression<Boolean> arg = ConstantImpl.create(true); Expressions.booleanTemplate(template, arg); Expressions.comparableTemplate(String.class, template, arg); Expressions.dateTemplate(Date.class, template, arg); Expressions.dateTimeTemplate(Date.class, template, arg); Expressions.enumTemplate(PropertyType.class, template, arg); Expressions.numberTemplate(Integer.class, template, arg); Expressions.template(Object.class, template, arg); Expressions.stringTemplate(template, arg); Expressions.timeTemplate(Time.class, template, arg); } }
@Test public void constructors() { Templates templates = new JavaTemplates(); Template template = TemplateFactory.DEFAULT.create("{0}"); ImmutableList<Expression<?>> args = ImmutableList.<Expression<?>>of(new StringPath("a")); List<TemplateExpression<?>> customs = Arrays.<TemplateExpression<?>>asList(
private static Template createTemplate(String function, int argCount) { StringBuilder builder = new StringBuilder(); builder.append(function); builder.append("("); for (int i = 0; i < argCount; i++) { if (i > 0) { builder.append(", "); } builder.append("{" + i + "}"); } builder.append(")"); return TemplateFactory.DEFAULT.create(builder.toString()); }
/** * 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); }
/** * 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)); }
@Test public void test() { Template template = TemplateFactory.DEFAULT.create("fetch first {0s} rows only"); assertTrue(template.getElements().get(1) instanceof Template.AsString); SQLSerializer serializer = new SQLSerializer(new Configuration(new DerbyTemplates())); serializer.handle(Expressions.template(Object.class, template, ConstantImpl.create(5))); assertEquals("fetch first 5 rows only", serializer.toString()); }