Class StyleElement

    • Field Detail

      • extensionNamespaces

        protected short[] extensionNamespaces
      • version

        protected java.math.BigDecimal version
      • reportingCircumstances

        protected int reportingCircumstances
      • defaultXPathNamespace

        protected java.lang.String defaultXPathNamespace
      • defaultCollationName

        protected java.lang.String defaultCollationName
      • REPORT_UNLESS_FORWARDS_COMPATIBLE

        public static final int REPORT_UNLESS_FORWARDS_COMPATIBLE
        See Also:
        Constant Field Values
      • REPORT_UNLESS_FALLBACK_AVAILABLE

        public static final int REPORT_UNLESS_FALLBACK_AVAILABLE
        See Also:
        Constant Field Values
      • children

        protected java.lang.Object children
      • sequence

        protected int sequence
    • Constructor Detail

      • StyleElement

        public StyleElement()
        Constructor
    • Method Detail

      • getExecutable

        public Executable getExecutable()
        Description copied from interface: Container
        Get the Executable (representing a complete stylesheet or query) of which this Container forms part
        Specified by:
        getExecutable in interface Container
        Returns:
        the executable
      • getLocationProvider

        public LocationProvider getLocationProvider()
        Get the LocationProvider allowing location identifiers to be resolved.
        Specified by:
        getLocationProvider in interface Container
        Returns:
        the location provider
      • getStaticContext

        public StaticContext getStaticContext()
        Get the static context for expressions on this element
        Returns:
        the static context
      • makeExpressionVisitor

        public ExpressionVisitor makeExpressionVisitor()
        Make an expression visitor
        Returns:
        the expression visitor
      • isExplaining

        protected boolean isExplaining()
        Determine whether saxon:explain has been set to "yes"
        Returns:
        true if saxon:explain has been set to "yes" on this element
      • 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.
        Parameters:
        temp - the element which this one is substituting for
      • setValidationError

        protected void setValidationError​(javax.xml.transform.TransformerException reason,
                                          int circumstances)
        Set a validation error. This is an error detected during construction of this element on the stylesheet, but which is not to be reported until later.
        Parameters:
        reason - the details of the error
        circumstances - a code identifying the circumstances under which the error is to be reported
      • isInstruction

        public boolean isInstruction()
        Determine whether this node is an instruction. The default implementation says it isn't.
        Returns:
        true if this element is an instruction
      • getReturnedItemType

        protected ItemType getReturnedItemType()
        Determine the type of item returned by this instruction (only relevant if it is an instruction). Default implementation returns Type.ITEM, indicating that we don't know, it might be anything. Returns null in the case of an element such as xsl:sort or xsl:variable that can appear in a sequence constructor but contributes nothing to the result sequence.
        Returns:
        the item type returned
      • getCommonChildItemType

        protected ItemType getCommonChildItemType()
        Get the most general type of item returned by the children of this instruction
        Returns:
        the lowest common supertype of the item types returned by the children
      • markTailCalls

        protected boolean markTailCalls()
        Mark tail-recursive calls on templates and functions. For most instructions, this returns false.
        Returns:
        true if one or more tail calls were identified
      • mayContainSequenceConstructor

        protected boolean mayContainSequenceConstructor()
        Determine whether this type of element is allowed to contain a sequence constructor
        Returns:
        true if this instruction is allowed to contain a sequence constructor
      • mayContainFallback

        protected boolean mayContainFallback()
        Determine whether this type of element is allowed to contain an xsl:fallback instruction
        Returns:
        true if this element is allowed to contain an xsl:fallback
      • mayContainParam

        protected boolean mayContainParam()
        Determine whether this type of element is allowed to contain an xsl:param element
        Returns:
        true if this element is allowed to contain an xsl:param
      • getContainingStylesheet

        public XSLStylesheet getContainingStylesheet()
        Get the containing XSLStylesheet element
        Returns:
        the XSLStylesheet element representing the outermost element of the containing stylesheet module. Exceptionally, return null if there is no containing XSLStylesheet element
      • getPrecedence

        public int getPrecedence()
        Get the import precedence of this stylesheet element.
        Returns:
        the import precedence. The actual numeric value is arbitrary, but a higher number indicates a higher precedence.
      • makeQName

        public final StructuredQName makeQName​(java.lang.String lexicalQName)
                                        throws XPathException,
                                               NamespaceException
        Make a structured QName, using this Element as the context for namespace resolution, and registering the code in the namepool. If the name is unprefixed, the default namespace is not used.
        Parameters:
        lexicalQName - The lexical QName as written, in the form "[prefix:]localname". The name must have already been validated as a syntactically-correct QName. Leading and trailing whitespace will be trimmed
        Returns:
        the StructuredQName representation of this lexical QName
        Throws:
        XPathException - if the qname is not a lexically-valid QName, or if the name is in a reserved namespace.
        NamespaceException - if the prefix of the qname has not been declared
      • makeNamespaceContext

        public SavedNamespaceContext makeNamespaceContext()
        Make a NamespaceContext object representing the list of in-scope namespaces. This will be a copy of the namespace context with no references to objects in the stylesheet tree, so that it can be kept until run-time without locking the tree down in memory.
        Returns:
        a copy of the namespace context
      • getNamespaceResolver

        public NamespaceResolver getNamespaceResolver()
        Get the namespace context of the instruction.
        Returns:
        the namespace context. This method does not make a copy of the namespace context, so a reference to the returned NamespaceResolver will lock the stylesheet tree in memory.
      • processAllAttributes

        protected void processAllAttributes()
                                     throws XPathException
        Process the attributes of this element and all its children
        Throws:
        XPathException - in the event of a static error being detected
      • getAttributeValue

        public java.lang.String getAttributeValue​(java.lang.String clarkName)
        Get an attribute value given the Clark name of the attribute (that is, the name in {uri}local format).
        Parameters:
        clarkName - the name of the attribute in {uri}local format
        Returns:
        the value of the attribute if it exists, or null otherwise
      • processAttributes

        protected final void processAttributes()
                                        throws XPathException
        Process the attribute list for the element. This is a wrapper method that calls prepareAttributes (provided in the subclass) and traps any exceptions
        Throws:
        XPathException
      • checkUnknownAttribute

        protected void checkUnknownAttribute​(int nc)
                                      throws XPathException
        Check whether an unknown attribute is permitted.
        Parameters:
        nc - The name code of the attribute name
        Throws:
        XPathException - (and reports the error) if this is an attribute that is not permitted on the containing element
      • prepareAttributes

        protected abstract void prepareAttributes()
                                           throws XPathException
        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
        Throws:
        XPathException
      • getLastChildInstruction

        protected StyleElement getLastChildInstruction()
        Find the last child instruction of this instruction. Returns null if there are no child instructions, or if the last child is a text node.
        Returns:
        the last child instruction, or null if there are no child instructions
      • makeExpression

        public Expression makeExpression​(java.lang.String expression)
                                  throws XPathException
        Compile an XPath expression in the context of this stylesheet element
        Parameters:
        expression - the source text of the XPath expression
        Returns:
        the compiled expression tree for the XPath expression
        Throws:
        XPathException
      • makePattern

        public Pattern makePattern​(java.lang.String pattern)
                            throws XPathException
        Make a pattern in the context of this stylesheet element
        Parameters:
        pattern - the source text of the pattern
        Returns:
        the compiled pattern
        Throws:
        XPathException
      • makeAttributeValueTemplate

        protected Expression makeAttributeValueTemplate​(java.lang.String expression)
                                                 throws XPathException
        Make an attribute value template in the context of this stylesheet element
        Parameters:
        expression - the source text of the attribute value template
        Returns:
        a compiled XPath expression that computes the value of the attribute (including concatenating the results of embedded expressions with any surrounding fixed text)
        Throws:
        XPathException
      • makeSequenceType

        public SequenceType makeSequenceType​(java.lang.String sequenceType)
                                      throws XPathException
        Process an attribute whose value is a SequenceType
        Parameters:
        sequenceType - the source text of the attribute
        Returns:
        the processed sequence type
        Throws:
        XPathException - if the syntax is invalid or for example if it refers to a type that is not in the static context
      • processExtensionElementAttribute

        protected void processExtensionElementAttribute​(java.lang.String nc)
                                                 throws XPathException
        Process the [xsl:]extension-element-prefixes attribute if there is one
        Parameters:
        nc - the Clark name of the attribute required
        Throws:
        XPathException
      • processExcludedNamespaces

        protected void processExcludedNamespaces​(java.lang.String nc)
                                          throws XPathException
        Process the [xsl:]exclude-result-prefixes attribute if there is one
        Parameters:
        nc - the Clark name of the attribute required
        Throws:
        XPathException
      • processVersionAttribute

        protected void processVersionAttribute​(java.lang.String nc)
                                        throws XPathException
        Process the [xsl:]version attribute if there is one
        Parameters:
        nc - the Clark name of the attribute required
        Throws:
        XPathException
      • getVersion

        public java.math.BigDecimal getVersion()
        Get the numeric value of the version number on this element, or inherited from its ancestors
        Returns:
        the version number as a decimal
      • forwardsCompatibleModeIsEnabled

        public boolean forwardsCompatibleModeIsEnabled()
        Determine whether forwards-compatible mode is enabled for this element
        Returns:
        true if forwards-compatible mode is enabled
      • backwardsCompatibleModeIsEnabled

        public boolean backwardsCompatibleModeIsEnabled()
        Determine whether backwards-compatible mode is enabled for this element
        Returns:
        true if backwards compatable mode is enabled, that is, if this or an enclosing element specifies [xsl:]version="1.0"
      • processDefaultCollationAttribute

        protected void processDefaultCollationAttribute​(java.lang.String nc)
                                                 throws XPathException
        Process the [xsl:]default-xpath-namespace attribute if there is one
        Parameters:
        nc - the Clark name of the attribute required
        Throws:
        XPathException
      • getDefaultCollationName

        protected java.lang.String getDefaultCollationName()
        Get the default collation for this stylesheet element. If no default collation is specified in the stylesheet, return the Unicode codepoint collation name.
        Returns:
        the name of the default collation
      • 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
        Returns:
        true if this namespace is defined on this element as an extension element namespace
      • 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
        Returns:
        true if the URI is an extension element namespace URI
      • 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
        Returns:
        true if the namespace is excluded by virtue of an [xsl:]exclude-result-prefixes attribute
      • 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
        Returns:
        true if this namespace URI is a namespace excluded by virtue of exclude-result-prefixes on this element or on an ancestor element
      • processDefaultXPathNamespaceAttribute

        protected void processDefaultXPathNamespaceAttribute​(java.lang.String nc)
        Process the [xsl:]default-xpath-namespace attribute if there is one
        Parameters:
        nc - the Clark name of the attribute required
      • getDefaultXPathNamespace

        protected java.lang.String getDefaultXPathNamespace()
        Get the default XPath namespace for elements and types
        Returns:
        the default namespace for elements and types. Return NamespaceConstant.NULL for the non-namespace
      • getSchemaType

        public SchemaType getSchemaType​(java.lang.String typeAtt)
                                 throws XPathException
        Get the Schema type definition for a type named in the stylesheet (in a "type" attribute).
        Parameters:
        typeAtt - the value of the type attribute
        Returns:
        the corresponding schema type
        Throws:
        XPathException - if the type is not declared in an imported schema, or is not a built-in type
      • getTypeAnnotation

        public int getTypeAnnotation​(SchemaType schemaType)
        Get the type annotation to use for a given schema type
        Parameters:
        schemaType - the schema type
        Returns:
        the corresponding numeric type annotation
      • validate

        public void validate()
                      throws XPathException
        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.
        Throws:
        XPathException
      • postValidate

        public void postValidate()
                          throws XPathException
        Hook to allow additional validation of a parent element immediately after its children have been validated.
        Throws:
        XPathException
      • typeCheck

        public Expression typeCheck​(java.lang.String name,
                                    Expression exp)
                             throws XPathException
        Type-check an expression. This is called to check each expression while the containing instruction is being validated. It is not just a static type-check, it also adds code to perform any necessary run-time type checking and/or conversion.
        Parameters:
        name - the name of the attribute containing the expression to be checked (used for diagnostics)
        exp - the expression to be checked
        Returns:
        the (possibly rewritten) expression after type checking
        Throws:
        XPathException
      • allocateSlots

        public void allocateSlots​(Expression exp)
        Allocate slots in the local stack frame to range variables used in an XPath expression
        Parameters:
        exp - the XPath expression for which slots are to be allocated
      • allocatePatternSlots

        public void allocatePatternSlots​(Pattern match,
                                         SlotManager frame)
        Allocate space for range variables within predicates in the match pattern. The xsl:template element has no XPath expressions among its attributes, so if this method is called on this object it can only be because there are variables used in the match pattern. We work out how many slots are needed for the match pattern in each template rule, and then apply-templates can allocate a stack frame that is large enough for the most demanding match pattern in the entire stylesheet.
        Parameters:
        match - the pattern
        frame - the stackframe outline for this pattern
      • typeCheck

        public Pattern typeCheck​(java.lang.String name,
                                 Pattern pattern)
                          throws XPathException
        Type-check a pattern. This is called to check each pattern while the containing instruction is being validated. It is not just a static type-check, it also adds code to perform any necessary run-time type checking and/or conversion.
        Parameters:
        name - the name of the attribute holding the pattern, for example "match": used in diagnostics
        pattern - the compiled pattern
        Returns:
        the original pattern, or a substitute pattern if it has been rewritten
        Throws:
        XPathException
      • fixupReferences

        public void fixupReferences()
                             throws XPathException
        Fix up references from XPath expressions. Overridden for function declarations and variable declarations
        Throws:
        XPathException
      • getContainingSlotManager

        public SlotManager getContainingSlotManager()
        Get the SlotManager for the containing Procedure definition
        Returns:
        the SlotManager associated with the containing Function, Template, etc, or null if there is no such containing Function, Template etc.
      • validateSubtree

        public void validateSubtree()
                             throws XPathException
        Recursive walk through the stylesheet to validate all nodes
        Throws:
        XPathException
      • validateChildren

        protected void validateChildren()
                                 throws XPathException
        Validate the children of this node, recursively. Overridden for top-level data elements.
        Throws:
        XPathException
      • isPermittedChild

        protected boolean isPermittedChild​(StyleElement child)
        Check whether a given child is permitted for this element. This method is used when a non-instruction child element such as xsl:sort is encountered in a context where instructions would normally be expected.
        Parameters:
        child - the child that may or may not be permitted
        Returns:
        true if the child is permitted.
      • getPrincipalStylesheet

        public 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
        Returns:
        the xsl:stylesheet element at the root of the principal stylesheet module. Exceptionally (with early errors in a simplified stylesheet module) return null.
      • getPreparedStylesheet

        public PreparedStylesheet getPreparedStylesheet()
        Get the PreparedStylesheet object.
        Returns:
        the PreparedStylesheet to which this stylesheet element belongs. Exceptionally (with early errors in a simplified stylesheet module) return null.
      • checkWithinTemplate

        public void checkWithinTemplate()
                                 throws XPathException
        Check that the stylesheet element is within a sequence constructor
        Throws:
        XPathException - if not within a sequence constructor
      • checkSortComesFirst

        protected void checkSortComesFirst​(boolean sortRequired)
                                    throws XPathException
        Check that among the children of this element, any xsl:sort elements precede any other elements
        Parameters:
        sortRequired - true if there must be at least one xsl:sort element
        Throws:
        XPathException - if invalid
      • checkTopLevel

        public void checkTopLevel​(java.lang.String errorCode)
                           throws XPathException
        Convenience method to check that the stylesheet element is at the top level
        Parameters:
        errorCode - the error to throw if it is not at the top level; defaults to XTSE0010 if the value is null
        Throws:
        XPathException - if not at top level
      • checkEmpty

        public void checkEmpty()
                        throws XPathException
        Convenience method to check that the stylesheet element is empty
        Throws:
        XPathException - if it is not empty
      • reportAbsence

        public void reportAbsence​(java.lang.String attribute)
                           throws XPathException
        Convenience method to report the absence of a mandatory attribute
        Parameters:
        attribute - the name of the attribute whose absence is to be reported
        Throws:
        XPathException - if the attribute is missing
      • compile

        public abstract Expression compile​(Executable exec)
                                    throws XPathException
        Compile the instruction on the stylesheet tree into an executable instruction for use at run-time.
        Parameters:
        exec - the Executable
        Returns:
        either a ComputedExpression, or null. The value null is returned when compiling an instruction that returns a no-op, or when compiling a top-level object such as an xsl:template that compiles into something other than an instruction.
        Throws:
        XPathException
      • compileSequenceConstructor

        public Expression compileSequenceConstructor​(Executable exec,
                                                     SequenceIterator iter,
                                                     boolean includeParams)
                                              throws XPathException
        Compile the children of this instruction on the stylesheet tree, adding the subordinate instructions to the parent instruction on the execution tree.
        Parameters:
        exec - the Executable
        iter - Iterator over the children. This is used in the case where there are children that are not part of the sequence constructor, for example the xsl:sort children of xsl:for-each; the iterator can be positioned past such elements.
        includeParams - true if xsl:param elements are to be treated as child instructions (true for templates but not for functions)
        Returns:
        an Expression tree representing the children of this instruction
        Throws:
        XPathException
      • makeTraceInstruction

        protected static TraceWrapper makeTraceInstruction​(StyleElement source,
                                                           Expression child)
        Create a trace instruction to wrap a real instruction
        Parameters:
        source - the parent element
        child - the compiled expression tree for the instruction to be traced
        Returns:
        a wrapper instruction that performs the tracing (if activated at run-time)
      • fallbackProcessing

        protected Expression fallbackProcessing​(Executable exec,
                                                StyleElement instruction)
                                         throws XPathException
        Perform fallback processing. Generate fallback code for an extension instruction that is not recognized by the implementation.
        Parameters:
        exec - the Executable
        instruction - The unknown extension instruction
        Returns:
        the expression tree representing the fallback code
        Throws:
        XPathException
      • allocateLocationId

        protected int allocateLocationId​(java.lang.String systemId,
                                         int lineNumber)
        Allocate a location identifier
        Parameters:
        systemId - identifies the module containing the instruction
        lineNumber - the line number of the instruction
        Returns:
        an integer location ID which can be used to report the location of the instruction, by reference to a LocationProvider
      • makeSortKeys

        protected SortKeyDefinition[] makeSortKeys()
                                            throws XPathException
        Construct sort keys for a SortedIterator
        Returns:
        an array of SortKeyDefinition objects if there are any sort keys; or null if there are none.
        Throws:
        XPathException
      • getAttributeSets

        protected AttributeSet[] getAttributeSets​(java.lang.String use,
                                                  java.util.List list)
                                           throws XPathException
        Get the list of attribute-sets associated with this element. This is used for xsl:element, xsl:copy, xsl:attribute-set, and on literal result elements
        Parameters:
        use - the original value of the [xsl:]use-attribute-sets attribute
        list - an empty list to hold the list of XSLAttributeSet elements in the stylesheet tree. Or null, if these are not required.
        Returns:
        an array of AttributeList instructions representing the compiled attribute sets
        Throws:
        XPathException
      • getWithParamInstructions

        protected WithParam[] getWithParamInstructions​(Executable exec,
                                                       boolean tunnel,
                                                       Instruction caller)
                                                throws XPathException
        Get the list of xsl:with-param elements for a calling element (apply-templates, call-template, apply-imports, next-match). This method can be used to get either the tunnel parameters, or the non-tunnel parameters.
        Parameters:
        exec - the Executable
        tunnel - true if the tunnel="yes" parameters are wanted, false to get
        caller - the calling instruction (for example xsl:apply-templates
        Returns:
        an array of WithParam objects for either the ordinary parameters or the tunnel parameters
        Throws:
        XPathException
      • compileError

        protected void compileError​(XPathException error)
                             throws XPathException
        Report an error with diagnostic information
        Parameters:
        error - contains information about the error
        Throws:
        XPathException - always, after reporting the error to the ErrorListener
      • compileError

        protected void compileError​(java.lang.String message)
                             throws XPathException
        Report a static error in the stylesheet
        Parameters:
        message - the error message
        Throws:
        XPathException - always, after reporting the error to the ErrorListener
      • compileError

        protected void compileError​(java.lang.String message,
                                    java.lang.String errorCode)
                             throws XPathException
        Compile time error, specifying an error code
        Parameters:
        message - the error message
        errorCode - the error code. May be null if not known or not defined
        Throws:
        XPathException
      • undeclaredNamespaceError

        protected void undeclaredNamespaceError​(java.lang.String prefix,
                                                java.lang.String errorCode)
                                         throws XPathException
        Throws:
        XPathException
      • compileWarning

        protected void compileWarning​(java.lang.String message,
                                      java.lang.String errorCode)
                               throws XPathException
        Throws:
        XPathException
      • issueWarning

        protected void issueWarning​(javax.xml.transform.TransformerException error)
        Report a warning to the error listener
        Parameters:
        error - an exception containing the warning text
      • issueWarning

        protected void issueWarning​(java.lang.String message,
                                    javax.xml.transform.SourceLocator locator)
        Report a warning to the error listener
        Parameters:
        message - the warning message text
        locator - the location of the problem in the source stylesheet
      • isTopLevel

        public boolean isTopLevel()
        Test whether this is a top-level element
        Returns:
        true if the element is a child of the xsl:stylesheet element
      • bindVariable

        public XSLVariableDeclaration bindVariable​(StructuredQName qName)
                                            throws XPathException
        Bind a variable used in this element to the compiled form of the XSLVariable element in which it is declared
        Parameters:
        qName - The name of the variable
        Returns:
        the XSLVariableDeclaration (that is, an xsl:variable or xsl:param instruction) for the variable
        Throws:
        XPathException - if the variable has not been declared
      • getStylesheetFunction

        public XSLFunction getStylesheetFunction​(StructuredQName qName,
                                                 int arity)
        Get a FunctionCall declared using an xsl:function element in the stylesheet
        Parameters:
        qName - the name of the function
        arity - the number of arguments in the function call. The value -1 indicates that any arity will do (this is used to support the function-available() function).
        Returns:
        the XSLFunction object representing the function declaration in the stylesheet, or null if no such function is defined.
      • getAllStylesheetFunctions

        public java.util.List getAllStylesheetFunctions()
        Get a list of all stylesheet functions, excluding any that are masked by one of higher precedence
        Returns:
        a list of all stylesheet functions. The members of the list are instances of class XSLFunction
      • getConstructType

        public int getConstructType()
        Get the type of construct. This will be a constant in class Location. This method is part of the InstructionInfo interface
        Specified by:
        getConstructType in interface InstructionInfo
        Returns:
        an integer identifying the kind of construct
      • 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 null.
        Specified by:
        getObjectName in interface InstructionInfo
        Returns:
        the name of the object declared in this element, if any
      • setObjectName

        public void setObjectName​(StructuredQName qName)
        Set the object name, for example the name of a function, variable, or template declared on this element
        Parameters:
        qName - the object name as a QName
      • getProperty

        public java.lang.Object getProperty​(java.lang.String name)
        Get the value of a particular property of the instruction. This is part of the InstructionInfo interface for run-time tracing and debugging. The properties available include all the attributes of the source instruction (named by the attribute name): these are all provided as string values.
        Specified by:
        getProperty in interface InstructionInfo
        Parameters:
        name - The name of the required property
        Returns:
        The value of the requested property, or null if the property is not available
      • getProperties

        public java.util.Iterator getProperties()
        Get an iterator over all the properties available. The values returned by the iterator will be of type String, and each string can be supplied as input to the getProperty() method to retrieve the value of the property.
        Specified by:
        getProperties in interface InstructionInfo
        Returns:
        an iterator over the properties.
      • getSystemId

        public java.lang.String getSystemId​(long locationId)
        Description copied from interface: LocationProvider
        Get the URI of the document or module containing a particular location
        Specified by:
        getSystemId in interface LocationProvider
        Parameters:
        locationId - identifier of the location in question (as passed down the Receiver pipeline)
        Returns:
        the URI of the document or module.
      • getLineNumber

        public int getLineNumber​(long locationId)
        Description copied from interface: LocationProvider
        Get the line number within the document or module containing a particular location
        Specified by:
        getLineNumber in interface LocationProvider
        Parameters:
        locationId - identifier of the location in question (as passed down the Receiver pipeline)
        Returns:
        the line number within the document or module.
      • getColumnNumber

        public int getColumnNumber​(long locationId)
        Description copied from interface: LocationProvider
        Get the column number within the document or module containing a particular location
        Specified by:
        getColumnNumber in interface LocationProvider
        Parameters:
        locationId - identifier of the location in question (as passed down the Receiver pipeline)
        Returns:
        the column number within the document or module, or -1 if this is not available
      • replaceSubExpression

        public boolean replaceSubExpression​(Expression original,
                                            Expression replacement)
        Replace one subexpression by a replacement subexpression
        Specified by:
        replaceSubExpression in interface Container
        Parameters:
        original - the original subexpression
        replacement - the replacement subexpression
        Returns:
        true if the original subexpression is 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 document nodes) 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. For nodes added by XQUery Update, the sequence number is -1L
        Overrides:
        getSequenceNumber in class NodeImpl
        Returns:
        the sequence number if there is one, or -1L otherwise.
      • hasChildNodes

        public final boolean hasChildNodes()
        Determine if the node has any children.
        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.
      • getNumberOfChildren

        public int getNumberOfChildren()
        Determine how many children the node has
        Returns:
        the number of children of this parent node
      • enumerateChildren

        protected final AxisIterator enumerateChildren​(NodeTest test)
        Get an enumeration of the children of this node
        Parameters:
        test - A NodeTest to be satisfied by the child nodes, or null if all child node are to be returned
        Returns:
        an iterator over the children of this node
      • getFirstChild

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

        public final NodeInfo getLastChild()
        Get the last child node of the element
        Overrides:
        getLastChild in class NodeImpl
        Returns:
        the last child of the element, or null if there are no children
      • getNthChild

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

        protected void removeChild​(NodeImpl child)
        Remove a given child
        Parameters:
        child - the child to be removed
      • getStringValue

        public java.lang.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.
        See Also:
        Item.getStringValueCS()
      • useChildrenArray

        protected void useChildrenArray​(NodeImpl[] array)
        Supply an array to be used for the array of children. For system use only.
        Parameters:
        array - the array to be used
      • 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.
        Parameters:
        node - the node to be added as a child of this node
        index - the position where the child is to be added
      • insertChildren

        public void insertChildren​(NodeInfo[] source,
                                   boolean atStart,
                                   boolean inherit)
        Insert copies of a sequence of nodes as children of this node.

        This method takes no action unless the target node is a document node or element node. It also takes no action in respect of any supplied nodes that are not elements, text nodes, comments, or processing instructions.

        The supplied nodes will be copied to form the new children. Adjacent text nodes will be merged, and zero-length text nodes removed.

        Specified by:
        insertChildren in interface MutableNodeInfo
        Overrides:
        insertChildren in class NodeImpl
        Parameters:
        source - the nodes to be inserted
        atStart - true if the new nodes are to be inserted before existing children; false if they are
        inherit - true if the inserted nodes are to inherit the namespaces that are in-scope for their new parent; false if such namespaces should be undeclared on the children
      • insertChildrenAt

        protected void insertChildrenAt​(NodeInfo[] source,
                                        int index,
                                        boolean inherit)
        Insert children before or after a given existing child
        Parameters:
        source - the children to be inserted
        index - the position before which they are to be inserted: 0 indicates insertion before the first child, 1 insertion before the second child, and so on.
        inherit - true if the inserted nodes are to inherit the namespaces that are in-scope for their new parent; false if such namespaces should be undeclared on the children
      • replaceChildrenAt

        protected void replaceChildrenAt​(NodeInfo[] source,
                                         int index,
                                         boolean inherit)
        Replace child at a given index by new children
        Parameters:
        source - the children to be inserted
        index - the position at which they are to be inserted: 0 indicates replacement of the first child, replacement of the second child, and so on. The effect is undefined if index is out of range
        inherit - set to true if the new child elements are to inherit the in-scope namespaces of their new parent
        Throws:
        java.lang.IllegalArgumentException - if any of the replacement nodes is not an element, text, comment, or processing instruction node
      • compact

        public void compact​(int size)
        Compact the space used by this node
        Parameters:
        size - the number of actual children