## net.sf.saxon.lib
Class ExtensionFunctionDefinition

    java.lang.Object
      net.sf.saxon.lib.ExtensionFunctionDefinition

All Implemented Interfaces:
  Serializable

Direct Known Subclasses:
  AnalyzeStringFunction, CompileQuery, CompileStylesheet, DeepEqual, DynamicErrorInfo, DynamicFunctionCallDefinition, DynamicFunctionConstructor, Evaluate, Find, ForEachGroupFunction, GeneralFilterFunction, Index, IsWholeNumber, ItemAt, LastModified, MapGet, MapKeys, MapNew, MapPut, Parse, Pi, QueryFn, Serialize, TransformFn, TrigonometricFn

    public abstract class ExtensionFunctionDefinition

extends Object
implements Serializable

This abstract class is provided to allow user-written extension functions to be implemented with the full capabilities of functions that are an intrinsic part of the Saxon product. In particular, the class has the opportunity to save data from the static context and to optimize itself at compile time.

There should be one class implementing this interface for each function name; if there are several functions with the same name but different arity, the same class should implement them all.

Note that an IntegratedFunction is trusted; calls are allowed even if the configuration option `FeatureKeys.ALLOW_EXTERNAL_FUNCTIONS` is false. In cases where an IntegratedFunction is used to load and execute untrusted code, it should check this configuration option before doing so.

Since:
  9.2
See Also:
  Serialized Form

Constructor Summary
`ExtensionFunctionDefinition()`

Method Summary
`boolean` `dependsOnFocus()` Ask whether the result of the function depends on the focus, or on other variable parts of the context.
`abstract SequenceType[]` `getArgumentTypes()` Get the required types for the arguments of this function.
`Object` `getCompilerForJava()` Return an object capable of compiling this IntegratedFunction call to Java source code.
`abstract StructuredQName` `getFunctionQName()` Get the name of the function, as a QName.
`int` `getMaximumNumberOfArguments()` Get the maximum number of arguments allowed by the function.
`int` `getMinimumNumberOfArguments()` Get the minimum number of arguments required by the function
`abstract SequenceType` `getResultType(SequenceType[] suppliedArgumentTypes)` Get the type of the result of the function
`boolean` `hasSideEffects()` Ask whether the function has side-effects.
`abstract ExtensionFunctionCall` `makeCallExpression()` Create a call on this function.
`boolean` `trustResultType()` Ask whether the result actually returned by the function can be trusted, or whether it should be checked against the declared type.

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

Constructor Detail

### ExtensionFunctionDefinition

    public ExtensionFunctionDefinition()

Method Detail

### getFunctionQName

    public abstract StructuredQName getFunctionQName()

  Get the name of the function, as a QName.

  This method must be implemented in all subclasses

  Returns:
    the function name

### getMinimumNumberOfArguments

    public int getMinimumNumberOfArguments()

  Get the minimum number of arguments required by the function

  The default implementation returns the number of items in the result of calling `getArgumentTypes()`

  Returns:
    the minimum number of arguments that must be supplied in a call to this function

### getMaximumNumberOfArguments

    public int getMaximumNumberOfArguments()

  Get the maximum number of arguments allowed by the function.

  The default implementation returns the value of `getMinimumNumberOfArguments()`

  Returns:
    the maximum number of arguments that may be supplied in a call to this function

### getArgumentTypes

    public abstract SequenceType[] getArgumentTypes()

  Get the required types for the arguments of this function.

  This method must be implemented in all subtypes.

  Returns:
    the required types of the arguments, as defined by the function signature. Normally this should be an array of size `getMaximumNumberOfArguments()`; however for functions that allow a variable number of arguments, the array can be smaller than this, with the last entry in the array providing the required type for all the remaining arguments.

### getResultType

    public abstract SequenceType getResultType(SequenceType[] suppliedArgumentTypes)

  Get the type of the result of the function

  This method must be implemented in all subtypes.

  Parameters:
    `suppliedArgumentTypes` - the static types of the supplied arguments to the function. This is provided so that a more precise result type can be returned in the common case where the type of the result depends on the types of the arguments.
  Returns:
    the return type of the function, as defined by its function signature

### trustResultType

    public boolean trustResultType()

  Ask whether the result actually returned by the function can be trusted, or whether it should be checked against the declared type.

  Returns:
    true if the function implementation warrants that the value it returns will be an instance of the declared result type. The default value is false, in which case the result will be checked at run-time to ensure that it conforms to the declared type. If the value true is returned, but the function returns a value of the wrong type, the consequences are unpredictable.

### dependsOnFocus

    public boolean dependsOnFocus()

  Ask whether the result of the function depends on the focus, or on other variable parts of the context.

  Returns:
    true if the result of the function depends on the context item, position, or size. Despite the method name, the method should also return true if the function depends on other parts of the context that vary from one part of the query/stylesheet to another, for example the XPath default namespace.

    The default implementation returns false.

    The method must return true if the function makes use of any of these values from the dynamic context. Returning true inhibits certain optimizations, such as moving the function call out of the body of an xsl:for-each loop, or extracting it into a global variable.

### hasSideEffects

    public boolean hasSideEffects()

  Ask whether the function has side-effects. If the function does have side-effects, the optimizer will be less aggressive in moving or removing calls to the function. However, calls on functions with side-effects can never be guaranteed.

  Returns:
    true if the function has side-effects (including creation of new nodes, if the identity of those nodes is significant). The default implementation returns false.

### makeCallExpression

    public abstract ExtensionFunctionCall makeCallExpression()

  Create a call on this function. This method is called by the compiler when it identifies a function call that calls this function.

### getCompilerForJava

    public Object getCompilerForJava()

  Return an object capable of compiling this IntegratedFunction call to Java source code. The returned object may be null, in which case Java code generation is not supported for this IntegratedFunction. If the returned object is not null, it must implement the interface com.saxonica.codegen.IntegratedFunctionCompiler. The default implementation returns null

  Returns:
    an instance of com.saxonica.codegen.IntegratedFunctionCompiler that generates Java code to implement the call on this extension function

Copyright (c) 2004-2010 Saxonica Limited. All rights reserved.