Package net.sf.saxon.expr.instruct

Class SequenceInstr

java.lang.Object
net.sf.saxon.expr.Expression
net.sf.saxon.expr.UnaryExpression
net.sf.saxon.expr.instruct.SequenceInstr
All Implemented Interfaces:
ExportAgent, Locatable, IdentityComparable, Traceable
public class SequenceInstr extends UnaryExpression
A compiled xsl:sequence instruction. Used only when strict streamability analysis is required; the instruction differs from its operand only by being marked as an instruction, which is sometimes relevant for streamability analysis. Used for xsl:sequence and also for xsl:map and xsl:map-entry; and also to wrap expressions in text value templates.

  • Constructor Details Link icon

    • SequenceInstr Link icon

      public SequenceInstr(Expression base)
      Create the instruction
      Parameters:
      base - the base expression

  • Method Details Link icon

    • isInstruction Link icon

      public boolean isInstruction()
      Ask whether this expression is an instruction. In XSLT streamability analysis this is used to distinguish constructs corresponding to XSLT instructions from other constructs.
      Overrides:
      isInstruction in class Expression
      Returns:
      true if this construct originates as an XSLT instruction

    • getOperandRole Link icon

      protected OperandRole getOperandRole()
      Get the usage (in terms of streamability analysis) of the single operand
      Specified by:
      getOperandRole in class UnaryExpression
      Returns:
      the operand usage

    • typeCheck Link icon

      public Expression typeCheck(ExpressionVisitor visitor, ContextItemStaticInfo contextInfo) throws XPathException
      Type-check the expression. Default implementation for unary operators that accept any kind of operand
      Overrides:
      typeCheck in class UnaryExpression
      Parameters:
      visitor - an expression visitor
      contextInfo - Information available statically about the context item: whether it is (possibly) absent; its static type; its streaming posture.
      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 Link icon

      public Expression optimize(ExpressionVisitor visitor, ContextItemStaticInfo contextInfo) throws XPathException
      Perform optimisation of an expression and its subexpressions.

      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 UnaryExpression
      Parameters:
      visitor - an expression visitor
      contextInfo - 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)

    • copy Link icon

      public Expression copy(RebindingMap rebindings)
      Description copied from class: Expression
      Copy an expression. This makes a deep copy.
      Specified by:
      copy in class Expression
      Parameters:
      rebindings - a mutable list of (old binding, new binding) pairs that is used to update the bindings held in any local variable references that are copied.
      Returns:
      the copy of the original expression

    • getImplementationMethod Link icon

      public int getImplementationMethod()
      An implementation of Expression must provide at least one of the methods evaluateItem(), iterate(), or process(). This method indicates which of these methods is provided directly. The other methods will always be available indirectly, using an implementation that relies on one of the other methods.
      Specified by:
      getImplementationMethod in class Expression
      Returns:
      the implementation method, for example Expression.ITERATE_METHOD or Expression.EVALUATE_METHOD or Expression.PROCESS_METHOD

    • getExpressionName Link icon

      public String getExpressionName()
      Get a name identifying the kind of expression, in terms meaningful to a user.
      Overrides:
      getExpressionName in class Expression
      Returns:
      a name identifying the kind of expression, in terms meaningful to a user. The name will always be in the form of a lexical XML QName, and should match the name used in export() output displaying the expression.

    • process Link icon

      public void process(Outputter output, XPathContext context) throws XPathException
      Process the instruction, without returning any tail calls
      Overrides:
      process in class Expression
      Parameters:
      output - the destination for the result
      context - The dynamic context, giving access to the current node, the current variables, etc.
      Throws:
      XPathException - if a dynamic error occurs

    • iterate Link icon

      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

    • export Link icon

      public void export(ExpressionPresenter out) throws XPathException
      Description copied from class: UnaryExpression
      Diagnostic print of expression structure. The abstract expression tree is written to the supplied output destination.
      Specified by:
      export in interface ExportAgent
      Overrides:
      export in class UnaryExpression
      Parameters:
      out - the expression presenter used to display the structure
      Throws:
      XPathException - if the export fails, for example if an expression is found that won't work in the target environment.

    • getStreamerName Link icon

      public String getStreamerName()
      Get the (partial) name of a class that supports streaming of this kind of expression
      Overrides:
      getStreamerName in class Expression
      Returns:
      the partial name of a class that can be instantiated to provide streaming support in Saxon-EE, or null if there is no such class

    • getElaborator Link icon

      public Elaborator getElaborator()
      Description copied from class: Expression
      Make an elaborator for this expression
      Overrides:
      getElaborator in class Expression
      Returns:
      an appropriate Elaborator