Class AdjacentTextNodeMerger

  • All Implemented Interfaces:
    ExportAgent, Locatable, IdentityComparable, Traceable

    public class AdjacentTextNodeMerger
    extends UnaryExpression
    This class performs the first phase of processing in "constructing simple content": it takes an input sequence, eliminates empty text nodes, and combines adjacent text nodes into one.
    Since:
    9.3
    • Constructor Detail

      • AdjacentTextNodeMerger

        public AdjacentTextNodeMerger​(Expression p0)
    • Method Detail

      • makeAdjacentTextNodeMerger

        public static Expression makeAdjacentTextNodeMerger​(Expression base)
        Make an AdjacentTextNodeMerger expression with a given operand, or a simpler equivalent expression if appropriate
        Parameters:
        base - the operand expression
        Returns:
        an AdjacentTextNodeMerger or equivalent expression
      • simplify

        public Expression simplify()
                            throws XPathException
        Description copied from class: Expression
        Simplify an expression. This performs any static optimization (by rewriting the expression as a different expression). The default implementation simplifies its operands.
        Overrides:
        simplify in class Expression
        Returns:
        the simplified expression (or the original if unchanged, or if modified in-situ)
        Throws:
        XPathException - if an error is discovered during expression rewriting
      • typeCheck

        public Expression typeCheck​(ExpressionVisitor visitor,
                                    ContextItemStaticInfo contextInfo)
                             throws XPathException
        Description copied from class: UnaryExpression
        Type-check the expression. Default implementation for unary operators that accept any kind of operand
        Overrides:
        typeCheck in class UnaryExpression
        Parameters:
        visitor - an expression visitor
        contextInfo - Information available statically about the context item: whether it is (possibly) absent; its static type; its streaming posture.
        Returns:
        the original expression, rewritten to perform necessary run-time type checks, and to perform other type-related optimizations
        Throws:
        XPathException - if an error is discovered during this phase (typically a type error)
      • getItemType

        public ItemType getItemType()
        Determine the data type of the expression, if possible. The default implementation for unary expressions returns the item type of the operand
        Overrides:
        getItemType in class UnaryExpression
        Returns:
        the item type of the items in the result sequence, insofar as this is known statically.
      • getStaticUType

        public UType getStaticUType​(UType contextItemType)
        Get the static type of the expression as a UType, following precisely the type inference rules defined in the XSLT 3.0 specification.
        Overrides:
        getStaticUType in class Expression
        Parameters:
        contextItemType - the static type of the context item
        Returns:
        the static item type of the expression according to the XSLT 3.0 defined rules
      • copy

        public Expression copy​(RebindingMap rebindings)
        Copy an expression. This makes a deep copy.
        Specified by:
        copy in class Expression
        Parameters:
        rebindings - variables that need to be rebound
        Returns:
        the copy of the original expression
      • getStreamerName

        public java.lang.String getStreamerName()
        Get the (partial) name of a class that supports streaming of this kind of expression
        Overrides:
        getStreamerName in class Expression
        Returns:
        the partial name of a class that can be instantiated to provide streaming support in Saxon-EE, or null if there is no such class
      • iterate

        public SequenceIterator iterate​(XPathContext context)
                                 throws XPathException
        Return an Iterator to iterate over the values of a sequence. The value of every expression can be regarded as a sequence, so this method is supported for all expressions. This default implementation handles iteration for expressions that return singleton values: for non-singleton expressions, the subclass must provide its own implementation.
        Overrides:
        iterate in class Expression
        Parameters:
        context - supplies the context for evaluation
        Returns:
        a SequenceIterator that can be used to iterate over the result of the expression
        Throws:
        XPathException - if any dynamic error occurs evaluating the expression
      • getExpressionName

        public java.lang.String getExpressionName()
        Description copied from class: Expression
        Get a name identifying the kind of expression, in terms meaningful to a user.
        Overrides:
        getExpressionName in class Expression
        Returns:
        a name identifying the kind of expression, in terms meaningful to a user. The name will always be in the form of a lexical XML QName, and should match the name used in export() output displaying the expression.
      • isTextNode

        public static boolean isTextNode​(Item item)
        Ask whether an item is a text node
        Parameters:
        item - the item in question
        Returns:
        true if the item is a node of kind text