/// <summary>
/// See the <see cref="IImmutableDictionary{TKey, TValue}"/> interface.
/// </summary>
public ImmutableSortedDictionary <TKey, TValue> AddRange(IEnumerable <KeyValuePair <TKey, TValue> > items)
{
Requires.NotNull(items, nameof(items));
return(this.AddRange(items, overwriteOnCollision: false, avoidToSortedMap: false));
}
public static int IndexOf <T>(this IImmutableList <T> list, T item, IEqualityComparer <T> equalityComparer)
{
Requires.NotNull(list, nameof(list));
return(list.IndexOf(item, 0, list.Count, equalityComparer));
}
public static ImmutableList <TSource> ToImmutableList <TSource>(this ImmutableList <TSource> .Builder builder)
{
Requires.NotNull(builder, nameof(builder));
return(builder.ToImmutable());
}
/// <summary>
/// Adds the specified items to the end of the array.
/// </summary>
/// <param name="items">The items.</param>
public void AddRange <TDerived>(ImmutableArray <TDerived> .Builder items) where TDerived : T
{
Requires.NotNull(items, "items");
this.AddRange(items._elements, items.Count);
}
public static IImmutableList <T> Remove <T>(this IImmutableList <T> list, T value)
{
Requires.NotNull(list, nameof(list));
return(list.Remove(value, EqualityComparer <T> .Default));
}
/// <summary>
/// See the <see cref="IImmutableDictionary{TKey, TValue}"/> interface.
/// </summary>
public bool TryGetKey(TKey equalKey, out TKey actualKey)
{
Requires.NotNullAllowStructs(equalKey, "equalKey");
return(TryGetKey(equalKey, this.Origin, out actualKey));
}
/// <summary>
/// Initializes a new instance of the <see cref="Builder"/> class.
/// </summary>
/// <param name="capacity">The initial capacity of the internal array.</param>
internal Builder(int capacity)
{
Requires.Range(capacity >= 0, "capacity");
_elements = new T[capacity];
_count = 0;
}
/// <summary>
/// Initializes a new instance of the <see cref="HashBucketByValueEqualityComparer"/> class.
/// </summary>
/// <param name="valueComparer">The value comparer for T.</param>
internal HashBucketByValueEqualityComparer(IEqualityComparer <T> valueComparer)
{
Requires.NotNull(valueComparer, nameof(valueComparer));
_valueComparer = valueComparer;
}
/// <summary>
/// Initializes a new instance of the <see cref="DebuggerProxy"/> class.
/// </summary>
/// <param name="map">The collection to display in the debugger</param>
public DebuggerProxy(ImmutableDictionary <TKey, TValue> map)
{
Requires.NotNull(map, "map");
this.map = map;
}
/// <summary>
/// Initializes a new instance of the <see cref="Builder"/> class.
/// </summary>
/// <param name="capacity">The initial capacity of the internal array.</param>
internal Builder(int capacity)
{
Requires.Range(capacity >= 0, "capacity");
this.elements = new RefAsValueType<T>[capacity];
this.Count = 0;
}
internal Comparer(IComparer<T> comparer = null)
{
Requires.NotNull(comparer, "comparer");
this.comparer = comparer;
}
/// <summary>
/// See the <see cref="IImmutableDictionary{TKey, TValue}"/> interface.
/// </summary>
public bool TryGetKey(TKey equalKey, out TKey actualKey)
{
Requires.NotNullAllowStructs(equalKey, nameof(equalKey));
return(_root.TryGetKey(equalKey, _keyComparer, out actualKey));
}
/// <summary>
/// See the <see cref="IImmutableDictionary{TKey, TValue}"/> interface.
/// </summary>
public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
{
Requires.NotNullAllowStructs(key, nameof(key));
return(_root.TryGetValue(key, _keyComparer, out value !));
}
/// <summary>
/// See the <see cref="IImmutableDictionary{TKey, TValue}"/> interface.
/// </summary>
public bool ContainsKey(TKey key)
{
Requires.NotNullAllowStructs(key, nameof(key));
return(_root.ContainsKey(key, _keyComparer));
}
/// <summary>
/// Determines whether the specified key contains key.
/// </summary>
/// <param name="key">The key.</param>
/// <returns>
/// <c>true</c> if the specified key contains key; otherwise, <c>false</c>.
/// </returns>
public bool ContainsKey(TKey key)
{
Requires.NotNullAllowStructs(key, "key");
return(ContainsKey(key, this.Origin));
}
/// <summary>
/// Adds the specified key.
/// </summary>
/// <param name="key">The key.</param>
/// <param name="value">The value.</param>
/// <param name="valueComparer">The value comparer.</param>
/// <param name="replacedExistingValue">Receives a value indicating whether an existing value was replaced.</param>
/// <param name="mutated">Receives a value indicating whether this node tree has mutated because of this operation.</param>
internal SortedInt32KeyNode <TValue> SetItem(int key, TValue value, IEqualityComparer <TValue> valueComparer, out bool replacedExistingValue, out bool mutated)
{
Requires.NotNull(valueComparer, "valueComparer");
return(this.SetOrAdd(key, value, valueComparer, true, out replacedExistingValue, out mutated));
}
/// <summary>
/// See the <see cref="IImmutableDictionary{TKey, TValue}"/> interface.
/// </summary>
public bool TryGetValue(TKey key, out TValue value)
{
Requires.NotNullAllowStructs(key, "key");
return(TryGetValue(key, this.Origin, out value));
}
private static bool IsLeftHeavy(SortedInt32KeyNode <TValue> tree)
{
Requires.NotNull(tree, "tree");
Debug.Assert(!tree.IsEmpty);
return(Balance(tree) <= -2);
}
internal SecurePooledObject(T newValue)
{
Requires.NotNullAllowStructs(newValue, nameof(newValue));
_value = newValue;
}
public static bool Contains <TKey, TValue>(this IImmutableDictionary <TKey, TValue> map, TKey key, TValue value)
{
Requires.NotNull(map, nameof(map));
Requires.NotNullAllowStructs(key, nameof(key));
return(map.Contains(new KeyValuePair <TKey, TValue>(key, value)));
}
/// <summary>
/// Adds the specified items to the end of the array.
/// </summary>
/// <param name="items">The items.</param>
public void AddRange(Builder items)
{
Requires.NotNull(items, "items");
this.AddRange(items._elements, items.Count);
}
public bool IsSupersetOf(IEnumerable <T> other)
{
Requires.NotNull(other, "other");
return(IsSupersetOf(other, this.Origin));
}
/// <summary>
/// Copies the current contents to the specified array.
/// </summary>
/// <param name="array">The array to copy to.</param>
/// <param name="index">The starting index of the target array.</param>
public void CopyTo(T[] array, int index)
{
Requires.NotNull(array, "array");
Requires.Range(index >= 0 && index + this.Count <= array.Length, "start");
Array.Copy(_elements, 0, array, index, this.Count);
}
public bool Overlaps(IEnumerable <T> other)
{
Requires.NotNull(other, "other");
return(Overlaps(other, this.Origin));
}
public static IImmutableList <T> RemoveRange <T>(this IImmutableList <T> list, IEnumerable <T> items)
{
Requires.NotNull(list, nameof(list));
return(list.RemoveRange(items, EqualityComparer <T> .Default));
}
/// <summary>
/// See the <see cref="IImmutableSet{T}"/> interface.
/// </summary>
public bool Contains(T item)
{
Requires.NotNullAllowStructs(item, "item");
return(Contains(item, this.Origin));
}
public static int LastIndexOf <T>(this IImmutableList <T> list, T item, int startIndex, int count)
{
Requires.NotNull(list, nameof(list));
return(list.LastIndexOf(item, startIndex, count, EqualityComparer <T> .Default));
}
/// <summary>
/// Initializes an <see cref="Enumerator"/> structure.
/// </summary>
/// <param name="root">The root of the set to be enumerated.</param>
/// <param name="builder">The builder, if applicable.</param>
/// <param name="startIndex">The index of the first element to enumerate.</param>
/// <param name="count">The number of elements in this collection.</param>
/// <param name="reversed"><c>true</c> if the list should be enumerated in reverse order.</param>
internal Enumerator(Node root, Builder builder = null, int startIndex = -1, int count = -1, bool reversed = false)
{
Requires.NotNull(root, nameof(root));
Requires.Range(startIndex >= -1, nameof(startIndex));
Requires.Range(count >= -1, nameof(count));
Requires.Argument(reversed || count == -1 || (startIndex == -1 ? 0 : startIndex) + count <= root.Count);
Requires.Argument(!reversed || count == -1 || (startIndex == -1 ? root.Count - 1 : startIndex) - count + 1 >= 0);
_root = root;
_builder = builder;
_current = null;
_currentNodeEnumeratingByIndex = null;
_startIndex = startIndex >= 0 ? startIndex : (reversed ? root.Count - 1 : 0);
_currentIndex = _startIndex;
_count = count == -1 ? root.Count : count;
_remainingCount = _count;
_reversed = reversed;
_enumeratingBuilderVersion = builder != null ? builder.Version : -1;
_stackSlot0 = default;
_stackSlot1 = default;
_stackSlot2 = default;
_stackSlot3 = default;
_stackSlot4 = default;
_stackSlot5 = default;
_stackSlot6 = default;
_stackSlot7 = default;
_stackSlot8 = default;
_stackSlot9 = default;
_stackSlot10 = default;
_stackSlot11 = default;
_stackSlot12 = default;
_stackSlot13 = default;
_stackSlot14 = default;
_stackSlot15 = default;
_stackSlot16 = default;
_stackSlot17 = default;
_stackSlot18 = default;
_stackSlot19 = default;
_stackSlot20 = default;
_stackSlot21 = default;
_stackSlot22 = default;
_stackSlot23 = default;
_stackSlot24 = default;
_stackSlot25 = default;
_stackSlot26 = default;
_stackSlot27 = default;
_stackSlot28 = default;
_stackSlot29 = default;
_stackSlot30 = default;
_stackSlot31 = default;
_stackSlot32 = default;
_stackSlot33 = default;
_stackSlot34 = default;
_stackSlot35 = default;
_stackSlot36 = default;
_stackSlot37 = default;
_stackSlot38 = default;
_stackSlot39 = default;
_stackSlot40 = default;
_stackSlot41 = default;
_stackSlot42 = default;
_stackSlot43 = default;
_stackSlot44 = default;
_stackSlot45 = default;
_stackSlot46 = default;
_stackTopIndex = -1;
if (_count > 0)
{
this.ResetStack();
}
}
public static IImmutableList <T> Replace <T>(this IImmutableList <T> list, T oldValue, T newValue)
{
Requires.NotNull(list, nameof(list));
return(list.Replace(oldValue, newValue, EqualityComparer <T> .Default));
}
/// <summary>
/// Returns a read-only reference to the value associated with the provided key.
/// </summary>
/// <exception cref="KeyNotFoundException">If the key is not present.</exception>
public ref readonly TValue ValueRef(TKey key)
{
Requires.NotNullAllowStructs(key, nameof(key));
return(ref _root.ValueRef(key, _keyComparer));
}