Package net.sf.saxon.expr

Class LookupExpression

  • All Implemented Interfaces:
    ExportAgent, Locatable, IdentityComparable, Traceable
    Direct Known Subclasses:
    ObjectLookupExpression
    public class LookupExpression
extends BinaryExpression
    A lookup expression is an expression of the form A?B. Here A must be a sequence of maps or arrays. In the general case B is an expression that computes a key/index into the map or array; the case where B is constant needs to be handled efficiently. The class also implements the unary lookup expression ?B, which is interpreted as .?B. It does not handle the case A?* - that is handled as a LookupAllExpression.

    • Field Detail

      • isArrayLookup

        protected boolean isArrayLookup

      • isMapLookup

        protected boolean isMapLookup

      • isSingleContainer

        protected boolean isSingleContainer

      • isSingleEntry

        protected boolean isSingleEntry

    • Constructor Detail

      • LookupExpression

        public LookupExpression​(Expression start,
                        Expression step)
        Constructor
        Parameters:
        start - The left hand operand (which must always select a sequence of maps or arrays).
        step - The step to be followed from each map/array in the start expression to yield a new sequence

    • Method Detail

      • 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.

      • getItemType

        public ItemType getItemType()
        Determine the data type of the items returned by this expression
        Specified by:
        getItemType in class Expression
        Returns:
        the type of the expression, as far as this is known. Prior to type-checking, the method returns AnyItemType

      • 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 - not used
        Returns:
        the static item type of the expression according to the XSLT 3.0 defined rules

      • typeCheck

        public Expression typeCheck​(ExpressionVisitor visitor,
                            ContextItemStaticInfo contextInfo)
                     throws XPathException
        Type-check the expression
        Overrides:
        typeCheck in class BinaryExpression
        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)

      • optimize

        public Expression optimize​(ExpressionVisitor visitor,
                           ContextItemStaticInfo contextInfo)
                    throws XPathException
        Description copied from class: BinaryExpression
        Perform optimisation of an expression and its subexpressions.

        This method is called after all references to functions and variables have been resolved to the declaration of the function or variable, and after all type checking has been done.

        Overrides:
        optimize in class BinaryExpression
        Parameters:
        visitor - an expression visitor
        contextInfo - the static type of "." at the point where this expression is invoked. The parameter is set to null if it is known statically that the context item will be undefined. If the type of the context item is not known statically, the argument is set to Type.ITEM_TYPE
        Returns:
        the original expression, rewritten if appropriate to optimize execution
        Throws:
        XPathException - if an error is discovered during this phase (typically a type error)

      • getCost

        public double getCost()
        Return the estimated cost of evaluating an expression. This is a very crude measure based on the syntactic form of the expression (we have no knowledge of data values). We take the cost of evaluating a simple scalar comparison or arithmetic expression as 1 (one), and we assume that a sequence has length 5. The resulting estimates may be used, for example, to reorder the predicates in a filter expression so cheaper predicates are evaluated first.
        Overrides:
        getCost in class Expression
        Returns:
        a rough estimate of the cost of evaluation

      • copy

        public LookupExpression copy​(RebindingMap rebindings)
        Copy an expression. This makes a deep copy.
        Specified by:
        copy in class Expression
        Parameters:
        rebindings - a mutable list of (old binding, new binding) pairs that is used to update the bindings held in any local variable references that are copied.
        Returns:
        the copy of the original expression

      • equals

        public boolean equals​(java.lang.Object other)
        Is this expression the same as another expression?
        Overrides:
        equals in class BinaryExpression
        Parameters:
        other - the other operand; the result is false if this is not an Expression
        Returns:
        true if the other operand is an expression and if it can be determined that the two expressions are equivalent, in the sense that they will always return the same result.

      • computeHashCode

        public int computeHashCode()
        get HashCode for comparing two expressions
        Overrides:
        computeHashCode in class BinaryExpression
        Returns:
        a computed hash code

      • iterate

        public SequenceIterator iterate​(XPathContext context)
                         throws XPathException
        Iterate the lookup-expression in a given context
        Overrides:
        iterate in class Expression
        Parameters:
        context - the evaluation context
        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

      • export

        public void export​(ExpressionPresenter destination)
            throws XPathException
        Diagnostic print of expression structure. The abstract expression tree is written to the supplied output destination.
        Specified by:
        export in interface ExportAgent
        Overrides:
        export in class BinaryExpression
        Parameters:
        destination - the output destination for the displayed expression tree
        Throws:
        XPathException - if the export fails, for example if an expression is found that won't work in the target environment.

      • toString

        public java.lang.String toString()
        The toString() method for an expression attempts to give a representation of the expression in an XPath-like form, but there is no guarantee that the syntax will actually be true XPath. In the case of XSLT instructions, the toString() method gives an abstracted view of the syntax
        Overrides:
        toString in class BinaryExpression
        Returns:
        a representation of the expression as a string