org.abora.white.collection.tables
Class IntegerTable

java.lang.Object
  |
  +--org.abora.white.xpp.basic.Heaper
        |
        +--org.abora.white.collection.tables.ScruTable
              |
              +--org.abora.white.collection.tables.MuTable
                    |
                    +--org.abora.white.collection.tables.IntegerTable

Direct Known Subclasses:

MuArray, OberIntegerTable

public abstract class IntegerTable

extends MuTable

The IntegerTable class is used for tables that have arbitrary XuInteger keys in their domain. Since ScruTable & MuTable already provide all the unboxed versions of the table protocol, there is little need for this class to be a type. However, this class does provide a bit of extra protocol convenience: highestIndex & lowestIndex. Unless these are retired, we cannot retire this class from type status.

Note that there may be tables with XuInteger keys (i.e., IntegerSpace domains) which are not kinds of IntegerTables. In particular it is perfectly sensible to create a HashTable with XuInteger keys when the domain region is likely to be sparse.

Constructor Summary

protected	IntegerTable() Create a new table with an unspecified number of initial domain positions.
protected	IntegerTable(Rcvr rcvr)

Method Summary

void	atIntIntroduce(IntegerValue key, Heaper value) Unboxed version.
void	atIntReplace(IntegerValue key, Heaper value) Unboxed version.
void	atIntroduce(Position key, Heaper value) Associate key with value unless key is already associated with another value.
abstract Heaper	atIntStore(IntegerValue key, Heaper value) Unboxed version.
void	atReplace(Position key, Heaper value) Associate key with value only if key is already associated with a value.
Heaper	atStore(Position key, Heaper value) Associate value with key, whether or not there is a previous association.
CoordinateSpace	coordinateSpace() The kind of elements used to index into the table are Positions of this coordinate space.
abstract ScruTable	copy() A new one whose initial state is my current state, but that doesn't track changes.
abstract IntegerValue	count() Return the number of domain elements, which is to say, the number of associations.
abstract XnRegion	domain() Return an XuRegion representing a snapshot of the current domain.
abstract ScruTable	emptySize(IntegerValue size) Return an empty table just like the current one.
Heaper	fetch(Position key) Return the range element at the domain position key.
abstract IntegerValue	highestIndex() Given that the table is non-empty, 'intTab->highestIndex()' is equivalent to 'CAST(IntegerRegion,intTab->domain())->upperBound() -1'.
abstract boolean	includesIntKey(IntegerValue aKey) Unboxed version.
boolean	includesKey(Position aKey) includesKey is used to test for the presence of a key->value pair in the table.
abstract Heaper	intFetch(IntegerValue key) Unboxed version.
void	intRemove(IntegerValue anIdx) Unboxed version.
abstract boolean	intWipe(IntegerValue anIdx) Unboxed version.
abstract boolean	isEmpty() Is there anything in the table? 'table->isEmpty()' iff 'table->domain()->isEmpty()'.
abstract IntegerValue	lowestIndex() Given that the table is non-empty, 'intTab->lowestIndex()' is equivalent to 'CAST(IntegerRegion,intTab->domain())->lowerBound()'.
static IntegerTable	make() A new empty IntegerTable
static IntegerTable	make(IntegerRegion reg) Hint that the domain of the new table will eventually be (or at least resemble) 'reg'.
static IntegerTable	make(IntegerValue someSize) A new empty IntegerTable.
static IntegerTable	make(IntegerValue fromIdx, IntegerValue toIdx) Hint that the domain's lowerBound (inclusive) will eventually be 'fromIdx', and the domain's upperBound (exclusive) will eventually be 'toIdx'.
abstract ScruTable	offsetSubTableBetween(IntegerValue startIndex, IntegerValue stopIndex, IntegerValue firstIndex) Return a table which contains the elements from start to stop, starting at firstIndex.
void	remove(Position aPos) Remove a key->value association from the table.
XnRegion	runAt(Position key) Return the length of the run starting at position key.
abstract XnRegion	runAtInt(IntegerValue key) Unboxed version.
abstract TableStepper	stepper(OrderSpec order) Return a TableStepper which will enumerate my key->value mappings.
abstract ScruTable	subTable(XnRegion reg) Return a table which contains only the intersection of this table's domain and the domain specified by 'region'.
abstract ScruTable	subTableBetween(IntegerValue startIndex, IntegerValue stopIndex) Hack for C++ overloading problem
boolean	wipe(Position anIdx) Remove a key->value association from the table.

Methods inherited from class org.abora.white.collection.tables.MuTable

actualHashForEqual, asImmuTable, asMuTable, introduceAll, introduceAll, introduceAll, isEqual, make, make, problems, removeAll, replaceAll, replaceAll, replaceAll, sendSelfTo, storeAll, storeAll, storeAll, wipeAll

Methods inherited from class org.abora.white.collection.tables.ScruTable

backfollowFrom, contentsEqual, contentsHash, get, intGet, printOn, printOnWithSimpleSyntax, printOnWithSyntax, range, stepper, theOne, transformedBy

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

destroy, destruct, equals, hashForEqual, printContentsOn, toString

Methods inherited from class java.lang.Object

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

Constructor Detail

IntegerTable

protected IntegerTable()

Create a new table with an unspecified number of initial domain positions.

IntegerTable

protected IntegerTable(Rcvr rcvr)

Method Detail

atIntIntroduce

public void atIntIntroduce(IntegerValue key,
                           Heaper value)

Description copied from class: MuTable

Unboxed version. See class comment for XuInteger

Overrides:

atIntIntroduce in class MuTable

atIntReplace

public void atIntReplace(IntegerValue key,
                         Heaper value)

Description copied from class: MuTable

Unboxed version. See class comment for XuInteger

Overrides:

atIntReplace in class MuTable

atIntStore

public abstract Heaper atIntStore(IntegerValue key,
                                  Heaper value)

Description copied from class: MuTable

Unboxed version. See class comment for XuInteger

Overrides:

atIntStore in class MuTable

coordinateSpace

public CoordinateSpace coordinateSpace()

Description copied from class: ScruTable

The kind of elements used to index into the table are Positions of this coordinate space. Therefore, the domain of this table is an XuRegion in this coordinate space.

Specified by:

coordinateSpace in class MuTable

count

public abstract IntegerValue count()

Description copied from class: ScruTable

Return the number of domain elements, which is to say, the number of associations. 'table->count()' should be equivalent to 'table->domain()->count()'. Used to say: 'Return the number of range elements'. This seems clearly wrong.

Specified by:

count in class MuTable

domain

public abstract XnRegion domain()

Description copied from class: ScruTable

Return an XuRegion representing a snapshot of the current domain. 'table->domain()->hasMember(p)' iff 'table->fetch(p) !!= NULL'.

Specified by:

domain in class MuTable

highestIndex

public abstract IntegerValue highestIndex()

Given that the table is non-empty, 'intTab->highestIndex()' is equivalent to 'CAST(IntegerRegion,intTab->domain())->upperBound() -1'. The reason for the '-1' is that the 'upperBound' is an exclusive upper bound (see IntegerRegion::upperBound), whereas 'highestIndex' is the highest index which is in my domain. I need to here specify what 'highestIndex' does if I am empty.

intFetch

public abstract Heaper intFetch(IntegerValue key)

Description copied from class: ScruTable

Unboxed version. See class comment for XuInteger

Overrides:

intFetch in class MuTable

intRemove

public void intRemove(IntegerValue anIdx)

Description copied from class: MuTable

Unboxed version. See class comment for XuInteger

Overrides:

intRemove in class MuTable

intWipe

public abstract boolean intWipe(IntegerValue anIdx)

Description copied from class: MuTable

Unboxed version. See class comment for XuInteger

Overrides:

intWipe in class MuTable

lowestIndex

public abstract IntegerValue lowestIndex()

Given that the table is non-empty, 'intTab->lowestIndex()' is equivalent to 'CAST(IntegerRegion,intTab->domain())->lowerBound()'. 'lowestIndex' is the lowest index which is in my domain. I need to here specify what 'lowestIndex' does if I am empty.

subTable

public abstract ScruTable subTable(XnRegion reg)

Description copied from class: ScruTable

Return a table which contains only the intersection of this table's domain and the domain specified by 'region'. table->subTable(r)->domain()->isEqual( table->domain()->intersect(r) ). It is unspecified whether the resulting table starts as a snapshot of a subset of me, after which we go our own ways; or whether the resulting table is a view onto a subset of me, such that changes to me are also visible to him. Of course, subclasses may specify more. If you want to ensure snapshot behavior, do 'table->subTable(r)->asImmuTable()'. NOTE: In the future we may specify snapshot behavior or we may specify view behavior. As a client this shouldn't effect you. However, if you implement a new kind of ScruTable, please let us know. Also, if you have an opinion as to which way you'd like the specification tightened up, please tell us.

Specified by:

subTable in class MuTable

atIntroduce

public void atIntroduce(Position key,
                        Heaper value)

Description copied from class: MuTable

Associate key with value unless key is already associated with another value. If so, blast.

Overrides:

atIntroduce in class MuTable

atReplace

public void atReplace(Position key,
                      Heaper value)

Description copied from class: MuTable

Associate key with value only if key is already associated with a value. Otherwise blast.

Overrides:

atReplace in class MuTable

atStore

public Heaper atStore(Position key,
                      Heaper value)

Description copied from class: MuTable

Associate value with key, whether or not there is a previous association. Return the old range element if the position was previously occupied, NULL otherwise

Specified by:

atStore in class MuTable

fetch

public Heaper fetch(Position key)

Description copied from class: ScruTable

Return the range element at the domain position key. The routine will return NULL if the position is not in the table.

Specified by:

fetch in class MuTable

includesKey

public boolean includesKey(Position aKey)

Description copied from class: ScruTable

includesKey is used to test for the presence of a key->value pair in the table. This routine returns true if there is a value present at the specified key, and false otherwise. 'table->includesKey(p)' iff 'table->domain()->hasMember(p)'.

Specified by:

includesKey in class MuTable

remove

public void remove(Position aPos)

Description copied from class: MuTable

Remove a key->value association from the table. Blast if the key is not present.

Overrides:

remove in class MuTable

runAt

public XnRegion runAt(Position key)

Description copied from class: ScruTable

Return the length of the run starting at position key. A run is defined as a contiguous (charming) sequence of domain positions mapping to equal (isEqual) objects. Charming is defined as: Given a charming region R, for all a,c which are elements of R and a >= b >= c, b is an element of R. Where '>=' is according to the 'isGE' message. NOTE: We may retire the above definition of charming. The possible changes will only effect spaces which aren't fully ordered. OrderedRegions, TreeRegions, and IntegerRegions will be unaffected, as any future definition of 'runAt' will be equivalent for them.

Specified by:

runAt in class MuTable

wipe

public boolean wipe(Position anIdx)

Description copied from class: MuTable

Remove a key->value association from the table. Do not blast (or do anything else) if the key is not in my current domain. Return TRUE if the association was present and removed, Return FALSE if the association was not there

Specified by:

wipe in class MuTable

includesIntKey

public abstract boolean includesIntKey(IntegerValue aKey)

Description copied from class: ScruTable

Unboxed version. See class comment for XuInteger

Overrides:

includesIntKey in class MuTable

isEmpty

public abstract boolean isEmpty()

Description copied from class: ScruTable

Is there anything in the table? 'table->isEmpty()' iff 'table->domain()->isEmpty()'.

Specified by:

isEmpty in class MuTable

stepper

public abstract TableStepper stepper(OrderSpec order)

Description copied from class: ScruTable

Return a TableStepper which will enumerate my key->value mappings. The Stepper component of the TableStepper protocol will just enumerate my values (as that is what I'm a container *of*--the keys are simply how I organize my contents). TableStepper provides additional protocol to ascetain the current key. See TableStepper and XuRegion::stepper. The TableStepper I produce given an order must enumerate keys according to the same rules which specify how XuRegion::stepper must enumerate positions. I am not asserting that the actual orders are the same, only that the correctness criteria on the allowable orders are the same. Keeping in mind that we are talking about equivalence of specification and not equivalence of particular behavior, the following two statements are equivalent: { SPTR(TableStepper) stomp = table->stepper(o); SPTR(Position) key; FOR_EACH(Heaper,val,stomp, { key = stomp->key(); doSomethingWith(key, val); }); } and { SPTR(Heaper) val; SPTR(ImmuTable) snapShot = table->asImmuTable(); FOR_EACH(Position,key,(snapShot->domain()->stepper(o)), { val = snapShot->get (key); doSomethingWith(key, val); }); }

Specified by:

stepper in class MuTable

runAtInt

public abstract XnRegion runAtInt(IntegerValue key)

Description copied from class: ScruTable

Unboxed version. See class comment for XuInteger

Overrides:

runAtInt in class MuTable

copy

public abstract ScruTable copy()

Description copied from class: ScruTable

A new one whose initial state is my current state, but that doesn't track changes. Note that there is no implication that these can be 'destroy'ed separately, because (for example) an ImmuTable just returns itself

Specified by:

copy in class MuTable

emptySize

public abstract ScruTable emptySize(IntegerValue size)

Description copied from class: ScruTable

Return an empty table just like the current one. The 'size' argument is a hint about how big the count of the table will probably become (so that the new table can be prepared to grow to that size efficiently).

Specified by:

emptySize in class MuTable

offsetSubTableBetween

public abstract ScruTable offsetSubTableBetween(IntegerValue startIndex,
                                                IntegerValue stopIndex,
                                                IntegerValue firstIndex)

Return a table which contains the elements from start to stop, starting at firstIndex. Zero-based subclasses will blast if firstIndex is non-zero

subTableBetween

public abstract ScruTable subTableBetween(IntegerValue startIndex,
                                          IntegerValue stopIndex)

Hack for C++ overloading problem

make

public static IntegerTable make()

A new empty IntegerTable

make

public static IntegerTable make(IntegerValue someSize)

A new empty IntegerTable. 'someSize' is a hint about how big the table is likely to need to be ('highestIndex - lowestIndex + 1', not 'count').

make

public static IntegerTable make(IntegerValue fromIdx,
                                IntegerValue toIdx)

Hint that the domain's lowerBound (inclusive) will eventually be 'fromIdx', and the domain's upperBound (exclusive) will eventually be 'toIdx'.

make

public static IntegerTable make(IntegerRegion reg)

Hint that the domain of the new table will eventually be (or at least resemble) 'reg'.