com.saxonica.xsltextn.instruct

## Class Assign

- java.lang.Object
- - net.sf.saxon.expr.Expression
  - - net.sf.saxon.expr.instruct.Instruction
    - - com.saxonica.xsltextn.instruct.Assign

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

      public class Assign
      extends Instruction
      implements BindingReference

  Compiled instruction deriving from saxon:assign element in stylesheet. The saxon:assign element has mandatory attribute name and optional attribute expr. It also allows xsl:extension-element-prefixes etc.
  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
    `Assign()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `Expression` | `copy()` Copy an expression.
    `void` | `explain(ExpressionPresenter out)` Diagnostic print of expression structure.
    `void` | `fixup(Binding binding)` Fix up this binding reference to a binding
    `ExpressionCompiler` | `getExpressionCompiler()` Return the compiler of the Assign expression
    `int` | `getInstructionNameCode()` Get the name of this instruction for diagnostic and tracing purposes
    `int` | `getIntrinsicDependencies()` Determine the intrinsic dependencies of an expression, that is, those which are not derived from the dependencies of its subexpressions.
    `Iterator<Expression>` | `iterateSubExpressions()` Get the immediate sub-expressions of this expression.
    `TailCall` | `processLeavingTail(XPathContext context)` ProcessLeavingTail: called to do the real work of this instruction.
    `Expression` | `promote(PromotionOffer offer, Expression parent)` Offer promotion for this subexpression.
    `protected void` | `promoteInst(PromotionOffer offer)` Handle promotion offers, that is, non-local tree rewrites.
    `void` | `setSelectExpression(Expression select)`
    `void` | `setStaticType(SequenceType type, GroundedValue constantValue, int properties)` Fix up the static type of this variable reference; optionally, supply a constant value for the variable.
    `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.instruct.Instruction

      `assembleParams, assembleTunnelParams, computeCardinality, computeSpecialProperties, createsNewNodes, dynamicError, evaluateAsString, evaluateItem, getConstructType, getExpressionName, getImplementationMethod, getInstructionName, getItemType, getIteratorFromProcessMethod, getSourceLocator, isXSLT, iterate, process`

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

      `addToPathMap, adoptChildExpression, checkForUpdatingSubexpressions, checkPermittedContents, computeDependencies, computeStaticProperties, doPromotion, dynamicError, effectiveBooleanValue, evaluatePendingUpdates, explain, getCardinality, getColumnNumber, getColumnNumber, getContainer, getDependencies, getEvaluationMethod, getExecutable, getHostLanguage, getIntegerBounds, getLineNumber, getLineNumber, getLocationId, getLocationProvider, getObjectName, getProperties, getProperty, getPublicId, getSlotsUsed, getSpecialProperties, getStreamability, getStreamingAdjunct, getSystemId, getSystemId, hasVariableBinding, implementsStaticTypeCheck, isSubtreeExpression, isUpdatingExpression, isVacuousExpression, iterateEvents, iterateSubExpressionInfo, markTailFunctionCalls, optimize, replaceSubExpression, 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`

    - ### Methods inherited from interface javax.xml.transform.SourceLocator

      `getColumnNumber, getLineNumber, getPublicId, getSystemId`

- - ### Constructor Detail

    - #### Assign

          public Assign()

  - ### Method Detail

    - #### setStaticType

          public void setStaticType(SequenceType type,
                           GroundedValue constantValue,
                           int properties)

      Description copied from interface: `BindingReference`
      Fix up the static type of this variable reference; optionally, supply a constant value for the variable. Also supplies other static properties of the expression to which the variable is bound, for example whether it is an ordered node-set.
      Specified by:
        `setStaticType` in interface `BindingReference`
      Parameters:
        `type` - The static type of the variable reference, typically either the declared type of the variable, or the static type of the expression to which the variable is bound
        `constantValue` - if non-null, indicates that the value of the variable is known at compile time, and supplies the value
        `properties` - static properties of the expression to which the variable is bound

    - #### setSelectExpression

          public void setSelectExpression(Expression select)

    - #### fixup

          public void fixup(Binding binding)

      Description copied from interface: `BindingReference`
      Fix up this binding reference to a binding
      Specified by:
        `fixup` in interface `BindingReference`
      Parameters:
        `binding` - the Binding to which the variable refers

    - #### getIntrinsicDependencies

          public int getIntrinsicDependencies()

      Description copied from class: `Expression`
      Determine the intrinsic dependencies of an expression, that is, those which are not derived from the dependencies of its subexpressions. For example, position() has an intrinsic dependency on the context position, while (position()+1) does not. The default implementation of the method returns 0, indicating "no dependencies".
      Overrides:
        `getIntrinsicDependencies` in class `Expression`
      Returns:
        a set of bit-significant flags identifying the "intrinsic" dependencies. The flags are documented in class net.sf.saxon.value.StaticProperty

    - #### 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.
      Specified by:
        `simplify` in class `Instruction`
      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.
      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)

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

    - #### iterateSubExpressions

          public Iterator<Expression> iterateSubExpressions()

      Description copied from class: `Expression`
      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

    - #### promote

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

      Offer promotion for this subexpression. This needs careful handling in the case of saxon:assign
      Overrides:
        `promote` in class `Instruction`
      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 expression of the expression to be promoted
      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

    - #### promoteInst

          protected void promoteInst(PromotionOffer offer)
                              throws XPathException

      Handle promotion offers, that is, non-local tree rewrites.
      Overrides:
        `promoteInst` in class `Instruction`
      Parameters:
        `offer` - The type of rewrite being offered
      Throws:
        `XPathException` - if an error occurs

    - #### getInstructionNameCode

          public int getInstructionNameCode()

      Get the name of this instruction for diagnostic and tracing purposes
      Overrides:
        `getInstructionNameCode` in class `Instruction`
      Returns:
        a code identifying the instruction: typically but not always the fingerprint of a name in the XSLT namespace

    - #### processLeavingTail

          public TailCall processLeavingTail(XPathContext context)
                                      throws XPathException

      Description copied from class: `Instruction`
      ProcessLeavingTail: called to do the real work of this instruction. This method must be implemented in each subclass. The results of the instruction are written to the current Receiver, which can be obtained via the Controller.
      Specified by:
        `processLeavingTail` in interface `TailCallReturner`
      Specified by:
        `processLeavingTail` in class `Instruction`
      Parameters:
        `context` - The dynamic context of the transformation, giving access to the current node, the current variables, etc.
      Returns:
        null if the instruction has completed execution; or a TailCall indicating a function call or template call that is delegated to the caller, to be made after the stack has been unwound so as to save stack space.
      Throws:
        `XPathException` - if a dynamic error occurs during the evaluation of the instruction

    - #### getExpressionCompiler

          public ExpressionCompiler getExpressionCompiler()

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

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

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