Class ComputedAttribute

    • Constructor Detail

      • ComputedAttribute

        public ComputedAttribute​(Expression attributeName,
                                 Expression namespace,
                                 NamespaceResolver nsContext,
                                 int validationAction,
                                 SimpleType schemaType,
                                 int annotation,
                                 boolean allowNameAsQName)
        Construct an Attribute instruction
        Parameters:
        attributeName - An expression to calculate the attribute name
        namespace - An expression to calculate the attribute namespace
        nsContext - a NamespaceContext object containing the static namespace context of the stylesheet instruction
        validationAction - e.g. validation=strict, lax, strip, preserve
        schemaType - Type against which the attribute must be validated. This must not be a namespace-sensitive type; it is the caller's responsibility to check this.
        annotation - Integer code identifying the type named in the type attribute
        allowNameAsQName - true if the attributeName expression is allowed to evaluate to a value of type xs:QName (true in XQuery, false in XSLT)
    • Method Detail

      • setRejectDuplicates

        public void setRejectDuplicates()
        Indicate that two attributes with the same name are not acceptable. (This option is set in XQuery, but not in XSLT)
        Overrides:
        setRejectDuplicates in class AttributeCreator
      • getInstructionNameCode

        public int getInstructionNameCode()
        Get the name of this instruction
        Overrides:
        getInstructionNameCode in class Instruction
        Returns:
        a code identifying the instruction: typically but not always the fingerprint of a name in the XSLT namespace
      • getNameExpression

        public Expression getNameExpression()
        Get the expression used to compute the name of the attribute
        Returns:
        the expression used to compute the name of the attribute
      • getNamespaceExpression

        public Expression getNamespaceExpression()
        Get the expression used to compute the namespace part of the name of the attribute
        Returns:
        the expression used to compute the namespace part of the name of the attribute
      • getNamespaceResolver

        public NamespaceResolver getNamespaceResolver()
        Get the namespace resolver used to resolve any prefix in the name of the attribute
        Returns:
        the namespace resolver if one has been saved; or null otherwise
      • getItemType

        public ItemType getItemType​(TypeHierarchy th)
        Get the static type of this expression
        Overrides:
        getItemType in class Instruction
        Parameters:
        th - the type hierarchy cache
        Returns:
        the static type of the item returned by this expression
      • getCardinality

        public int getCardinality()
        Get the static cardinality of this expression
        Overrides:
        getCardinality in class Expression
        Returns:
        the static cardinality (exactly one)
      • 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 SimpleNodeConstructor
        Returns:
        a set of flags indicating static properties of this expression
      • simplify

        public Expression simplify​(ExpressionVisitor visitor)
                            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.
        Overrides:
        simplify in class SimpleNodeConstructor
        Parameters:
        visitor - an expression visitor
        Returns:
        the simplified expression
        Throws:
        XPathException - if an error is discovered during expression rewriting
      • optimize

        public Expression optimize​(ExpressionVisitor visitor,
                                   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 SimpleNodeConstructor
        Parameters:
        visitor - an expression visitor
        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 - if an error is discovered during this phase (typically a type error)
      • copy

        public Expression copy()
        Copy an expression. This makes a deep copy.
        Specified by:
        copy in class Expression
        Returns:
        the copy of the original expression
      • iterateSubExpressions

        public java.util.Iterator iterateSubExpressions()
        Get the subexpressions of this expression
        Overrides:
        iterateSubExpressions in class SimpleNodeConstructor
        Returns:
        an iterator over the subexpressions
      • replaceSubExpression

        public boolean replaceSubExpression​(Expression original,
                                            Expression replacement)
        Replace one subexpression by a replacement subexpression
        Overrides:
        replaceSubExpression in class SimpleNodeConstructor
        Parameters:
        original - the original subexpression
        replacement - the replacement subexpression
        Returns:
        true if the original subexpression is found
      • 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 SimpleNodeConstructor
        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
      • checkPermittedContents

        public void checkPermittedContents​(SchemaType parentType,
                                           StaticContext env,
                                           boolean whole)
                                    throws XPathException
        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.
        Overrides:
        checkPermittedContents in class Expression
        Parameters:
        parentType - the "given complex type": the method is checking that the nodes returned by this expression are acceptable members of the content model of this type
        env - the static context
        whole - if true, we want to check that the value of this expression satisfies the content model as a whole; if false we want to check that the value of the expression is acceptable as one part of the content
        Throws:
        XPathException - if the value delivered by this expression cannot be part of the content model of the given type
      • explain

        public void explain​(ExpressionPresenter out)
        Diagnostic print of expression structure. The abstract expression tree is written to the supplied output destination.
        Specified by:
        explain in class Expression
        Parameters:
        out - the expression presenter used to display the structure