org.abora.white.collection.steppers
Class ITGenericStepper

java.lang.Object
  |
  +--org.abora.white.xpp.basic.Heaper
        |
        +--org.abora.white.collection.steppers.Stepper
              |
              +--org.abora.white.collection.steppers.TableStepper
                    |
                    +--org.abora.white.collection.steppers.IntegerTableStepper
                          |
                          +--org.abora.white.collection.steppers.ITGenericStepper

public class ITGenericStepper

extends IntegerTableStepper

Field Summary

protected IntegerTable	arrayInternal
protected int	incrementInternal
protected IntegerValue	indexInternal
protected IntegerValue	lastValueInternal

Fields inherited from class org.abora.white.collection.steppers.Stepper

TheEmptyStepper

Constructor Summary

ITGenericStepper(IntegerTable array)

ITGenericStepper(IntegerTable array, IntegerValue index)

ITGenericStepper(IntegerTable array, IntegerValue start, IntegerValue stop)

ITGenericStepper(IntegerTable array, IntegerValue start, IntegerValue stop, IntegerValue direction)

ITGenericStepper(IntegerTable onTable, OrderSpec anOrder)

Method Summary

Stepper	copy() Return a new stepper which steps independently of me, but whose current value is the same as mine, and which must produce a future history of values which satisfies the same obligation that my contract obligates me to produce now.
Heaper	fetch() If I am exhausted (i.e., if (!! this->hasValue())), then return NULL.
boolean	hasValue() Iff I have a current value (i.e.
IntegerValue	index() Unboxed version of TableStepper::key.
Position	position() A TableStepper actually enumerates the associations of a table.
void	step() Essential.
void	verifyEntry()

Methods inherited from class org.abora.white.collection.steppers.IntegerTableStepper

get, make, make

Methods inherited from class org.abora.white.collection.steppers.TableStepper

ascending, descending, info, key, stepManyPairs, stepManyPairs

Methods inherited from class org.abora.white.collection.steppers.Stepper

actualHashForEqual, atEnd, emptyStepper, isEqual, itemStepper, stepMany, stepMany, theOne

Methods inherited from class org.abora.white.xpp.basic.Heaper

destroy, destruct, equals, hashForEqual, printContentsOn, printOn, sendSelfTo, toString

Methods inherited from class java.lang.Object

clone, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

arrayInternal

protected IntegerTable arrayInternal

indexInternal

protected IntegerValue indexInternal

lastValueInternal

protected IntegerValue lastValueInternal

incrementInternal

protected int incrementInternal

Constructor Detail

ITGenericStepper

public ITGenericStepper(IntegerTable array)

ITGenericStepper

public ITGenericStepper(IntegerTable onTable,
                        OrderSpec anOrder)

ITGenericStepper

public ITGenericStepper(IntegerTable array,
                        IntegerValue index)

ITGenericStepper

public ITGenericStepper(IntegerTable array,
                        IntegerValue start,
                        IntegerValue stop)

ITGenericStepper

public ITGenericStepper(IntegerTable array,
                        IntegerValue start,
                        IntegerValue stop,
                        IntegerValue direction)

Method Detail

fetch

public Heaper fetch()

Description copied from class: Stepper

If I am exhausted (i.e., if (!! this->hasValue())), then return NULL. Else return current element. I return wimpily since most items returned are held by collections. If I create a new object, I should cache it.

Specified by:

fetch in class IntegerTableStepper

hasValue

public boolean hasValue()

Description copied from class: Stepper

Iff I have a current value (i.e. this message returns true), then I am not exhasted. 'fetch' and 'get' will both return this value, and I can be 'step'ped to my next state. As I am stepped, eventually I may become exhausted (the reverse of all the above), which is a permanent condition. Note that not all steppers have to be exhaustable. A Stepper which enumerates all primes is perfectly reasonable. Assuming otherwise will create infinite loops. See class comment.

Specified by:

hasValue in class IntegerTableStepper

step

public void step()

Description copied from class: Stepper

Essential. If I am currently exhausted (see Stepper::hasValue()), then it is an error to step me. The result of doing so isn't currently specified (we probably should specify it to BLAST, but I know that the implementation doesn't currently live up to that spec). If I am not exhausted, then this advances me to my next state. If my current value (see Stepper::get()) was my final value, then I am now exhausted, otherwise my new current value is the next value.

Specified by:

step in class IntegerTableStepper

index

public IntegerValue index()

Description copied from class: TableStepper

Unboxed version of TableStepper::key. See class comment in XuInteger.

Overrides:

index in class TableStepper

position

public Position position()

Description copied from class: TableStepper

A TableStepper actually enumerates the associations of a table. Through the normal Stepper protocol, it makes available the range element of the current association. Through this additional protocol, it make accessible the key of the current association. This message returns the same object as TwoStepper::other, the only difference being the static knowledge that it's a Position.

Specified by:

position in class IntegerTableStepper

copy

public Stepper copy()

Description copied from class: Stepper

Return a new stepper which steps independently of me, but whose current value is the same as mine, and which must produce a future history of values which satisfies the same obligation that my contract obligates me to produce now. Typically, this will mean that he must produce the same future history that I'm going to produce. However, let's say that I am enumerating the elements of a partial order in some full order which is consistent with the partial order. If a copy of me is made after I'm part way through, then me and my copy may produce any future history compatable both with the partial order and the elements I've already produced by the time of the copy. Of course, a subclass or a Stepper creating message (like IntegerRegion::stepper()) may specify the more stringent requirement (that a copy must produce the same sequence). To prevent aliasing, Steppers should typically be passed by copy. See class comment.

Specified by:

copy in class IntegerTableStepper

verifyEntry

public void verifyEntry()