Class PatternThatSetsCurrent

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

    public class PatternThatSetsCurrent
    extends Pattern
    This class represents a pattern that sets the value of current() to the node being matched, and then wraps another pattern that uses the value of current()
    • Constructor Detail

      • PatternThatSetsCurrent

        public PatternThatSetsCurrent​(Pattern wrappedPattern)
    • Method Detail

      • operands

        public java.lang.Iterable<Operand> operands()
        Get the immediate sub-expressions of this expression, with information about the relationship of each expression to its parent expression. Default implementation works off the results of iterateSubExpressions()

        If the expression is a Callable, then it is required that the order of the operands returned by this function is the same as the order of arguments supplied to the corresponding call() method.

        Overrides:
        operands in class Expression
        Returns:
        an iterator containing the sub-expressions of this expression
      • getCurrentBinding

        public LocalBinding getCurrentBinding()
        Get the binding of the item being matched by the pattern, that is, the binding that represents the value of the current() function
        Returns:
        the binding of the item being matched by the pattern
      • hasVariableBinding

        public boolean hasVariableBinding​(Binding binding)
        Ask whether this expression is, or contains, the binding of a given variable
        Overrides:
        hasVariableBinding in class Expression
        Parameters:
        binding - the variable binding
        Returns:
        true if this expression is the variable binding (for example a ForExpression or LetExpression) or if it is a FLWOR expression that binds the variable in one of its clauses.
      • allocateSlots

        public int allocateSlots​(SlotManager slotManager,
                                 int nextFree)
        Allocate slots to any variables used within the pattern
        Overrides:
        allocateSlots in class Pattern
        Parameters:
        slotManager - the slot manager representing the stack frame for local variables
        nextFree - the next slot that is free to be allocated
        Returns:
        the next slot that is free to be allocated
      • matches

        public boolean matches​(Item item,
                               XPathContext context)
                        throws XPathException
        Determine whether this Pattern matches the given item. This is the main external interface for matching patterns: it sets current() to the node being tested
        Specified by:
        matches in class Pattern
        Parameters:
        item - The item to be tested against the Pattern
        context - The dynamic context. Only relevant if the pattern uses variables, or contains calls on functions such as document() or key().
        Returns:
        true if the item matches the Pattern, false otherwise
        Throws:
        XPathException - if an error occurs while matching the pattern (the caller will usually treat this the same as a false result)
      • getItemType

        public ItemType getItemType()
        Get an ItemType that all the items matching this pattern must satisfy
        Specified by:
        getItemType in class Pattern
        Returns:
        an ItemType, as specific as possible, which all the matching items satisfy
      • simplify

        public Pattern simplify()
                         throws XPathException
        Simplify the pattern by applying any context-independent optimisations. Default implementation does nothing.
        Overrides:
        simplify in class Pattern
        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 Pattern typeCheck​(ExpressionVisitor visitor,
                                 ContextItemStaticInfo contextItemType)
                          throws XPathException
        Type-check the pattern.
        Overrides:
        typeCheck in class Pattern
        Parameters:
        visitor - the expression visitor
        contextItemType - the type of the context item at the point where the pattern is defined. Set to null if it is known that the context item is undefined.
        Returns:
        the optimised Pattern
        Throws:
        XPathException - if an error is discovered during this phase (typically a type error)
      • getUType

        public UType getUType()
        Get a UType indicating which kinds of items this Pattern can match.
        Specified by:
        getUType in class Pattern
        Returns:
        a UType indicating all the primitive types of item that the pattern can match.
      • getFingerprint

        public int getFingerprint()
        Determine the name fingerprint of nodes to which this pattern applies. Used for optimisation.
        Overrides:
        getFingerprint in class Pattern
        Returns:
        A fingerprint that the nodes must match, or -1 if it can match multiple fingerprints, or it if matches atomic values
      • reconstruct

        public java.lang.String reconstruct()
        Get the original pattern text
        Overrides:
        reconstruct in class Pattern
      • isMotionless

        public boolean isMotionless()
        Test whether a pattern is motionless, that is, whether it can be evaluated against a node without repositioning the input stream. This is a necessary condition for patterns used as the match pattern of a streamed template rule.
        Overrides:
        isMotionless in class Pattern
        Returns:
        true if the pattern is motionless, that is, if it can be evaluated against a streamed node without changing the position in the streamed input file
      • matchesBeneathAnchor

        public boolean matchesBeneathAnchor​(NodeInfo node,
                                            NodeInfo anchor,
                                            XPathContext context)
                                     throws XPathException
        Determine whether this pattern matches a given Node within the subtree rooted at a given anchor node. This method is used when the pattern is used for streaming.
        Overrides:
        matchesBeneathAnchor in class Pattern
        Parameters:
        node - The NodeInfo representing the Element or other node to be tested against the Pattern
        anchor - The anchor node, which must match any AnchorPattern subpattern
        context - The dynamic context. Only relevant if the pattern uses variables, or contains calls on functions such as document() or key().
        Returns:
        true if the node matches the Pattern, false otherwise
        Throws:
        XPathException - if an error occurs while matching the pattern (the caller will usually treat this the same as a false result)
      • convertToTypedPattern

        public Pattern convertToTypedPattern​(java.lang.String val)
                                      throws XPathException
        Convert the pattern to a typed pattern, in which an element name is treated as schema-element(N)
        Overrides:
        convertToTypedPattern in class Pattern
        Parameters:
        val - either "strict" or "lax" depending on the value of xsl:mode/@typed
        Returns:
        either the original pattern unchanged, or a new pattern as the result of the conversion
        Throws:
        XPathException - if the pattern cannot be converted
      • copy

        public Pattern copy​(RebindingMap rebindings)
        Copy a pattern. This makes a deep copy.
        Specified by:
        copy in class Pattern
        Parameters:
        rebindings - variables that need to be re-bound
        Returns:
        the copy of the original pattern
      • export

        public void export​(ExpressionPresenter presenter)
                    throws XPathException
        Description copied from class: Expression
        Diagnostic print of expression structure. The abstract expression tree is written to the supplied output destination.
        Specified by:
        export in interface ExportAgent
        Specified by:
        export in class Pattern
        Parameters:
        presenter - the expression presenter used to display the structure
        Throws:
        XPathException - if the export fails, for example if an expression is found that won't work in the target environment.
      • getWrappedPattern

        public Pattern getWrappedPattern()