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:
    Serializable, SourceLocator, LocationProvider, SaxonLocator, TailCallReturner, InstructionInfo, Locator

      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.
  See Also:
    Serialized Form

- - ### Field Summary

    - ### Fields inherited from class net.sf.saxon.expr.instruct.SimpleNodeConstructor

      `select`

    - ### Fields inherited from class net.sf.saxon.expr.Expression

      `EFFECTIVE_BOOLEAN_VALUE, EVALUATE_METHOD, EVENT_FEED_METHOD, INHERITED_CONTEXT, INSPECTION_CONTEXT, ITEM_FEED_METHOD, ITERATE_METHOD, locationId, MAX_SEQUENCE_LENGTH, MAX_STRING_LENGTH, NAVIGATION_CONTEXT, NODE_VALUE_CONTEXT, PROCESS_METHOD, PUSH_SELECTION, staticProperties, UNBOUNDED_LOWER, UNBOUNDED_UPPER, W3C_CONSUMING, W3C_FREE_RANGING, W3C_GROUP_CONSUMING, W3C_MOTIONLESS, WATCH_METHOD`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ValueOf(Expression select, boolean disable, boolean noNodeIfEmpty)` Create a new ValueOf expression

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `checkPermittedContents(SchemaType parentType, StaticContext env, boolean whole)` Check statically that the results of the expression are capable of constructing the content of a given schema type.
    `int` | `computeCardinality()` Get the cardinality of the sequence returned by evaluating this instruction
    `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.
    `Expression` | `copy()` Copy an expression.
    `NodeInfo` | `evaluateItem(XPathContext context)` Evaluate this expression, returning the resulting text node to the caller
    `void` | `explain(ExpressionPresenter out)` Diagnostic print of expression structure.
    `ExpressionCompiler` | `getExpressionCompiler()` Return the compiler of the ValueOf expression
    `int` | `getInstructionNameCode()` Get the name of this instruction for diagnostic and tracing purposes
    `ItemType` | `getItemType(TypeHierarchy th)` Get the item type of the items returned by evaluating this instruction
    `int` | `getOptions()` Test for any special options such as disable-output-escaping
    `boolean` | `isDisableOutputEscaping()` Test whether disable-output-escaping was requested
    `boolean` | `isNoNodeIfEmpty()`
    `boolean` | `isNumberingInstruction()` Determine whether this is really an xsl:number instruction
    `void` | `localTypeCheck(ExpressionVisitor visitor, ExpressionVisitor.ContextItemType contextItemType)` Method to perform type-checking specific to the kind of instruction
    `TailCall` | `processLeavingTail(XPathContext context)` Process this instruction
    `void` | `processValue(CharSequence value, XPathContext context)` Process the value of the node, to create the new node.
    `void` | `setIsNumberingInstruction()` Indicate that this is really an xsl:nunber instruction

    - ### Methods inherited from class net.sf.saxon.expr.instruct.SimpleNodeConstructor

      `checkContent, computeSpecialProperties, createsNewNodes, evaluateNodeName, getContentExpression, getStreamingAdjunct, iterate, iterateSubExpressionInfo, iterateSubExpressions, optimize, promoteInst, replaceSubExpression, setSelect, simplify, typeCheck`

    - ### Methods inherited from class net.sf.saxon.expr.instruct.Instruction

      `assembleParams, assembleTunnelParams, dynamicError, evaluateAsString, getConstructType, getExpressionName, getImplementationMethod, getInstructionName, getIteratorFromProcessMethod, getSourceLocator, isXSLT, process, promote`

    - ### Methods inherited from class net.sf.saxon.expr.Expression

      `addToPathMap, adoptChildExpression, checkForUpdatingSubexpressions, computeDependencies, computeStaticProperties, doPromotion, dynamicError, effectiveBooleanValue, evaluatePendingUpdates, explain, getCardinality, getColumnNumber, getColumnNumber, getContainer, getDependencies, getEvaluationMethod, getExecutable, getHostLanguage, getIntegerBounds, getIntrinsicDependencies, getLineNumber, getLineNumber, getLocationId, getLocationProvider, getObjectName, getProperties, getProperty, getPublicId, getSlotsUsed, getSpecialProperties, getStreamability, getSystemId, getSystemId, hasVariableBinding, implementsStaticTypeCheck, isSubtreeExpression, isUpdatingExpression, isVacuousExpression, iterateEvents, markTailFunctionCalls, resetLocalStaticProperties, setContainer, setEvaluationMethod, setFiltered, setFlattened, setLocationId, staticTypeCheck, suppressValidation, toPattern, toStreamingPattern, toString, typeError`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface javax.xml.transform.SourceLocator

      `getColumnNumber, getLineNumber, getPublicId, getSystemId`

- - ### 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()

    - #### 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(TypeHierarchy th)

      Description copied from class: `Instruction`
      Get the item type of the items returned by evaluating this instruction
      Overrides:
        `getItemType` in class `Instruction`
      Parameters:
        `th` - the type hierarchy cache
      Returns:
        the static item type of the instruction

    - #### computeCardinality

          public 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,
                            ExpressionVisitor.ContextItemType 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

    - #### 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

    - #### checkPermittedContents

          public void checkPermittedContents(SchemaType parentType,
                                    StaticContext env,
                                    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
        `env` - the static context
        `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

    - #### processLeavingTail

          public TailCall processLeavingTail(XPathContext context)
                                      throws XPathException

      Process this instruction
      Specified by:
        `processLeavingTail` in interface `TailCallReturner`
      Overrides:
        `processLeavingTail` in class `SimpleNodeConstructor`
      Parameters:
        `context` - the dynamic context of the transformation
      Returns:
        a TailCall to be executed by the caller, always null for this instruction
      Throws:
        `XPathException` - if a dynamic error occurs during the evaluation of the instruction

    - #### processValue

          public void processValue(CharSequence value,
                          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
        `context` - the dynamic evaluation context
      Throws:
        `XPathException`

    - #### 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`

    - #### getExpressionCompiler

          public ExpressionCompiler getExpressionCompiler()

      Return the compiler of the ValueOf expression
      Overrides:
        `getExpressionCompiler` in class `Expression`
      Returns:
        the relevant ExpressionCompiler

    - #### 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

Copyright (c) 2004-2013 Saxonica Limited. All rights reserved.