net.sf.saxon.instruct
public abstract class ParentNodeConstructor extends Instruction implements DivisibleInstruction
Field Summary | |
---|---|
protected Expression | content |
int | validation |
Constructor Summary | |
---|---|
ParentNodeConstructor()
Create a document or element node constructor instruction |
Method Summary | |
---|---|
PathMap.PathMapNodeSet | addToPathMap(PathMap pathMap, PathMap.PathMapNodeSet pathMapNodeSet)
Add a representation of this expression to a PathMap. |
protected abstract void | checkContentSequence(StaticContext env)
Check that the child instructions don't violate any obvious constraints for this kind of node |
int | computeCardinality()
Get the cardinality of the sequence returned by evaluating this instruction |
boolean | createsNewNodes()
Determine whether this instruction creates new nodes.
|
String | getBaseURI()
Get the static base URI of the instruction |
int | getCardinality() |
Expression | getContentExpression()
Get the expression that constructs the content of the element |
SchemaType | getSchemaType()
Get the schema type chosen for validation; null if not defined |
int | getValidationMode()
Get the validation mode for this instruction |
boolean | isLazyConstruction()
Establish whether lazy construction is to be used |
boolean | isNamespaceSensitive()
Determine whether the schema type is namespace sensitive. |
Iterator<Expression> | iterateSubExpressions()
Get the immediate sub-expressions of this expression. |
Expression | optimize(ExpressionVisitor visitor, ItemType contextItemType) |
protected void | promoteInst(PromotionOffer offer)
Handle promotion offers, that is, non-local tree rewrites. |
boolean | replaceSubExpression(Expression original, Expression replacement)
Replace one subexpression by a replacement subexpression |
void | setBaseURI(String uri)
Set the static base URI of the instruction |
void | setContentExpression(Expression content)
Set the expression that constructs the content of the element |
void | setLazyConstruction(boolean lazy)
Indicate that lazy construction should (or should not) be used. |
void | setSchemaType(SchemaType type)
Set the schema type to be used for validation |
void | setValidationMode(int mode)
Set the validation mode for the new document or element node |
Expression | simplify(ExpressionVisitor visitor)
Simplify an expression. |
Expression | typeCheck(ExpressionVisitor visitor, ItemType contextItemType) |
void | verifyLazyConstruction()
Check that lazy construction is possible for this element |
The default implementation of this method assumes that an expression does no navigation other than the navigation done by evaluating its subexpressions, and that the subexpressions are evaluated in the same context as the containing expression. The method must be overridden for any expression where these assumptions do not hold. For example, implementations exist for AxisExpression, ParentExpression, and RootExpression (because they perform navigation), and for the doc(), document(), and collection() functions because they create a new navigation root. Implementations also exist for PathExpression and FilterExpression because they have subexpressions that are evaluated in a different context from the calling expression.
Parameters: pathMap the PathMap to which the expression should be added pathMapNodeSet the PathMapNodeSet to which the paths embodied in this expression should be added
Returns: the pathMapNodeSet representing the points in the source document that are both reachable by this expression, and that represent possible results of this expression. For an expression that does navigation, it represents the end of the arc in the path map that describes the navigation route. For other expressions, it is the same as the input pathMapNode.
Parameters: env the static context
Throws: XPathException
Returns: the static cardinality
Returns: the static base URI
Returns: the content expression
Returns: the type to be used for validation. (For a document constructor, this is the required type of the document element)
Returns: the validation mode, for example STRICT or PRESERVE
Returns: true if lazy construction is to be used
Returns: true if the schema type is namespace sensitive
Returns: an iterator containing the sub-expressions of this expression
Parameters: offer The type of rewrite being offered
Throws: net.sf.saxon.trans.XPathException
Parameters: original the original subexpression replacement the replacement subexpression
Returns: true if the original subexpression is found
Parameters: uri the static base URI
Parameters: content the content expression
Parameters: lazy set to true if lazy construction should be used
Parameters: type the type to be used for validation. (For a document constructor, this is the required type of the document element)
Parameters: mode the validation mode, for example STRICT
Parameters: visitor an expression visitor
Returns: the simplified expression
Throws: net.sf.saxon.trans.XPathException if an error is discovered during expression rewriting