static void AddTranslation(Keys srcKey, KeyTranslation translation)
{
byte index = (byte)srcKey;
if (m_translationTable[index] == null)
m_translationTable[index] = new List<KeyTranslation>(2);
m_translationTable[index].Add(translation);
}
static void AddTranslation(Keys srcKey, KeyTranslation translation)
{
byte index = (byte)srcKey;
if (m_translationTable[index] == null)
{
m_translationTable[index] = new List <KeyTranslation>(2);
}
m_translationTable[index].Add(translation);
}
public MetaData LoadMetaData(int key)
{
int key_pointer = GetKeyPointer(key);
if (key_pointer == -1)
{
throw new System.Exception("Key does not exist");
}
KeyTranslation k = keys[key_pointer];
return(k.meta_data);
}
public void SaveMetaData(int key, MetaData meta_data)
{
int key_pointer = GetKeyPointer(key);
if (key_pointer == -1)
{
throw new System.Exception("Key does not exist");
}
KeyTranslation k = keys[key_pointer];
k.meta_data = meta_data;
keys[key_pointer] = k;
}
// Get the first value form list in the key:[list]
public int GetFirstValue(int key)
{
int key_pointer = GetKeyPointer(key);
if (key_pointer == -1)
{
throw new System.Exception("Key does not exist");
return(-1);
}
KeyTranslation x = keys[key_pointer];
return(x.index);
}
public int Observe(int key, int index)
{
Logging.log.Trace($"Observing on key: {key} at index: {index}");
int key_pointer = GetKeyPointer(key);
if (key_pointer == -1)
{
throw new System.Exception("Key does not exist");
}
KeyTranslation k = keys[key_pointer];
// With the pointer from the key lookup, we can traverse the link list
return(TraverseLinkPointerExact(k.index, index - k.offset));
}
// Mark the current key as free, and therefore release all list data
public bool Free(int key)
{
int key_pointer = GetKeyPointer(key);
if (key_pointer == -1)
{
throw new System.Exception("Key does not exist");
return(false);
}
KeyTranslation x = keys[key_pointer];
x.used = false;
keys[key_pointer] = x;
TraverseLinkPointerAndFree(keys[key_pointer].index);
return(true);
}
// Get the length of the list
public int ListLength(int key)
{
int key_pointer = GetKeyPointer(key);
if (key_pointer == -1)
{
throw new System.Exception("Key does not exist");
return(-1);
}
KeyTranslation k = keys[key_pointer];
// if the list is 0 long, return as such
if (k.index == -1)
{
return(0);
}
int last_index = TraverseLinkPointerToEnd(k.index);
return(DistancebetweenLinks(k.index, last_index) + k.offset);
}
public bool New(int key)
{
int count = 0;
// Limit to checking all keys only once
while (count++ < this.keys.Length)
{
// Test if the current free pointer is free
if (!keys[last_key_pointer].used)
{
KeyTranslation x = keys[last_key_pointer];
x.used = true;
x.key = key;
x.index = -1;
keys[last_key_pointer] = x;
Logging.log.Info($"New key: {key} at key pointer: {last_key_pointer}");
return(true);
}
last_key_pointer = (last_key_pointer + 1) % keys.Length;
}
return(false);
}
public DictionaryListSparseLinked(int key_list_length, int total_list_length)
{
this.keys = new KeyTranslation[key_list_length];
this.links = new LinkEntry[total_list_length];
// Reset initial data
for (int i = 0; i < this.links.Length; i++)
{
LinkEntry x = links[i];
x.next = -1;
x.offset = 0;
x.used = false;
links[i] = x;
}
// Reset initial data
for (int i = 0; i < this.keys.Length; i++)
{
KeyTranslation x = keys[i];
x.used = false;
x.index = -1;
keys[i] = x;
}
}
public int Delete(int key, int index)
{
// XXXXXX Possible edgecases
Logging.log.Trace($"Delete called on: key: {key} index: {index}");
int key_pointer = GetKeyPointer(key);
if (key_pointer == -1)
{
throw new System.Exception("Key does not exist");
}
KeyTranslation k = keys[key_pointer];
// If the key is empty, we cant delete stuff
if (k.index == -1)
{
Logging.log.Warn($"The list is empty! key pointer: {key_pointer}");
return(-1);
}
// Get the exact link, if it is not -1, it is not sparse, and we must remove it
int link_index_exact = TraverseLinkPointerExact(k.index, index - k.offset);
// If it is not -1, then it must exist and be correct, therefore return
if (link_index_exact == -1)
{
return(link_index_exact);
}
// If it is the root node, we replace the lookup in keys
if (index == k.offset)
{
// Get the delete node
LinkEntry delete_node = links[link_index_exact];
// Set the key
k.index = delete_node.next;
k.offset = delete_node.offset + k.offset; //index + k.offset; // delete_node.offset + k.offset;
keys[key_pointer] = k;
// Delete it
delete_node.used = false;
delete_node.next = -1;
delete_node.offset = 0;
links[link_index_exact] = delete_node;
return(index);
}
// Is not an root node, it must have an before node, we scope that and shuffle around!
else
{
// Delete the node
LinkEntry delete_node = links[index];
delete_node.used = false;
delete_node.next = -1;
delete_node.offset = 0;
links[index] = delete_node;
// the before node
int link_index_before = TraverseLinkPointerBefore(k.index, index - k.offset);
LinkEntry before_node = links[link_index_before];
before_node.used = true;
before_node.offset = before_node.offset + delete_node.offset;
before_node.next = delete_node.next;
links[link_index_before] = before_node;
return(index);
}
}
public int Insert(int key, int index)
{
Logging.log.Trace($"Inserting on key: {key} at index: {index}");
int key_pointer = GetKeyPointer(key);
int link_index_new = -1;
if (key_pointer == -1)
{
throw new System.Exception("Key does not exist");
}
KeyTranslation k = keys[key_pointer];
// The pointer in the key table is negative 1, therefore we need a new module.
// We create this and returns and saves the pointer
if (k.index == -1)
{
link_index_new = GetFreeLinkAndReserve();
if (link_index_new == -1)
{
throw new System.Exception("Link could not be allocated");
}
// Set the key
k.index = link_index_new;
k.offset = index;
keys[key_pointer] = k;
// Set the list link
LinkEntry link_node_new = links[link_index_new];
link_node_new.used = true;
link_node_new.offset = 0;
link_node_new.next = -1;
links[link_index_new] = link_node_new;
return(link_index_new);
}
int root_index = k.index;
LinkEntry root_node = links[root_index];
// There are now 4 cases:
// * the new node is the very first (Not hitting an node)
// * the node is somewhere in the center of it all(not hitting an node)
// * the node is the very last(Not hitting an node)
// * the node hits an already existing node
// Test if the node actually exist
// Remove the key initial offset
int link_index_exact = TraverseLinkPointerExact(k.index, index - k.offset);
// If it is not -1, then it must exist and be correct, therefore return
if (link_index_exact != -1)
{
return(link_index_exact);
}
// We now know that the root key element points to an element, and
// we are not hitting any elements directly
// We find the element before the next existing element
int link_index_before = TraverseLinkPointerBefore(k.index, index - k.offset);
// If there exist no before element, we are the new root, change accordingly
if (link_index_before == -1)
{
// Get a new link
link_index_new = GetFreeLinkAndReserve();
// Set the key
k.index = link_index_new;
k.offset = index;
keys[key_pointer] = k;
// Set the list link
LinkEntry link_node_new = links[link_index_new];
link_node_new.used = true;
link_node_new.offset = k.offset - index;
link_node_new.next = root_index;
links[link_index_new] = link_node_new;
return(link_index_new);
}
// There exist an before element, we merge between the before and next node
else
{
// Get a new link
link_index_new = GetFreeLinkAndReserve();
LinkEntry link_node_before = links[link_index_before];
// Calculate the link distance from the root offset to the before node
int link_node_before_depth = DistancebetweenLinks(k.index, link_index_before) + k.offset;
link_node_before.used = true;
int link_node_before_offset = link_node_before.offset;
link_node_before.offset = index - link_node_before_depth;
int link_node_before_next = link_node_before.next;
link_node_before.next = link_index_new;
links[link_index_before] = link_node_before;
// Set the list link
LinkEntry link_node_new = links[link_index_new];
link_node_new.used = true;
link_node_new.offset = link_node_before_offset + link_node_before_depth - index; //link_node_before_offset - link_node_before.offset;
link_node_new.next = link_node_before_next;
links[link_index_new] = link_node_new;
return(link_index_new);
}
}
