## net.sf.saxon.query
Class XQueryFunctionLibrary

    java.lang.Object
      |
      +--net.sf.saxon.query.XQueryFunctionLibrary

All Implemented Interfaces:
  FunctionLibrary, java.io.Serializable

public class XQueryFunctionLibrary
extends java.lang.Object
implements FunctionLibrary

An XQueryFunctionLibrary is a function library containing all the user-defined functions available for use within a particular XQurey module: that is, the functions declared in that module, and the functions imported from other modules.

See Also:
  Serialized Form

Constructor Summary
`XQueryFunctionLibrary(Configuration config, boolean allowForwardsReferences)` Create an XQueryFunctionLibrary

Method Summary
`Expression` `bind(int nameCode, java.lang.String uri, java.lang.String local, Expression[] arguments)` Identify a (namespace-prefixed) function appearing in the expression.
`void` `bindUnboundFunctionCalls()` Bind function calls that could not be bound when first encountered.
`void` `declareFunction(XQueryFunction function)` Register a user-defined XQuery function
`void` `explainGlobalFunctions()` Output "explain" information about each declared function
`protected void` `fixupGlobalFunctions(StaticQueryContext env)` Fixup all references to global functions.
`Configuration` `getConfiguration()` Get the Configuration options
`java.util.Iterator` `getFunctionDefinitions()` Get an iterator over the Functions defined in this module
`UserFunction` `getUserDefinedFunction(java.lang.String uri, java.lang.String localName, int arity)` Get the function with a given name and arity.
`boolean` `isAvailable(int fingerprint, java.lang.String uri, java.lang.String local, int arity)` Test whether a function with a given name and arity is available.
`void` `setAllowForwardsReferences(boolean allow)` Disallow any further forwards references
`void` `setConfiguration(Configuration config)` Set the Configuration options

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### XQueryFunctionLibrary

    public XQueryFunctionLibrary(Configuration config,
                                 boolean allowForwardsReferences)

  Create an XQueryFunctionLibrary

Method Detail

### setConfiguration

    public void setConfiguration(Configuration config)

  Set the Configuration options

### getConfiguration

    public Configuration getConfiguration()

  Get the Configuration options

### setAllowForwardsReferences

    public void setAllowForwardsReferences(boolean allow)

  Disallow any further forwards references

### declareFunction

    public void declareFunction(XQueryFunction function)
                         throws StaticError

  Register a user-defined XQuery function

    `StaticError`

### isAvailable

    public boolean isAvailable(int fingerprint,
                               java.lang.String uri,
                               java.lang.String local,
                               int arity)

  Test whether a function with a given name and arity is available. This supports the function-available() function in XSLT. This method may be called either at compile time or at run time.

  Specified by:
    `isAvailable` in interface `FunctionLibrary`
  Parameters:
    `uri` - The URI of the function name
    `local` - The local part of the function name
    `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 matching extension function, regardless of its arity.
    `fingerprint` - The namepool fingerprint of the function name. This must match the uri and localName; the information is provided redundantly to avoid repeated lookups in the name pool.

### bind

    public Expression bind(int nameCode,
                           java.lang.String uri,
                           java.lang.String local,
                           Expression[] arguments)
                    throws XPathException

  Identify a (namespace-prefixed) function appearing in the expression. This method is called by the XQuery parser to resolve function calls found within the query.

  Note that a function call may appear earlier in the query than the definition of the function to which it is bound. Unlike XSLT, we cannot search forwards to find the function definition. Binding of function calls is therefore a two-stage process; at the time the function call is parsed, we simply register it as pending; subsequently at the end of query parsing all the pending function calls are resolved. Another consequence of this is that we cannot tell at the time a function call is parsed whether it is a call to an internal (XSLT or XQuery) function or to an extension function written in Java.

  Specified by:
    `bind` in interface `FunctionLibrary`
  Parameters:
    `nameCode` - The namepool nameCode of the function name. The uri and local name are also supplied (redundantly) to avoid fetching them from the name pool.
    `uri` - The URI of the function name
    `local` - The local part of the function name
    `arguments` - 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.
  Returns:
    an Expression representing the function call. This will normally be a FunctionCall, but it may be rewritten as some other expression.
  Throws:
    `XPathException` - if the function call is invalid, either because it is an unprefixed call to a non-system function, or because it is calling a system function that is available in XSLT only. A prefixed function call that cannot be recognized at this stage is assumed to be a forwards reference, and is bound later when bindUnboundFunctionCalls() is called.

### bindUnboundFunctionCalls

    public void bindUnboundFunctionCalls()
                                  throws StaticError

  Bind function calls that could not be bound when first encountered. These will either be forwards references to functions declared later in the query, or errors. This method is for internal use.

  Throws:
    `StaticError` - if a function call refers to a function that has not been declared

### getFunctionDefinitions

    public java.util.Iterator getFunctionDefinitions()

  Get an iterator over the Functions defined in this module

  Returns:
    an Iterator, whose items are `XQueryFunction` objects. It returns all function known to this module including those imported from elsewhere; they can be distinguished by their namespace.

### fixupGlobalFunctions

    protected void fixupGlobalFunctions(StaticQueryContext env)
                                 throws StaticError

  Fixup all references to global functions. This method is called on completion of query parsing. Each XQueryFunction is required to bind all references to that function to the object representing the run-time executable code of the function.

  This method is for internal use.

    `StaticError`

### explainGlobalFunctions

    public void explainGlobalFunctions()
                                throws XPathException

  Output "explain" information about each declared function

    `XPathException`

### getUserDefinedFunction

    public UserFunction getUserDefinedFunction(java.lang.String uri,
                                               java.lang.String localName,
                                               int arity)

  Get the function with a given name and arity. This method is provided so that XQuery functions can be called directly from a Java application. Note that there is no type checking or conversion of arguments when this is done: the arguments must be provided in exactly the form that the function signature declares them.

  Parameters:
    `uri` - the uri of the function name
    `localName` - the local part of the function name
    `arity` - the number of arguments.