Package net.sf.saxon.expr.instruct

Class ValueOf

java.lang.Object
net.sf.saxon.expr.Expression
net.sf.saxon.expr.instruct.Instruction
net.sf.saxon.expr.instruct.SimpleNodeConstructor
net.sf.saxon.expr.instruct.ValueOf
All Implemented Interfaces:
ExportAgent, 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 Details

    • 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 Details

    • setIsNumberingInstruction

      public void setIsNumberingInstruction()
      Indicate that this is really an xsl:number 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 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(BiConsumer<String,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

    • computeCardinality

      protected int computeCardinality()
      Description copied from class: SimpleNodeConstructor
      Get the cardinality of the sequence returned by evaluating this instruction
      Overrides:
      computeCardinality in class SimpleNodeConstructor
      Returns:
      the static cardinality

    • localTypeCheck

      public void localTypeCheck(ExpressionVisitor visitor, ContextItemStaticInfo contextItemType)
      Description copied from class: SimpleNodeConstructor
      Method to perform type-checking specific to the kind of instruction
      Specified by:
      localTypeCheck in class SimpleNodeConstructor
      Parameters:
      visitor - an expression visitor
      contextItemType - the static type of the context item

    • 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

    • processValue

      public void processValue(UnicodeString value, Outputter output, XPathContext context) throws XPathException
      Process the value of the node, to create the new node.
      Specified by:
      processValue in class SimpleNodeConstructor
      Parameters:
      value - the string value of the new node
      output - the destination for the result
      context - the dynamic evaluation context
      Throws:
      XPathException - if a dynamic error occurs

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

    • getElaborator

      public Elaborator getElaborator()
      Make an elaborator for this expression
      Overrides:
      getElaborator in class Expression
      Returns:
      a suitable elaborator