## 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, EvaluableItem, TailCallReturner, SequenceIterable, 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
`EVALUATE_METHOD, EVENT_FEED_METHOD, ITEM_FEED_METHOD, ITERATE_METHOD, locationId, PROCESS_METHOD, PUSH_SELECTION, staticProperties, WATCH_METHOD`

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` `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.
`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
`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, evaluateNameCode, getContentExpression, iterate, 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, getIntrinsicDependencies, getLineNumber, getLineNumber, getLocationId, getLocationProvider, getObjectName, getProperties, getProperty, getPublicId, getSlotsUsed, getSpecialProperties, getSystemId, getSystemId, hasLoopingSubexpression, implementsStaticTypeCheck, isSubtreeExpression, isUpdatingExpression, isVacuousExpression, iterateEvents, iterateSameFocusSubExpressions, markTailFunctionCalls, resetLocalStaticProperties, setContainer, setEvaluationMethod, 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

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

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

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