com.saxonica.update

## Class CopyModifyExpression

- java.lang.Object
- - net.sf.saxon.expr.Expression
  - - com.saxonica.update.CopyModifyExpression

- All Implemented Interfaces:
    Serializable, SourceLocator, LocationProvider, SaxonLocator, InstructionInfo, Locator

      public class CopyModifyExpression
      extends Expression

  A copy-modify expression (called a "transform" expression in the XQuery Update specification)
  See Also:
    Serialized Form

- - ### Field Summary

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

      `EFFECTIVE_BOOLEAN_VALUE, EVALUATE_METHOD, EVENT_FEED_METHOD, INHERITED_CONTEXT, INSPECTION_CONTEXT, ITEM_FEED_METHOD, ITERATE_METHOD, locationId, MAX_SEQUENCE_LENGTH, MAX_STRING_LENGTH, NAVIGATION_CONTEXT, NODE_VALUE_CONTEXT, PROCESS_METHOD, PUSH_SELECTION, staticProperties, UNBOUNDED_LOWER, UNBOUNDED_UPPER, W3C_CONSUMING, W3C_FREE_RANGING, W3C_GROUP_CONSUMING, W3C_MOTIONLESS, WATCH_METHOD`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `CopyModifyExpression(Expression updateExp, Expression returnExp, int validationMode)` Create a copy-modify expression (also known as a transform expresion)

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `checkForUpdatingSubexpressions()` Check to ensure that this expression does not contain any inappropriate updating subexpressions.
    `int` | `computeCardinality()` Determine the static cardinality of the expression.
    `Expression` | `copy()` Copy an expression.
    `Item` | `evaluateItem(XPathContext context)` Evaluate an expression as a single item.
    `void` | `explain(ExpressionPresenter out)` Diagnostic print of expression structure.
    `ExpressionCompiler` | `getExpressionCompiler()` Return the compiler of the CopyModify expression
    `ItemType` | `getItemType(TypeHierarchy th)` Determine the data type of the expression, if possible.
    `boolean` | `isUpdatingExpression()` Determine whether this is an updating expression as defined in the XQuery update specification
    `SequenceIterator` | `iterate(XPathContext context)` Return an Iterator to iterate over the values of a sequence.
    `EventIterator` | `iterateEvents(XPathContext context)` Deliver the result of the expression as a sequence of events.
    `Iterator<Expression>` | `iterateSubExpressions()` Get the immediate sub-expressions of this expression.
    `Expression` | `optimize(ExpressionVisitor visitor, ExpressionVisitor.ContextItemType contextItemType)` Perform optimisation of an expression and its subexpressions.
    `void` | `process(XPathContext context)` Process the instruction, without returning any tail calls
    `Expression` | `promote(PromotionOffer offer, Expression parent)` Offer promotion for this subexpression.
    `boolean` | `replaceSubExpression(Expression original, Expression replacement)` Replace one subexpression by a replacement subexpression
    `void` | `setCopyBindings(Expression copyBindings)` Set the copy bindings.
    `Expression` | `simplify(ExpressionVisitor visitor)` Simplify an expression.
    `Expression` | `typeCheck(ExpressionVisitor visitor, ExpressionVisitor.ContextItemType contextItemType)` Perform type checking of an expression and its subexpressions.

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

      `addToPathMap, adoptChildExpression, checkPermittedContents, computeDependencies, computeSpecialProperties, computeStaticProperties, doPromotion, dynamicError, effectiveBooleanValue, evaluateAsString, evaluatePendingUpdates, explain, getCardinality, getColumnNumber, getColumnNumber, getConstructType, getContainer, getDependencies, getEvaluationMethod, getExecutable, getExpressionName, getHostLanguage, getImplementationMethod, getIntegerBounds, getIntrinsicDependencies, getLineNumber, getLineNumber, getLocationId, getLocationProvider, getObjectName, getProperties, getProperty, getPublicId, getSlotsUsed, getSpecialProperties, getStreamability, getStreamingAdjunct, getSystemId, getSystemId, hasVariableBinding, implementsStaticTypeCheck, isSubtreeExpression, isVacuousExpression, iterateSubExpressionInfo, markTailFunctionCalls, resetLocalStaticProperties, setContainer, setEvaluationMethod, setFiltered, setFlattened, setLocationId, staticTypeCheck, suppressValidation, toPattern, toStreamingPattern, toString, typeError`

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

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

- - ### Constructor Detail

    - #### CopyModifyExpression

          public CopyModifyExpression(Expression updateExp,
                              Expression returnExp,
                              int validationMode)

      Create a copy-modify expression (also known as a transform expresion)
      Parameters:
        `updateExp` - the expression appearing in the modify clause
        `returnExp` - the expression appearing in the return clause
        `validationMode` - the mode for validating the updated nodes (strict, lax, or skip)

  - ### Method Detail

    - #### setCopyBindings

          public void setCopyBindings(Expression copyBindings)

      Set the copy bindings. This is an expression whose value is the set of nodes that are allowed to be updated. Normally it will consist of a variable reference or a sequence of variable references.
      Parameters:
        `copyBindings` - the set of Let expressions that bind variables that were copied during the copy phase and that therefore may be updated during the modify phase

    - #### computeCardinality

          public int computeCardinality()

      Determine the static cardinality of the expression. This establishes how many items there will be in the result of the expression, at compile time (i.e., without actually evaluating the result.
      Specified by:
        `computeCardinality` in class `Expression`
      Returns:
        one of the values Cardinality.ONE_OR_MORE, Cardinality.ZERO_OR_MORE, Cardinality.EXACTLY_ONE, Cardinality.ZERO_OR_ONE, Cardinality.EMPTY. This default implementation returns ZERO_OR_MORE (which effectively gives no information).

    - #### getItemType

          public ItemType getItemType(TypeHierarchy th)

      Determine the data type of the expression, if possible. All expression return sequences, in general; this method determines the type of the items within the sequence, assuming that (a) this is known in advance, and (b) it is the same for all items in the sequence.

      This method should always return a result, though it may be the best approximation that is available at the time.

      Specified by:
        `getItemType` in class `Expression`
      Parameters:
        `th` - the type hierarchy cache
      Returns:
        a value such as Type.STRING, Type.BOOLEAN, Type.NUMBER, Type.NODE, or Type.ITEM (meaning not known at compile time)

    - #### isUpdatingExpression

          public boolean isUpdatingExpression()

      Determine whether this is an updating expression as defined in the XQuery update specification
      Overrides:
        `isUpdatingExpression` in class `Expression`
      Returns:
        false: although this expression performs updates, it is not classified as an updating expression

    - #### iterateSubExpressions

          public Iterator<Expression> iterateSubExpressions()

      Get the immediate sub-expressions of this expression. Default implementation returns a zero-length array, appropriate for an expression that has no sub-expressions.
      Overrides:
        `iterateSubExpressions` in class `Expression`
      Returns:
        an iterator containing the sub-expressions of this expression

    - #### checkForUpdatingSubexpressions

          public void checkForUpdatingSubexpressions()
                                              throws XPathException

      Check to ensure that this expression does not contain any inappropriate updating subexpressions. This check is overridden for those expressions that permit updating subexpressions.
      Overrides:
        `checkForUpdatingSubexpressions` in class `Expression`
      Throws:
        `XPathException` - if the expression has a non-permitted updating subexpression

    - #### replaceSubExpression

          public boolean replaceSubExpression(Expression original,
                                     Expression replacement)

      Replace one subexpression by a replacement subexpression
      Overrides:
        `replaceSubExpression` in class `Expression`
      Parameters:
        `original` - the original subexpression
        `replacement` - the replacement subexpression
      Returns:
        true if the original subexpression is found

    - #### simplify

          public Expression simplify(ExpressionVisitor visitor)
                              throws XPathException

      Simplify an expression. This performs any static optimization (by rewriting the expression as a different expression). The default implementation does nothing.
      Overrides:
        `simplify` in class `Expression`
      Parameters:
        `visitor` - an expression visitor
      Returns:
        the simplified expression
      Throws:
        `XPathException` - if an error is discovered during expression rewriting

    - #### typeCheck

          public Expression typeCheck(ExpressionVisitor visitor,
                             ExpressionVisitor.ContextItemType contextItemType)
                               throws XPathException

      Perform type checking of an expression and its subexpressions. This is the second phase of static optimization.

      This checks statically that the operands of the expression have the correct type; if necessary it generates code to do run-time type checking or type conversion. A static type error is reported only if execution cannot possibly succeed, that is, if a run-time type error is inevitable. The call may return a modified form of the expression.

      This method is called after all references to functions and variables have been resolved to the declaration of the function or variable. However, the types of such functions and variables may not be accurately known if they have not been explicitly declared.

      If the implementation returns a value other than "this", then it is required to ensure that the parent pointer and location information in the returned expression have been set up correctly. It should not rely on the caller to do this, although for historical reasons many callers do so.

      Overrides:
        `typeCheck` in class `Expression`
      Parameters:
        `visitor` - an expression visitor
        `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
      Throws:
        `XPathException` - if an error is discovered during this phase (typically a type error)

    - #### optimize

          public Expression optimize(ExpressionVisitor visitor,
                            ExpressionVisitor.ContextItemType contextItemType)
                              throws XPathException

      Perform optimisation of an expression and its subexpressions. This is the third and final phase of static optimization.

      This method is called after all references to functions and variables have been resolved to the declaration of the function or variable, and after all type checking has been done.

      Overrides:
        `optimize` in class `Expression`
      Parameters:
        `visitor` - an expression visitor
        `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 if appropriate to optimize execution
      Throws:
        `XPathException` - if an error is discovered during this phase (typically a type error)

    - #### promote

          public Expression promote(PromotionOffer offer,
                           Expression parent)
                             throws XPathException

      Offer promotion for this subexpression. The offer will be accepted if the subexpression is not dependent on the factors (e.g. the context item) identified in the PromotionOffer. By default the offer is not accepted - this is appropriate in the case of simple expressions such as constant values and variable references where promotion would give no performance advantage. This method is always called at compile time.
      Overrides:
        `promote` in class `Expression`
      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
        `parent` - the parent of this 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

    - #### copy

          public Expression copy()

      Copy an expression. This makes a deep copy.
      Specified by:
        `copy` in class `Expression`
      Returns:
        the copy of the original expression

    - #### explain

          public void explain(ExpressionPresenter out)

      Diagnostic print of expression structure. The abstract expression tree is written to the supplied output destination.
      Specified by:
        `explain` in class `Expression`
      Parameters:
        `out` - the expression presenter used to display the structure

    - #### iterate

          public SequenceIterator iterate(XPathContext context)
                                   throws XPathException

      Return an Iterator to iterate over the values of a sequence. The value of every expression can be regarded as a sequence, so this method is supported for all expressions. This default implementation handles iteration for expressions that return singleton values: for non-singleton expressions, the subclass must provide its own implementation.
      Overrides:
        `iterate` in class `Expression`
      Parameters:
        `context` - supplies the context for evaluation
      Returns:
        a SequenceIterator that can be used to iterate over the result of the expression
      Throws:
        `XPathException` - if any dynamic error occurs evaluating the expression

    - #### evaluateItem

          public Item evaluateItem(XPathContext context)
                            throws XPathException

      Evaluate an expression as a single item. This always returns either a single Item or null (denoting the empty sequence). No conversion is done. This method should not be used unless the static type of the expression is a subtype of "item" or "item?": that is, it should not be called if the expression may return a sequence. There is no guarantee that this condition will be detected.
      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

    - #### iterateEvents

          public EventIterator iterateEvents(XPathContext context)
                                      throws XPathException

      Deliver the result of the expression as a sequence of events.

      The events (of class `PullEvent`) are either complete items, or one of startElement, endElement, startDocument, or endDocument, known as semi-nodes. The stream of events may also include a nested EventIterator. If a start-end pair exists in the sequence, then the events between this pair represent the content of the document or element. The content sequence will have been processed to the extent that any attribute and namespace nodes in the content sequence will have been merged into the startElement event. Namespace fixup will have been performed: that is, unique prefixes will have been allocated to element and attribute nodes, and all namespaces will be declared by means of a namespace node in the startElement event or in an outer startElement forming part of the sequence. However, duplicate namespaces may appear in the sequence.

      The content of an element or document may include adjacent or zero-length text nodes, atomic values, and nodes represented as nodes rather than broken down into events.

      Overrides:
        `iterateEvents` in class `Expression`
      Parameters:
        `context` - The dynamic evaluation context
      Returns:
        the result of the expression as an iterator over a sequence of PullEvent objects
      Throws:
        `XPathException` - if a dynamic error occurs during expression evaluation

    - #### process

          public void process(XPathContext context)
                       throws XPathException

      Process the instruction, without returning any tail calls
      Overrides:
        `process` in class `Expression`
      Parameters:
        `context` - The dynamic context, giving access to the current node, the current variables, etc.
      Throws:
        `XPathException` - if a dynamic error occurs

    - #### getExpressionCompiler

          public ExpressionCompiler getExpressionCompiler()

      Return the compiler of the CopyModify expression
      Overrides:
        `getExpressionCompiler` in class `Expression`
      Returns:
        the relevant ExpressionCompiler

Copyright (c) 2004-2013 Saxonica Limited. All rights reserved.