protected V SetValueForEntry(Tuple2KeyEntry <Key1, Key2, V> entry, V value)
{
V oldValue = entry.GetValue();
entry.SetValue(value);
return(oldValue);
}
public V Put(Key1 key1, Key2 key2, V value)
{
int hash = Hash(ExtractHash(key1, key2));
Tuple2KeyEntry <Key1, Key2, V>[] table = this.table;
int i = hash & (table.Length - 1);
Tuple2KeyEntry <Key1, Key2, V> entry = table[i];
while (entry != null)
{
if (EqualKeys(key1, key2, entry))
{
if (IsSetValueForEntryAllowed())
{
return(SetValueForEntry(entry, value));
}
V oldValue = entry.GetValue();
RemoveEntryForKey(key1, key2);
AddEntry(hash, key1, key2, value, i);
return(oldValue);
}
entry = entry.GetNextEntry();
}
AddEntry(hash, key1, key2, value, i);
return(default(V));
}
public void ToString(StringBuilder sb)
{
sb.Append(Count).Append(" items: [");
bool first = true;
Tuple2KeyEntry <Key1, Key2, V>[] table = this.table;
for (int a = table.Length; a-- > 0;)
{
Tuple2KeyEntry <Key1, Key2, V> entry = table[a];
while (entry != null)
{
if (first)
{
first = false;
}
else
{
sb.Append(',');
}
StringBuilderUtil.AppendPrintable(sb, entry);
entry = entry.GetNextEntry();
}
}
sb.Append(']');
}
protected V RemoveEntryForKey(Key1 key1, Key2 key2)
{
int hash = Hash(ExtractHash(key1, key2));
Tuple2KeyEntry <Key1, Key2, V>[] table = this.table;
int i = hash & (table.Length - 1);
Tuple2KeyEntry <Key1, Key2, V> entry = table[i];
if (entry != null)
{
if (EqualKeys(key1, key2, entry))
{
table[i] = entry.GetNextEntry();
V value = entry.GetValue();
EntryRemoved(entry);
return(value);
}
Tuple2KeyEntry <Key1, Key2, V> prevEntry = entry;
entry = entry.GetNextEntry();
while (entry != null)
{
if (EqualKeys(key1, key2, entry))
{
prevEntry.SetNextEntry(entry.GetNextEntry());
V value = entry.GetValue();
EntryRemoved(entry);
return(value);
}
prevEntry = entry;
entry = entry.GetNextEntry();
}
}
return(default(V));
}
public Tuple2KeyEntry(Key1 key1, Key2 key2, V value, int hash, Tuple2KeyEntry <Key1, Key2, V> nextEntry)
{
this.key1 = key1;
this.key2 = key2;
this.value = value;
this.hash = hash;
this.nextEntry = nextEntry;
}
public override void Remove()
{
if (!removeAllowed)
{
throw new NotSupportedException();
}
hashMap.Remove(currEntry.GetKey1(), currEntry.GetKey2());
currEntry = null;
}
protected void AddEntry(int hash, Key1 key1, Key2 key2, V value, int bucketIndex)
{
Tuple2KeyEntry <Key1, Key2, V>[] table = this.table;
Tuple2KeyEntry <Key1, Key2, V> e = table[bucketIndex];
e = CreateEntry(hash, key1, key2, value, e);
table[bucketIndex] = e;
EntryAdded(e);
if (Count >= threshold)
{
Resize(2 * table.Length);
}
}
protected Tuple2KeyEntry <Key1, Key2, V> GetNextBucketFromIndex(int index)
{
Tuple2KeyEntry <Key1, Key2, V>[] table = this.table;
while (index-- > 0)
{
Tuple2KeyEntry <Key1, Key2, V> entry = table[index];
if (entry != null)
{
this.index = index;
return(entry);
}
}
return(null);
}
public V[] ToArray(V[] targetArray)
{
int index = 0;
Tuple2KeyEntry <Key1, Key2, V>[] table = this.table;
for (int a = table.Length; a-- > 0;)
{
Tuple2KeyEntry <Key1, Key2, V> entry = table[a];
while (entry != null)
{
targetArray[index++] = entry.GetValue();
entry = entry.GetNextEntry();
}
}
return(targetArray);
}
public IList <V> Values()
{
Tuple2KeyEntry <Key1, Key2, V>[] table = this.table;
List <V> valueList = new List <V>(Count);
for (int a = table.Length; a-- > 0;)
{
Tuple2KeyEntry <Key1, Key2, V> entry = table[a];
while (entry != null)
{
valueList.Add(entry.GetValue());
entry = entry.GetNextEntry();
}
}
return(valueList);
}
public bool ContainsKey(Key1 key1, Key2 key2)
{
int hash = Hash(ExtractHash(key1, key2));
Tuple2KeyEntry <Key1, Key2, V>[] table = this.table;
int i = hash & (table.Length - 1);
Tuple2KeyEntry <Key1, Key2, V> entry = table[i];
while (entry != null)
{
if (EqualKeys(key1, key2, entry))
{
return(true);
}
entry = entry.GetNextEntry();
}
return(false);
}
public V Get(Key1 key1, Key2 key2)
{
int hash = Hash(ExtractHash(key1, key2));
Tuple2KeyEntry <Key1, Key2, V>[] table = this.table;
int i = hash & (table.Length - 1);
Tuple2KeyEntry <Key1, Key2, V> entry = table[i];
while (entry != null)
{
if (EqualKeys(key1, key2, entry))
{
return(entry.GetValue());
}
entry = entry.GetNextEntry();
}
return(default(V));
}
protected virtual void Transfer(Tuple2KeyEntry <Key1, Key2, V>[] newTable)
{
int newCapacityMinus1 = newTable.Length - 1;
Tuple2KeyEntry <Key1, Key2, V>[] table = this.table;
for (int a = table.Length; a-- > 0;)
{
Tuple2KeyEntry <Key1, Key2, V> entry = table[a], next;
while (entry != null)
{
next = entry.GetNextEntry();
int i = entry.GetHash() & newCapacityMinus1;
entry.SetNextEntry(newTable[i]);
newTable[i] = entry;
entry = next;
}
}
}
public bool RemoveIfValue(Key1 key1, Key2 key2, V value)
{
int hash = Hash(ExtractHash(key1, key2));
Tuple2KeyEntry <Key1, Key2, V>[] table = this.table;
int i = hash & (table.Length - 1);
Tuple2KeyEntry <Key1, Key2, V> entry = table[i];
if (entry != null)
{
if (EqualKeys(key1, key2, entry))
{
table[i] = entry.GetNextEntry();
V existingValue = entry.GetValue();
if (!Object.ReferenceEquals(existingValue, value)) // Test if reference identical
{
return(false);
}
EntryRemoved(entry);
return(true);
}
Tuple2KeyEntry <Key1, Key2, V> prevEntry = entry;
entry = entry.GetNextEntry();
while (entry != null)
{
if (EqualKeys(key1, key2, entry))
{
prevEntry.SetNextEntry(entry.GetNextEntry());
V existingValue = entry.GetValue();
if (!Object.ReferenceEquals(existingValue, value)) // Test if reference identical
{
return(false);
}
EntryRemoved(entry);
return(true);
}
prevEntry = entry;
entry = entry.GetNextEntry();
}
}
return(false);
}
public bool PutIfNotExists(Key1 key1, Key2 key2, V value)
{
int hash = Hash(ExtractHash(key1, key2));
Tuple2KeyEntry <Key1, Key2, V>[] table = this.table;
int i = hash & (table.Length - 1);
Tuple2KeyEntry <Key1, Key2, V> entry = table[i];
while (entry != null)
{
if (EqualKeys(key1, key2, entry))
{
return(false);
}
entry = entry.GetNextEntry();
}
AddEntry(hash, key1, key2, value, i);
return(true);
}
public override bool MoveNext()
{
if (first)
{
currEntry = GetNextBucketFromIndex(table.Length);
if (currEntry == null)
{
return(false);
}
first = false;
return(true);
}
else if (currEntry != null)
{
currEntry = currEntry.GetNextEntry();
}
if (currEntry == null)
{
currEntry = GetNextBucketFromIndex(index);
}
return(currEntry != null);
}
public void Clear()
{
if (IsEmpty)
{
return;
}
Tuple2KeyEntry <Key1, Key2, V>[] table = this.table;
for (int a = table.Length; a-- > 0;)
{
Tuple2KeyEntry <Key1, Key2, V> entry = table[a];
if (entry != null)
{
table[a] = null;
while (entry != null)
{
Tuple2KeyEntry <Key1, Key2, V> nextEntry = entry.GetNextEntry();
EntryRemoved(entry);
entry = nextEntry;
}
}
}
}
/**
* @see java.util.Map#containsValue(java.lang.Object)
*/
public bool ContainsValue(V value)
{
Tuple2KeyEntry <Key1, Key2, V>[] table = this.table;
if (value == null)
{
for (int a = table.Length; a-- > 0;)
{
Tuple2KeyEntry <Key1, Key2, V> entry = table[a];
while (entry != null)
{
Object entryValue = entry.GetValue();
if (entryValue == null)
{
return(true);
}
entry = entry.GetNextEntry();
}
}
}
else
{
for (int a = table.Length; a-- > 0;)
{
Tuple2KeyEntry <Key1, Key2, V> entry = table[a];
while (entry != null)
{
Object entryValue = entry.GetValue();
if (value.Equals(entryValue))
{
return(true);
}
entry = entry.GetNextEntry();
}
}
}
return(false);
}
protected virtual bool EqualKeys(Key1 key1, Key2 key2, Tuple2KeyEntry <Key1, Key2, V> entry)
{
return(Object.Equals(key1, entry.GetKey1()) && Object.Equals(key2, entry.GetKey2()));
}
protected virtual void EntryRemoved(Tuple2KeyEntry <Key1, Key2, V> entry)
{
// Intended blank
}
protected abstract Tuple2KeyEntry <Key1, Key2, V> CreateEntry(int hash, Key1 key1, Key2 key2, V value,
Tuple2KeyEntry <Key1, Key2, V> nextEntry);
public void SetNextEntry(Tuple2KeyEntry <Key1, Key2, V> nextEntry)
{
this.nextEntry = nextEntry;
}