Class Assignation

java.lang.Object
net.sf.saxon.expr.Expression
net.sf.saxon.expr.Assignation
All Implemented Interfaces:
Serializable, SourceLocator, LocationProvider, SaxonLocator, Binding, InstructionInfo, Locator
Direct Known Subclasses:
ForExpression, LetExpression, QuantifiedExpression
public abstract class Assignation extends Expression implements Binding
Assignation is an abstract superclass for the kinds of expression that declare range variables: for, some, and every.
See Also:

  • Field Details

    • slotNumber

      protected int slotNumber

    • sequence

      protected Expression sequence

    • action

      protected Expression action

    • variableName

      protected StructuredQName variableName

    • requiredType

      protected SequenceType requiredType

    • refCount

      int refCount

  • Constructor Details

    • Assignation

      public Assignation()

  • Method Details

    • setRequiredType

      public void setRequiredType(SequenceType requiredType)
      Set the required type (declared type) of the variable
      Parameters:
      requiredType - the required type

    • setVariableQName

      public void setVariableQName(StructuredQName variableName)
      Set the name of the variable
      Parameters:
      variableName - the name of the variable

    • getVariableQName

      public StructuredQName getVariableQName()
      Get the name of the variable
      Specified by:
      getVariableQName in interface Binding
      Returns:
      the variable name, as a QName

    • getObjectName

      public StructuredQName getObjectName()
      Description copied from interface: InstructionInfo
      Get a name identifying the object of the expression, for example a function name, template name, variable name, key name, element name, etc. This is used only where the name is known statically.
      Specified by:
      getObjectName in interface InstructionInfo
      Overrides:
      getObjectName in class Expression
      Returns:
      the QName of the object declared or manipulated by this instruction or expression

    • getRequiredType

      public SequenceType getRequiredType()
      Get the declared type of the variable
      Specified by:
      getRequiredType in interface Binding
      Returns:
      the declared type

    • getIntegerBoundsForVariable

      public IntegerValue[] getIntegerBoundsForVariable()
      If the variable is bound to an integer, get the minimum and maximum possible values. Return null if unknown or not applicable
      Specified by:
      getIntegerBoundsForVariable in interface Binding
      Returns:
      a pair of integers containing the minimum and maximum values for the integer value; or null if the value is not an integer or the range is unknown

    • getLocalSlotNumber

      public int getLocalSlotNumber()
      If this is a local variable held on the local stack frame, return the corresponding slot number. In other cases, return -1.
      Specified by:
      getLocalSlotNumber in interface Binding
      Returns:
      the slot number on the local stack frame

    • evaluateVariable

      public ValueRepresentation evaluateVariable(XPathContext context) throws XPathException
      Get the value of the range variable
      Specified by:
      evaluateVariable in interface Binding
      Parameters:
      context - the XPath dynamic evaluation context
      Returns:
      the result of evaluating the variable
      Throws:
      XPathException - if an error occurs while evaluating the variable

    • setAction

      public void setAction(Expression action)
      Add the "return" or "satisfies" expression, and fix up all references to the range variable that occur within that expression
      Parameters:
      action - the expression that occurs after the "return" keyword of a "for" expression, the "satisfies" keyword of "some/every", or the ":=" operator of a "let" expression.

    • isGlobal

      public final boolean isGlobal()
      Indicate whether the binding is local or global. A global binding is one that has a fixed value for the life of a query or transformation; any other binding is local.
      Specified by:
      isGlobal in interface Binding
      Returns:
      true if the binding is global

    • isAssignable

      public final boolean isAssignable()
      Test whether it is permitted to assign to the variable using the saxon:assign extension element. This will only be for an XSLT global variable where the extra attribute saxon:assignable="yes" is present.
      Specified by:
      isAssignable in interface Binding
      Returns:
      true if the binding is assignable

    • 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 updateing subexpression

    • isUpdatingExpression

      public boolean isUpdatingExpression()
      Determine whether this is an updating expression as defined in the XQuery update specification
      Overrides:
      isUpdatingExpression in class Expression
      Returns:
      true if this is an updating expression

    • getAction

      public Expression getAction()
      Get the action expression
      Returns:
      the action expression (introduced by "return" or "satisfies")

    • setSequence

      public void setSequence(Expression sequence)
      Set the "sequence" expression - the one to which the variable is bound
      Parameters:
      sequence - the expression to which the variable is bound

    • getSequence

      public Expression getSequence()
      Get the "sequence" expression - the one to which the variable is bound
      Returns:
      the expression to which the variable is bound

    • setSlotNumber

      public void setSlotNumber(int nr)
      Set the slot number for the range variable
      Parameters:
      nr - the slot number to be used

    • getRequiredSlots

      public int getRequiredSlots()
      Get the number of slots required. Normally 1, except for a FOR expression with an AT clause, where it is 2.
      Returns:
      the number of slots required

    • simplify

      public Expression simplify(ExpressionVisitor visitor) throws XPathException
      Simplify the expression
      Overrides:
      simplify in class Expression
      Parameters:
      visitor - an expression visitor
      Returns:
      the simplified expression
      Throws:
      XPathException - if an error is discovered during expression rewriting

    • hasVariableBinding

      public boolean hasVariableBinding(Binding binding)
      Overrides:
      hasVariableBinding in class Expression

    • promote

      public Expression promote(PromotionOffer offer, Expression parent) throws XPathException
      Promote this expression if possible
      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 containing expression in the expression tree
      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

    • suppressValidation

      public void suppressValidation(int validationMode)
      Suppress validation on contained element constructors, on the grounds that the parent element is already performing validation. The default implementation does nothing.
      Overrides:
      suppressValidation in class Expression
      Parameters:
      validationMode - the kind of validation being performed on the parent expression

    • extendBindingList

      public Binding[] extendBindingList(Binding[] in)
      Extend an array of variable bindings to include the binding(s) defined in this expression
      Parameters:
      in - a set of variable bindings
      Returns:
      a set of variable bindings including all those supplied plus this one

    • promoteWhereClause

      protected Expression promoteWhereClause(Binding positionBinding)
      Promote a WHERE clause whose condition doesn't depend on the variable being bound. This rewrites an expression of the form

      let $i := SEQ return if (C) then R else ()

      to the form:

      if (C) then (let $i := SEQ return R) else ()

      Parameters:
      positionBinding - the binding of the position variable if any
      Returns:
      an expression in which terms from the WHERE clause that can be extracted have been extracted

    • iterateSubExpressions

      public Iterator<Expression> iterateSubExpressions()
      Get the immediate subexpressions of this expression
      Overrides:
      iterateSubExpressions in class Expression
      Returns:
      an iterator containing the sub-expressions of this expression

    • 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

    • addToPathMap

      public PathMap.PathMapNodeSet addToPathMap(PathMap pathMap, PathMap.PathMapNodeSet pathMapNodeSet)
      Add a representation of this expression to a PathMap. The PathMap captures a map of the nodes visited by an expression in a source tree.

      The default implementation of this method assumes that an expression does no navigation other than the navigation done by evaluating its subexpressions, and that the subexpressions are evaluated in the same context as the containing expression. The method must be overridden for any expression where these assumptions do not hold. For example, implementations exist for AxisExpression, ParentExpression, and RootExpression (because they perform navigation), and for the doc(), document(), and collection() functions because they create a new navigation root. Implementations also exist for PathExpression and FilterExpression because they have subexpressions that are evaluated in a different context from the calling expression.

      Overrides:
      addToPathMap in class Expression
      Parameters:
      pathMap - the PathMap to which the expression should be added
      pathMapNodeSet - the PathMapNodeSet to which the paths embodied in this expression should be added
      Returns:
      the pathMapNodeSet representing the points in the source document that are both reachable by this expression, and that represent possible results of this expression. For an expression that does navigation, it represents the end of the arc in the path map that describes the navigation route. For other expressions, it is the same as the input pathMapNode.

    • getVariableName

      public String getVariableName()
      Get the display name of the range variable, for diagnostics only
      Returns:
      the lexical QName of the range variable

    • refineTypeInformation

      public void refineTypeInformation(ItemType type, int cardinality, Value constantValue, int properties, ExpressionVisitor visitor, Assignation currentExpression)
      Refine the type information associated with this variable declaration. This is useful when the type of the variable has not been explicitly declared (which is common); the variable then takes a static type based on the type of the expression to which it is bound. The effect of this call is to update the static expression type for all references to this variable.
      Parameters:
      type - the inferred item type of the expression to which the variable is bound
      cardinality - the inferred cardinality of the expression to which the variable is bound
      constantValue - the constant value to which the variable is bound (null if there is no constant value)
      properties - other static properties of the expression to which the variable is bound
      visitor - an expression visitor to provide context information
      currentExpression - the expression that binds the variable

    • addReference

      public void addReference(boolean isLoopingReference)
      Register a variable reference that refers to the variable bound in this expression
      Specified by:
      addReference in interface Binding
      Parameters:
      isLoopingReference - - true if the reference occurs within a loop, such as the predicate of a filter expression

    • getNominalReferenceCount

      public int getNominalReferenceCount()
      Get the (nominal) count of the number of references to this variable
      Returns:
      zero if there are no references, one if there is a single reference that is not in a loop, some higher number if there are multiple references (or a single reference in a loop), or the special value @link RangeVariable#FILTERED} if there are any references in filter expressions that require searching.

    • isIndexedVariable

      public boolean isIndexedVariable()
      Test whether the variable bound by this let expression should be indexable
      Returns:
      true if the variable should be indexable

    • replaceVariable

      public void replaceVariable(Optimizer opt, Expression seq) throws XPathException
      Replace all references to the variable bound by this let expression, that occur within the action expression, with the given expression
      Parameters:
      opt - The optimizer
      seq - the expression
      Throws:
      XPathException

    • setIndexedVariable

      public void setIndexedVariable()
      Indicate that the variable bound by this let expression should be indexable (because it is used in an appropriate filter expression)