## net.sf.saxon.value
Class SequenceExtent

    java.lang.Object
      |
      +--net.sf.saxon.value.Value
            |
            +--net.sf.saxon.value.SequenceValue
                  |
                  +--net.sf.saxon.value.SequenceExtent

All Implemented Interfaces:
  Expression, java.io.Serializable

public final class SequenceExtent
extends SequenceValue

A sequence value implemented extensionally. That is, this class represents a sequence by allocating memory to each item in the sequence.

See Also:
  Serialized Form

Field Summary

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

Constructor Summary
`SequenceExtent(Item[] items)` Construct an sequence from an array of items.
`SequenceExtent(java.util.List list)` Construct a SequenceExtent from a List.
`SequenceExtent(SequenceExtent ext, int start, int length)` Construct a SequenceExtent as a view of another SequenceExtent
`SequenceExtent(SequenceIterator iter)` Construct a sequence containing all the items in a SequenceIterator.

Method Summary
`boolean` `effectiveBooleanValue(XPathContext context)` Get the effective boolean value
`int` `getCardinality()` Determine the cardinality
`ItemType` `getItemType()` Get the (lowest common) item type
`int` `getLength()` Get the number of items in the sequence
`Item` `itemAt(int n)` Get the n'th item in the sequence (starting with 0 as the first item)
`SequenceIterator` `iterate(XPathContext context)` Return an iterator over this sequence.
`SequenceExtent` `materialize()` Materialize the SequenceValue as a SequenceExtent
`AxisIterator` `reverseIterate()` Return an enumeration of this sequence in reverse order (used for reverse axes)
`void` `swap(int a, int b)` Swap two items (needed to support sorting)

Methods inherited from class net.sf.saxon.value.SequenceValue
`convertToJava, display, equals, evaluateAsString, evaluateItem, getImplementationMethod, getStringValue, hashCode, process`

Methods inherited from class net.sf.saxon.value.Value
`analyze, asItem, asValue, collapseWhitespace, convertJavaObjectToXPath, getDependencies, getParentExpression, getSpecialProperties, inverse, iterateSubExpressions, normalizeWhitespace, promote, simplify, stringToNumber, toString, trimWhitespace`

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

Constructor Detail

### SequenceExtent

    public SequenceExtent(Item[] items)

  Construct an sequence from an array of items. Note, the array of items is used as is, which means the caller must not subsequently change its contents.

Parameters:
  `items` - the array of items to be included in the sequence

### SequenceExtent

    public SequenceExtent(SequenceExtent ext,
                          int start,
                          int length)

  Construct a SequenceExtent as a view of another SequenceExtent

Parameters:
  `ext` - The existing SequenceExtent
  `start` - zero-based offset of the first item in the existing SequenceExtent that is to be included in the new SequenceExtent
  `length` - The number of items in the new SequenceExtent

### SequenceExtent

    public SequenceExtent(java.util.List list)

  Construct a SequenceExtent from a List. The members of the list must all be Items

Parameters:
  `list` - the list of items to be included in the sequence

### SequenceExtent

    public SequenceExtent(SequenceIterator iter)
                   throws XPathException

  Construct a sequence containing all the items in a SequenceIterator.

Parameters:
  `iter` - The supplied sequence of items. This must be positioned at the start, so that hasNext() returns true if there are any nodes in the node-set, and next() returns the first node.
Throws:
  `XPathException` - if reading the items using the SequenceIterator raises an error

Method Detail

### materialize

    public SequenceExtent materialize()
                               throws XPathException

  Materialize the SequenceValue as a SequenceExtent

  Overrides:
    `materialize` in class `SequenceValue`
    `XPathException`

### getLength

    public int getLength()

  Get the number of items in the sequence

  Returns:
    the number of items in the sequence

### getCardinality

    public int getCardinality()

  Determine the cardinality

  Specified by:
    `getCardinality` in interface `Expression`
  Overrides:
    `getCardinality` in class `SequenceValue`
  Returns:
    the cardinality of the sequence, using the constants defined in net.sf.saxon.value.Cardinality
  See Also:
    `Cardinality`

### getItemType

    public ItemType getItemType()

  Get the (lowest common) item type

  Specified by:
    `getItemType` in interface `Expression`
  Overrides:
    `getItemType` in class `SequenceValue`
  Returns:
    integer identifying an item type to which all the items in this sequence conform

### itemAt

    public Item itemAt(int n)

  Get the n'th item in the sequence (starting with 0 as the first item)

  Overrides:
    `itemAt` in class `SequenceValue`
  Parameters:
    `n` - the position of the required item
  Returns:
    the n'th item in the sequence

### swap

    public void swap(int a,
                     int b)

  Swap two items (needed to support sorting)

  Parameters:
    `a` - the position of the first item to be swapped
    `b` - the position of the second item to be swapped

### iterate

    public SequenceIterator iterate(XPathContext context)

  Return an iterator over this sequence.

  Parameters:
    `context` - dynamic evaluation context; not used in this implementation of the method
  Returns:
    the required SequenceIterator, positioned at the start of the sequence

### reverseIterate

    public AxisIterator reverseIterate()

  Return an enumeration of this sequence in reverse order (used for reverse axes)

  Returns:
    an AxisIterator that processes the items in reverse order

### effectiveBooleanValue

    public boolean effectiveBooleanValue(XPathContext context)

  Get the effective boolean value

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