public List selectNodes(Object object, NamespaceContext namespaces) throws TemplateModelException { Context context = getContext(object); context.getContextSupport().setNamespaceContext(namespaces); try { return selectNodesForContext(context); } catch (Exception e) { throw new TemplateModelException(e); } }
@Override @SuppressWarnings("rawtypes") public Object call(Context context, List arguments) throws FunctionCallException { if (arguments.size() == 2) { return evaluate(arguments.get(0), arguments.get(1), context.getNavigator()); } else if ((arguments.size() == 3) && (arguments.get(2) != null)) { return evaluate(arguments.get(0), arguments.get(1), arguments.get(2), context.getNavigator()); } throw new FunctionCallException("matches() requires two or three arguments"); }
/* */ public Object call(Context context, List args) /* */ throws FunctionCallException /* */ { /* 127 */ if (args.size() == 3) { /* 128 */ return evaluate(args.get(0), args.get(1), args.get(2), context.getNavigator()); /* */ } /* */ /* 134 */ throw new FunctionCallException("translate() requires three arguments."); /* */ }
/** * Returns a substring of an XPath string-value by character index. * * @param context the context at the point in the expression when the function is called * @param args a list that contains two or three items * @return a <code>String</code> containing the specifed character subsequence of the original * string or the string-value of the context node * @throws FunctionCallException if <code>args</code> has more than three or less than two items */ public Object call(Context context, List args) throws FunctionCallException { final int argc = args.size(); if (argc < 2 || argc > 3) { throw new FunctionCallException("substring() requires two or three arguments."); } final Navigator nav = context.getNavigator(); final String str = StringFunction.evaluate(args.get(0), nav); // The spec doesn't really address this case if (str == null) { return ""; } final int stringLength = (StringLengthFunction.evaluate(args.get(0), nav)).intValue(); if (stringLength == 0) { return ""; } Double d1 = NumberFunction.evaluate(args.get(1), nav); if (d1.isNaN()) { return ""; } // Round the value and subtract 1 as Java strings are zero based int start = RoundFunction.evaluate(d1, nav).intValue() - 1; int substringLength = stringLength; if (argc == 3) { Double d2 = NumberFunction.evaluate(args.get(2), nav); if (!d2.isNaN()) { substringLength = RoundFunction.evaluate(d2, nav).intValue(); } else { substringLength = 0; } } if (substringLength < 0) return ""; int end = start + substringLength; if (argc == 2) end = stringLength; // negative start is treated as 0 if (start < 0) { start = 0; } else if (start > stringLength) { return ""; } if (end > stringLength) { end = stringLength; } else if (end < start) return ""; if (stringLength == str.length()) { // easy case; no surrogate pairs return str.substring(start, end); } else { return unicodeSubstring(str, start, end); } }