private HashtableItem <T, K> GetEntry(T value)
{
// Compute the hashcode of the object.
int hashcode = this.hashcode_proc(value);
// Compute the index into the indice table.
int index = hashcode % this.indice_count;
// Check if there is a HashtableItem at this index.
if (this.indices[index] == -1)
{
return(null);
}
// Loop through the bucket and search for an entry with matching value.
for (HashtableItem <T, K> item = this.nodes[this.indices[index]];
item != null; item = item.Next)
{
// Check if the hashcode matches.
if (item.Hashcode != hashcode)
{
continue;
}
// Check if the objects matching using the compare proc.
if (this.compare_proc(value, item.Value) == true)
{
return(item);
}
}
// An entry with matching value was not found, return null;
return(null);
}
/// <summary>
/// Clears all the items from the hashtable.
/// </summary>
public void Clear()
{
// Clear the indice array.
for (int i = 0; i < this.indice_count; i++)
{
this.indices[i] = -1;
}
// Set the head node pointer to null.
this.items = null;
// Initialize the linked list of HashtableItem nodes.
for (int i = 0; i < this.Capacity; i++)
{
// Initialize the node.
this.nodes[i] = new HashtableItem <T, K>();
this.nodes[i].Value = default(T);
this.nodes[i].Key = default(K);
this.nodes[i].Hashcode = 0;
this.nodes[i].Next = this.items;
// Set the new head node to this HashtableItem structure.
this.items = this.nodes[i];
}
}
/// <summary>
/// Adds a value-key pair to the hashtable.
/// </summary>
/// <param name="value">Object to add to the hashtable.</param>
/// <param name="key">Unique key object that corresponds with <paramref name="value"/></param>
/// <returns>True if the item was added, false otherwise.</returns>
public bool Add(T value, K key)
{
// Check if there are any empty items in the hashtable left.
if (this.items == null)
{
return(false);
}
// Compute the hashcode of the item.
int hashcode = this.hashcode_proc(value);
// Get the next unused HashtableItem structure.
HashtableItem <T, K> item = this.items;
item.Value = value;
item.Key = key;
item.Hashcode = hashcode;
// Update the head node pointer.
this.items = item.Next;
// Compute the index into the indice table.
int index = hashcode % this.indice_count;
// Update the next pointer for the new HashtableItem.
item.Next = this.indices[index] == -1 ? null : this.nodes[this.indices[index]];
// Update the indice table to point to our new HashtableItem.
this.indices[index] = Array.IndexOf(this.nodes, item);
// The item was successfully added.
return(true);
}
public T ContainsValue(T value, ref K key)
{
// Try to find a HashtableItem with matching value.
HashtableItem <T, K> item = GetEntry(value);
if (item == null)
{
return(default(T));
}
// Copy the key object.
key = item.Key;
// Return the item value.
return(item.Value);
}
public bool GetKey(T value, ref K key)
{
// Satisfy the compiler.
//key = default(K);
// Try to find a HashtableItem with matching value.
HashtableItem <T, K> item = GetEntry(value);
if (item == null)
{
return(false);
}
// Copy the key object and return true.
key = item.Key;
return(true);
}
