## net.sf.saxon.instruct
Class SimpleNodeConstructor

    java.lang.Object
      net.sf.saxon.expr.Expression
          net.sf.saxon.instruct.Instruction
              net.sf.saxon.instruct.SimpleNodeConstructor

All Implemented Interfaces:
  Serializable, SourceLocator, Container, EvaluableItem, SequenceIterable, TailCallReturner, InstructionInfoProvider

Direct Known Subclasses:
  Comment, ComputedAttribute, FixedAttribute, Namespace, ProcessingInstruction, ValueOf

    public abstract class SimpleNodeConstructor

extends Instruction

Common superclass for XSLT instructions whose content template produces a text value: xsl:attribute, xsl:comment, xsl:processing-instruction, xsl:namespace, and xsl:text

See Also:
  Serialized Form

Field Summary

Fields inherited from class net.sf.saxon.expr.Expression
`EVALUATE_METHOD, ITERATE_METHOD, PROCESS_METHOD`

Constructor Summary
`SimpleNodeConstructor()`

Method Summary
`int` `computeCardinality()` Get the cardinality of the sequence returned by evaluating this instruction
`int` `computeSpecialProperties()` Get the static properties of this expression (other than its type).
`boolean` `createsNewNodes()` Determine whether this instruction creates new nodes.
`void` `display(int level, PrintStream out, Configuration config)` Display this instruction as an expression, for diagnostics
`Item` `evaluateItem(XPathContext context)` Evaluate as an expression.
`int` `evaluateNameCode(XPathContext context)`
`CharSequence` `expandChildren(XPathContext context)` Expand the stylesheet elements subordinate to this one, returning the result as a string.
`Expression` `getSelect()`
`SequenceIterator` `iterate(XPathContext context)` Return an Iterator to iterate over the values of a sequence.
`Iterator` `iterateSubExpressions()` Get the immediate sub-expressions of this expression.
`abstract void` `localTypeCheck(StaticContext env, ItemType contextItemType)` Method to perform type-checking specific to the kind of instruction
`Expression` `optimize(Optimizer opt, StaticContext env, ItemType contextItemType)` Perform optimisation of an expression and its subexpressions.
`boolean` `replaceSubExpression(Expression original, Expression replacement)` Replace one subexpression by a replacement subexpression
`void` `setSelect(Expression select, Configuration config)`
`Expression` `simplify(StaticContext env)` Simplify an expression.
`Expression` `typeCheck(StaticContext env, ItemType contextItemType)` The typeCheck() method is called in XQuery, where node constructors are implemented as Expressions.

Methods inherited from class net.sf.saxon.instruct.Instruction
`appendItem, evaluateAsString, getImplementationMethod, getInstructionInfo, getInstructionNameCode, getItemType, getSourceLocator, isXSLT, process, processLeavingTail, promote`

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

`adoptChildExpression, checkPermittedContents, computeDependencies, computeStaticProperties, doPromotion, effectiveBooleanValue, getCardinality, getColumnNumber, getContainingProcedure, getDependencies, getExecutable, getHostLanguage, getIntrinsicDependencies, getLineNumber, getLocationId, getLocationProvider, getParentExpression, getPublicId, getSlotsUsed, getSpecialProperties, getSystemId, hasBadParentPointer, markTailFunctionCalls, resetStaticProperties, setLocationId, setParentExpression, setParentExpression, suppressValidation`

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Methods inherited from interface javax.xml.transform.SourceLocator
`getColumnNumber, getLineNumber, getPublicId, getSystemId`

Constructor Detail

### SimpleNodeConstructor

    public SimpleNodeConstructor()

Method Detail

### setSelect

    public void setSelect(Expression select,
                          Configuration config)
                   throws StaticError

  Throws:
    `StaticError`

### getSelect

    public Expression getSelect()

### createsNewNodes

    public final boolean createsNewNodes()

  Determine whether this instruction creates new nodes. This implementation returns true.

  Overrides:
    `createsNewNodes` in class `Instruction`

### computeCardinality

    public int computeCardinality()

  Get the cardinality of the sequence returned by evaluating this instruction

  Overrides:
    `computeCardinality` in class `Instruction`
  Returns:
    the static cardinality

### simplify

    public Expression simplify(StaticContext env)
                        throws XPathException

  Description copied from class: `Instruction`
  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`
  Returns:
    the simplified expression
  Throws:
    `XPathException` - if an error is discovered during expression rewriting

### computeSpecialProperties

    public int computeSpecialProperties()

  Get the static properties of this expression (other than its type). The result is bit-signficant. These properties are used for optimizations. In general, if property bit is set, it is true, but if it is unset, the value is unknown.

  Overrides:
    `computeSpecialProperties` in class `Instruction`
  Returns:
    a set of flags indicating static properties of this expression

### localTypeCheck

    public abstract void localTypeCheck(StaticContext env,
                                        ItemType contextItemType)
                                 throws XPathException

  Method to perform type-checking specific to the kind of instruction

  Parameters:
    `env` -
    `contextItemType` -
  Throws:
    `XPathException`

### typeCheck

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

  The typeCheck() method is called in XQuery, where node constructors are implemented as Expressions. In this case the required type for the select expression is a single string.

  Overrides:
    `typeCheck` in class `Expression`
  Parameters:
    `env` - The static context for the query
    `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 rewritten expression
  Throws:
    `XPathException` - if any static errors are found in this expression or any of its children

### optimize

    public Expression optimize(Optimizer opt,
                               StaticContext env,
                               ItemType contextItemType)
                        throws XPathException

  Description copied from class: `Expression`
  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:
    `opt` - the optimizer in use. This provides access to supporting functions; it also allows different optimization strategies to be used in different circumstances.
    `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 if appropriate to optimize execution
  Throws:
    `StaticError` - if an error is discovered during this phase (typically a type error)
    `XPathException`

### iterateSubExpressions

    public Iterator 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

### replaceSubExpression

    public boolean replaceSubExpression(Expression original,
                                        Expression replacement)

  Replace one subexpression by a replacement subexpression

  Specified by:
    `replaceSubExpression` in interface `Container`
  Overrides:
    `replaceSubExpression` in class `Expression`
  Parameters:
    `original` - the original subexpression
    `replacement` - the replacement subexpression
  Returns:
    true if the original subexpression is found

### expandChildren

    public CharSequence expandChildren(XPathContext context)
                                throws XPathException

  Expand the stylesheet elements subordinate to this one, returning the result as a string. The expansion must not generate any element or attribute nodes.

  Parameters:
    `context` - The dynamic context for the transformation
  Throws:
    `XPathException`

### evaluateItem

    public Item evaluateItem(XPathContext context)
                      throws XPathException

  Evaluate as an expression. We rely on the fact that when these instructions are generated by XQuery, there will always be a valueExpression to evaluate the content

  Specified by:
    `evaluateItem` in interface `EvaluableItem`
  Overrides:
    `evaluateItem` in class `Instruction`
  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

### evaluateNameCode

    public int evaluateNameCode(XPathContext context)
                         throws XPathException,
                                XPathException

  Throws:
    `XPathException`

### iterate

    public SequenceIterator iterate(XPathContext context)
                             throws XPathException

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

  Specified by:
    `iterate` in interface `SequenceIterable`
  Overrides:
    `iterate` in class `Instruction`
  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

### display

    public void display(int level,
                        PrintStream out,
                        Configuration config)

  Display this instruction as an expression, for diagnostics

  Specified by:
    `display` in class `Expression`
  Parameters:
    `level` - indentation level for this expression
    `out` - Output destination

Copyright (C) Michael H. Kay. All rights reserved.