net.sf.saxon.instruct

Class ComputedElement

public class ComputedElement extends ElementCreator

An instruction representing an xsl:element element in an XSLT stylesheet, or a computed element constructor in XQuery. (In both cases, if the element name is expressed as a compile-time expression, then a FixedElement instruction is used instead.)

See Also: FixedElement

Constructor Summary
ComputedElement(Expression elementName, Expression namespace, NamespaceResolver nsContext, SchemaType schemaType, int validation, boolean inheritNamespaces, boolean allowQName)
Create an instruction that creates a new element node
Method Summary
voidcheckPermittedContents(SchemaType parentType, StaticContext env, boolean whole)
Check that any elements and attributes constructed or returned by this expression are acceptable in the content model of a given complex type.
Expressioncopy()
Copy an expression.
voidexplain(ExpressionPresenter out)
Diagnostic print of expression structure.
intgetInstructionNameCode()
Get the name of this instruction for diagnostic and tracing purposes
ItemTypegetItemType(TypeHierarchy th)
Get the item type of the value returned by this instruction
intgetNameCode(XPathContext context)
Callback from the superclass ElementCreator to get the nameCode for the element name
ExpressiongetNameExpression()
Get the expression used to compute the element name
ExpressiongetNamespaceExpression()
Get the expression used to compute the namespace URI
NamespaceResolvergetNamespaceResolver()
Get the namespace resolver that provides the namespace bindings defined in the static context
StringgetNewBaseURI(XPathContext context)
Iterator<Expression>iterateSubExpressions()
Expressionoptimize(ExpressionVisitor visitor, ItemType contextItemType)
protected voidoutputNamespaceNodes(XPathContext context, Receiver out, int nameCode)
Callback to output namespace nodes for the new element.
protected voidpromoteInst(PromotionOffer offer)
Offer promotion for subexpressions.
booleanreplaceSubExpression(Expression original, Expression replacement)
Replace one subexpression by a replacement subexpression
Expressionsimplify(ExpressionVisitor visitor)
ExpressiontypeCheck(ExpressionVisitor visitor, ItemType contextItemType)

Constructor Detail

ComputedElement

public ComputedElement(Expression elementName, Expression namespace, NamespaceResolver nsContext, SchemaType schemaType, int validation, boolean inheritNamespaces, boolean allowQName)
Create an instruction that creates a new element node

Parameters: elementName Expression that evaluates to produce the name of the element node as a lexical QName namespace Expression that evaluates to produce the namespace URI of the element node. Set to null if the namespace is to be deduced from the prefix of the elementName. nsContext Saved copy of the static namespace context for the instruction. Can be set to null if namespace is supplied. This namespace context must resolve the null prefix correctly, based on the different rules for XSLT and XQuery. //* @param defaultNamespace Default namespace to be used if no namespace is supplied and the //* computed element is a string with no prefix. validation Required validation mode (e.g. STRICT, LAX, SKIP) inheritNamespaces true if child elements automatically inherit the namespaces of their parent schemaType The required schema type for the content allowQName True if the elementName expression is allowed to return a QNameValue; false if it must return a string (that is, true in XQuery, false in XSLT).

Method Detail

checkPermittedContents

public void checkPermittedContents(SchemaType parentType, StaticContext env, boolean whole)
Check that any elements and attributes constructed or returned by this expression are acceptable in the content model of a given complex type. It's always OK to say yes, since the check will be repeated at run-time. The process of checking element and attribute constructors against the content model of a complex type also registers the type of content expected of those constructors, so the static validation can continue recursively.

copy

public Expression copy()
Copy an expression. This makes a deep copy.

Returns: the copy of the original expression

explain

public void explain(ExpressionPresenter out)
Diagnostic print of expression structure. The abstract expression tree is written to the supplied output destination.

getInstructionNameCode

public int getInstructionNameCode()
Get the name of this instruction for diagnostic and tracing purposes

getItemType

public ItemType getItemType(TypeHierarchy th)
Get the item type of the value returned by this instruction

Parameters: th the type hierarchy cache

Returns: the item type

getNameCode

public int getNameCode(XPathContext context)
Callback from the superclass ElementCreator to get the nameCode for the element name

Parameters: context The evaluation context (not used)

Returns: the name code for the element name

getNameExpression

public Expression getNameExpression()
Get the expression used to compute the element name

Returns: the expression used to compute the element name

getNamespaceExpression

public Expression getNamespaceExpression()
Get the expression used to compute the namespace URI

Returns: the expression used to compute the namespace URI

getNamespaceResolver

public NamespaceResolver getNamespaceResolver()
Get the namespace resolver that provides the namespace bindings defined in the static context

Returns: the namespace resolver

getNewBaseURI

public String getNewBaseURI(XPathContext context)

iterateSubExpressions

public Iterator<Expression> iterateSubExpressions()

optimize

public Expression optimize(ExpressionVisitor visitor, ItemType contextItemType)

outputNamespaceNodes

protected void outputNamespaceNodes(XPathContext context, Receiver out, int nameCode)
Callback to output namespace nodes for the new element.

Parameters: context The execution context out the Receiver where the namespace nodes are to be written nameCode

Throws: XPathException

promoteInst

protected void promoteInst(PromotionOffer offer)
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.

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: net.sf.saxon.trans.XPathException if any error is detected

replaceSubExpression

public boolean replaceSubExpression(Expression original, Expression replacement)
Replace one subexpression by a replacement subexpression

Parameters: original the original subexpression replacement the replacement subexpression

Returns: true if the original subexpression is found

simplify

public Expression simplify(ExpressionVisitor visitor)

typeCheck

public Expression typeCheck(ExpressionVisitor visitor, ItemType contextItemType)