public PredicateTemplate(String template, Object... args) { super(Boolean.class, 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 OperationImpl.create(String.class, Ops.CONCAT, PERCENT, (Expression)arg); } else { return "%" + escapeForLike(String.valueOf(arg)); } } };
@Override public Object apply(Object arg) { if (arg instanceof Constant) { return ConstantImpl.create(apply(arg.toString()).toString()); } else if (arg instanceof Expression) { return OperationImpl.create(String.class, Ops.CONCAT, (Expression)arg, PERCENT); } 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); } }
@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 = OperationImpl.create(String.class, Ops.CONCAT, PERCENT, (Expression)arg); return OperationImpl.create(String.class, Ops.LOWER, concatenated); } else { return "%" + escapeForLike(String.valueOf(arg).toLowerCase(Locale.ENGLISH)); } } };
protected final void add(Operator<?> op, String pattern, int pre) { templates.put(op, templateFactory.create(pattern)); precedence.put(op, pre); }
@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 = OperationImpl.create(String.class, Ops.CONCAT, (Expression)arg, PERCENT); return OperationImpl.create(String.class, Ops.LOWER, concatenated); } else { return escapeForLike(String.valueOf(arg).toLowerCase(Locale.ENGLISH)) + "%"; } } };
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()); }
@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 = OperationImpl.create(String.class, Ops.CONCAT, PERCENT, (Expression)arg); return OperationImpl.create(String.class, Ops.CONCAT, concatenated, 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, 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) { Expression<String> concatenated = OperationImpl.create(String.class, Ops.CONCAT, PERCENT, (Expression)arg); concatenated = OperationImpl.create(String.class, Ops.CONCAT, concatenated, PERCENT); return OperationImpl.create(String.class, Ops.LOWER, concatenated); } else { return "%" + escapeForLike(String.valueOf(arg).toLowerCase(Locale.ENGLISH)) + "%"; } } };
/** * Create a new Template expression * * @param template template * @param args template parameters * @return template expression */ 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, ImmutableList<?> args) { return template(cl, TemplateFactory.DEFAULT.create(template), args); }
/** * 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)); }
public static <T> DslExpression<T> create(Class<? extends T> type, String template, Object one) { return new DslTemplate<T>(type, TemplateFactory.DEFAULT.create(template), ImmutableList.of(one)); }
public static <T extends Comparable<?>> TimeTemplate<T> create(Class<T> type, String template) { return new TimeTemplate<T>(type, TemplateFactory.DEFAULT.create(template), ImmutableList.of()); }
public static <T extends Comparable<?>> TimeTemplate<T> create(Class<T> type, String template, Object one, Object two) { return new TimeTemplate<T>(type, TemplateFactory.DEFAULT.create(template), ImmutableList.of(one, two)); }
public static <T extends Comparable<?>> ComparableExpression<T> create(Class<T> type, String template, Object one, Object two) { return new ComparableTemplate<T>(type, TemplateFactory.DEFAULT.create(template), ImmutableList.of(one, two)); }
public static StringExpression create(String template, Object one) { return new StringTemplate(TemplateFactory.DEFAULT.create(template), ImmutableList.of(one)); }
public static <T> SimpleExpression<T> create(Class<? extends T> type, String template, Object one) { return new SimpleTemplate<T>(type, TemplateFactory.DEFAULT.create(template), ImmutableList.of(one)); }