/**
* Remove all entries from <code>self</code>. This will result in a re-initialization of the table
* upon the first insertion into <code>self</code>.
*/
public void clear() {
{
StellaHashTable self = this;
self.theTable = null;
self.size = Stella.NULL_INTEGER;
self.freeElements = Stella.NULL_INTEGER;
}
}
public static StellaHashTable newStellaHashTable() {
{
StellaHashTable self = null;
self = new StellaHashTable();
self.theStellaHashTable = null;
self.theHashTable = null;
self.equalTestP = false;
self.freeElements = Stella.NULL_INTEGER;
self.initialSize = 50;
self.size = Stella.NULL_INTEGER;
self.initializeHashTable();
return (self);
}
}
/**
* Return a copy of the hash table <code>self</code>. The bucket table and buckets are freshly
* allocated, however, the keys and values of entries are not copied themselves (similar to what
* we do for lists, etc.).
*
* @return StellaHashTable
*/
public StellaHashTable copy() {
{
StellaHashTable self = this;
{
int size = self.size;
{
StellaHashTable self000 = StellaHashTable.newStellaHashTable();
self000.size = size;
self000.initialSize = self.initialSize;
self000.freeElements = self.freeElements;
self000.equalTestP = self.equalTestP;
{
StellaHashTable copy = self000;
KvCons[] table = self.theTable;
KvCons[] tablecopy = table;
KvCons bucket = null;
if (table != null) {
tablecopy = new KvCons[size];
copy.theTable = tablecopy;
{
int i = Stella.NULL_INTEGER;
int iter000 = 0;
int upperBound000 = size - 1;
for (; iter000 <= upperBound000; iter000 = iter000 + 1) {
i = iter000;
bucket = table[i];
if (bucket != null) {
tablecopy[i] = KvCons.copyKvConsList(bucket);
} else {
tablecopy[i] = null;
}
}
}
}
return (copy);
}
}
}
}
}
public static void initializeStellaHashTable(StellaHashTable self) {
{
int size =
Stella.pickHashTableSizePrime(
Native.floor(self.initialSize / Stella.$STELLA_HASH_TABLE_AVG_BUCKET_LENGTH$));
KvCons[] table = new KvCons[size];
{
int i = Stella.NULL_INTEGER;
int iter000 = 0;
int upperBound000 = size - 1;
for (; iter000 <= upperBound000; iter000 = iter000 + 1) {
i = iter000;
table[i] = null;
}
}
self.theTable = table;
self.size = size;
self.freeElements = Native.floor(size * Stella.$STELLA_HASH_TABLE_AVG_BUCKET_LENGTH$);
}
}
public static Stella_Object accessStellaHashTableSlotValue(
StellaHashTable self, Symbol slotname, Stella_Object value, boolean setvalueP) {
if (slotname == Stella.SYM_STELLA_SIZE) {
if (setvalueP) {
self.size = ((IntegerWrapper) (value)).wrapperValue;
} else {
value = IntegerWrapper.wrapInteger(self.size);
}
} else if (slotname == Stella.SYM_STELLA_INITIAL_SIZE) {
if (setvalueP) {
self.initialSize = ((IntegerWrapper) (value)).wrapperValue;
} else {
value = IntegerWrapper.wrapInteger(self.initialSize);
}
} else if (slotname == Stella.SYM_STELLA_FREE_ELEMENTS) {
if (setvalueP) {
self.freeElements = ((IntegerWrapper) (value)).wrapperValue;
} else {
value = IntegerWrapper.wrapInteger(self.freeElements);
}
} else if (slotname == Stella.SYM_STELLA_EQUAL_TESTp) {
if (setvalueP) {
self.equalTestP = BooleanWrapper.coerceWrappedBooleanToBoolean(((BooleanWrapper) (value)));
} else {
value = (self.equalTestP ? Stella.TRUE_WRAPPER : Stella.FALSE_WRAPPER);
}
} else {
{
OutputStringStream stream000 = OutputStringStream.newOutputStringStream();
stream000.nativeStream.print("`" + slotname + "' is not a valid case option");
throw ((StellaException)
(StellaException.newStellaException(stream000.theStringReader()).fillInStackTrace()));
}
}
return (value);
}
public static void rehashStellaHashTable(StellaHashTable self, int newsize) {
if (self.theTable == null) {
StellaHashTable.initializeStellaHashTable(self);
return;
}
{
int size = self.size;
KvCons[] table = self.theTable;
KvCons[] newtable = new KvCons[newsize];
int newbucketindex = 0;
KvCons newbucket = null;
KvCons cursor = null;
KvCons current = null;
boolean equaltestP = self.equalTestP;
{
int i = Stella.NULL_INTEGER;
int iter000 = 0;
int upperBound000 = newsize - 1;
for (; iter000 <= upperBound000; iter000 = iter000 + 1) {
i = iter000;
newtable[i] = null;
}
}
{
int i = Stella.NULL_INTEGER;
int iter001 = 0;
int upperBound001 = size - 1;
for (; iter001 <= upperBound001; iter001 = iter001 + 1) {
i = iter001;
cursor = table[i];
while (cursor != null) {
if (equaltestP) {
newbucketindex = (((cursor.key.equalHashCode()) & 0x7FFFFFFF) % newsize);
} else {
newbucketindex = (((cursor.key.hashCode_()) & 0x7FFFFFFF) % newsize);
}
newbucket = newtable[newbucketindex];
current = cursor;
cursor = cursor.rest;
if (newbucket != null) {
current.rest = newbucket.rest;
newbucket.rest = current;
} else {
newtable[newbucketindex] = current;
current.rest = null;
}
}
}
}
self.theTable = newtable;
self.size = newsize;
self.freeElements =
Stella.max(
self.freeElements
+ Native.floor((newsize - size) * Stella.$STELLA_HASH_TABLE_AVG_BUCKET_LENGTH$),
0);
}
}