Package net.sf.saxon.expr.instruct

Class ValueOf

  • All Implemented Interfaces:
    ExportAgent, TailCallReturner, Locatable, IdentityComparable, Traceable
    public final class ValueOf
extends SimpleNodeConstructor
    An xsl:value-of element in the stylesheet.
    The xsl:value-of element takes attributes:
    • a mandatory attribute select="expression". This must be a valid String expression
    • an optional disable-output-escaping attribute, value "yes" or "no"
    • an optional separator attribute. This is handled at compile-time: if the separator attribute is present, the select expression passed in here will be a call to the string-join() function.

    • Constructor Detail

      • ValueOf

        public ValueOf​(Expression select,
               boolean disable,
               boolean noNodeIfEmpty)
        Create a new ValueOf expression
        Parameters:
        select - the select expression
        disable - true if disable-output-escaping is in force
        noNodeIfEmpty - true if the instruction is to return () if the select expression is (), false if it is to return an empty text node

    • Method Detail

      • setIsNumberingInstruction

        public void setIsNumberingInstruction()
        Indicate that this is really an xsl:nunber instruction

      • isNumberingInstruction

        public boolean isNumberingInstruction()
        Determine whether this is really an xsl:number instruction
        Returns:
        true if this derives from xsl:number

      • isNoNodeIfEmpty

        public boolean isNoNodeIfEmpty()

      • toShortString

        public java.lang.String toShortString()
        Description copied from class: Expression
        Produce a short string identifying the expression for use in error messages
        Overrides:
        toShortString in class Expression
        Returns:
        a short string, sufficient to identify the expression

      • gatherProperties

        public void gatherProperties​(java.util.function.BiConsumer<java.lang.String,​java.lang.Object> consumer)
        Get the properties of this object to be included in trace messages, by supplying the property values to a supplied consumer function
        Parameters:
        consumer - the function to which the properties should be supplied, as (property name, value) pairs.

      • getInstructionNameCode

        public int getInstructionNameCode()
        Get the name of this instruction for diagnostic and tracing purposes
        Overrides:
        getInstructionNameCode in class Instruction
        Returns:
        the namecode of the instruction name

      • getOptions

        public int getOptions()
        Test for any special options such as disable-output-escaping
        Returns:
        any special options

      • isDisableOutputEscaping

        public boolean isDisableOutputEscaping()
        Test whether disable-output-escaping was requested
        Returns:
        true if disable-output-escaping was requested

      • getItemType

        public ItemType getItemType()
        Description copied from class: Instruction
        Get the item type of the items returned by evaluating this instruction
        Overrides:
        getItemType in class Instruction
        Returns:
        the static item type of the instruction

      • getIntrinsicDependencies

        public int getIntrinsicDependencies()
        Determine the intrinsic dependencies of an expression, that is, those which are not derived from the dependencies of its subexpressions. For example, position() has an intrinsic dependency on the context position, while (position()+1) does not. The default implementation of the method returns 0, indicating "no dependencies".
        Overrides:
        getIntrinsicDependencies in class Expression
        Returns:
        a set of bit-significant flags identifying the "intrinsic" dependencies. The flags are documented in class net.sf.saxon.value.StaticProperty

      • copy

        public Expression copy​(RebindingMap rebindings)
        Copy an expression. This makes a deep copy.
        Specified by:
        copy in class Expression
        Parameters:
        rebindings - variables that need to be re-bound
        Returns:
        the copy of the original expression

      • checkPermittedContents

        public void checkPermittedContents​(SchemaType parentType,
                                   boolean whole)
                            throws XPathException
        Check statically that the results of the expression are capable of constructing the content of a given schema type.
        Overrides:
        checkPermittedContents in class Expression
        Parameters:
        parentType - The schema type
        whole - true if this expression is to account for the whole value of the type
        Throws:
        XPathException - if the expression doesn't match the required content type

      • convertToCastAsString

        public Expression convertToCastAsString()
        Convert this value-of instruction to an expression that delivers the string-value of the resulting text node as an untyped atomic value.
        Returns:
        the converted expression

      • evaluateItem

        public NodeInfo evaluateItem​(XPathContext context)
                      throws XPathException
        Evaluate this expression, returning the resulting text node to the caller
        Overrides:
        evaluateItem in class SimpleNodeConstructor
        Parameters:
        context - the dynamic evaluation context
        Returns:
        the parentless text node that results from evaluating this instruction, or null to represent an empty sequence
        Throws:
        XPathException - if a dynamic error occurs

      • export

        public void export​(ExpressionPresenter out)
            throws XPathException
        Diagnostic print of expression structure. The abstract expression tree is written to the supplied output destination.
        Specified by:
        export in interface ExportAgent
        Specified by:
        export in class Expression
        Parameters:
        out - the expression presenter used to display the structure
        Throws:
        XPathException - if the export fails, for example if an expression is found that won't work in the target environment.