Package net.sf.saxon.expr

## Class ArithmeticExpression

- java.lang.Object
- - net.sf.saxon.expr.Expression
  - - net.sf.saxon.expr.BinaryExpression
    - - net.sf.saxon.expr.ArithmeticExpression

- All Implemented Interfaces:
    `ExportAgent`, `Locatable`, `IdentityComparable`, `Traceable`
  Direct Known Subclasses:
    `ArithmeticExpression10`

      public class ArithmeticExpression
      extends BinaryExpression

  Arithmetic Expression: an expression using one of the operators plus, minus, multiply, div, idiv, mod. Note that this code does not handle backwards compatibility mode: see `ArithmeticExpression10`

- - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `protected Calculator` | `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
    --- | ---
    `ArithmeticExpression​(Expression p0, int operator, Expression p1)` | Create an arithmetic expression

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `static AtomicValue` | `compute​(AtomicValue value0, int operator, AtomicValue value1, XPathContext context)` | Static method to apply arithmetic to two values
    `int` | `computeSpecialProperties()` | Determine the special properties of this 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.
    `Calculator` | `getCalculator()` | Get the calculator allocated to evaluate this expression
    `java.lang.String` | `getExpressionName()` | Get a name identifying the kind of expression, in terms meaningful to a user.
    `IntegerValue[]` | `getIntegerBounds()` | For an expression that returns an integer or a sequence of integers, get a lower and upper bound on the values of the integers that may be returned, from static analysis.
    `PlainType` | `getItemType()` | Determine the data type of the expression, insofar as this is known statically
    `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.
    `static int` | `mapOpCode​(int op)` | Map operator codes from those in the Token class to those in the Calculator class
    `void` | `resetLocalStaticProperties()` | Reset the static properties of the expression to -1, so that they have to be recomputed next time they are used.
    `void` | `setCalculator​(Calculator calculator)` | Set the calculator allocated to evaluate this expression
    `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.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`

- - ### Field Detail

    - #### calculator

          protected Calculator calculator

  - ### Constructor Detail

    - #### ArithmeticExpression

          public ArithmeticExpression​(Expression p0,
                                      int operator,
                                      Expression p1)

      Create an arithmetic expression
      Parameters:
        `p0` - the first operand
        `operator` - the operator, for example `Token.PLUS`
        `p1` - the second operand

  - ### Method Detail

    - #### getExpressionName

          public java.lang.String getExpressionName()

      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 explain() output displaying the expression.

    - #### computeSpecialProperties

          public int computeSpecialProperties()

      Determine the special properties of this expression
      Overrides:
        `computeSpecialProperties` in class `BinaryExpression`
      Returns:
        `StaticProperty.NO_NODES_NEWLY_CREATED`. This is overridden for some subclasses.

    - #### setCalculator

          public void setCalculator​(Calculator calculator)

      Set the calculator allocated to evaluate this expression
      Parameters:
        `calculator` - the calculator to be used

    - #### getCalculator

          public Calculator getCalculator()

      Get the calculator allocated to evaluate this expression
      Returns:
        the calculator, a helper object that does the actual calculation

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

    - #### getIntegerBounds

          public IntegerValue[] getIntegerBounds()

      For an expression that returns an integer or a sequence of integers, get a lower and upper bound on the values of the integers that may be returned, from static analysis. The default implementation returns null, meaning "unknown" or "not applicable". Other implementations return an array of two IntegerValue objects, representing the lower and upper bounds respectively. The values UNBOUNDED_LOWER and UNBOUNDED_UPPER are used by convention to indicate that the value may be arbitrarily large. The values MAX_STRING_LENGTH and MAX_SEQUENCE_LENGTH are used to indicate values limited by the size of a string or the size of a sequence.
      Overrides:
        `getIntegerBounds` in class `Expression`
      Returns:
        the lower and upper bounds of integer values in the result, or null to indicate unknown or not applicable.

    - #### copy

          public Expression copy​(RebindingMap rebindings)

      Copy an expression. This makes a deep copy.
      Specified by:
        `copy` in class `Expression`
      Parameters:
        `rebindings` - variables that need to be rebound
      Returns:
        the copy of the original expression

    - #### compute

          public static AtomicValue compute​(AtomicValue value0,
                                            int operator,
                                            AtomicValue value1,
                                            XPathContext context)
                                     throws XPathException

      Static method to apply arithmetic to two values
      Parameters:
        `value0` - the first value
        `operator` - the operator as denoted in the Calculator class, for example `Calculator.PLUS`
        `value1` - the second value
        `context` - the XPath dynamic evaluation context
      Returns:
        the result of the arithmetic operation
      Throws:
        `XPathException` - if a dynamic error occurs during evaluation

    - #### mapOpCode

          public static int mapOpCode​(int op)

      Map operator codes from those in the Token class to those in the Calculator class
      Parameters:
        `op` - an operator denoted by a constant in the `Token` class, for example `Token.PLUS`
      Returns:
        an operator denoted by a constant defined in the `Calculator` class, for example `Calculator.PLUS`

    - #### getItemType

          public PlainType getItemType()

      Determine the data type of the expression, insofar as this is known statically
      Specified by:
        `getItemType` in class `Expression`
      Returns:
        the atomic type of the result of this arithmetic expression

    - #### 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` - static information about the context item
      Returns:
        the static item type of the expression according to the XSLT 3.0 defined rules

    - #### resetLocalStaticProperties

          public void resetLocalStaticProperties()

      Reset the static properties of the expression to -1, so that they have to be recomputed next time they are used.
      Overrides:
        `resetLocalStaticProperties` in class `Expression`

    - #### evaluateItem

          public AtomicValue evaluateItem​(XPathContext context)
                                   throws XPathException

      Evaluate the expression.
      Overrides:
        `evaluateItem` in class `Expression`
      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

    - #### 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 `BinaryExpression`
      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 `BinaryExpression`
      Parameters:
        `out` - the output destination for the displayed expression tree