## net.sf.saxon.value
Class SingletonNode

    java.lang.Object
      net.sf.saxon.value.Value
          net.sf.saxon.value.SingletonNode

All Implemented Interfaces:
  Expression, java.io.Serializable, ValueRepresentation

public class SingletonNode
extends Value

A value that is a sequence containing zero or one nodes

See Also:
  Serialized Form

Field Summary
`protected NodeInfo` `node`

Fields inherited from interface net.sf.saxon.expr.Expression
`EVALUATE_METHOD, ITERATE_METHOD, PROCESS_METHOD`

Constructor Summary
`SingletonNode(NodeInfo node)` Create a node-set containing zero or one nodes

Method Summary
`java.lang.Object` `convertToJava(java.lang.Class target, XPathContext context)` Convert to Java object (for passing to external functions)
`void` `display(int depth, NamePool pool, java.io.PrintStream out)` Diagnostic display
`boolean` `effectiveBooleanValue(XPathContext context)` Get the effective boolean value
`java.lang.String` `evaluateAsString(XPathContext context)` Evaluate an expression as a String.
`Item` `evaluateItem(XPathContext context)` Evaluate as an item
`int` `getCardinality()` Determine the static cardinality
`int` `getImplementationMethod()` An implementation of Expression must provide at least one of the methods evaluateItem(), iterate(), or process().
`ItemType` `getItemType()` Determine the data type of the items in the expression
`int` `getLength()` Get the length of the sequence
`NodeInfo` `getNode()` Get the node that forms the node-set.
`int` `getSpecialProperties()` Get the static properties of this expression (other than its type).
`java.lang.String` `getStringValue()` Convert the value to a string, using the serialization rules.
`Item` `itemAt(int n)` Get the n'th item in the sequence (starting from 0).
`SequenceIterator` `iterate(XPathContext context)` Return an enumeration of this nodeset value.
`void` `process(XPathContext context)` Process the instruction, without returning any tail calls

Methods inherited from class net.sf.saxon.value.Value
`analyze, asItem, asValue, checkPermittedContents, collapseWhitespace, convert, convertJavaObjectToXPath, equals, getDependencies, getIterator, getParentExpression, hashCode, iterateSubExpressions, makeQNameValue, normalizeWhitespace, promote, simplify, stringToNumber, toString, trimWhitespace`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Field Detail

### node

    protected NodeInfo node

Constructor Detail

### SingletonNode

    public SingletonNode(NodeInfo node)

  Create a node-set containing zero or one nodes

Parameters:
  `node` - The node to be contained in the node-set, or null if the node-set is to be empty

Method Detail

### getImplementationMethod

    public int getImplementationMethod()

  An implementation of Expression must provide at least one of the methods evaluateItem(), iterate(), or process(). This method indicates which of these methods is prefered.

### process

    public void process(XPathContext context)
                 throws XPathException

  Process the instruction, without returning any tail calls

  Specified by:
    `process` in interface `Expression`
  Overrides:
    `process` in class `Value`
  Parameters:
    `context` - The dynamic context, giving access to the current node, the current variables, etc.
  Throws:
    `XPathException`

### getItemType

    public ItemType getItemType()

  Determine the data type of the items in the expression

  Specified by:
    `getItemType` in interface `Expression`
  Overrides:
    `getItemType` in class `Value`
  Returns:
    Type.NODE

### getCardinality

    public int getCardinality()

  Determine the static cardinality

  Specified by:
    `getCardinality` in interface `Expression`
  Overrides:
    `getCardinality` in class `Value`

### getLength

    public int getLength()
                  throws XPathException

  Get the length of the sequence

  Overrides:
    `getLength` in class `Value`
  Throws:
    `XPathException`

### itemAt

    public Item itemAt(int n)
                throws XPathException

  Get the n'th item in the sequence (starting from 0). This is defined for all SequenceValues, but its real benefits come for a SequenceValue stored extensionally (or for a MemoClosure, once all the values have been read)

  Overrides:
    `itemAt` in class `Value`
  Throws:
    `XPathException`

### getNode

    public NodeInfo getNode()

  Get the node that forms the node-set. Return null if there is none.

### getSpecialProperties

    public int getSpecialProperties()

  Get the static properties of this expression (other than its type). The result is bit-signficant. These properties are used for optimizations. In general, if property bit is set, it is true, but if it is unset, the value is unknown.

  Specified by:
    `getSpecialProperties` in interface `Expression`
  Overrides:
    `getSpecialProperties` in class `Value`
  Returns:
    `StaticProperty.NON_CREATIVE`

### iterate

    public SequenceIterator iterate(XPathContext context)

  Return an enumeration of this nodeset value.

  Parameters:
    `context` - supplies the context for evaluation
  Returns:
    a SequenceIterator that can be used to iterate over the result of the expression

### evaluateItem

    public Item evaluateItem(XPathContext context)

  Evaluate as an item

  Specified by:
    `evaluateItem` in interface `Expression`
  Overrides:
    `evaluateItem` in class `Value`

### effectiveBooleanValue

    public boolean effectiveBooleanValue(XPathContext context)

  Get the effective boolean value

  Specified by:
    `effectiveBooleanValue` in interface `Expression`
  Overrides:
    `effectiveBooleanValue` in class `Value`
  Parameters:
    `context` - The context in which the expression is to be evaluated
  Returns:
    the effective boolean value

### getStringValue

    public java.lang.String getStringValue()

  Convert the value to a string, using the serialization rules. For atomic values this is the same as a cast; for sequence values it gives a space-separated list. For QNames and NOTATIONS, or lists containing them, it fails.

  Overrides:
    `getStringValue` in class `Value`

### evaluateAsString

    public java.lang.String evaluateAsString(XPathContext context)
                                      throws XPathException

  Evaluate an expression as a String. This function must only be called in contexts where it is known that the expression will return a single string (or where an empty sequence is to be treated as a zero-length string). Implementations should not attempt to convert the result to a string, other than converting () to "". This method is used mainly to evaluate expressions produced by compiling an attribute value template.

  Specified by:
    `evaluateAsString` in interface `Expression`
  Overrides:
    `evaluateAsString` in class `Value`
  Parameters:
    `context` - The context in which the expression is to be evaluated
  Returns:
    the value of the expression, evaluated in the current context. The expression must return a string or (); if the value of the expression is (), this method returns "".
  Throws:
    `XPathException` - if any dynamic error occurs evaluating the expression

### display

    public void display(int depth,
                        NamePool pool,
                        java.io.PrintStream out)

  Diagnostic display

  Specified by:
    `display` in interface `Expression`
  Overrides:
    `display` in class `Value`

### convertToJava

    public java.lang.Object convertToJava(java.lang.Class target,
                                          XPathContext context)
                                   throws XPathException

  Convert to Java object (for passing to external functions)

  Overrides:
    `convertToJava` in class `Value`
  Throws:
    `XPathException`