public static void Init(PtrIntDict *self)
{
#if FDB
Should.NotNull("self", self);
self->type = Type;
#endif
self->tag = Tag.PtrIntDict;
int level = self->level = 0;
int len = self->len = Const.Lens[level];
self->count = 0;
self->free = 0;
// | (Entry)entries... | (int)arr... |
// used entry: next: next entry in the bucket
// free entry: next: next free entry
int EntrySize = Const.EntrySize;
var entries = self->entries = (Entry *)Mem.Malloc(len * (EntrySize + IntSize));
Entry *entry = null;
for (int i = 0; i < len; i += 1)
{
entry = entries + i;
entry->val = null;
entry->next = i + 1;
}
entry->next = -1; // the last free entry
int *arr = self->arr = (int *)((byte *)entries + len * EntrySize);
for (int i = 0; i < len; i += 1)
{
arr[i] = -1;
}
}
public static void Clear(PtrIntDict *self)
{
int len = self->len;
self->count = 0;
self->free = 0;
var entries = self->entries;
Entry *entry = null;
for (int i = 0; i < len; i += 1)
{
entry = entries + i;
entry->val = null;
entry->next = i + 1;
}
entry->next = -1; // the last free entry
int *arr = self->arr;
for (int i = 0; i < len; i += 1)
{
arr[i] = -1;
}
}
public static void Decon(PtrIntDict *self)
{
#if FDB
Verify(self);
#endif
Mem.Free(self->entries);
}
public void Dispose()
{
cmdQueue.Clear();
esJobList.Clear();
PtrIntDict.Decon(nodeDict); Mem.Free(nodeDict); nodeDict = null;
Pool.Decon(spritePool); Mem.Free(spritePool); spritePool = null;
PtrLst.Decon(spritePtrLst); Mem.Free(spritePtrLst); spritePtrLst = null;
DrawCtx.Dispose();
Debug.Log("Clean up GPC");
}
public static void Verify(PtrIntDict *self)
{
Should.NotNull("self", self);
Should.InRange("self->level", self->level, 0, Const.Lens.Length - 1);
Should.Equal("self->len", self->len, Const.Lens[self->level]);
Should.InRange("self->count", self->count, 0, self->len);
Should.InRange("self->free", self->free, -1, self->len - 1);
Mem.Verify(self->entries);
Should.NotNull("self->arr", self->arr);
int len = self->len;
int count = self->count;
int j = 0;
for (int i = 0; i < len; i += 1)
{
var entry = self->entries + i;
if (entry->val != null) // a real key
{
j += 1;
}
}
Should.Equal("j", j, count);
int freeCount = len - count;
int free = self->free;
while (free != -1)
{
freeCount -= 1;
free = self->entries[free].next;
}
Should.Zero("freeCount", freeCount);
j = 0;
for (int i = 0; i < len; i += 1)
{
int idx = self->arr[i];
while (idx != -1)
{
var entry = self->entries + idx;
Should.Equal("entry->hash % len", (uint)entry->hash % len, i);
j += 1;
idx = entry->next;
}
}
// Fdb.Dump(self->arr, self->len * IntSize);
// Fdb.Dump(self->entries, self->len * EntrySize, EntrySize);
Should.Equal("j", j, count);
}
public static void ShiftBase(PtrIntDict *self, long shift)
{
#if FDB
Verify(self);
#endif
var entries = self->entries;
for (int i = 0, len = self->len; i < len; i += 1)
{
var entry = entries + i;
void *val = entry->val;
if (val != null)
{
entry->val = (byte *)val + shift;
}
}
}
public static bool Contains(PtrIntDict *self, int hash)
{
#if FDB
Verify(self);
#endif
int cur = self->arr[(uint)hash % self->len];
var entries = self->entries;
while (cur != -1)
{
var entry = entries + cur;
if (entry->hash == hash) // found the key
{
return(true);
}
cur = entry->next;
}
return(false);
}
public static void *Get(PtrIntDict *self, int hash)
{
#if FDB
Verify(self);
#endif
int cur = self->arr[(uint)hash % self->len];
var entries = self->entries;
while (cur != -1)
{
var entry = entries + cur;
if (entry->hash == hash) // found the key
{
return(entry->val);
}
cur = entry->next;
}
return(null);
}
public static void *Remove(PtrIntDict *self, int hash)
{
#if FDB
Verify(self);
#endif
int *arr = self->arr;
long mod = (uint)hash % self->len;
int cur = arr[mod], prev = -1;
var entries = self->entries;
while (cur != -1)
{
var entry = entries + cur;
if (entry->hash == hash) // found the key
{
if (prev != -1)
{
entries[prev].next = entry->next;
}
else // the first entry in the bucket
{
arr[mod] = entry->next;
}
// insert into the front of free list
void *val = entry->val;
entry->val = null;
entry->next = self->free;
self->free = cur;
self->count -= 1;
#if FDB
Verify(self);
#endif
return(val);
}
prev = cur;
cur = entry->next;
}
// do nothing if no key is found
#if FDB
Fdb.Error("hash {0:X} does not exist in NumDict {1:X}", hash, (long)self);
#endif
return(null);
}
public static void Set(PtrIntDict *self, int hash, void *val)
{
#if FDB
Verify(self);
Should.NotNull("val", val);
#endif
int * arr = self->arr;
long mod = (uint)hash % self->len;
int idx = arr[mod], cur = idx;
var entries = self->entries;
Entry *entry = null;
while (cur != -1)
{
entry = entries + cur;
if (entry->hash == hash) // found the key
{
entry->val = val;
#if FDB
Verify(self);
#endif
return;
}
cur = entry->next;
}
// find a free entry
int free = self->free;
if (free == -1) // expand
{
int level = self->level += 1;
int oldLen = self->len;
int len = self->len = Const.Lens[level];
// rehash
int EntrySize = Const.EntrySize;
entries = self->entries = (Entry *)Mem.Realloc(entries, len * (EntrySize + IntSize));
arr = self->arr = (int *)((byte *)entries + len * EntrySize);
for (int i = 0; i < len; i += 1)
{
arr[i] = -1; // clear the buckets
}
for (int i = 0; i < oldLen; i += 1)
{
entries[i].next = -1; // clear old links
}
for (int i = 0; i < oldLen; i += 1) // insert all old entries
{
entry = entries + i;
mod = (uint)entry->hash % len;
entry->next = arr[mod];
arr[mod] = i;
}
// link all new entries
self->free = oldLen + 1; // point to new allocated entries
for (int i = oldLen + 1; i < len; i += 1)
{
entry = entries + i;
entry->val = null;
entry->next = i + 1;
}
entry->next = -1; // the last free entry
entry = entries + oldLen;
idx = arr[mod = (uint)hash % len]; // different idx after expand
free = oldLen;
}
else
{
entry = entries + free;
self->free = entry->next;
}
entry->hash = hash;
entry->next = idx;
entry->val = val;
arr[mod] = free;
self->count += 1;
#if FDB
Verify(self);
#endif
}
