private static bool TryInsert <K, V>(UnsafeSortedDictionary *map, K key, V value, MapInsertionBehaviour behaviour)
where K : unmanaged, IComparable <K>
where V : unmanaged
{
UDebug.Assert(map != null);
UDebug.Assert(typeof(K).TypeHandle.Value == map->_typeHandleKey);
UDebug.Assert(typeof(V).TypeHandle.Value == map->_typeHandleValue);
var entry = UnsafeOrderedCollection.Find <K>(&map->_collection, key);
// Entry is already present
if (entry != null)
{
if (behaviour == MapInsertionBehaviour.Overwrite)
{
*GetValue <V>(map->_valueOffset, entry) = value;
return(true);
}
if (behaviour == MapInsertionBehaviour.ThrowIfExists)
{
throw new ArgumentException(string.Format(ThrowHelper.Arg_AddingDuplicateWithKey, key));
}
return(false);
}
// Create new entry
else
{
entry = UnsafeOrderedCollection.Insert <K>(&map->_collection, key);
*GetValue <V>(map->_valueOffset, entry) = value;
return(true);
}
}
public static void CopyTo <K, V>(UnsafeSortedDictionary *map, KeyValuePair <K, V>[] destination, int destinationIndex)
where K : unmanaged, IComparable <K>
where V : unmanaged
{
if (destination == null)
{
throw new ArgumentNullException(nameof(destination));
}
if (GetCount(map) + (uint)destinationIndex > destination.Length)
{
throw new ArgumentOutOfRangeException(ThrowHelper.Arg_ArrayPlusOffTooSmall);
}
UDebug.Assert(map != null);
UDebug.Assert(typeof(K).TypeHandle.Value == map->_typeHandleKey);
UDebug.Assert(typeof(V).TypeHandle.Value == map->_typeHandleValue);
UDebug.Assert(destination != null);
UDebug.Assert(destination.Length >= GetCount(map) + destinationIndex);
var enumerator = GetEnumerator <K, V>(map);
int i = 0;
while (enumerator.MoveNext())
{
destination[destinationIndex + i] = enumerator.Current;
i++;
}
}
public static bool ContainsKey <K>(UnsafeSortedDictionary *map, K key)
where K : unmanaged, IComparable <K>
{
UDebug.Assert(map != null);
UDebug.Assert(typeof(K).TypeHandle.Value == map->_typeHandleKey);
return(UnsafeOrderedCollection.Find <K>(&map->_collection, key) != null);
}
public static KeyEnumerator <K> GetKeyEnumerator <K>(UnsafeSortedDictionary *map)
where K : unmanaged, IComparable <K>
{
UDebug.Assert(map != null);
UDebug.Assert(typeof(K).TypeHandle.Value == map->_typeHandleKey);
return(new KeyEnumerator <K>(map));
}
public static ValueEnumerator <V> GetValueEnumerator <V>(UnsafeSortedDictionary *map)
where V : unmanaged
{
UDebug.Assert(map != null);
UDebug.Assert(typeof(V).TypeHandle.Value == map->_typeHandleValue);
return(new ValueEnumerator <V>(map));
}
public static V Get <K, V>(UnsafeSortedDictionary *map, K key)
where K : unmanaged, IComparable <K>
where V : unmanaged
{
var entry = UnsafeOrderedCollection.Find(&map->_collection, key);
if (entry == null)
{
throw new ArgumentException(string.Format(ThrowHelper.Arg_KeyNotFoundWithKey, key));
}
return(*GetValue <V>(map->_valueOffset, entry));
}
public static bool ContainsValue <V>(UnsafeSortedDictionary *map, V value)
where V : unmanaged, IEquatable <V>
{
var iterator = new ValueEnumerator <V>(map);
while (iterator.MoveNext())
{
if (value.Equals(iterator.Current))
{
return(true);
}
}
return(false);
}
public static bool TryGetValue <K, V>(UnsafeSortedDictionary *map, K key, out V val)
where K : unmanaged, IComparable <K>
where V : unmanaged
{
var entry = UnsafeOrderedCollection.Find <K>(&map->_collection, key);
if (entry != null)
{
val = *GetValue <V>(map->_valueOffset, entry);
return(true);
}
val = default;
return(false);
}
public static void Free(UnsafeSortedDictionary *map)
{
if (map == null)
{
return;
}
if (map->_collection.Entries.Dynamic == 1)
{
UnsafeBuffer.Free(&map->_collection.Entries);
}
// clear memory
*map = default;
// free it
Memory.Free(map);
}
public ValueEnumerator(UnsafeSortedDictionary *dictionary)
{
_valueOffset = dictionary->_valueOffset;
_iterator = new UnsafeOrderedCollection.Enumerator(&dictionary->_collection);
}
public static int GetCount(UnsafeSortedDictionary *map)
{
UDebug.Assert(map != null);
return(UnsafeOrderedCollection.GetCount(&map->_collection));
}
public static bool IsFixedSize(UnsafeSortedDictionary *map)
{
UDebug.Assert(map != null);
return(map->_collection.Entries.Dynamic == 0);
}
public KeyEnumerator(UnsafeSortedDictionary *dictionary)
{
_keyOffset = dictionary->_collection.KeyOffset;
_iterator = new UnsafeOrderedCollection.Enumerator(&dictionary->_collection);
}
public static void Add <K, V>(UnsafeSortedDictionary *map, K key, V value)
where K : unmanaged, IComparable <K>
where V : unmanaged
{
TryInsert(map, key, value, MapInsertionBehaviour.ThrowIfExists);
}
public static bool TryAdd <K, V>(UnsafeSortedDictionary *map, K key, V value)
where K : unmanaged, IComparable <K>
where V : unmanaged
{
return(TryInsert(map, key, value, MapInsertionBehaviour.None));
}
public static void Clear(UnsafeSortedDictionary *map)
{
UDebug.Assert(map != null);
UnsafeOrderedCollection.Clear(&map->_collection);
}
public static void Set <K, V>(UnsafeSortedDictionary *map, K key, V value)
where K : unmanaged, IComparable <K>
where V : unmanaged
{
TryInsert(map, key, value, MapInsertionBehaviour.Overwrite);
}
public static int GetCapacity(UnsafeSortedDictionary *map)
{
UDebug.Assert(map != null);
return(map->_collection.Entries.Length);
}