org.abora.gold.spaces.cross
Class BoxStepper

java.lang.Object
  |
  +--org.abora.gold.java.AboraHeaper
        |
        +--org.abora.gold.xpp.basic.Heaper
              |
              +--org.abora.gold.collection.steppers.Stepper
                    |
                    +--org.abora.gold.spaces.cross.BoxStepper

public class BoxStepper

extends Stepper

Steps over all boxes. was NOT.A.TYPE but this prevented compilation

Field Summary

protected int	myIndex
protected GenericCrossRegion	myRegion
protected XnRegion	myValue
protected static InstanceCache	SomeSteppers

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

TheEmptyStepper

Fields inherited from class org.abora.gold.xpp.basic.Heaper

AllBlasts, BecomeMap, GarbageCount, InGC, InitializedClasses, InitializingClasses, LastMemory, NextClientRequestNumber, NotOneElementSignal, PackageTable, PromiseNameTable, StringHashSBoxes

Fields inherited from class org.abora.gold.java.AboraHeaper

ActiveClubs, CurrentAuthor, CurrentBertCanopyCache, CurrentBertCrum, CurrentChunk, CurrentGrandMap, CurrentKeyMaster, CurrentPacker, CurrentSensorCanopyCache, CurrentServer, CurrentSession, CurrentSessions, CurrentTrace, InitialEditClub, InitialOwner, InitialReadClub, InitialSponsor, InsideTransactionFlag

Constructor Summary

BoxStepper(GenericCrossRegion region)

BoxStepper(GenericCrossRegion region, int index, XnRegion value)

Method Summary

GenericCrossRegion	boxComplement() The complement of this box
BoxAccumulator	boxComplementAccumulator() The complement of this box
int	boxHash()
boolean	boxHasMember(ActualTuple tuple) Whether my current box contains a position
int	boxIndex()
boolean	boxIntersects(BoxStepper other) Whether my current box intersects others current box
boolean	boxIsEqual(BoxStepper other) Whether my current box isEqual others current box
boolean	boxIsSubsetOf(BoxStepper other) Whether my current box isSubsetOf others current box
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()
Heaper	fetch() If I am exhausted (i.e., if (!! this->hasValue())), then return NULL.
boolean	hasValue() Iff I have a current value (i.e.
static void	initTimeNonInherited()
boolean	intersectBoxInto(PtrArray result, int boxIndex) Intersect each projection in the box into the array.
boolean	isBoxOf(GenericCrossRegion other) Whether my box is also a box in the other region
static void	linkTimeNonInherited()
static Heaper	make(GenericCrossRegion region)
XnRegion	projection(int dimension) The projection of my current box into one dimension
BoxProjectionStepper	projectionStepper() A stepper over all the projections in the current box
GenericCrossRegion	region()
void	step() Essential.
void	unionBoxInto(PtrArray result, int boxIndex) Union each projection in the box into the array

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

actualHashForEqual, asArray, atEnd, emptyStepper, forEach, forEachPromise, get, info, isEqual, itemStepper, stepMany, stepMany, theOne

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

abstractDeclarationFor, abstractTypeFor, addMethodAttributeToInOf, addPackage, addPackageCategory, allClientProtocolOn, argumentTypesFor, arrow, blast, blast, BLAST, cachePromiseNameTable, cachePromiseNameTableIn, canYouBecome, cast, cleanPromiseClasses, cleanupGarbage, clientClassesDo, clientFunctionsOn, clientMethodsOn, clientProtocol, clientProtocolDo, clientProtocolOn, clientProtocolOn, collectibleClasses, compare, compileClientSubclasses, compileConstantPromiseMethods, compileCreateFromRcvr, compileEQ, compileGeneratedClassMethod, compileGeneratedMethod, compileHook, compilePromise, compilePromiseDefaultMethods, compilePromiseFluidDeclarations, compilePromiseHandlers, compilePromiseMethods, compileRequestCreateMsgInArguments, compileRequestEvaluateMsgInReturningArguments, compileRPCSpecialistEvaluateMsgForReturningArguments, compileSendSelfTo, compileSendSelfToSendHook, compileStubbleMethods, compileSubclassStubbleMethods, computeMangle, computePreorder, constantTypeValue, convert, convertCopyDeclarations, convertDeferredDeclarations, convertProxyDeclarations, convertSubclassCopyDeclarations, convertSubclassDeferredDeclarations, convertSubclassProxyDeclarations, copyReferencesToType, create, create, create, create, create, create, create, create, create, create, createRequestClassArguments, definesProxyMethods, delete, deref, destruct, destructor, enum, enumFlags, equals, exportName, fetchAttribute, fetchPackage, fetchSuperCategory, fileOutClientProtocol, findCategory, findSenderAndReceiverMethods, findTailInto, flushPromiseNameTable, foo, freezeClientClasses, freezeClientProtocol, freezeStProtocol, frozenClasses, garbageCollect, garbageCollectFrom, gcOpportunity, gcOpportunity, generatedCategory, generatePromiseNames, getCategory, getOrMakePackage, getSuperCategory, handlerSignaturesFrom, hash, hashForEqual, hasProxyMethods, info_clientClasses, info_clientSideClasses, info_promiseClasses, info_stProtocol, inGC, initializedClasses, initializingClasses, initPackages, initStringHashSBoxes, inspectPieces, instanceSize, IntegerVar, isByProxy, isConstructed, isDestructed, isEqual, isEqualOrSubclassOf, isGenerated, isIntType, isKindOf, isRawType, isUnlocked, make, makeClassTable, makeFillTable, makeRequestTable, mangle, markChildren, markCount, markInstances, mayBecome, mayBecomeAnySubclassOf, new1, newX, nonCopyVariables, notWorking, pack, packageClasses, packagingCategory, parseExportName, passe, pointerToStaticMember, pointerToStaticMember, pointerToVirtualMember, preorderMax, preorderNumber, printOn, PROBLEM, problems, promiseClass, promiseDefaultValue, promiseName, promiseNameTable, promiseToAbstract, registerPackageCategory, removeGeneratedCode, removeStubbleMethods, removeSubclassGeneratedCode, removeSubclassStubbleMethods, requestProcedure, requestProceduresFrom, returnTypeFor, rootName, scheduleTermination, sendProxyTo, sendSelfTo, serverNameFor, setGC, signal, signals, smalltalkSelector, stClientProtocol, stubbleSelectorTokenReturnsArguments, subclassNonCopyVariables, takeOop, togglePromiseName, togglePromiseOfParse, unimplemented, unmangle, verifyFreeze, wipeStubble

Methods inherited from class org.abora.gold.java.AboraHeaper

asOop, basicInspect, displayString, error, hack, halt, inspect, knownBug, mightNotImplement, REQUIRES, shouldImplement, shouldNotImplement, stubbleForSubclassResponsibility, thingToDo, willNotImplement

Methods inherited from class java.lang.Object

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

Field Detail

myRegion

protected GenericCrossRegion myRegion

myIndex

protected int myIndex

myValue

protected XnRegion myValue

SomeSteppers

protected static InstanceCache SomeSteppers

Constructor Detail

BoxStepper

public BoxStepper(GenericCrossRegion region)

BoxStepper

public BoxStepper(GenericCrossRegion region,
                  int index,
                  XnRegion value)

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.

Overrides:

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.

Overrides:

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.

Overrides:

step in class Stepper

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.

Overrides:

copy in class Stepper

destroy

public void destroy()

Overrides:

destroy in class Heaper

boxComplement

public GenericCrossRegion boxComplement()

The complement of this box

boxComplementAccumulator

public BoxAccumulator boxComplementAccumulator()

The complement of this box

boxHash

public int boxHash()

boxHasMember

public boolean boxHasMember(ActualTuple tuple)

Whether my current box contains a position

boxIndex

public int boxIndex()

boxIntersects

public boolean boxIntersects(BoxStepper other)

Whether my current box intersects others current box

boxIsEqual

public boolean boxIsEqual(BoxStepper other)

Whether my current box isEqual others current box

boxIsSubsetOf

public boolean boxIsSubsetOf(BoxStepper other)

Whether my current box isSubsetOf others current box

intersectBoxInto

public boolean intersectBoxInto(PtrArray result,
                                int boxIndex)

Intersect each projection in the box into the array. Return false if the result is empty,
stopping at the first dimension for which the intersection is empty.

isBoxOf

public boolean isBoxOf(GenericCrossRegion other)

Whether my box is also a box in the other region

projection

public XnRegion projection(int dimension)

The projection of my current box into one dimension

projectionStepper

public BoxProjectionStepper projectionStepper()

A stepper over all the projections in the current box

region

public GenericCrossRegion region()

unionBoxInto

public void unionBoxInto(PtrArray result,
                         int boxIndex)

Union each projection in the box into the array

initTimeNonInherited

public static void initTimeNonInherited()

linkTimeNonInherited

public static void linkTimeNonInherited()

make

public static Heaper make(GenericCrossRegion region)