## net.sf.saxon.instruct
Class ValueOf

    java.lang.Object
      net.sf.saxon.expr.Expression
          net.sf.saxon.instruct.Instruction
              net.sf.saxon.instruct.SimpleNodeConstructor
                  net.sf.saxon.instruct.ValueOf

All Implemented Interfaces:
  java.io.Serializable, javax.xml.transform.SourceLocator, LocationProvider, SaxonLocator, EvaluableItem, SequenceIterable, TailCallReturner, InstructionInfo, org.xml.sax.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.instruct.SimpleNodeConstructor
`select`

Fields inherited from class net.sf.saxon.expr.Expression
`EVALUATE_METHOD, ITERATE_METHOD, locationId, PROCESS_METHOD, staticProperties`

Constructor Summary
`ValueOf(Expression select, boolean disable, boolean noNodeIfEmpty)` Create a new ValueOf expression

Method Summary
`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` `convertToStringJoin(StaticContext env)` Convert this value-of instruction to an expression that delivers the string-value of the resulting text node.
`Expression` `copy()` Copy an expression.
`Item` `evaluateItem(XPathContext context)` Evaluate this expression, returning the resulting text node to the caller
`void` `explain(ExpressionPresenter out)` Diagnostic print of expression structure.
`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` `isNumberingInstruction()` Determine whether this is really an xsl:number instruction
`void` `localTypeCheck(ExpressionVisitor visitor, ItemType contextItemType)` Method to perform type-checking specific to the kind of instruction
`TailCall` `processLeavingTail(XPathContext context)` Process this instruction, sending the resulting text node to the current output destination
`protected void` `promoteInst(PromotionOffer offer)` Offer promotion for subexpressions.
`void` `setIsNumberingInstruction()` Indicate that this is really an xsl:nunber instruction

Methods inherited from class net.sf.saxon.instruct.SimpleNodeConstructor
`checkContent, computeSpecialProperties, createsNewNodes, evaluateNameCode, expandChildren, getSelect, iterate, iterateSubExpressions, optimize, replaceSubExpression, setSelect, simplify, typeCheck`

Methods inherited from class net.sf.saxon.instruct.Instruction
`assembleParams, assembleTunnelParams, dynamicError, evaluateAsString, getConstructType, getImplementationMethod, getSourceLocator, isXSLT, process, promote`

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

`addToPathMap, adoptChildExpression, checkForUpdatingSubexpressions, computeDependencies, computeStaticProperties, display, doPromotion, dynamicError, effectiveBooleanValue, evaluatePendingUpdates, explain, findParentOf, getCardinality, getColumnNumber, getColumnNumber, getContainer, getDependencies, getExecutable, getHostLanguage, getIntrinsicDependencies, getLineNumber, getLineNumber, getLocationId, getLocationProvider, getObjectName, getProperties, getProperty, getPublicId, getSlotsUsed, getSpecialProperties, getSystemId, getSystemId, hasLoopingSubexpression, implementsStaticTypeCheck, isUpdatingExpression, iterateEvents, markTailFunctionCalls, resetLocalStaticProperties, setContainer, setFiltered, setFlattened, setLocationId, staticTypeCheck, suppressValidation, 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

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

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

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

### convertToStringJoin

    public Expression convertToStringJoin(StaticContext env)

  Convert this value-of instruction to an expression that delivers the string-value of the resulting text node. This will often be a call on the string-join function.

  Parameters:
    `env` - the static evaluation context
  Returns:
    the converted expression

### processLeavingTail

    public TailCall processLeavingTail(XPathContext context)
                                throws XPathException

  Process this instruction, sending the resulting text node to the current output destination

  Specified by:
    `processLeavingTail` in interface `TailCallReturner`
  Specified by:
    `processLeavingTail` in class `Instruction`
  Parameters:
    `context` - the dynamic evaluation context
  Returns:
    Always returns null
  Throws:
    `XPathException`

### evaluateItem

    public Item evaluateItem(XPathContext context)
                      throws XPathException

  Evaluate this expression, returning the resulting text node to the caller

  Specified by:
    `evaluateItem` in interface `EvaluableItem`
  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`

### 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) Saxonica Limited. All rights reserved.