org.abora.white.spaces.integers
Class IntegerEdgeStepper

java.lang.Object
  |
  +--org.abora.white.xpp.basic.Heaper
        |
        +--org.abora.white.collection.steppers.Stepper
              |
              +--org.abora.white.spaces.integers.IntegerEdgeStepper

public class IntegerEdgeStepper

extends Stepper

A single instance of this class is cached. To take advantage of this, a method that uses IntegerEdgeSteppers should explicitly destroy at least one of them.

Field Summary

protected int	myCount
protected IntegerVarArray	myEdges
protected boolean	myEntering
protected int	myIndex
protected static InstanceCache	SomeEdgeSteppers

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

TheEmptyStepper

Constructor Summary

protected	IntegerEdgeStepper(boolean entering, int count, IntegerVarArray edges)
protected	IntegerEdgeStepper(boolean entering, int index, int count, IntegerVarArray edges)

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.
void	destroy()
IntegerValue	edge() the current transition
Heaper	fetch() If I am exhausted (i.e., if (!! this->hasValue())), then return NULL.
boolean	hasValue() Iff I have a current value (i.e.
boolean	isEntering() whether the current transition is entering or leaving the set
static IntegerEdgeStepper	make(boolean entering, int count, IntegerVarArray edges)
static void	outOfBounds()
void	printOn(java.io.PrintWriter oo) This should rarely be overridden.
void	step() Essential.

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

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

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

destruct, equals, hashForEqual, printContentsOn, sendSelfTo, toString

Methods inherited from class java.lang.Object

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

Field Detail

myEntering

protected boolean myEntering

myIndex

protected int myIndex

myCount

protected int myCount

myEdges

protected IntegerVarArray myEdges

SomeEdgeSteppers

protected static InstanceCache SomeEdgeSteppers

Constructor Detail

IntegerEdgeStepper

protected IntegerEdgeStepper(boolean entering,
                             int count,
                             IntegerVarArray edges)

IntegerEdgeStepper

protected IntegerEdgeStepper(boolean entering,
                             int index,
                             int count,
                             IntegerVarArray edges)

Method Detail

make

public static IntegerEdgeStepper make(boolean entering,
                                      int count,
                                      IntegerVarArray edges)

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 Stepper

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 Stepper

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 Stepper

edge

public IntegerValue edge()

the current transition

isEntering

public boolean isEntering()

whether the current transition is entering or leaving the set

destroy

public void destroy()

Overrides:

destroy in class Heaper

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 Stepper

printOn

public void printOn(java.io.PrintWriter oo)

Description copied from class: Heaper

This should rarely be overridden. In Tofu, it prints ClassName(...), where ... is either produced by printInsideOn or is ??? if printInsideOn it not overridden.

Overrides:

printOn in class Heaper

outOfBounds

public static void outOfBounds()