net.sf.saxon.instruct
Class ElementCreator

java.lang.Object
  |
  +--net.sf.saxon.instruct.Instruction
        |
        +--net.sf.saxon.instruct.ExprInstruction
              |
              +--net.sf.saxon.instruct.ElementCreator
All Implemented Interfaces:
Expression, java.io.Serializable, javax.xml.transform.SourceLocator
Direct Known Subclasses:
Copy, Element, FixedElement

public abstract class ElementCreator
extends ExprInstruction

An instruction that creates an element node. There are two subtypes, FixedElement for use where the name is known statically, and Element where it is computed dynamically. To allow use in both XSLT and XQuery, the class acts both as an Instruction and as an Expression.

See Also:
Serialized Form

Field Summary
protected  SchemaType schemaType
           
protected  AttributeSet[] useAttributeSets
           
protected  int validation
           
protected  ValidationContext validationContext
           
 
Fields inherited from class net.sf.saxon.instruct.Instruction
children
 
Constructor Summary
ElementCreator()
           
 
Method Summary
 Expression analyze(StaticContext env)
          Perform static analysis of an expression and its subexpressions.
 Item evaluateItem(XPathContext context)
          Evaluate as an expression.
protected abstract  int getNameCode(XPathContext context)
           
 SequenceType getResultType()
          Get the result type returned by this instruction
 ValidationContext getValidationContext()
          Get the validation context for the constructed element
 int getValidationMode()
          Get the validation mode for the constructed element
protected abstract  void outputNamespaceNodes(XPathContext context, Receiver receiver)
          Callback to output namespace nodes for the new element.
 TailCall processLeavingTail(XPathContext context)
          Evaluate the instruction to produce a new element node
 void promoteInst(PromotionOffer offer)
          Offer promotion for subexpressions.
 void setValidationContext(ValidationContext context)
          Set the validation context for the new element
 void setValidationMode(int mode)
          Set the validation mode for the new element
 
Methods inherited from class net.sf.saxon.instruct.ExprInstruction
effectiveBooleanValue, evaluateAsString, getCardinality, getDependencies, getItemType, getSpecialProperties, getSubExpressions, getXPathExpressions, iterate, promote, simplify
 
Methods inherited from class net.sf.saxon.instruct.Instruction
assembleParams, assembleTunnelParams, getChildren, getColumnNumber, getInstructionDetails, getInstructionName, getLineNumber, getPublicId, getSystemId, getSystemId, process, processChildren, processChildrenLeavingTail, recoverableError, setChildren, setInstructionDetails, setSourceLocation, styleError, styleError
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 
Methods inherited from interface net.sf.saxon.expr.Expression
display
 

Field Detail

useAttributeSets

protected AttributeSet[] useAttributeSets

schemaType

protected SchemaType schemaType

validation

protected int validation

validationContext

protected ValidationContext validationContext
Constructor Detail

ElementCreator

public ElementCreator()
Method Detail

getResultType

public SequenceType getResultType()
Get the result type returned by this instruction

Overrides:
getResultType in class Instruction
Returns:
a SequenceType representing the type element(*,*)

analyze

public Expression analyze(StaticContext env)
                   throws XPathException
Description copied from interface: Expression
Perform static analysis of an expression and its subexpressions.

This checks statically that the operands of the expression have the correct type; if necessary it generates code to do run-time type checking or type conversion. A static type error is reported only if execution cannot possibly succeed, that is, if a run-time type error is inevitable. The call may return a modified form of the expression.

This method is called after all references to functions and variables have been resolved to the declaration of the function or variable. However, the types of such functions and variables will only be accurately known if they have been explicitly declared.

Parameters:
env - the static context of the expression
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)

setValidationMode

public void setValidationMode(int mode)
Set the validation mode for the new element


getValidationMode

public int getValidationMode()
Get the validation mode for the constructed element


setValidationContext

public void setValidationContext(ValidationContext context)
Set the validation context for the new element


getValidationContext

public ValidationContext getValidationContext()
Get the validation context for the constructed element


promoteInst

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

Specified by:
promoteInst in class ExprInstruction
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

getNameCode

protected abstract int getNameCode(XPathContext context)
                            throws javax.xml.transform.TransformerException
javax.xml.transform.TransformerException

outputNamespaceNodes

protected abstract void outputNamespaceNodes(XPathContext context,
                                             Receiver receiver)
                                      throws javax.xml.transform.TransformerException
Callback to output namespace nodes for the new element.

Parameters:
context - The execution context
receiver - the Receiver where the namespace nodes are to be written
Throws:
javax.xml.transform.TransformerException

processLeavingTail

public TailCall processLeavingTail(XPathContext context)
                            throws javax.xml.transform.TransformerException
Evaluate the instruction to produce a new element node

Specified by:
processLeavingTail in class Instruction
Parameters:
context -
Returns:
null (this instruction never returns a tail call)
Throws:
javax.xml.transform.TransformerException

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