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); } }