org.abora.gold.collection.steppers
Class TableStepper

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

Direct Known Subclasses:

ArrayStepper, BucketArrayStepper, EditionStepper, GrandHashTableStepper, GrantStepper, IntegerTableStepper, OffsetArrayStepper, OffsetScruTableStepper, PtrArrayStepper

public class TableStepper

extends Stepper

For enumerating the key->value associations of a table. A typical use (for a table whose
range elements were all Foos) might be:
SPTR(TableStepper) stomp = table->stepper();
FOR_EACH(Foo,f,stomp, {
doSomethingWith(stomp->key(), z);
});
Each iteration of the loop would correspond to an association of the table (snapshotted at
the time "->stepper()" was sent). For each association, "f" (a pointer to Foo) points at
the range element, while "stomp->key()" provides the domain element. See
ScruTable::stepper.

Field Summary

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

TableStepper()

Method Summary

static TableStepper	ascending(PtrArray array) Note: this being a low level operation, and there being no lightweight form of immutable or lazily copied PtrArray, it is my caller's responsibility to pass me a PtrArray which will in fact not be changed during the life of this stepper.
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.
static TableStepper	descending(PtrArray array) Note: this being a low level operation, and there being no lightweight form of immutable or lazily copied PtrArray, it is my caller's responsibility to pass me a PtrArray which will in fact not be changed during the life of this stepper.
Heaper	fetch() If I am exhausted (i.e., if (!! this->hasValue())), then return NULL.
void	forIndices(BlockClosure fn)
void	forKeyValues(BlockClosure fn)
void	forPositions(BlockClosure fn)
void	forPromisedPairs(java.lang.Object aBlock)
boolean	hasValue() Iff I have a current value (i.e.
IntegerVar	index() Unboxed version of TableStepper::key.
static void	info() {Position CLIENT} position {PrimArray CLIENT} stepManyPairs: count {Int32 default: -1}
Position	key() A TableStepper actually enumerates the associations of a table.
Position	position() A TableStepper actually enumerates the associations of a table.
void	step() Essential.
PrimArray	stepManyPairs()
PrimArray	stepManyPairs(int count) An array of the remaining elements in alternating positions in the array [k1, v1, k2, v2, k3, v3, ...] Returns an array of up to count * 2 elements (or some arbitrary number if count is negative), and steps the stepper the corresponding number of times.

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

actualHashForEqual, asArray, atEnd, emptyStepper, forEach, forEachPromise, get, initTimeNonInherited, isEqual, itemStepper, linkTimeNonInherited, 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, destroy, 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

Constructor Detail

TableStepper

public TableStepper()

Method Detail

forIndices

public void forIndices(BlockClosure fn)

forKeyValues

public void forKeyValues(BlockClosure fn)

forPositions

public void forPositions(BlockClosure fn)

key

public Position key()

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.

index

public IntegerVar index()

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

position

public Position position()

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.

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

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

stepManyPairs

public PrimArray stepManyPairs(int count)

An array of the remaining elements in alternating positions in the array
[k1, v1, k2, v2, k3, v3, ...]
Returns an array of up to count * 2 elements (or some arbitrary number if count is
negative), and steps the stepper the corresponding number of times. You should check
whether the stepper is atEnd, since it can stop before the number you give it because of
some internal limit or grouping issue.

forPromisedPairs

public void forPromisedPairs(java.lang.Object aBlock)

stepManyPairs

public PrimArray stepManyPairs()

info

public static void info()

{Position CLIENT} position
{PrimArray CLIENT} stepManyPairs: count {Int32 default: -1}

ascending

public static TableStepper ascending(PtrArray array)

Note: this being a low level operation, and there being no lightweight form of immutable
or lazily copied PtrArray, it is my caller's responsibility to pass me a PtrArray which
will in fact not be changed during the life of this stepper. This is an unchecked an
uncheckable precondition on my clients.

descending

public static TableStepper descending(PtrArray array)

Note: this being a low level operation, and there being no lightweight form of immutable
or lazily copied PtrArray, it is my caller's responsibility to pass me a PtrArray which
will in fact not be changed during the life of this stepper. This is an unchecked an
uncheckable precondition on my clients.