java.lang.Object
- net.sf.saxon.expr.RangeIterator
- - net.sf.saxon.expr.AscendingRangeIterator

All Implemented Interfaces:

java.io.Closeable, java.lang.AutoCloseable, LastPositionFinder, SequenceIterator, AtomicIterator, GroundedIterator, LookaheadIterator, ReversibleIterator
```
public class AscendingRangeIterator
extends net.sf.saxon.expr.RangeIterator
implements AtomicIterator, ReversibleIterator, LastPositionFinder, LookaheadIterator, GroundedIterator
```
An Iterator that produces numeric values in a monotonic sequence, ascending or descending. Applying the reverse() function will produce a DescendinggRangeIterator.

Constructor Summary

Constructors
Constructor	Description
`AscendingRangeIterator(long start, long step, long end)`	Create an iterator over a range of monotonically increasing integers

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`IntegerValue`	`getFirst()`
`IntegerValue`	`getLast()`
`int`	`getLength()`	Get the last position (that is, the number of items in the sequence).
`IntegerValue`	`getMax()`
`IntegerValue`	`getMin()`
`GroundedValue`	`getResidue()`	Return a GroundedValue containing all the remaining items in the sequence returned by this SequenceIterator, starting at the current position.
`AtomicIterator`	`getReverseIterator()`	Get a new SequenceIterator that returns the same items in reverse order.
`IntegerValue`	`getStep()`	Get the increment between successive values.
`boolean`	`hasNext()`	Determine whether there are more items to come.
`boolean`	`isActuallyGrounded()`	Ask if the iterator is actually grounded.
`static AtomicIterator`	`makeLongRangeIterator(long start, long step, long end)`	Factory method for use from bytecode
`static AtomicIterator`	`makeRangeIterator(IntegerValue start, IntegerValue step, IntegerValue end)`
`GroundedValue`	`materialize()`	Return a Value containing all the items in the sequence returned by this SequenceIterator.
`IntegerValue`	`next()`	Get the next atomic value in the sequence.
`boolean`	`supportsGetLength()`	Ask whether this iterator supports use of the `LastPositionFinder.getLength()` method.
`boolean`	`supportsHasNext()`	Ask whether the hasNext() method can be called.

Methods inherited from class net.sf.saxon.expr.RangeIterator
getProperties, makeRangeIterator

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, discharge

- Constructor Detail
  - AscendingRangeIterator
```
public AscendingRangeIterator(long start,
                              long step,
                              long end)
```
    Create an iterator over a range of monotonically increasing integers
    
    Parameters:
    
    start - the first integer in the sequence
    
    step - the increment; must be GT 0
    
    end - the last integer in the sequence. Must be GE start.
- Method Detail
  - makeRangeIterator
```
public static AtomicIterator makeRangeIterator(IntegerValue start,
                                               IntegerValue step,
                                               IntegerValue end)
                                        throws XPathException
```
    Throws:
    
    XPathException
  - makeLongRangeIterator
```
public static AtomicIterator makeLongRangeIterator(long start,
                                                   long step,
                                                   long end)
                                            throws XPathException
```
    Factory method for use from bytecode
    
    Parameters:
    
    start - the first integer to return
    
    step - the interval between successive integers (positive or negative, not zero)
    
    end - stop the iteration when this value or one beyond it is reached
    
    Returns:
    
    an iterator over a range of integers
    
    Throws:
    
    XPathException - if, for example, implementation-defined limits are exceeded
  - getFirst
```
public IntegerValue getFirst()
```
  - getLast
```
public IntegerValue getLast()
```
  - getMin
```
public IntegerValue getMin()
```
  - getMax
```
public IntegerValue getMax()
```
  - getStep
```
public IntegerValue getStep()
```
    Get the increment between successive values. For a descending iterator this will be negatiive value.
    
    Returns:
    
    the increment between successive values
  - supportsHasNext
```
public boolean supportsHasNext()
```
    Description copied from interface: LookaheadIterator
    
    Ask whether the hasNext() method can be called. This method must be called before calling hasNext(), because some iterators implement this interface, but only support look-ahead under particular circumstances (this is usually because they delegate to another iterator)
    
    Specified by:
    
    supportsHasNext in interface LookaheadIterator
    
    Returns:
    
    true if the LookaheadIterator.hasNext() method is available
  - hasNext
```
public boolean hasNext()
```
    Description copied from interface: LookaheadIterator
    
    Determine whether there are more items to come. Note that this operation is stateless and it is not necessary (or usual) to call it before calling next(). It is used only when there is an explicit need to tell if we are at the last element.
    This method must not be called unless the result of LookaheadIterator.supportsHasNext() is true.
    
    Specified by:
    
    hasNext in interface LookaheadIterator
    
    Overrides:
    
    hasNext in class net.sf.saxon.expr.RangeIterator
    
    Returns:
    
    true if there are more items in the sequence
  - next
```
public IntegerValue next()
```
    Description copied from interface: AtomicIterator
    
    Get the next atomic value in the sequence.
    
    Specified by:
    
    next in interface AtomicIterator
    
    Specified by:
    
    next in interface SequenceIterator
    
    Overrides:
    
    next in class net.sf.saxon.expr.RangeIterator
    
    Returns:
    
    the next Item. If there are no more items, return null.
  - isActuallyGrounded
```
public boolean isActuallyGrounded()
```
    Description copied from interface: GroundedIterator
    
    Ask if the iterator is actually grounded. This method must be called before calling GroundedIterator.materialize() or GroundedIterator.getResidue(), because the iterator might be grounded under some conditions and not others (usually when it delegates to another iterator)
    
    Specified by:
    
    isActuallyGrounded in interface GroundedIterator
    
    Returns:
    
    true if this iterator is grounded
  - supportsGetLength
```
public boolean supportsGetLength()
```
    Description copied from interface: LastPositionFinder
    
    Ask whether this iterator supports use of the LastPositionFinder.getLength() method. This method should always be called before calling LastPositionFinder.getLength(), because an iterator that implements this interface may support use of LastPositionFinder.getLength() in some situations and not in others
    
    Specified by:
    
    supportsGetLength in interface LastPositionFinder
    
    Returns:
    
    true if the LastPositionFinder.getLength() method can be called to determine the length of the underlying sequence.
  - getLength
```
public int getLength()
```
    Description copied from interface: LastPositionFinder
    
    Get the last position (that is, the number of items in the sequence). This method is non-destructive: it does not change the state of the iterator. The result is undefined if the next() method of the iterator has already returned null. This method must not be called unless the LastPositionFinder.supportsGetLength() has been called and has returned true.
    
    Specified by:
    
    getLength in interface LastPositionFinder
    
    Overrides:
    
    getLength in class net.sf.saxon.expr.RangeIterator
    
    Returns:
    
    the number of items in the sequence
  - getReverseIterator
```
public AtomicIterator getReverseIterator()
```
    Description copied from interface: ReversibleIterator
    
    Get a new SequenceIterator that returns the same items in reverse order. If this SequenceIterator is an AxisIterator, then the returned SequenceIterator must also be an AxisIterator.
    
    Specified by:
    
    getReverseIterator in interface ReversibleIterator
    
    Returns:
    
    an iterator over the items in reverse order
  - materialize
```
public GroundedValue materialize()
```
    Return a Value containing all the items in the sequence returned by this SequenceIterator. This should be an "in-memory" value, not a Closure.
    
    Specified by:
    
    materialize in interface GroundedIterator
    
    Overrides:
    
    materialize in class net.sf.saxon.expr.RangeIterator
    
    Returns:
    
    the corresponding Value
  - 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
    
    Overrides:
    
    getResidue in class net.sf.saxon.expr.RangeIterator
    
    Returns:
    
    the corresponding Value

Class AscendingRangeIterator

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

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

Constructor Detail

AscendingRangeIterator

Method Detail

makeRangeIterator

makeLongRangeIterator

getFirst

getLast

getMin

getMax

getStep

supportsHasNext

hasNext

next

isActuallyGrounded

supportsGetLength

getLength

getReverseIterator

materialize

getResidue