Package net.sf.saxon.style

## Class XSLFunction

- java.lang.Object
- - net.sf.saxon.tree.linked.NodeImpl
  - - net.sf.saxon.tree.linked.ParentNodeImpl
    - - net.sf.saxon.tree.linked.ElementImpl
      - - net.sf.saxon.style.StyleElement
        - - net.sf.saxon.style.XSLFunction

- All Implemented Interfaces:
    `javax.xml.transform.Source`, `javax.xml.transform.SourceLocator`, `GroundedValue`, `Item`, `MutableNodeInfo`, `NamespaceResolver`, `NodeInfo`, `Sequence`, `Location`, `StylesheetComponent`, `SteppingNode<NodeImpl>`, `SiblingCountingNode`, `org.xml.sax.Locator`

      public class XSLFunction
      extends StyleElement
      implements StylesheetComponent

  Handler for xsl:function elements in stylesheet (XSLT 2.0).
  Attributes:
  name gives the name of the function saxon:memo-function=yes|no indicates whether it acts as a memo function.

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class net.sf.saxon.style.StyleElement

      `StyleElement.OnFailure`

  - ### Field Summary

    - ### Fields inherited from class net.sf.saxon.style.StyleElement

      `ACTION_COMPILE, ACTION_FIXUP, ACTION_OPTIMIZE, ACTION_PROCESS_ATTRIBUTES, ACTION_TYPECHECK, ACTION_VALIDATE, actionsCompleted, defaultCollationName, defaultMode, defaultXPathNamespace, expandText, extensionNamespaces, reportingCircumstances, staticContext, validationError, version`

    - ### Fields inherited from class net.sf.saxon.tree.linked.NodeImpl

      `NODE_LETTER`

    - ### Fields inherited from interface net.sf.saxon.om.NodeInfo

      `IS_DTD_TYPE, IS_NILLED`

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `XSLFunction()` |

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | `checkCompatibility​(Component component)` | Check the compatibility of this component with another component that it is overriding
    `void` | `compileDeclaration​(Compilation compilation, ComponentDeclaration decl)` | Compile the function definition to create an executable representation The compileDeclaration() method has the side-effect of binding all references to the function to the executable representation (a UserFunction object)
    `void` | `generateByteCode​(Optimizer opt)` | Generate byte code if appropriate
    `UserFunction` | `getActor()` | Get the corresponding Procedure object that results from the compilation of this StylesheetProcedure
    `SequenceType[]` | `getArgumentTypes()` | Get the argument types
    `UserFunction` | `getCompiledFunction()` | Get the compiled function
    `int` | `getNumberOfArguments()` | Get the number of arguments declared by this function (that is, its arity).
    `StructuredQName` | `getObjectName()` | Get a name identifying the object of the expression, for example a function name, template name, variable name, key name, element name, etc.
    `SequenceType` | `getResultType()` | Get the type of value returned by this function
    `SlotManager` | `getSlotManager()` | Get associated stack frame details.
    `SymbolicName.F` | `getSymbolicName()` | Get the symbolic name of the component, that is, the combination of the component kind and the qualified name
    `Visibility` | `getVisibility()` | Get the visibility of the component.
    `void` | `index​(ComponentDeclaration decl, PrincipalStylesheetModule top)` | Method supplied by declaration elements to add themselves to a stylesheet-level index
    `boolean` | `isDeclaration()` | Ask whether this node is a declaration, that is, a permitted child of xsl:stylesheet (including xsl:include and xsl:import).
    `boolean` | `isOverrideExtensionFunction()` | Is override-extension-function="yes"?.
    `protected boolean` | `isPermittedChild​(StyleElement child)` | Specify that xsl:param is a permitted child
    `protected boolean` | `mayContainParam()` | Determine whether this type of element is allowed to contain an xsl:param element
    `boolean` | `mayContainSequenceConstructor()` | Determine whether this type of element is allowed to contain a template-body.
    `void` | `optimize​(ComponentDeclaration declaration)` | Optimize the stylesheet construct
    `void` | `prepareAttributes()` | Set the attribute list for the element.
    `void` | `setParameterDefinitions​(UserFunction fn)` | Set the definitions of the parameters in the compiled function, as an array.
    `void` | `validate​(ComponentDeclaration decl)` | Check that the stylesheet element is valid.

    - ### Methods inherited from class net.sf.saxon.style.StyleElement

      `allocateLocation, bindLocalVariable, bindVariable, checkEmpty, checkTopLevel, checkUnknownAttribute, compile, compileError, compileError, compileError, compileError, compileError, compileError, compileErrorInAttribute, compileSequenceConstructor, compileSequenceConstructor, compileWarning, compileWarning, compileWarning, fixupReferences, generateId, getAttributeValue, getBaseURI, getBindingInformation, getCompilation, getConfiguration, getContainingPackage, getContainingSlotManager, getDeclaredVisibility, getDefaultCollationName, getDefaultXPathNamespace, getNamespaceResolver, getPackageData, getPrincipalStylesheetModule, getProperties, getSchemaType, getStaticContext, getStaticContext, getTypeAnnotation, getUsedPackage, getWithParamInstructions, getXslOriginal, hasImplicitBinding, invalidAttribute, isExtensionAttributeAllowed, isExtensionNamespace, isInstruction, isSchemaAware, issueWarning, issueWarning, isTopLevel, isWithinDeclaredStreamableConstruct, makeAttributeValueTemplate, makeExpression, makeExpressionVisitor, makeQName, makeRetainedStaticContext, makeSequenceType, markTailCalls, mayContainFallback, postValidate, processAllAttributes, processBooleanAttribute, processStandardAttributes, processVersionAttribute, reportAbsence, requireSyntaxExtensions, seesAvuncularVariables, setCompilation, setObjectName, setValidationError, substituteFor, typeCheck, typeCheck, validateChildren, validateSubtree, validateValidationAttribute`

    - ### Methods inherited from class net.sf.saxon.tree.linked.ElementImpl

      `addAttribute, addNamespace, addNamespace, attributes, checkNotNamespaceSensitiveElement, copy, delete, fixupInsertedNamespaces, generateId, getAllNamespaces, getAttributeValue, getColumnNumber, getDeclaredNamespaces, getLineNumber, getNodeKind, getNodeName, getRoot, getSchemaType, getSystemId, getURIForPrefix, initialise, isId, isIdref, isInScopeNamespace, isNilled, iteratePrefixes, removeAttribute, removeNamespace, removeTypeAnnotation, rename, replaceStringValue, setAttributeInfo, setAttributes, setLocation, setNamespaceMap, setNilled, setNodeName, setSystemId, setTypeAnnotation`

    - ### Methods inherited from class net.sf.saxon.tree.linked.ParentNodeImpl

      `addChild, children, compact, getFirstChild, getLastChild, getNthChild, getNumberOfChildren, getRawSequenceNumber, getSequenceNumber, getStringValue, getStringValueCS, hasChildNodes, insertChildren, iterateChildren, removeChild, replaceChildrenAt, setChildren, setRawSequenceNumber`

    - ### Methods inherited from class net.sf.saxon.tree.linked.NodeImpl

      `atomize, compareOrder, effectiveBooleanValue, equals, getDisplayName, getFingerprint, getLocalPart, getNamePool, getNextInDocument, getNextSibling, getParent, getPhysicalRoot, getPrefix, getPreviousInDocument, getPreviousSibling, getRawParent, getSiblingPosition, getSuccessorElement, getTreeInfo, getURI, hasFingerprint, head, insertSiblings, isDeleted, iterateAxis, iterateAxis, newBuilder, replace, saveLocation, setRawParent, setSiblingPosition`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface net.sf.saxon.om.GroundedValue

      `asIterable, concatenate, containsNode, materialize`

    - ### Methods inherited from interface net.sf.saxon.om.Item

      `getLength, itemAt, iterate, reduce, subsequence`

    - ### Methods inherited from interface net.sf.saxon.om.NodeInfo

      `children, equals, getGenre, getPublicId, hashCode, isSameNodeInfo, isStreamed, toShortString`

    - ### Methods inherited from interface net.sf.saxon.om.Sequence

      `makeRepeatable`

    - ### Methods inherited from interface javax.xml.transform.Source

      `isEmpty`

- - ### Constructor Detail

    - #### XSLFunction

          public XSLFunction()

  - ### Method Detail

    - #### getActor

          public UserFunction getActor()

      Get the corresponding Procedure object that results from the compilation of this StylesheetProcedure
      Specified by:
        `getActor` in interface `StylesheetComponent`
      Returns:
        the compiled ComponentCode

    - #### isDeclaration

          public boolean isDeclaration()

      Ask whether this node is a declaration, that is, a permitted child of xsl:stylesheet (including xsl:include and xsl:import).
      Overrides:
        `isDeclaration` in class `StyleElement`
      Returns:
        true for this element

    - #### prepareAttributes

          public void prepareAttributes()

      Description copied from class: `StyleElement`
      Set the attribute list for the element. This is called to process the attributes (note the distinction from processAttributes in the superclass). Must be supplied in a subclass
      Specified by:
        `prepareAttributes` in class `StyleElement`

    - #### getObjectName

          public StructuredQName getObjectName()

      Get a name identifying the object of the expression, for example a function name, template name, variable name, key name, element name, etc. This is used only where the name is known statically. If there is no name, the value will be -1.
      Overrides:
        `getObjectName` in class `StyleElement`
      Returns:
        the name of the object declared in this element, if any

    - #### mayContainSequenceConstructor

          public boolean mayContainSequenceConstructor()

      Determine whether this type of element is allowed to contain a template-body.
      Overrides:
        `mayContainSequenceConstructor` in class `StyleElement`
      Returns:
        true: yes, it may contain a general template-body

    - #### mayContainParam

          protected boolean mayContainParam()

      Description copied from class: `StyleElement`
      Determine whether this type of element is allowed to contain an xsl:param element
      Overrides:
        `mayContainParam` in class `StyleElement`
      Returns:
        true if this element is allowed to contain an xsl:param

    - #### isPermittedChild

          protected boolean isPermittedChild​(StyleElement child)

      Specify that xsl:param is a permitted child
      Overrides:
        `isPermittedChild` in class `StyleElement`
      Parameters:
        `child` - the child that may or may not be permitted
      Returns:
        true if the child is permitted.

    - #### getVisibility

          public Visibility getVisibility()

      Description copied from class: `StyleElement`
      Get the visibility of the component. Returns the actual value of the visibility attribute, after validation, unless this is absent, in which case it returns the default value of PRIVATE. Invokes `StyleElement.invalidAttribute(String, String)` if the value is invalid.
      Overrides:
        `getVisibility` in class `StyleElement`
      Returns:
        the declared visibility of the component, or `Visibility.PRIVATE` if the visibility attribute is absent.

    - #### getSymbolicName

          public SymbolicName.F getSymbolicName()

      Description copied from interface: `StylesheetComponent`
      Get the symbolic name of the component, that is, the combination of the component kind and the qualified name
      Specified by:
        `getSymbolicName` in interface `StylesheetComponent`
      Returns:
        the component's symbolic name

    - #### checkCompatibility

          public void checkCompatibility​(Component component)

      Description copied from interface: `StylesheetComponent`
      Check the compatibility of this component with another component that it is overriding
      Specified by:
        `checkCompatibility` in interface `StylesheetComponent`
      Parameters:
        `component` - the overridden component

    - #### isOverrideExtensionFunction

          public boolean isOverrideExtensionFunction()

      Is override-extension-function="yes"?.
      Returns:
        true if override-extension-function="yes" was specified, otherwise false

    - #### index

          public void index​(ComponentDeclaration decl,
                            PrincipalStylesheetModule top)

      Description copied from class: `StyleElement`
      Method supplied by declaration elements to add themselves to a stylesheet-level index
      Overrides:
        `index` in class `StyleElement`
      Parameters:
        `decl` - the Declaration being indexed. (This corresponds to the StyleElement object except in cases where one module is imported several times with different precedence.)
        `top` - represents the outermost XSLStylesheet or XSLPackage element

    - #### validate

          public void validate​(ComponentDeclaration decl)
                        throws XPathException

      Description copied from class: `StyleElement`
      Check that the stylesheet element is valid. This is called once for each element, after the entire tree has been built. As well as validation, it can perform first-time initialisation. The default implementation does nothing; it is normally overriden in subclasses.
      Overrides:
        `validate` in class `StyleElement`
      Parameters:
        `decl` - the declaration to be validated
      Throws:
        `XPathException` - if any error is found during validation

    - #### compileDeclaration

          public void compileDeclaration​(Compilation compilation,
                                         ComponentDeclaration decl)
                                  throws XPathException

      Compile the function definition to create an executable representation The compileDeclaration() method has the side-effect of binding all references to the function to the executable representation (a UserFunction object)
      Overrides:
        `compileDeclaration` in class `StyleElement`
      Parameters:
        `compilation` - the compilation episode
        `decl` - the containing top-level declaration, for example xsl:function or xsl:template
      Throws:
        `XPathException` - if compilation fails

    - #### optimize

          public void optimize​(ComponentDeclaration declaration)
                        throws XPathException

      Description copied from interface: `StylesheetComponent`
      Optimize the stylesheet construct
      Specified by:
        `optimize` in interface `StylesheetComponent`
      Parameters:
        `declaration` - the combination of the source XSLT element defining the component, and the module in which it appears
      Throws:
        `XPathException`

    - #### generateByteCode

          public void generateByteCode​(Optimizer opt)
                                throws XPathException

      Generate byte code if appropriate
      Specified by:
        `generateByteCode` in interface `StylesheetComponent`
      Parameters:
        `opt` - the optimizer
      Throws:
        `XPathException` - if bytecode generation fails

    - #### getSlotManager

          public SlotManager getSlotManager()

      Get associated stack frame details.
      Specified by:
        `getSlotManager` in interface `StylesheetComponent`
      Returns:
        the associated SlotManager object

    - #### getResultType

          public SequenceType getResultType()

      Get the type of value returned by this function
      Returns:
        the declared result type, or the inferred result type if this is more precise

    - #### getNumberOfArguments

          public int getNumberOfArguments()

      Get the number of arguments declared by this function (that is, its arity).
      Returns:
        the arity of the function

    - #### setParameterDefinitions

          public void setParameterDefinitions​(UserFunction fn)

      Set the definitions of the parameters in the compiled function, as an array.
      Parameters:
        `fn` - the compiled object representing the user-written function

    - #### getArgumentTypes

          public SequenceType[] getArgumentTypes()

      Get the argument types
      Returns:
        the declared types of the arguments

    - #### getCompiledFunction

          public UserFunction getCompiledFunction()

      Get the compiled function
      Returns:
        the object representing the compiled user-written function