org.abora.gold.spaces.cross
Class BoxProjectionStepper

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.BoxProjectionStepper

public class BoxProjectionStepper

extends Stepper

Steps over all projections of some boxes. was not.a.type but this prevented compilation

Field Summary

protected int	myBoxIndex
protected int	myBoxLimit
protected int	myDimension
protected GenericCrossRegion	myRegion
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

BoxProjectionStepper(GenericCrossRegion region)

BoxProjectionStepper(GenericCrossRegion region, int boxIndex, int boxLimit)

BoxProjectionStepper(GenericCrossRegion region, int boxIndex, int boxLimit, int dimension)

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()
int	dimension()
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()
static void	linkTimeNonInherited()
static Heaper	make(GenericCrossRegion region)
static Heaper	make(GenericCrossRegion region, int boxIndex, int boxLimit)
XnRegion	projection()
void	step() Essential.

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

myBoxIndex

protected int myBoxIndex

myBoxLimit

protected int myBoxLimit

myDimension

protected int myDimension

SomeSteppers

protected static InstanceCache SomeSteppers

Constructor Detail

BoxProjectionStepper

public BoxProjectionStepper(GenericCrossRegion region)

BoxProjectionStepper

public BoxProjectionStepper(GenericCrossRegion region,
                            int boxIndex,
                            int boxLimit)

BoxProjectionStepper

public BoxProjectionStepper(GenericCrossRegion region,
                            int boxIndex,
                            int boxLimit,
                            int dimension)

Method Detail

copy

public 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. 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

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

dimension

public int dimension()

projection

public XnRegion projection()

make

public static Heaper make(GenericCrossRegion region)

make

public static Heaper make(GenericCrossRegion region,
                          int boxIndex,
                          int boxLimit)

initTimeNonInherited

public static void initTimeNonInherited()

linkTimeNonInherited

public static void linkTimeNonInherited()