Package net.sf.saxon.tree.iter

## Class ArrayIterator<T extends Item>

- java.lang.Object
- - net.sf.saxon.tree.iter.ArrayIterator<T>

- All Implemented Interfaces:
    `java.io.Closeable`, `java.lang.AutoCloseable`, `LastPositionFinder`, `SequenceIterator`, `GroundedIterator`, `LookaheadIterator`, `UnfailingIterator`
  Direct Known Subclasses:
    `ArrayIterator.OfNodes`

      public class ArrayIterator<T extends Item>
      extends java.lang.Object
      implements UnfailingIterator, LastPositionFinder, LookaheadIterator, GroundedIterator

  ArrayIterator is used to enumerate items held in an array. The items are always held in the correct sorted order for the sequence.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class | Description
    --- | --- | ---
    `static class` | `ArrayIterator.OfNodes` | ArrayIterator.OfNodes is a subclass of ArrayIterator where the array always contains Nodes; it therefore implements the AxisIterator interface.

    - ### Nested classes/interfaces inherited from interface net.sf.saxon.om.SequenceIterator

      `SequenceIterator.Property`

  - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `protected int` | `end` |
    `protected T[]` | `items` |
    `protected int` | `start` |

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `ArrayIterator​(T[] nodes)` | Create an iterator over all the items in an array
    `ArrayIterator​(T[] items, int start, int end)` | Create an iterator over a range of an array.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `T[]` | `getArray()` | Get the underlying array
    `int` | `getEndPosition()` | Get the end position in the array
    `int` | `getLength()` | Get the number of items in the part of the array being processed
    `java.util.EnumSet<SequenceIterator.Property>` | `getProperties()` | Get properties of this iterator, as a bit-significant integer.
    `GroundedValue` | `getResidue()` | Return a GroundedValue containing all the remaining items in the sequence returned by this SequenceIterator, starting at the current position.
    `int` | `getStartPosition()` | Get the initial start position
    `boolean` | `hasNext()` | Test whether there are any more items
    `SequenceIterator` | `makeSliceIterator​(int min, int max)` | Create a new ArrayIterator over the same items, with a different start point and end point
    `GroundedValue` | `materialize()` | Return a SequenceValue containing all the items in the sequence returned by this SequenceIterator
    `T` | `next()` | Get the next item in the array

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

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

    - ### Methods inherited from interface net.sf.saxon.om.SequenceIterator

      `close, forEachOrFail`

    - ### Methods inherited from interface net.sf.saxon.tree.iter.UnfailingIterator

      `forEach, toList`

- - ### Field Detail

    - #### items

          protected T extends Item[] items

    - #### start

          protected int start

    - #### end

          protected int end

  - ### Constructor Detail

    - #### ArrayIterator

          public ArrayIterator​(T[] nodes)

      Create an iterator over all the items in an array
      Parameters:
        `nodes` - the array (of any items, not necessarily nodes) to be processed by the iterator

    - #### ArrayIterator

          public ArrayIterator​(T[] items,
                               int start,
                               int end)

      Create an iterator over a range of an array. Note that the start position is zero-based
      Parameters:
        `items` - the array (of nodes or simple values) to be processed by the iterator
        `start` - the position of the first item to be processed (numbering from zero). Must be between zero and nodes.length-1; if not, undefined exceptions are likely to occur.
        `end` - position of first item that is NOT returned, zero-based. Must be beween 1 and nodes.length; if not, undefined exceptions are likely to occur.

  - ### Method Detail

    - #### makeSliceIterator

          public SequenceIterator makeSliceIterator​(int min,
                                                    int max)

      Create a new ArrayIterator over the same items, with a different start point and end point
      Parameters:
        `min` - the start position (1-based) of the new ArrayIterator relative to the original
        `max` - the end position (1-based) of the last item to be delivered by the new ArrayIterator, relative to the original. For example, min=2, max=3 delivers the two items ($base[2], $base[3]). Set this to Integer.MAX_VALUE if there is no end limit.
      Returns:
        an iterator over the items between the min and max positions

    - #### hasNext

          public boolean hasNext()

      Test whether there are any more items
      Specified by:
        `hasNext` in interface `LookaheadIterator`
      Returns:
        true if there are more items

    - #### next

          public T next()

      Get the next item in the array
      Specified by:
        `next` in interface `SequenceIterator`
      Specified by:
        `next` in interface `UnfailingIterator`
      Returns:
        the next item in the array

    - #### getLength

          public int getLength()

      Get the number of items in the part of the array being processed
      Specified by:
        `getLength` in interface `LastPositionFinder`
      Returns:
        the number of items; equivalently, the position of the last item

    - #### getArray

          public T[] getArray()

      Get the underlying array
      Returns:
        the underlying array being processed by the iterator

    - #### getStartPosition

          public int getStartPosition()

      Get the initial start position
      Returns:
        the start position of the iterator in the array (zero-based)

    - #### getEndPosition

          public int getEndPosition()

      Get the end position in the array
      Returns:
        the position in the array (zero-based) of the first item not included in the iteration

    - #### materialize

          public GroundedValue materialize()

      Return a SequenceValue containing all the items in the sequence returned by this SequenceIterator
      Specified by:
        `materialize` in interface `GroundedIterator`
      Specified by:
        `materialize` in interface `SequenceIterator`
      Returns:
        the corresponding SequenceValue

    - #### getResidue

          public GroundedValue getResidue()

      Description copied from interface: `GroundedIterator`
      Return a GroundedValue containing all the remaining items in the sequence returned by this SequenceIterator, starting at the current position. This should be an "in-memory" value, not a Closure. This method does not change the state of the iterator (in particular, it does not consume the iterator).
      Specified by:
        `getResidue` in interface `GroundedIterator`
      Returns:
        the corresponding Value

    - #### getProperties

          public java.util.EnumSet<SequenceIterator.Property> getProperties()

      Get properties of this iterator, as a bit-significant integer.
      Specified by:
        `getProperties` in interface `SequenceIterator`
      Returns:
        the properties of this iterator. This will be some combination of properties such as `SequenceIterator.Property.GROUNDED`, `SequenceIterator.Property.LAST_POSITION_FINDER`, and `SequenceIterator.Property.LOOKAHEAD`. It is always acceptable to return the value zero, indicating that there are no known special properties. It is acceptable for the properties of the iterator to change depending on its state.