Class Template

    • Constructor Detail

      • Template

        public Template()
        Create a template
    • Method Detail

      • init

        public void init​(StructuredQName templateName,
                         int precedence,
                         int minImportPrecedence)
        Initialize the template
        Parameters:
        templateName - the name of the template (if any)
        precedence - the import precedence
        minImportPrecedence - the minimum import precedence to be considered in the search performed by apply-imports
      • setMatchPattern

        public void setMatchPattern​(Pattern pattern)
        Set the match pattern used with this template
        Parameters:
        pattern - the match pattern (may be null for a named template)
      • getMatchPattern

        public Pattern getMatchPattern()
        Get the match pattern used with this template
        Returns:
        the match pattern, or null if this is a named template with no match pattern
      • setBody

        public void setBody​(Expression body)
        Set the expression that forms the body of the template
        Overrides:
        setBody in class Procedure
        Parameters:
        body - the body of the template
      • getTemplateName

        public StructuredQName getTemplateName()
        Get the name of the template (if it is named)
        Returns:
        the template name, or null if unnamed
      • 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.
        Returns:
        the QName of the object declared or manipulated by this instruction or expression
      • getPrecedence

        public int getPrecedence()
        Get the import precedence of the template
        Returns:
        the import precedence (a higher number means a higher precedence)
      • getMinImportPrecedence

        public int getMinImportPrecedence()
        Get the minimum import precedence used by xsl:apply-imports
        Returns:
        the minimum import precedence of templates that are candidates for calling by apply-imports
      • setHasRequiredParams

        public void setHasRequiredParams​(boolean has)
        Set whether this template has one or more required parameters
        Parameters:
        has - true if the template has at least one required parameter
      • hasRequiredParams

        public boolean hasRequiredParams()
        Ask whether this template has one or more required parameters
        Returns:
        true if this template has at least one required parameter
      • setRequiredType

        public void setRequiredType​(SequenceType type)
        Set the required type to be returned by this template
        Parameters:
        type - the required type as defined in the "as" attribute on the xsl:template element
      • getRequiredType

        public SequenceType getRequiredType()
        Get the required type to be returned by this template
        Returns:
        the required type as defined in the "as" attribute on the xsl:template element
      • apply

        public void apply​(XPathContext context,
                          Rule rule)
                   throws XPathException
        Process the template, without returning any tail calls. This path is used by xsl:apply-imports and xsl:next-match
        Parameters:
        context - The dynamic context, giving access to the current node,
        rule - the template rule that caused this template to be invoked. When a template has a match pattern defined as a union, there can be more than one Rule referring to the same template, and further calls on next-match or apply-imports need to know which one in in force
        Throws:
        XPathException
      • applyLeavingTail

        public TailCall applyLeavingTail​(XPathContext context,
                                         Rule rule)
                                  throws XPathException
        Process this template, with the possibility of returning a tail call package if the template contains any tail calls that are to be performed by the caller.
        Parameters:
        context - the XPath dynamic context
        rule - the template rule that caused this template to be invoked. When a template has a match pattern defined as a union, there can be more than one Rule referring to the same template, and further calls on next-match or apply-imports need to know which one in in force
        Returns:
        null if the template exited normally; but if it was a tail call, details of the call that hasn't been made yet and needs to be made by the caller
        Throws:
        XPathException
      • expand

        public TailCall expand​(XPathContext context)
                        throws XPathException
        Expand the template. Called when the template is invoked using xsl:call-template. Invoking a template by this method does not change the current template.
        Parameters:
        context - the XPath dynamic context
        Returns:
        null if the template exited normally; but if it was a tail call, details of the call that hasn't been made yet and needs to be made by the caller
        Throws:
        XPathException
      • getConstructType

        public int getConstructType()
        Get the type of construct. This will either be the fingerprint of a standard XSLT instruction name (values in StandardNames: all less than 1024) or it will be a constant in class Location.
        Returns:
        an integer identifying the kind of construct