public static void stellaHashTableRemoveAt(StellaHashTable self, Stella_Object key) {
{
KvCons[] table = self.theTable;
int bucketindex = 0;
KvCons bucket = null;
boolean equaltestP = self.equalTestP;
if (table == null) {
return;
}
if (equaltestP) {
bucketindex = (((key.equalHashCode()) & 0x7FFFFFFF) % (self.size));
} else {
bucketindex = (((key.hashCode_()) & 0x7FFFFFFF) % (self.size));
}
bucket = table[bucketindex];
if (bucket == null) {
return;
} else if ((!equaltestP) && Stella_Object.eqlP(bucket.key, key)) {
table[bucketindex] = bucket.rest;
self.freeElements = self.freeElements + 1;
return;
} else if (equaltestP && Stella_Object.equalP(bucket.key, key)) {
table[bucketindex] = bucket.rest;
self.freeElements = self.freeElements + 1;
return;
} else {
{
KvCons trailer = bucket;
bucket = bucket.rest;
while (bucket != null) {
if ((!equaltestP) && Stella_Object.eqlP(bucket.key, key)) {
trailer.rest = bucket.rest;
self.freeElements = self.freeElements + 1;
return;
} else if (equaltestP && Stella_Object.equalP(bucket.key, key)) {
trailer.rest = bucket.rest;
self.freeElements = self.freeElements + 1;
return;
} else {
trailer = bucket;
bucket = bucket.rest;
}
}
}
}
}
}
/**
* 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);
}
}
public static void stellaHashTableInsertAt(
StellaHashTable self, Stella_Object key, Stella_Object value) {
{
KvCons[] table = self.theTable;
int free = self.freeElements;
int bucketindex = 0;
KvCons bucket = null;
boolean equaltestP = self.equalTestP;
if (table == null) {
StellaHashTable.initializeStellaHashTable(self);
table = self.theTable;
free = self.freeElements;
}
if (free == 0) {
StellaHashTable.rehashStellaHashTable(self, Stella.pickHashTableSizePrime(self.size + 1));
table = self.theTable;
free = self.freeElements;
}
if (equaltestP) {
bucketindex = (((key.equalHashCode()) & 0x7FFFFFFF) % (self.size));
} else {
bucketindex = (((key.hashCode_()) & 0x7FFFFFFF) % (self.size));
}
bucket = table[bucketindex];
if (bucket == null) {
{
KvCons self000 = KvCons.newKvCons();
self000.key = key;
self000.value = value;
table[bucketindex] = self000;
}
self.freeElements = free - 1;
} else {
{
KvCons cursor = bucket;
if (equaltestP) {
while ((cursor != null) && (!Stella_Object.equalP(cursor.key, key))) {
cursor = cursor.rest;
}
} else {
while ((cursor != null) && (!Stella_Object.eqlP(cursor.key, key))) {
cursor = cursor.rest;
}
}
if (cursor != null) {
cursor.value = value;
} else {
{
KvCons self001 = KvCons.newKvCons();
self001.key = key;
self001.value = value;
self001.rest = bucket.rest;
bucket.rest = self001;
}
self.freeElements = free - 1;
}
}
}
}
}