## com.icl.saxon.expr
Class FunctionProxy

    java.lang.Object
      com.icl.saxon.expr.Expression
          com.icl.saxon.expr.Function
              com.icl.saxon.expr.FunctionProxy

public class FunctionProxy
extends Function

This class acts as a proxy for an extension function defined as a method in a user-defined class

Field Summary

Fields inherited from class com.icl.saxon.expr.Function
`argument`

Fields inherited from class com.icl.saxon.expr.Expression
`staticContext`

Constructor Summary
`FunctionProxy()` Constructor: creates an uncommitted FunctionProxy

Method Summary
`static Value` `convertJavaObjectToXPath(java.lang.Object result, Controller controller)` Convert a Java object to an XPath value.
`NodeEnumeration` `enumerate(Context context, boolean requireSorted)` Return an enumeration of nodes in a nodeset.
`Value` `evaluate(Context context)` Evaluate the function.
`boolean` `evaluateAsBoolean(Context context)` Evaluate an expression as a Boolean. The result of x.evaluateAsBoolean(c) must be equivalent to x.evaluate(c).asBoolean(); but optimisations are possible when it is known that a boolean result is required, especially in the case of a NodeSet.
`double` `evaluateAsNumber(Context context)` Evaluate an expression as a Number. The result of x.evaluateAsNumber(c) must be equivalent to x.evaluate(c).asNumber(); but optimisations are possible when it is known that a numeric result is required, especially in the case of a NodeSet.
`java.lang.String` `evaluateAsString(Context context)` Evaluate an expression as a String. The result of x.evaluateAsString(c) must be equivalent to x.evaluate(c).asString(); but optimisations are possible when it is known that a string result is required, especially in the case of a NodeSet.
`java.lang.Object` `getBestFit(Value[] argValues)` Get the best fit amongst all the candidate methods or constructors
`int` `getDataType()` Determine the data type of the expression, if possible
`int` `getDependencies()` Determine which aspects of the context the expression depends on.
`java.lang.String` `getName()` Get the name of the function
`Expression` `reduce(int dependencies, Context context)` Perform a partial evaluation of the expression, by eliminating specified dependencies on the context.
`boolean` `setFunctionName(java.lang.Class reqClass, java.lang.String localName)` setFunctionName: locates the external class and the method (or candidate methods) to which this function relates.
`Expression` `simplify()` Simplify the function (by simplifying its arguments)

Methods inherited from class com.icl.saxon.expr.Function
`addArgument, checkArgumentCount, display, getNumberOfArguments`

Methods inherited from class com.icl.saxon.expr.Expression
`containsReferences, evaluateAsNodeSet, getStaticContext, indent, isContextDocumentNodeSet, make, outputStringValue, setStaticContext, usesCurrent`

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

Constructor Detail

### FunctionProxy

    public FunctionProxy()

  Constructor: creates an uncommitted FunctionProxy

Method Detail

### setFunctionName

    public boolean setFunctionName(java.lang.Class reqClass,
                                   java.lang.String localName)

  setFunctionName: locates the external class and the method (or candidate methods) to which this function relates. At this stage addArguments() will have normally been called, so the number of arguments is known. If no method of the required name is located, an exception is saved, but it is not thrown until an attempt is made to evaluate the function. All methods that match the required number of arguments are saved in a list (candidateMethods), a decision among these methods is made at run-time when the types of the actual arguments are known.

  The method is also used while calling function-available(). In this case the number of arguments is not known (it will be set to zero). We return true if a match was found, regardless of the number of arguments.

  Parameters:
    `reqClass` - The Java class name
    `localName` - The local name used in the XPath function call
  Returns:
    true if the function is available (with some number of arguments).

### getDataType

    public int getDataType()

  Determine the data type of the expression, if possible

  Specified by:
    `getDataType` in class `Expression`
  Returns:
    Value.ANY (meaning not known in advance)

### getName

    public java.lang.String getName()

  Get the name of the function

  Specified by:
    `getName` in class `Function`
  Returns:
    the name of the function, as used in XSL expressions, but excluding its namespace prefix

### simplify

    public Expression simplify()
                        throws XPathException

  Simplify the function (by simplifying its arguments)

  Overrides:
    `simplify` in class `Expression`
  Returns:
    the simplified expression
  Throws:
    `XPathException`

### getDependencies

    public int getDependencies()

  Determine which aspects of the context the expression depends on. The result is a bitwise-or'ed value composed from constants such as Context.VARIABLES and Context.CURRENT_NODE

  Specified by:
    `getDependencies` in class `Expression`

### reduce

    public Expression reduce(int dependencies,
                             Context context)
                      throws XPathException

  Perform a partial evaluation of the expression, by eliminating specified dependencies on the context.

  Specified by:
    `reduce` in class `Expression`
  Parameters:
    `dependencies` - The dependencies to be removed
    `context` - The context to be used for the partial evaluation
  Returns:
    a new expression that does not have any of the specified dependencies
  Throws:
    `XPathException`

### getBestFit

    public java.lang.Object getBestFit(Value[] argValues)
                                throws XPathException

  Get the best fit amongst all the candidate methods or constructors

  Returns:
    the result is either a Method or a Constructor. In JDK 1.2 these have a common superclass, AccessibleObject, but this is not available in JDK 1.1, which we still support.
  Throws:
    `XPathException`

### evaluate

    public Value evaluate(Context context)
                   throws XPathException

  Evaluate the function.

  Specified by:
    `evaluate` in class `Expression`
  Parameters:
    `context` - The context in which the function is to be evaluated
  Returns:
    a Value representing the result of the function.
  Throws:
    `XPathException` - if the function cannot be evaluated.

### evaluateAsString

    public java.lang.String evaluateAsString(Context context)
                                      throws XPathException

  Description copied from class: `Expression`
  Evaluate an expression as a String.
  The result of x.evaluateAsString(c) must be equivalent to x.evaluate(c).asString(); but optimisations are possible when it is known that a string result is required, especially in the case of a NodeSet.

  Overrides:
    `evaluateAsString` in class `Expression`
  Parameters:
    `context` - The context in which the expression is to be evaluated
  Returns:
    the value of the expression, evaluated in the current context
  Throws:
    `XPathException`

### evaluateAsNumber

    public double evaluateAsNumber(Context context)
                            throws XPathException

  Description copied from class: `Expression`
  Evaluate an expression as a Number.
  The result of x.evaluateAsNumber(c) must be equivalent to x.evaluate(c).asNumber(); but optimisations are possible when it is known that a numeric result is required, especially in the case of a NodeSet.

  Overrides:
    `evaluateAsNumber` in class `Expression`
  Parameters:
    `context` - The context in which the expression is to be evaluated
  Returns:
    the value of the expression, evaluated in the current context
  Throws:
    `XPathException`

### evaluateAsBoolean

    public boolean evaluateAsBoolean(Context context)
                              throws XPathException

  Description copied from class: `Expression`
  Evaluate an expression as a Boolean.
  The result of x.evaluateAsBoolean(c) must be equivalent to x.evaluate(c).asBoolean(); but optimisations are possible when it is known that a boolean result is required, especially in the case of a NodeSet.

  Overrides:
    `evaluateAsBoolean` in class `Expression`
  Parameters:
    `context` - The context in which the expression is to be evaluated
  Returns:
    the value of the expression, evaluated in the current context
  Throws:
    `XPathException`

### enumerate

    public NodeEnumeration enumerate(Context context,
                                     boolean requireSorted)
                              throws XPathException

  Description copied from class: `Expression`
  Return an enumeration of nodes in a nodeset.

  Overrides:
    `enumerate` in class `Expression`
  Parameters:
    `context` - The context in which the expression is to be evaluated
    `requireSorted` - Indicates whether the nodes are required in document order. If this is false, they may come in any order, but there will be no duplicates.
  Throws:
    `XPathException` - when the expression does not return a nodeset.

### convertJavaObjectToXPath

    public static Value convertJavaObjectToXPath(java.lang.Object result,
                                                 Controller controller)
                                          throws XPathException

  Convert a Java object to an XPath value. This method is called to handle the result of an external function call (but only if the required type is not known), and also to process global parameters passed to the stylesheet.

  Throws:
    `XPathException`