public bool ContainsValue <TKey, TValue>(Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue> dictionary, TValue value)
{
if (value == null)
{
for (var i = 0; i < dictionary.Count; i++)
{
if (dictionary.Entries[i].HashCode >= 0 && dictionary.Entries[i].Value == null)
{
return(true);
}
}
}
else
{
var c = EqualityComparer <TValue> .Default;
for (var i = 0; i < dictionary.Count; i++)
{
if (dictionary.Entries[i].HashCode >= 0 && c.Equals(dictionary.Entries[i].Value, value))
{
return(true);
}
}
}
return(false);
}
public void CopyTo <TKey, TValue>(Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue> dictionary, Models.E01D.Core.Collections.KeyValuePair <TKey, TValue>[] array, int index)
{
if (array == null)
{
throw XExceptions.Argument.IsNull(nameof(array));
}
if (index < 0 || index > array.Length)
{
throw XExceptions.Argument.OutOfRange.NeedNonNegativeNumber();
}
if (array.Length - index < dictionary.Count)
{
throw XExceptions.Api.Arrays.InsufficientSpaceToCopy();
}
var count = dictionary.Count;
var entries = dictionary.Entries;
for (var i = 0; i < count; i++)
{
if (entries[i].HashCode >= 0)
{
array[index++] = new Models.E01D.Core.Collections.KeyValuePair <TKey, TValue>(entries[i].Key, entries[i].Value);
}
}
}
// Method similar to TryGetValue that returns the value instead of putting it in an out param. If the entry
// doesn't exist, returns the defaultValue instead.
public TValue GetValueOrDefault <TKey, TValue>(Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue> dictionary, TKey key, TValue defaultValue)
{
var i = FindEntry(dictionary, key);
if (i >= 0)
{
return(dictionary.Entries[i].Value);
}
return(defaultValue);
}
public TValue GetValue <TValue, TKey>(Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue> dictionary, TKey key)
{
int i = FindEntry(dictionary, key);
if (i >= 0)
{
return(dictionary.Entries[i].Value);
}
throw new Exception("KeyNotFound");
}
public bool TryGetValue <TKey, TValue>(Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue> dictionary, TKey key, out TValue value)
{
var i = FindEntry(dictionary, key);
if (i >= 0)
{
value = dictionary.Entries[i].Value;
return(true);
}
value = default(TValue);
return(false);
}
/// <summary>
/// Clones a dictionary
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <typeparam name="TValue"></typeparam>
/// <param name="dictionary"></param>
/// <returns></returns>
public Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue> Clone <TKey, TValue>(Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue> dictionary)
{
if (dictionary == null)
{
return(null);
}
if (dictionary?.Buckets.Length > 0 && dictionary?.Entries.Length > 0)
{
var newDictionary = new Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue>()
{
Buckets = new int[dictionary.Buckets.Length],
Entries = new DictionaryEntry <TKey, TValue> [dictionary.Entries.Length],
Count = dictionary.Count
};
for (var i = 0; i < dictionary.Buckets.Length; i++)
{
newDictionary.Buckets[i] = dictionary.Buckets[i];
}
for (var i = 0; i < dictionary.Entries.Length; i++)
{
var newEntry = new DictionaryEntry <TKey, TValue>()
{
HashCode = newDictionary.Entries[i].HashCode,
Next = newDictionary.Entries[i].Next,
Key = newDictionary.Entries[i].Key,
Value = newDictionary.Entries[i].Value,
};
newDictionary.Entries[i] = newEntry;
}
return(newDictionary);
}
else
{
var newDictionary = new Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue>();
throw new System.NotImplementedException();
//foreach (var item in dictionary)
//{
// newDictionary.Add(item.Key, item.Value);
//}
//return newDictionary;
}
}
public KeyCollection <TKey, TValue> Create <TKey, TValue>(Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue> dictionary)
{
if (dictionary == null)
{
throw XExceptions.Argument.IsNull(nameof(dictionary));
}
var collection = new KeyCollection <TKey, TValue>
{
Dictionary = dictionary
};
return(collection);
}
private void Initialize <TKey, TValue>(Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue> dictionary, int capacity)
{
var size = Hashing.GetPrime(capacity);
dictionary.Buckets = new int[size];
for (var i = 0; i < dictionary.Buckets.Length; i++)
{
dictionary.Buckets[i] = -1;
}
dictionary.Entries = new DictionaryEntry <TKey, TValue> [size];
dictionary.FreeList = -1;
}
public void Clear <TKey, TValue>(Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue> dictionary)
{
if (dictionary.Count > 0)
{
for (var i = 0; i < dictionary.Buckets.Length; i++)
{
dictionary.Buckets[i] = -1;
}
Array.Clear(dictionary.Entries, 0, dictionary.Count);
dictionary.FreeList = -1;
dictionary.Count = 0;
dictionary.FreeCount = 0;
dictionary.Version++;
}
}
public int FindEntry <TKey, TValue>(Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue> dictionary, TKey key)
{
if (key == null)
{
throw XExceptions.Argument.IsNull(nameof(key));
}
if (dictionary.Buckets != null)
{
var hashCode = dictionary.Comparer.GetHashCode(key) & 0x7FFFFFFF;
for (var i = dictionary.Buckets[hashCode % dictionary.Buckets.Length]; i >= 0; i = dictionary.Entries[i].Next)
{
if (dictionary.Entries[i].HashCode == hashCode && dictionary.Comparer.Equals(dictionary.Entries[i].Key, key))
{
return(i);
}
}
}
return(-1);
}
public bool Remove <TKey, TValue>(Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue> dictionary, TKey key)
{
if (key == null)
{
throw XExceptions.Argument.IsNull(nameof(key));
}
if (dictionary.Buckets != null)
{
var hashCode = dictionary.Comparer.GetHashCode(key) & 0x7FFFFFFF;
var bucket = hashCode % dictionary.Buckets.Length;
var last = -1;
for (var i = dictionary.Buckets[bucket]; i >= 0; last = i, i = dictionary.Entries[i].Next)
{
if (dictionary.Entries[i].HashCode == hashCode && dictionary.Comparer.Equals(dictionary.Entries[i].Key, key))
{
if (last < 0)
{
dictionary.Buckets[bucket] = dictionary.Entries[i].Next;
}
else
{
dictionary.Entries[last].Next = dictionary.Entries[i].Next;
}
dictionary.Entries[i].HashCode = -1;
dictionary.Entries[i].Next = dictionary.FreeList;
dictionary.Entries[i].Key = default(TKey);
dictionary.Entries[i].Value = default(TValue);
dictionary.FreeList = i;
dictionary.FreeCount++;
dictionary.Version++;
return(true);
}
}
}
return(false);
}
private void Resize <TKey, TValue>(Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue> dictionary, int newSize, bool forceNewHashCodes)
{
XDebug.Assert(newSize >= dictionary.Entries.Length);
var newBuckets = new int[newSize];
for (var i = 0; i < newBuckets.Length; i++)
{
newBuckets[i] = -1;
}
var newEntries = new DictionaryEntry <TKey, TValue> [newSize];
Array.Copy(dictionary.Entries, 0, newEntries, 0, dictionary.Count);
if (forceNewHashCodes)
{
for (var i = 0; i < dictionary.Count; i++)
{
if (newEntries[i].HashCode != -1)
{
newEntries[i].HashCode = (dictionary.Comparer.GetHashCode(newEntries[i].Key) & 0x7FFFFFFF);
}
}
}
for (var i = 0; i < dictionary.Count; i++)
{
if (newEntries[i].HashCode >= 0)
{
var bucket = newEntries[i].HashCode % newSize;
newEntries[i].Next = newBuckets[bucket];
newBuckets[bucket] = i;
}
}
dictionary.Buckets = newBuckets;
dictionary.Entries = newEntries;
}
public Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue> Create <TKey, TValue>(int capacity, IEqualityComparer <TKey> comparer, Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue> dictionary)
{
if (capacity < 0)
{
throw XExceptions.Argument.OutOfRange.CapacityLessThanZero(nameof(capacity));
}
if (capacity > 0)
{
Initialize(dictionary, capacity);
}
dictionary.Comparer = comparer ?? EqualityComparer <TKey> .Default;
#if FEATURE_RANDOMIZED_STRING_HASHING
if (HashHelpers.s_UseRandomizedStringHashing && comparer == EqualityComparer <string> .Default)
{
this.comparer = (IEqualityComparer <TKey>)NonRandomizedStringEqualityComparer.Default;
}
#endif // FEATURE_RANDOMIZED_STRING_HASHING
return(dictionary);
}
public void SetValue <TValue, TKey>(Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue> dictionary, TKey key,
TValue xValue)
{
Insert(dictionary, key, xValue, false);
}
// Method similar to TryGetValue that returns the value instead of putting it in an out param. public TValue GetValueOrDefault <TKey, TValue>(Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue> dictionary, TKey key) => GetValueOrDefault(dictionary, key, default(TValue));
public void Add <TKey, TValue>(Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue> dictionary, TKey key, TValue value)
{
Insert(dictionary, key, value, true);
}
private void Resize <TKey, TValue>(Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue> dictionary)
{
Resize(dictionary, Hashing.ExpandPrime(dictionary.Count), false);
}
private void Insert <TKey, TValue>(Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue> dictionary, TKey key, TValue value, bool add)
{
if (dictionary.Comparer == null)
{
Create(0, null, dictionary);
}
if (key == null)
{
throw XExceptions.Argument.IsNull(nameof(key));
}
if (dictionary.Buckets == null)
{
Initialize(dictionary, 0);
}
var hashCode = dictionary.Comparer.GetHashCode(key) & 0x7FFFFFFF;
var targetBucket = hashCode % dictionary.Buckets.Length;
#if FEATURE_RANDOMIZED_STRING_HASHING
int collisionCount = 0;
#endif
for (var i = dictionary.Buckets[targetBucket]; i >= 0; i = dictionary.Entries[i].Next)
{
if (dictionary.Entries[i].HashCode == hashCode && dictionary.Comparer.Equals(dictionary.Entries[i].Key, key))
{
if (add)
{
throw XExceptions.Argument.AddingDuplicateWithKey(key);
}
dictionary.Entries[i].Value = value;
dictionary.Version++;
return;
}
#if FEATURE_RANDOMIZED_STRING_HASHING
collisionCount++;
#endif
}
int index;
if (dictionary.FreeCount > 0)
{
index = dictionary.FreeList;
dictionary.FreeList = dictionary.Entries[index].Next;
dictionary.FreeCount--;
}
else
{
if (dictionary.Count == dictionary.Entries.Length)
{
Resize(dictionary);
targetBucket = hashCode % dictionary.Buckets.Length;
}
index = dictionary.Count;
dictionary.Count++;
}
dictionary.Entries[index].HashCode = hashCode;
dictionary.Entries[index].Next = dictionary.Buckets[targetBucket];
dictionary.Entries[index].Key = key;
dictionary.Entries[index].Value = value;
dictionary.Buckets[targetBucket] = index;
dictionary.Version++;
#if FEATURE_RANDOMIZED_STRING_HASHING
// In case we hit the collision threshold we'll need to switch to the comparer which is using randomized string hashing
// in this case will be EqualityComparer<string>.Default.
// Note, randomized string hashing is turned on by default on coreclr so EqualityComparer<string>.Default will
// be using randomized string hashing
if (collisionCount > HashHelpers.HashCollisionThreshold && comparer == NonRandomizedStringEqualityComparer.Default)
{
comparer = (IEqualityComparer <TKey>)EqualityComparer <string> .Default;
Resize(entries.Length, true);
}
#endif
}
public bool ContainsKey <TKey, TValue>(Root.Code.Models.E01D.Core.Collections.Generic.Dictionary <TKey, TValue> dictionary, TKey key)
{
return(FindEntry <TKey, TValue>(dictionary, key) >= 0);
}
