Class ArithmeticExpression10

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

public class ArithmeticExpression10 extends ArithmeticExpression implements Callable
Arithmetic Expression: an expression using one of the operators plus, minus, multiply, div, idiv, mod, in backwards compatibility mode: see ArithmeticExpression for the non-backwards compatible case.
  • Constructor Details

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

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