## net.sf.saxon.expr
Class AppendExpression

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

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

public final class AppendExpression
extends net.sf.saxon.expr.BinaryExpression

An expression representing a sequence that is the concatenation of two given sequences. This implements the "comma" operator in XPath sequence expressions.

See Also:
  Serialized Form

Nested Class Summary
`static class` `AppendExpression.AppendIterator` Iterator that concatenates the results of two supplied iterators

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
`AppendExpression(Expression p1, int op, Expression p2)` Constructor

Method Summary
`Expression` `analyze(StaticContext env, ItemType contextItemType)` Type-check the expression.
`int` `computeCardinality()` Determine the static cardinality of the expression
`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?
`ItemType` `getItemType()` Determine the data type of the items returned by this expression
`int` `hashCode()` get HashCode for comparing two expressions.
`protected static boolean` `isCommutative(int operator)`
`SequenceIterator` `iterate(XPathContext c)` Iterate over the value of the expression.
`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 the expression

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

`adoptChildExpression, computeDependencies, computeSpecialProperties, computeStaticProperties, dynamicError, dynamicError, effectiveBooleanValue, evaluateAsString, evaluateItem, getCardinality, getColumnNumber, getConstructType, getDependencies, getExecutable, getImplementationMethod, getInstructionInfo, getIntrinsicDependencies, getLineNumber, getLocationId, getParentExpression, getPublicId, getSpecialProperties, getSystemId, 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

### AppendExpression

    public AppendExpression(Expression p1,
                            int op,
                            Expression p2)

  Constructor

Parameters:
  `p1` - the left-hand operand
  `op` - the operator (always ",")
  `p2` - the right-hand operand

Method Detail

### getItemType

    public final ItemType getItemType()

  Determine the data type of the items returned by this expression

  Returns:
    the data type

### computeCardinality

    public final int computeCardinality()

  Determine the static cardinality of the expression

  Overrides:
    `computeCardinality` in class `net.sf.saxon.expr.BinaryExpression`

### simplify

    public Expression simplify(StaticContext env)
                        throws XPathException

  Simplify the expression

  Specified by:
    `simplify` in interface `Expression`
  Overrides:
    `simplify` in class `net.sf.saxon.expr.BinaryExpression`
  Returns:
    the simplified expression
    `XPathException`

### iterate

    public SequenceIterator iterate(XPathContext c)
                             throws XPathException

  Iterate over the value of the expression.

  Specified by:
    `iterate` in interface `Expression`
  Overrides:
    `iterate` in class `ComputedExpression`
  Parameters:
    `c` - The context for evaluation
  Returns:
    a SequenceIterator representing the concatenation of the two operands
  Throws:
    `XPathException` - if any dynamic error occurs evaluating the expression

### analyze

    public Expression analyze(StaticContext env,
                              ItemType contextItemType)
                       throws XPathException

  Type-check the expression. Default implementation for binary operators that accept any kind of operand

  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`

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

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