## net.sf.saxon.expr
Class ArithmeticExpression.DurationMultiplication

    java.lang.Object
      |
      +--net.sf.saxon.expr.ComputedExpression
            |
            +--net.sf.saxon.expr.BinaryExpression
                  |
                  +--net.sf.saxon.expr.ArithmeticExpression
                        |
                        +--net.sf.saxon.expr.ArithmeticExpression.DurationMultiplication

All Implemented Interfaces:
  Container, Expression, InstructionInfoProvider, java.io.Serializable, javax.xml.transform.SourceLocator

Enclosing class:
  net.sf.saxon.expr.ArithmeticExpression

public static class ArithmeticExpression.DurationMultiplication
extends net.sf.saxon.expr.ArithmeticExpression

Inner class to handle multiplication (or division) of a duration by a number

See Also:
  Serialized Form

Nested Class Summary
`static class` `ArithmeticExpression.DateAndDuration` Inner class to handle addition or subtraction of a Date (or Time, or DateTime) and a Duration
`static class` `ArithmeticExpression.DateDifference` Inner class to handle subtraction of a Date (or Time, or DateTime) from another, to return a Duration
`static class` `ArithmeticExpression.DurationAddition` Inner class to handle addition and subtraction of two durations
`static class` `ArithmeticExpression.DurationDivision` Inner class to handle division of two durations to give a number
`static class` `ArithmeticExpression.DurationMultiplication` Inner class to handle multiplication (or division) of a duration by a number
`static class` `ArithmeticExpression.NumericArithmetic` Inner class to handle numeric arithmetic expressions

Field Summary
`protected Expression` `operand0`
`protected Expression` `operand1`
`protected int` `operator`

Fields inherited from class net.sf.saxon.expr.ComputedExpression
`locationId, staticProperties`

Fields inherited from interface net.sf.saxon.expr.Expression
`EVALUATE_METHOD, ITERATE_METHOD, PROCESS_METHOD`

Constructor Summary
`ArithmeticExpression.DurationMultiplication(Expression p1, int operator, Expression p2)`

Method Summary
`Expression` `analyze(StaticContext env, ItemType contextItemType)` Type-check the expression statically.
`int` `computeCardinality()` Determine the static cardinality.
`void` `display(int level, NamePool pool, java.io.PrintStream out)` Diagnostic print of expression structure
`protected java.lang.String` `displayOperator()`
`boolean` `equals(java.lang.Object other)` Is this expression the same as another expression?
`Item` `evaluateItem(XPathContext context)` Evaluate the expression.
`ItemType` `getItemType()` Determine the data type of the expression, if this is known statically
`int` `hashCode()` get HashCode for comparing two expressions.
`protected static boolean` `isCommutative(int operator)`
`java.util.Iterator` `iterateSubExpressions()` Get the immediate subexpressions of this expression
`Expression` `promote(PromotionOffer offer)` Promote this expression if possible
`Expression` `simplify(StaticContext env)` Simplify an expression

Methods inherited from class net.sf.saxon.expr.ComputedExpression

`adoptChildExpression, computeDependencies, computeSpecialProperties, computeStaticProperties, dynamicError, dynamicError, effectiveBooleanValue, evaluateAsString, getCardinality, getColumnNumber, getConstructType, getDependencies, getExecutable, getImplementationMethod, getInstructionInfo, getIntrinsicDependencies, getLineNumber, getLocationId, getParentExpression, getPublicId, getSpecialProperties, getSystemId, iterate, markTailFunctionCalls, process, resetStaticProperties, setLocationId, setParentExpression, typeError`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### operand0

    protected Expression operand0

### operand1

    protected Expression operand1

### operator

    protected int operator

Constructor Detail

### ArithmeticExpression.DurationMultiplication

    public ArithmeticExpression.DurationMultiplication(Expression p1,
                                                       int operator,
                                                       Expression p2)

Method Detail

### evaluateItem

    public Item evaluateItem(XPathContext context)
                      throws XPathException

  Evaluate the expression.

  Specified by:
    `evaluateItem` in interface `Expression`
  Overrides:
    `evaluateItem` in class `net.sf.saxon.expr.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

### analyze

    public Expression analyze(StaticContext env,
                              ItemType contextItemType)
                       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.

  Specified by:
    `analyze` in interface `Expression`
  Overrides:
    `analyze` in class `net.sf.saxon.expr.BinaryExpression`
  Parameters:
    `env` - the static context of the expression
    `contextItemType` - 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 to perform necessary run-time type checks, and to perform other type-related optimizations
    `XPathException`

### getItemType

    public ItemType getItemType()

  Determine the data type of the expression, if this is known statically

  Returns:
    a value such as Type.STRING, Type.BOOLEAN, Type.NUMBER, Type.NODE, or Type.ITEM (meaning not known at compile time)

### simplify

    public Expression simplify(StaticContext env)
                        throws XPathException

  Simplify an expression

  Specified by:
    `simplify` in interface `Expression`
  Overrides:
    `simplify` in class `ComputedExpression`
  Returns:
    the simplified expression
  Throws:
    `XPathException` - if an error is discovered during expression rewriting

### promote

    public Expression promote(PromotionOffer offer)
                       throws XPathException

  Promote this expression if possible

  Specified by:
    `promote` in interface `Expression`
  Overrides:
    `promote` in class `ComputedExpression`
  Parameters:
    `offer` - details of the offer, for example the offer to move expressions that don't depend on the context to an outer level in the containing expression
  Returns:
    if the offer is not accepted, return this expression unchanged. Otherwise return the result of rewriting the expression to promote this subexpression
  Throws:
    `XPathException` - if any error is detected

### iterateSubExpressions

    public java.util.Iterator iterateSubExpressions()

  Get the immediate subexpressions of this expression

  Specified by:
    `iterateSubExpressions` in interface `Expression`
  Overrides:
    `iterateSubExpressions` in class `ComputedExpression`
  Returns:
    an iterator containing the sub-expressions of this expression

### computeCardinality

    public int computeCardinality()

  Determine the static cardinality. Default implementation returns [0..1] if either operand can be empty, or [1..1] otherwise.

  Specified by:
    `computeCardinality` in class `ComputedExpression`

### isCommutative

    protected static boolean isCommutative(int operator)

### equals

    public boolean equals(java.lang.Object other)

  Is this expression the same as another expression?

  Overrides:
    `equals` in class `java.lang.Object`

### hashCode

    public int hashCode()

  get HashCode for comparing two expressions. Note that this hashcode gives the same result for (A op B) and for (B op A), whether or not the operator is commutative.

  Overrides:
    `hashCode` in class `java.lang.Object`

### display

    public void display(int level,
                        NamePool pool,
                        java.io.PrintStream out)

  Diagnostic print of expression structure

  Parameters:
    `level` - indentation level for this expression
    `pool` - NamePool used to expand any names appearing in the expression
    `out` - Output destination

### displayOperator

    protected java.lang.String displayOperator()