Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## net.sf.saxon.instruct
Class SimpleNodeConstructor

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

All Implemented Interfaces:
  Container, Expression, InstructionInfoProvider, java.io.Serializable, javax.xml.transform.SourceLocator, TailCallReturner

Direct Known Subclasses:
  Attribute, Comment, 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
`protected Expression` | `select`

Fields inherited from class net.sf.saxon.expr.ComputedExpression
`locationId, staticProperties`

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

Constructor Summary
`SimpleNodeConstructor()`

Method Summary
`protected java.lang.String` | `checkContent(java.lang.String data, XPathContext context)` Check the content of the node, and adjust it if necessary.
`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, NamePool pool, java.io.PrintStream out)` Display this instruction as an expression, for diagnostics
`Item` | `evaluateItem(XPathContext context)` Evaluate as an expression.
`protected int` | `evaluateNameCode(XPathContext context)`
`java.lang.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.
`java.util.Iterator` | `iterateSubExpressions()` Get the immediate sub-expressions of this expression.
`abstract void` | `localTypeCheck(StaticContext env, ItemType contextItemType)`
`Expression` | `optimize(Optimizer opt, StaticContext env, ItemType contextItemType)` Perform optimisation of an expression and its subexpressions.
`protected void` | `promoteInst(PromotionOffer offer)` Offer promotion for subexpressions.
`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, assembleParams, assembleTunnelParams, computeCardinality, dynamicError, evaluateAsString, getImplementationMethod, getInstructionInfo, getInstructionNameCode, getItemType, getSourceLocator, isXSLT, process, processLeavingTail, promote`

Methods inherited from class net.sf.saxon.expr.ComputedExpression
`adoptChildExpression, checkPermittedContents, computeDependencies, computeStaticProperties, doPromotion, dynamicError, dynamicError, effectiveBooleanValue, getCardinality, getColumnNumber, getConstructType, getDependencies, getExecutable, getHostLanguage, getIntrinsicDependencies, getLineNumber, getLocationId, getLocationProvider, getParentExpression, getPublicId, getSlotsUsed, getSpecialProperties, getSystemId, hasBadParentPointer, markTailFunctionCalls, resetStaticProperties, setLocationId, setParentExpression, suppressValidation, typeError, typeError`

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

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

Field Detail

### select

    protected Expression select

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`

### 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 interface `Expression`
  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

  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.

  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 interface: `Expression`
  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.

  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:
    `XPathException`

### iterateSubExpressions

    public java.util.Iterator iterateSubExpressions()

  Description copied from class: `ComputedExpression`
  Get the immediate sub-expressions of this expression. Default implementation returns a zero-length array, appropriate for an expression that has no sub-expressions.

  Specified by:
    `iterateSubExpressions` in interface `Expression`
  Overrides:
    `iterateSubExpressions` in class `ComputedExpression`
  Returns:
    an iterator containing the sub-expressions of this expression

### expandChildren

    public java.lang.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 `Expression`
  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

### checkContent

    protected java.lang.String checkContent(java.lang.String data,
                                            XPathContext context)
                                     throws DynamicError

  Check the content of the node, and adjust it if necessary. The checks depend on the node kind.

  Parameters:
    `data` - the supplied content
    `context` - the dynamic context
  Returns:
    the original content, unless adjustments are needed
  Throws:
    `DynamicError` - if the content is invalid

### evaluateNameCode

    protected 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 `Expression`
  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,
                        NamePool pool,
                        java.io.PrintStream out)

  Display this instruction as an expression, for diagnostics

  Parameters:
    `level` - indentation level for this expression
    `pool` - NamePool used to expand any names appearing in the expression
    `out` - Output destination

### promoteInst

    protected void promoteInst(PromotionOffer offer)
                        throws XPathException

  Offer promotion for subexpressions. 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:
    `promoteInst` 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
  Throws:
    `XPathException` - if any error is detected

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD