/**
* Bind a function, given the URI and local parts of the function name, and the list of
* expressions supplied as arguments. This method is called at compile time.
*
* @param functionName
* @param staticArgs The expressions supplied statically in the function call. The intention is
* that the static type of the arguments (obtainable via getItemType() and getCardinality()
* may be used as part of the binding algorithm.
* @param env
* @return An object representing the extension function to be called, if one is found; null if no
* extension function was found matching the required name and arity.
* @throws net.sf.saxon.trans.XPathException if a function is found with the required name and
* arity, but the implementation of the function cannot be loaded or used; or if an error
* occurs while searching for the function; or if this function library "owns" the namespace
* containing the function call, but no function was found.
*/
public Expression bind(StructuredQName functionName, Expression[] staticArgs, StaticContext env)
throws XPathException {
XSLFunction fn = stylesheet.getStylesheetFunction(functionName, staticArgs.length);
if (fn == null) {
return null;
}
if (fn.isOverriding() != overriding) {
return null;
}
UserFunctionCall fc = new UserFunctionCall();
fn.registerReference(fc);
fc.setFunctionName(functionName);
fc.setArguments(staticArgs);
fc.setConfirmed(true);
return fc;
}
/**
* Test whether a function with a given name and arity is available; if so, return its signature.
* This supports the function-available() function in XSLT; it is also used to support
* higher-order functions introduced in XQuery 1.1.
*
* <p>This method may be called either at compile time or at run time. If the function library is
* to be used only in an XQuery or free-standing XPath environment, this method may throw an
* UnsupportedOperationException.
*
* @param functionName the qualified name of the function being called
* @param arity The number of arguments. This is set to -1 in the case of the single-argument
* function-available() function; in this case the method should return true if there is some
* function of this name available for calling.
* @return if a function of this name and arity is available for calling, then the type signature
* of the function, as an array of sequence types in which the zeroth entry represents the
* return type; or a zero-length array if the function exists but the signature is not known;
* or null if the function does not exist
*/
public SequenceType[] getFunctionSignature(StructuredQName functionName, int arity) {
XSLFunction fn = stylesheet.getStylesheetFunction(functionName, arity);
if (fn != null) {
SequenceType[] sig = new SequenceType[arity + 1];
UserFunction uf = fn.getCompiledFunction();
if (uf == null) {
// XSLT: function not yet compiled
Arrays.fill(sig, SequenceType.ANY_SEQUENCE);
} else {
UserFunctionParameter[] params = uf.getParameterDefinitions();
sig[0] = uf.getResultType(stylesheet.getConfiguration().getTypeHierarchy());
for (int i = 0; i < params.length; i++) {
sig[i + 1] = params[i].getRequiredType();
}
}
return sig;
} else {
return null;
}
}
