Package net.sf.saxon.expr.compat

## Class ArithmeticExpression10

- java.lang.Object
- - net.sf.saxon.expr.Expression
  - - net.sf.saxon.expr.BinaryExpression
    - - net.sf.saxon.expr.ArithmeticExpression
      - - net.sf.saxon.expr.compat.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.

- - ### Field Summary

    - ### Fields inherited from class net.sf.saxon.expr.ArithmeticExpression

      `calculator`

    - ### Fields inherited from class net.sf.saxon.expr.BinaryExpression

      `operator`

    - ### Fields inherited from class net.sf.saxon.expr.Expression

      `EFFECTIVE_BOOLEAN_VALUE, EVALUATE_METHOD, ITEM_FEED_METHOD, ITERATE_METHOD, MAX_COST, MAX_SEQUENCE_LENGTH, MAX_STRING_LENGTH, PROCESS_METHOD, staticProperties, UNBOUNDED_LOWER, UNBOUNDED_UPPER, UPDATE_METHOD, WATCH_METHOD`

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `ArithmeticExpression10​(Expression p0, int operator, Expression p1)` | Create an arithmetic expression to be evaluated in XPath 1.0 mode

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `AtomicValue` | `call​(XPathContext context, Sequence[] arguments)` | Evaluate the expression
    `Expression` | `copy​(RebindingMap rebindings)` | Copy an expression.
    `AtomicValue` | `evaluateItem​(XPathContext context)` | Evaluate the expression.
    `protected void` | `explainExtraAttributes​(ExpressionPresenter out)` | Add subclass-specific attributes to the expression tree explanation.
    `PlainType` | `getItemType()` | Determine the data type of the expression, if this is known statically
    `void` | `setCalculator​(Calculator calc)` | Set the calculator externally (used when reconstructing the expression tree)
    `protected java.lang.String` | `tag()` | Get the element name used to identify this expression in exported expression format
    `Expression` | `typeCheck​(ExpressionVisitor visitor, ContextItemStaticInfo contextInfo)` | Type-check the expression statically.

    - ### Methods inherited from class net.sf.saxon.expr.ArithmeticExpression

      `compute, computeSpecialProperties, getCalculator, getExpressionName, getIntegerBounds, getStaticUType, mapOpCode, resetLocalStaticProperties`

    - ### Methods inherited from class net.sf.saxon.expr.BinaryExpression

      `computeCardinality, computeHashCode, displayOperator, equals, export, getImplementationMethod, getLhs, getLhsExpression, getOperandRole, getOperator, getRhs, getRhsExpression, isAssociative, isCommutative, isInverse, operands, optimize, setFlattened, setLhsExpression, setRhsExpression, toShortString, toString`

    - ### Methods inherited from class net.sf.saxon.expr.Expression

      `addToPathMap, adoptChildExpression, allowExtractingCommonSubexpressions, checkedOperands, checkForUpdatingSubexpressions, checkPermittedContents, computeDependencies, computeStaticProperties, dynamicError, effectiveBooleanValue, evaluateAsString, evaluatePendingUpdates, explain, getCardinality, getConfiguration, getCost, getDependencies, getEvaluationMethod, getExtraProperty, getInterpretedExpression, getIntrinsicDependencies, getLocalRetainedStaticContext, getLocation, getNetCost, getObjectName, getPackageData, getParentExpression, getProperties, getProperty, getRetainedStaticContext, getScopingExpression, getSlotsUsed, getSpecialProperties, getStaticBaseURI, getStaticBaseURIString, getStaticType, getStreamerName, getTracingTag, hasCompatibleStaticContext, hashCode, hasSpecialProperty, hasVariableBinding, identityHashCode, implementsStaticTypeCheck, isCallOn, isEqual, isIdentical, isInstruction, isLiftable, isMultiThreaded, isStaticPropertiesKnown, isSubtreeExpression, isUpdatingExpression, isVacuousExpression, iterate, markTailFunctionCalls, operandList, operandSparseList, optimizeChildren, prepareForStreaming, process, restoreParentPointers, setEvaluationMethod, setExtraProperty, setFiltered, setLocation, setParentExpression, setRetainedStaticContext, setRetainedStaticContextLocally, setRetainedStaticContextThoroughly, setStaticProperty, simplify, simplifyChildren, staticTypeCheck, suppressValidation, toPattern, typeCheckChildren, typeError, unordered, verifyParentPointers`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface net.sf.saxon.trace.Traceable

      `gatherProperties`

- - ### 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` -
      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