Package net.sf.saxon.style

## Class XSLTemplate

- 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.XSLTemplate

- 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 final class XSLTemplate
      extends StyleElement
      implements StylesheetComponent

  An xsl:template element in the style sheet.

- - ### 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
    --- | ---
    `XSLTemplate()` |

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | `allocatePatternSlotNumbers()` | Allocate slot numbers to any local variables declared within a predicate within the match pattern
    `void` | `checkCompatibility​(Component component)` | Check the compatibility of this component with another component that it is overriding
    `void` | `compileDeclaration​(Compilation compilation, ComponentDeclaration decl)` | Compile: creates the executable form of the template
    `void` | `compileTemplateRule​(Compilation compilation, Expression body, ComponentDeclaration decl)` |
    `void` | `generateByteCode​(Optimizer opt)` | Generate byte code for the template (if appropriate)
    `NamedTemplate` | `getActor()` | Get the corresponding NamedTemplate object that results from the compilation of this StylesheetComponent
    `java.util.Set<Mode>` | `getApplicableModes()` | Get the modes to which this template rule applies
    `NamedTemplate` | `getCompiledNamedTemplate()` | Get the compiled template
    `ItemType` | `getContextItemTypeForTemplateRule()` |
    `Pattern` | `getMatch()` |
    `StructuredQName[]` | `getModeNames()` | Return the list of mode names to which this template rule is applicable.
    `XSLLocalParam` | `getParam​(StructuredQName name)` |
    `ItemType` | `getRequiredContextItemType()` |
    `SlotManager` | `getSlotManager()` | Get associated Procedure (for details of stack frame)
    `SymbolicName` | `getSymbolicName()` | Get the symbolic name of the component, that is, the combination of the component kind and the qualified name
    `StructuredQName` | `getTemplateName()` | Return the name of this template.
    `java.util.Map<StructuredQName,​TemplateRule>` | `getTemplateRulesByMode()` |
    `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` | `isDeferredCompilation​(Compilation compilation)` | Ask whether the compilation of the template should be deferred
    `boolean` | `isMayOmitContextItem()` |
    `boolean` | `isOmniMode()` | Ask whether this is a template rule with mode="#all
    `protected boolean` | `isPermittedChild​(StyleElement child)` | Specify that xsl:param and xsl:context-item are permitted children
    `protected boolean` | `isWithinDeclaredStreamableConstruct()` |
    `void` | `jitCompile​(Compilation compilation, ComponentDeclaration decl)` | Code executed when the template is first executed under JIT.
    `boolean` | `markTailCalls()` | Mark tail-recursive calls on templates and functions.
    `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)` | This method is a bit of a misnomer, because it does more than invoke optimization of the template body.
    `void` | `prepareAttributes()` | Set the attribute list for the element.
    `void` | `processAllAttributes()` | Process the attributes of this element and all its children
    `void` | `register​(ComponentDeclaration declaration)` | Registers the template rule with each Mode that it belongs to.
    `void` | `setCompilation​(Compilation compilation)` |
    `void` | `setContextItemRequirements​(ItemType type, boolean mayBeOmitted, boolean absentFocus)` | Set the required context item type.
    `void` | `validate​(ComponentDeclaration decl)` | Check that the stylesheet element is valid.
    `void` | `validateSubtree​(ComponentDeclaration decl, boolean excludeStylesheet)` | Recursive walk through the stylesheet to validate all nodes

    - ### 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, getObjectName, getPackageData, getPrincipalStylesheetModule, getProperties, getSchemaType, getStaticContext, getStaticContext, getTypeAnnotation, getUsedPackage, getVisibility, getWithParamInstructions, getXslOriginal, hasImplicitBinding, invalidAttribute, isExtensionAttributeAllowed, isExtensionNamespace, isInstruction, isSchemaAware, issueWarning, issueWarning, isTopLevel, makeAttributeValueTemplate, makeExpression, makeExpressionVisitor, makeQName, makeRetainedStaticContext, makeSequenceType, mayContainFallback, postValidate, processBooleanAttribute, processStandardAttributes, processVersionAttribute, reportAbsence, requireSyntaxExtensions, seesAvuncularVariables, setObjectName, setValidationError, substituteFor, typeCheck, typeCheck, validateChildren, 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

    - #### XSLTemplate

          public XSLTemplate()

  - ### Method Detail

    - #### getActor

          public NamedTemplate getActor()

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

    - #### setCompilation

          public void setCompilation​(Compilation compilation)

      Overrides:
        `setCompilation` in class `StyleElement`

    - #### 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

    - #### isDeferredCompilation

          public boolean isDeferredCompilation​(Compilation compilation)

      Ask whether the compilation of the template should be deferred
      Parameters:
        `compilation` - the compilation
      Returns:
        true if compilation should be deferred

    - #### 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 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

    - #### isWithinDeclaredStreamableConstruct

          protected boolean isWithinDeclaredStreamableConstruct()

      Overrides:
        `isWithinDeclaredStreamableConstruct` in class `StyleElement`

    - #### setContextItemRequirements

          public void setContextItemRequirements​(ItemType type,
                                                 boolean mayBeOmitted,
                                                 boolean absentFocus)

      Set the required context item type. Used when there is an xsl:context-item child element
      Parameters:
        `type` - the required context item type
        `mayBeOmitted` - true if the context item may be absent
        `absentFocus` - true if use=absent is specified

    - #### isPermittedChild

          protected boolean isPermittedChild​(StyleElement child)

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

    - #### getTemplateName

          public StructuredQName getTemplateName()

      Return the name of this template. Note that this may be called before prepareAttributes has been called.
      Returns:
        the name of the template as a Structured QName.

    - #### getSymbolicName

          public SymbolicName 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

    - #### getRequiredContextItemType

          public ItemType getRequiredContextItemType()

    - #### isMayOmitContextItem

          public boolean isMayOmitContextItem()

    - #### 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

    - #### getParam

          public XSLLocalParam getParam​(StructuredQName name)

    - #### 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`

    - #### processAllAttributes

          public void processAllAttributes()
                                    throws XPathException

      Description copied from class: `StyleElement`
      Process the attributes of this element and all its children
      Overrides:
        `processAllAttributes` in class `StyleElement`
      Throws:
        `XPathException` - in the event of a static error being detected

    - #### getModeNames

          public StructuredQName[] getModeNames()
                                         throws XPathException

      Return the list of mode names to which this template rule is applicable.
      Returns:
        the list of mode names. If the mode attribute is absent, #default is assumed. If #default is present explicitly or implicitly, it is replaced by the default mode, taken from the in-scope default-modes attribute, which defaults to #unnamed. The unnamed mode is represented by `Mode.UNNAMED_MODE_NAME`. The token #all translates to `Mode.OMNI_MODE`.
      Throws:
        `XPathException` - if the attribute is invalid.

    - #### getApplicableModes

          public java.util.Set<Mode> getApplicableModes()
                                                 throws XPathException

      Get the modes to which this template rule applies
      Returns:
        the set of modes to which it applies
      Throws:
        `XPathException` - should not happen

    - #### isOmniMode

          public boolean isOmniMode()
                             throws XPathException

      Ask whether this is a template rule with mode="#all
      Throws:
        `XPathException`

    - #### 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

    - #### validateSubtree

          public void validateSubtree​(ComponentDeclaration decl,
                                      boolean excludeStylesheet)
                               throws XPathException

      Description copied from class: `StyleElement`
      Recursive walk through the stylesheet to validate all nodes
      Overrides:
        `validateSubtree` in class `StyleElement`
      Parameters:
        `decl` - the declaration to be validated
        `excludeStylesheet` - true if the XSLStylesheet element is to be excluded
      Throws:
        `XPathException` - if validation fails

    - #### index

          public void index​(ComponentDeclaration decl,
                            PrincipalStylesheetModule top)
                     throws XPathException

      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
      Throws:
        `XPathException` - if any error is encountered

    - #### markTailCalls

          public boolean markTailCalls()

      Mark tail-recursive calls on templates and functions.
      Overrides:
        `markTailCalls` in class `StyleElement`
      Returns:
        true if one or more tail calls were identified

    - #### compileDeclaration

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

      Compile: creates the executable form of the template
      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

    - #### compileTemplateRule

          public void compileTemplateRule​(Compilation compilation,
                                          Expression body,
                                          ComponentDeclaration decl)

    - #### jitCompile

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

      Code executed when the template is first executed under JIT. If the template is defined in several modes, then this may be called several times, but it only does anything the first time. Mode-specific processing is done in the TemplateRuleInitializer.
      Parameters:
        `compilation` - the compilation episode
        `decl` - the template rule declaration
      Throws:
        `XPathException` - if anything goes wrong

    - #### register

          public void register​(ComponentDeclaration declaration)
                        throws XPathException

      Registers the template rule with each Mode that it belongs to.
      Parameters:
        `declaration` - Associates this template with a stylesheet module (in principle an xsl:template element can be in a document that is imported more than once; these are separate declarations)
      Throws:
        `XPathException` - if a failure occurs

    - #### allocatePatternSlotNumbers

          public void allocatePatternSlotNumbers()

      Allocate slot numbers to any local variables declared within a predicate within the match pattern

    - #### optimize

          public void optimize​(ComponentDeclaration declaration)
                        throws XPathException

      This method is a bit of a misnomer, because it does more than invoke optimization of the template body. In particular, it also registers the template rule with each Mode that it belongs to.
      Specified by:
        `optimize` in interface `StylesheetComponent`
      Parameters:
        `declaration` - Associates this template with a stylesheet module (in principle an xsl:template element can be in a document that is imported more than once; these are separate declarations)
      Throws:
        `XPathException` - if errors are found

    - #### getContextItemTypeForTemplateRule

          public ItemType getContextItemTypeForTemplateRule()
                                                     throws XPathException

      Throws:
        `XPathException`

    - #### generateByteCode

          public void generateByteCode​(Optimizer opt)
                                throws XPathException

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

    - #### getSlotManager

          public SlotManager getSlotManager()

      Get associated Procedure (for details of stack frame)
      Specified by:
        `getSlotManager` in interface `StylesheetComponent`
      Returns:
        the associated SlotManager object

    - #### getCompiledNamedTemplate

          public NamedTemplate getCompiledNamedTemplate()

      Get the compiled template
      Returns:
        the compiled template

    - #### getMatch

          public Pattern getMatch()

    - #### getTemplateRulesByMode

          public java.util.Map<StructuredQName,​TemplateRule> getTemplateRulesByMode()