Package com.icl.saxon.style

Class StyleElement

    • Field Detail

      • attributeSets

        protected Vector attributeSets

      • extensionNamespaces

        protected short[] extensionNamespaces

      • version

        protected String version

      • reportingCircumstances

        protected int reportingCircumstances

      • REPORT_UNLESS_FORWARDS_COMPATIBLE

        public static final int REPORT_UNLESS_FORWARDS_COMPATIBLE
        See Also:
        Constant Field Values

      • sequence

        protected int sequence

    • Constructor Detail

      • StyleElement

        public StyleElement()
        Constructor

    • Method Detail

      • substituteFor

        public void substituteFor​(StyleElement temp)
        Make this node a substitute for a temporary one previously added to the tree. See StyleNodeFactory for details. "A node like the other one in all things but its class". Note that at this stage, the node will not yet be known to its parent, though it will contain a reference to its parent; and it will have no children.

      • setValidationError

        protected void setValidationError​(TransformerException reason,
                                  int circumstances)
        Set a validation error

      • isInstruction

        public boolean isInstruction()
        Determine whether this node is an instruction. The default implementation says it isn't.

      • doesPostProcessing

        public boolean doesPostProcessing()
        Determine whether this element does any processing after instantiating any children. The default implementation says it does. Tail recursion only works if call-template is nested entirely in elements that do no such processing. (If the element is empty, this property is irrelevant, because the element cannot contain an xsl:call-template).

      • mayContainTemplateBody

        public boolean mayContainTemplateBody()
        Determine whether this type of element is allowed to contain a template-body

      • getContainingStyleSheet

        public XSLStyleSheet getContainingStyleSheet()
        Get the containing XSLStyleSheet element

      • getPrecedence

        public int getPrecedence()
        Get the import precedence of this stylesheet element.

      • getStandardNames

        public final StandardNames getStandardNames()
        Get the StandardNames object

      • processVersionAttribute

        protected void processVersionAttribute​(int nc)
        Process the [xsl:]version attribute if there is one
        Parameters:
        nc - the name code of the attribute required

      • getVersion

        public String getVersion()
        Get the version number on this element, or inherited from its ancestors

      • forwardsCompatibleModeIsEnabled

        public boolean forwardsCompatibleModeIsEnabled()
        Determine whether forwards-compatible mode is enabled for this element

      • definesExtensionElement

        protected boolean definesExtensionElement​(short uriCode)
        Check whether a particular extension element namespace is defined on this node. This checks this node only, not the ancestor nodes. The implementation checks whether the prefix is included in the [xsl:]extension-element-prefixes attribute.
        Parameters:
        uriCode - the namespace URI code being tested

      • isExtensionNamespace

        public boolean isExtensionNamespace​(short uriCode)
        Check whether a namespace uri defines an extension element. This checks whether the namespace is defined as an extension namespace on this or any ancestor node.
        Parameters:
        uriCode - the namespace URI code being tested

      • definesExcludedNamespace

        protected boolean definesExcludedNamespace​(short uriCode)
        Check whether this node excludes a particular namespace from the result. This method checks this node only, not the ancestor nodes.
        Parameters:
        uriCode - the code of the namespace URI being tested

      • isExcludedNamespace

        public boolean isExcludedNamespace​(short uriCode)
        Check whether a namespace uri defines an namespace excluded from the result. This checks whether the namespace is defined as an excluded namespace on this or any ancestor node.
        Parameters:
        uriCode - the code of the namespace URI being tested

      • validate

        public void validate()
              throws TransformerConfigurationException
        Check that the 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.
        Throws:
        TransformerConfigurationException

      • preprocess

        public void preprocess()
                throws TransformerConfigurationException
        Default preprocessing method does nothing. It is implemented for those top-level elements that can be evaluated before the source document is available, for example xsl:key, xsl:attribute-set, xsl:template, xsl:locale
        Throws:
        TransformerConfigurationException

      • getPrincipalStyleSheet

        protected XSLStyleSheet getPrincipalStyleSheet()
        Get the principal XSLStyleSheet node. This gets the principal style sheet, i.e. the one originally loaded, that forms the root of the import/include tree

      • getPreparedStyleSheet

        public PreparedStyleSheet getPreparedStyleSheet()
        Get the PreparedStyleSheet object.
        Returns:
        the PreparedStyleSheet to which this stylesheet element belongs

      • process

        public abstract void process​(Context context)
                      throws TransformerException
        Process: called to do the real work of this stylesheet element. This method must be implemented in each subclass.
        Parameters:
        context - The context in the source XML document, giving access to the current node, the current variables, etc.
        Throws:
        TransformerException

      • processChildren

        public void processChildren​(Context context)
                     throws TransformerException
        Process the children of this node in the stylesheet
        Parameters:
        context - The context in the source XML document, giving access to the current node, the current variables, etc.
        Throws:
        TransformerException

      • isTopLevel

        public boolean isTopLevel()
        Test whether this is a top-level element

      • bindVariable

        public Binding bindVariable​(int fingerprint)
                     throws XPathException
        Bind a variable used in this element to the XSLVariable element in which it is declared
        Parameters:
        fingerprint - The fingerprint of the name of the variable
        Returns:
        a Binding for the variable
        Throws:
        XPathException - if the variable has not been declared

      • getVariableBinding

        public Binding getVariableBinding​(int fprint)
        Bind a variable used in this element to the XSLVariable element in which it is declared
        Parameters:
        fprint - The absolute name of the variable (as a namepool fingerprint)
        Returns:
        a Binding for the variable, or null if it has not been declared

      • getVariableNames

        public Enumeration[] getVariableNames()
        List the variables that are in scope for this stylesheet element. Designed for a debugger, not used by the processor.
        Returns:
        two Enumeration of Strings, the global ones [0] and the local ones [1]

      • getStyleSheetFunction

        public Function getStyleSheetFunction​(int fingerprint)
        Get a Function declared using a saxon:function element in the stylesheet
        Parameters:
        fingerprint - the fingerprint of the name of the function
        Returns:
        the Function object represented by this saxon:function; or null if not found

      • getSequenceNumber

        protected final long getSequenceNumber()
        Get the node sequence number (in document order). Sequence numbers are monotonic but not consecutive. In the current implementation, parent nodes (elements and roots) have a zero least-significant word, while namespaces, attributes, text nodes, comments, and PIs have the top word the same as their owner and the bottom half reflecting their relative position.
        Overrides:
        getSequenceNumber in class NodeImpl

      • hasChildNodes

        public final boolean hasChildNodes()
        Determine if the node has any children.
        Specified by:
        hasChildNodes in interface Node
        Specified by:
        hasChildNodes in interface NodeInfo
        Overrides:
        hasChildNodes in class NodeImpl
        Returns:
        true if the node has any children, false if the node has no children.

      • enumerateChildren

        public final AxisEnumeration enumerateChildren​(NodeTest test)
        Get an enumeration of the children of this node

      • getFirstChild

        public final Node getFirstChild()
        Get the first child node of the element
        Specified by:
        getFirstChild in interface Node
        Overrides:
        getFirstChild in class NodeImpl
        Returns:
        the first child node of the required type, or null if there are no children

      • getLastChild

        public final Node getLastChild()
        Get the last child node of the element
        Specified by:
        getLastChild in interface Node
        Overrides:
        getLastChild in class NodeImpl
        Returns:
        the last child of the element, or null if there are no children

      • getChildNodes

        public final NodeList getChildNodes()
        Return a NodeList that contains all children of this node. If there are no children, this is a NodeList containing no nodes.
        Specified by:
        getChildNodes in interface Node
        Overrides:
        getChildNodes in class NodeImpl

      • getNthChild

        protected final NodeImpl getNthChild​(int n)
        Get the nth child node of the element (numbering from 0)
        Returns:
        the last child of the element, or null if there is no n'th child

      • getStringValue

        public String getStringValue()
        Return the string-value of the node, that is, the concatenation of the character content of all descendent elements and text nodes.
        Returns:
        the accumulated character content of the element, including descendant elements.

      • useChildrenArray

        public void useChildrenArray​(NodeImpl[] array)
        Supply an array to be used for the array of children. For system use only.

      • addChild

        public void addChild​(NodeImpl node,
                     int index)
        Add a child node to this node. For system use only. Note: normalizing adjacent text nodes is the responsibility of the caller.

      • removeChild

        public void removeChild​(int index)
        Remove node at given index. Will always be followed by a renumberChildren().

      • renumberChildren

        public void renumberChildren()
        Renumber the children of a given parent node. For system use only

      • dropChildren

        public void dropChildren()
        Drop a branch of the tree. The target element remains in the tree, but its children are disconnected from the parent. Unless there are other references to the children (e.g. in a variable) they will be deleted from memory next time the garbage collector comes round.

      • compact

        public void compact​(int size)
        Compact the space used by this node

      • getNodeValue

        public String getNodeValue()
        Get the node value as defined in the DOM. This is not the same as the XPath string-value.
        Specified by:
        getNodeValue in interface Node
        Overrides:
        getNodeValue in class AbstractNode