Class ArithmeticExpression10

    • Constructor Detail

      • ArithmeticExpression10

        public ArithmeticExpression10​(Expression p0,
                                      int operator,
                                      Expression p1)
        Create an arithmetic expression to be evaluated in XPath 1.0 mode
        Parameters:
        p0 - the first operand
        operator - the operator, for example Token.PLUS
        p1 - the second operand
    • Method Detail

      • typeCheck

        public Expression typeCheck​(ExpressionVisitor visitor,
                                    ContextItemStaticInfo contextInfo)
                             throws XPathException
        Type-check the expression statically. We try to work out which particular arithmetic function to use if the types of operands are known an compile time.
        Overrides:
        typeCheck in class ArithmeticExpression
        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)
      • setCalculator

        public void setCalculator​(Calculator calc)
        Set the calculator externally (used when reconstructing the expression tree)
        Overrides:
        setCalculator in class ArithmeticExpression
        Parameters:
        calc - the calculator to be used
      • getItemType

        public PlainType getItemType()
        Determine the data type of the expression, if this is known statically
        Overrides:
        getItemType in class ArithmeticExpression
        Returns:
        the atomic type of the result of this arithmetic expression
      • copy

        public Expression copy​(RebindingMap rebindings)
        Copy an expression. This makes a deep copy.
        Overrides:
        copy in class ArithmeticExpression
        Parameters:
        rebindings - variables that must be re-bound
        Returns:
        the copy of the original expression
      • tag

        protected java.lang.String tag()
        Description copied from class: BinaryExpression
        Get the element name used to identify this expression in exported expression format
        Overrides:
        tag in class ArithmeticExpression
        Returns:
        the element name used to identify this expression
      • explainExtraAttributes

        protected void explainExtraAttributes​(ExpressionPresenter out)
        Description copied from class: BinaryExpression
        Add subclass-specific attributes to the expression tree explanation. Default implementation does nothing; this is provided for subclasses to override.
        Overrides:
        explainExtraAttributes in class ArithmeticExpression
        Parameters:
        out - the output destination for the displayed expression tree
      • evaluateItem

        public AtomicValue evaluateItem​(XPathContext context)
                                 throws XPathException
        Evaluate the expression.
        Overrides:
        evaluateItem in class ArithmeticExpression
        Parameters:
        context - The context in which the expression is to be evaluated
        Returns:
        the node or atomic value that results from evaluating the expression; or null to indicate that the result is an empty sequence
        Throws:
        XPathException - if any dynamic error occurs evaluating the expression
      • call

        public AtomicValue call​(XPathContext context,
                                Sequence[] arguments)
                         throws XPathException
        Evaluate the expression
        Specified by:
        call in interface Callable
        Parameters:
        context - the dynamic evaluation context
        arguments - the values of the arguments, supplied as SequenceIterators
        Returns:
        the result of the evaluation, in the form of a SequenceIterator
        Throws:
        XPathException - if a dynamic error occurs during the evaluation of the expression