963 lines
71 KiB
Markdown
963 lines
71 KiB
Markdown
|
# System.Collections.Immutable
|
||
|
|
||
|
``` diff
|
||
|
+namespace System.Collections.Immutable {
|
||
|
+ public interface IImmutableDictionary<TKey, TValue> : IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
|
||
|
+ IImmutableDictionary<TKey, TValue> Add(TKey key, TValue value);
|
||
|
+ IImmutableDictionary<TKey, TValue> AddRange(IEnumerable<KeyValuePair<TKey, TValue>> pairs);
|
||
|
+ IImmutableDictionary<TKey, TValue> Clear();
|
||
|
+ bool Contains(KeyValuePair<TKey, TValue> pair);
|
||
|
+ IImmutableDictionary<TKey, TValue> Remove(TKey key);
|
||
|
+ IImmutableDictionary<TKey, TValue> RemoveRange(IEnumerable<TKey> keys);
|
||
|
+ IImmutableDictionary<TKey, TValue> SetItem(TKey key, TValue value);
|
||
|
+ IImmutableDictionary<TKey, TValue> SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items);
|
||
|
+ bool TryGetKey(TKey equalKey, out TKey actualKey);
|
||
|
+ }
|
||
|
+ public interface IImmutableList<T> : IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
|
||
|
+ IImmutableList<T> Add(T value);
|
||
|
+ IImmutableList<T> AddRange(IEnumerable<T> items);
|
||
|
+ IImmutableList<T> Clear();
|
||
|
+ int IndexOf(T item, int index, int count, IEqualityComparer<T> equalityComparer);
|
||
|
+ IImmutableList<T> Insert(int index, T element);
|
||
|
+ IImmutableList<T> InsertRange(int index, IEnumerable<T> items);
|
||
|
+ int LastIndexOf(T item, int index, int count, IEqualityComparer<T> equalityComparer);
|
||
|
+ IImmutableList<T> Remove(T value, IEqualityComparer<T> equalityComparer);
|
||
|
+ IImmutableList<T> RemoveAll(Predicate<T> match);
|
||
|
+ IImmutableList<T> RemoveAt(int index);
|
||
|
+ IImmutableList<T> RemoveRange(IEnumerable<T> items, IEqualityComparer<T> equalityComparer);
|
||
|
+ IImmutableList<T> RemoveRange(int index, int count);
|
||
|
+ IImmutableList<T> Replace(T oldValue, T newValue, IEqualityComparer<T> equalityComparer);
|
||
|
+ IImmutableList<T> SetItem(int index, T value);
|
||
|
+ }
|
||
|
+ public interface IImmutableQueue<T> : IEnumerable, IEnumerable<T> {
|
||
|
+ bool IsEmpty { get; }
|
||
|
+ IImmutableQueue<T> Clear();
|
||
|
+ IImmutableQueue<T> Dequeue();
|
||
|
+ IImmutableQueue<T> Enqueue(T value);
|
||
|
+ T Peek();
|
||
|
+ }
|
||
|
+ public interface IImmutableSet<T> : IEnumerable, IEnumerable<T>, IReadOnlyCollection<T> {
|
||
|
+ IImmutableSet<T> Add(T value);
|
||
|
+ IImmutableSet<T> Clear();
|
||
|
+ bool Contains(T value);
|
||
|
+ IImmutableSet<T> Except(IEnumerable<T> other);
|
||
|
+ IImmutableSet<T> Intersect(IEnumerable<T> other);
|
||
|
+ bool IsProperSubsetOf(IEnumerable<T> other);
|
||
|
+ bool IsProperSupersetOf(IEnumerable<T> other);
|
||
|
+ bool IsSubsetOf(IEnumerable<T> other);
|
||
|
+ bool IsSupersetOf(IEnumerable<T> other);
|
||
|
+ bool Overlaps(IEnumerable<T> other);
|
||
|
+ IImmutableSet<T> Remove(T value);
|
||
|
+ bool SetEquals(IEnumerable<T> other);
|
||
|
+ IImmutableSet<T> SymmetricExcept(IEnumerable<T> other);
|
||
|
+ bool TryGetValue(T equalValue, out T actualValue);
|
||
|
+ IImmutableSet<T> Union(IEnumerable<T> other);
|
||
|
+ }
|
||
|
+ public interface IImmutableStack<T> : IEnumerable, IEnumerable<T> {
|
||
|
+ bool IsEmpty { get; }
|
||
|
+ IImmutableStack<T> Clear();
|
||
|
+ T Peek();
|
||
|
+ IImmutableStack<T> Pop();
|
||
|
+ IImmutableStack<T> Push(T value);
|
||
|
+ }
|
||
|
+ public static class ImmutableArray {
|
||
|
+ public static int BinarySearch<T>(this ImmutableArray<T> array, int index, int length, T value);
|
||
|
+ public static int BinarySearch<T>(this ImmutableArray<T> array, int index, int length, T value, IComparer<T> comparer);
|
||
|
+ public static int BinarySearch<T>(this ImmutableArray<T> array, T value);
|
||
|
+ public static int BinarySearch<T>(this ImmutableArray<T> array, T value, IComparer<T> comparer);
|
||
|
+ public static ImmutableArray<T> Create<T>();
|
||
|
+ public static ImmutableArray<T> Create<T>(ImmutableArray<T> items, int start, int length);
|
||
|
+ public static ImmutableArray<T> Create<T>(T item);
|
||
|
+ public static ImmutableArray<T> Create<T>(T item1, T item2);
|
||
|
+ public static ImmutableArray<T> Create<T>(T item1, T item2, T item3);
|
||
|
+ public static ImmutableArray<T> Create<T>(T item1, T item2, T item3, T item4);
|
||
|
+ public static ImmutableArray<T> Create<T>(params T[] items);
|
||
|
+ public static ImmutableArray<T> Create<T>(T[] items, int start, int length);
|
||
|
+ public static ImmutableArray<T>.Builder CreateBuilder<T>();
|
||
|
+ public static ImmutableArray<T>.Builder CreateBuilder<T>(int initialCapacity);
|
||
|
+ public static ImmutableArray<T> CreateRange<T>(IEnumerable<T> items);
|
||
|
+ public static ImmutableArray<TResult> CreateRange<TSource, TArg, TResult>(ImmutableArray<TSource> items, Func<TSource, TArg, TResult> selector, TArg arg);
|
||
|
+ public static ImmutableArray<TResult> CreateRange<TSource, TArg, TResult>(ImmutableArray<TSource> items, int start, int length, Func<TSource, TArg, TResult> selector, TArg arg);
|
||
|
+ public static ImmutableArray<TResult> CreateRange<TSource, TResult>(ImmutableArray<TSource> items, Func<TSource, TResult> selector);
|
||
|
+ public static ImmutableArray<TResult> CreateRange<TSource, TResult>(ImmutableArray<TSource> items, int start, int length, Func<TSource, TResult> selector);
|
||
|
+ public static ImmutableArray<TSource> ToImmutableArray<TSource>(this ImmutableArray<TSource>.Builder builder);
|
||
|
+ public static ImmutableArray<TSource> ToImmutableArray<TSource>(this IEnumerable<TSource> items);
|
||
|
+ }
|
||
|
+ public struct ImmutableArray<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IEquatable<ImmutableArray<T>>, IImmutableList<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, IStructuralComparable, IStructuralEquatable {
|
||
|
+ public static readonly ImmutableArray<T> Empty;
|
||
|
+ public bool IsDefault { get; }
|
||
|
+ public bool IsDefaultOrEmpty { get; }
|
||
|
+ public bool IsEmpty { get; }
|
||
|
+ public int Length { get; }
|
||
|
+ int System.Collections.Generic.ICollection<T>.Count { get; }
|
||
|
+ bool System.Collections.Generic.ICollection<T>.IsReadOnly { get; }
|
||
|
+ T System.Collections.Generic.IList<T>.this[int index] { get; set; }
|
||
|
+ int System.Collections.Generic.IReadOnlyCollection<T>.Count { get; }
|
||
|
+ T System.Collections.Generic.IReadOnlyList<T>.this[int index] { get; }
|
||
|
+ int System.Collections.ICollection.Count { get; }
|
||
|
+ bool System.Collections.ICollection.IsSynchronized { get; }
|
||
|
+ object System.Collections.ICollection.SyncRoot { get; }
|
||
|
+ bool System.Collections.IList.IsFixedSize { get; }
|
||
|
+ bool System.Collections.IList.IsReadOnly { get; }
|
||
|
+ object System.Collections.IList.this[int index] { get; set; }
|
||
|
+ public T this[int index] { get; }
|
||
|
+ public ImmutableArray<T> Add(T item);
|
||
|
+ public ImmutableArray<T> AddRange(IEnumerable<T> items);
|
||
|
+ public ImmutableArray<T> AddRange(ImmutableArray<T> items);
|
||
|
+ public ImmutableArray<TOther> As<TOther>() where TOther : class;
|
||
|
+ public ReadOnlyMemory<T> AsMemory();
|
||
|
+ public ReadOnlySpan<T> AsSpan();
|
||
|
+ public ImmutableArray<TOther> CastArray<TOther>() where TOther : class;
|
||
|
+ public static ImmutableArray<T> CastUp<TDerived>(ImmutableArray<TDerived> items) where TDerived : class, T;
|
||
|
+ public ImmutableArray<T> Clear();
|
||
|
+ public bool Contains(T item);
|
||
|
+ public void CopyTo(int sourceIndex, T[] destination, int destinationIndex, int length);
|
||
|
+ public void CopyTo(T[] destination);
|
||
|
+ public void CopyTo(T[] destination, int destinationIndex);
|
||
|
+ public bool Equals(ImmutableArray<T> other);
|
||
|
+ public override bool Equals(object obj);
|
||
|
+ public ImmutableArray<T>.Enumerator GetEnumerator();
|
||
|
+ public override int GetHashCode();
|
||
|
+ public int IndexOf(T item);
|
||
|
+ public int IndexOf(T item, int startIndex);
|
||
|
+ public int IndexOf(T item, int startIndex, IEqualityComparer<T> equalityComparer);
|
||
|
+ public int IndexOf(T item, int startIndex, int count);
|
||
|
+ public int IndexOf(T item, int startIndex, int count, IEqualityComparer<T> equalityComparer);
|
||
|
+ public ImmutableArray<T> Insert(int index, T item);
|
||
|
+ public ImmutableArray<T> InsertRange(int index, IEnumerable<T> items);
|
||
|
+ public ImmutableArray<T> InsertRange(int index, ImmutableArray<T> items);
|
||
|
+ public ref readonly T ItemRef(int index);
|
||
|
+ public int LastIndexOf(T item);
|
||
|
+ public int LastIndexOf(T item, int startIndex);
|
||
|
+ public int LastIndexOf(T item, int startIndex, int count);
|
||
|
+ public int LastIndexOf(T item, int startIndex, int count, IEqualityComparer<T> equalityComparer);
|
||
|
+ public IEnumerable<TResult> OfType<TResult>();
|
||
|
+ public static bool operator ==(ImmutableArray<T> left, ImmutableArray<T> right);
|
||
|
+ public static bool operator ==(ImmutableArray<T>? left, ImmutableArray<T>? right);
|
||
|
+ public static bool operator !=(ImmutableArray<T> left, ImmutableArray<T> right);
|
||
|
+ public static bool operator !=(ImmutableArray<T>? left, ImmutableArray<T>? right);
|
||
|
+ public ImmutableArray<T> Remove(T item);
|
||
|
+ public ImmutableArray<T> Remove(T item, IEqualityComparer<T> equalityComparer);
|
||
|
+ public ImmutableArray<T> RemoveAll(Predicate<T> match);
|
||
|
+ public ImmutableArray<T> RemoveAt(int index);
|
||
|
+ public ImmutableArray<T> RemoveRange(IEnumerable<T> items);
|
||
|
+ public ImmutableArray<T> RemoveRange(IEnumerable<T> items, IEqualityComparer<T> equalityComparer);
|
||
|
+ public ImmutableArray<T> RemoveRange(ImmutableArray<T> items);
|
||
|
+ public ImmutableArray<T> RemoveRange(ImmutableArray<T> items, IEqualityComparer<T> equalityComparer);
|
||
|
+ public ImmutableArray<T> RemoveRange(int index, int length);
|
||
|
+ public ImmutableArray<T> Replace(T oldValue, T newValue);
|
||
|
+ public ImmutableArray<T> Replace(T oldValue, T newValue, IEqualityComparer<T> equalityComparer);
|
||
|
+ public ImmutableArray<T> SetItem(int index, T item);
|
||
|
+ public ImmutableArray<T> Sort();
|
||
|
+ public ImmutableArray<T> Sort(IComparer<T> comparer);
|
||
|
+ public ImmutableArray<T> Sort(Comparison<T> comparison);
|
||
|
+ public ImmutableArray<T> Sort(int index, int count, IComparer<T> comparer);
|
||
|
+ void System.Collections.Generic.ICollection<T>.Add(T item);
|
||
|
+ void System.Collections.Generic.ICollection<T>.Clear();
|
||
|
+ bool System.Collections.Generic.ICollection<T>.Remove(T item);
|
||
|
+ IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
|
||
|
+ void System.Collections.Generic.IList<T>.Insert(int index, T item);
|
||
|
+ void System.Collections.Generic.IList<T>.RemoveAt(int index);
|
||
|
+ void System.Collections.ICollection.CopyTo(Array array, int index);
|
||
|
+ IEnumerator System.Collections.IEnumerable.GetEnumerator();
|
||
|
+ int System.Collections.IList.Add(object value);
|
||
|
+ void System.Collections.IList.Clear();
|
||
|
+ bool System.Collections.IList.Contains(object value);
|
||
|
+ int System.Collections.IList.IndexOf(object value);
|
||
|
+ void System.Collections.IList.Insert(int index, object value);
|
||
|
+ void System.Collections.IList.Remove(object value);
|
||
|
+ void System.Collections.IList.RemoveAt(int index);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.Add(T value);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.AddRange(IEnumerable<T> items);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.Clear();
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.Insert(int index, T element);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.InsertRange(int index, IEnumerable<T> items);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.Remove(T value, IEqualityComparer<T> equalityComparer);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.RemoveAll(Predicate<T> match);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.RemoveAt(int index);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.RemoveRange(IEnumerable<T> items, IEqualityComparer<T> equalityComparer);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.RemoveRange(int index, int count);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.Replace(T oldValue, T newValue, IEqualityComparer<T> equalityComparer);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.SetItem(int index, T value);
|
||
|
+ int System.Collections.IStructuralComparable.CompareTo(object other, IComparer comparer);
|
||
|
+ bool System.Collections.IStructuralEquatable.Equals(object other, IEqualityComparer comparer);
|
||
|
+ int System.Collections.IStructuralEquatable.GetHashCode(IEqualityComparer comparer);
|
||
|
+ public ImmutableArray<T>.Builder ToBuilder();
|
||
|
+ public sealed class Builder : ICollection<T>, IEnumerable, IEnumerable<T>, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
|
||
|
+ public int Capacity { get; set; }
|
||
|
+ public int Count { get; set; }
|
||
|
+ bool System.Collections.Generic.ICollection<T>.IsReadOnly { get; }
|
||
|
+ public T this[int index] { get; set; }
|
||
|
+ public void Add(T item);
|
||
|
+ public void AddRange(ImmutableArray<T>.Builder items);
|
||
|
+ public void AddRange(IEnumerable<T> items);
|
||
|
+ public void AddRange(ImmutableArray<T> items);
|
||
|
+ public void AddRange(ImmutableArray<T> items, int length);
|
||
|
+ public void AddRange(params T[] items);
|
||
|
+ public void AddRange(T[] items, int length);
|
||
|
+ public void AddRange<TDerived>(ImmutableArray<TDerived>.Builder items) where TDerived : T;
|
||
|
+ public void AddRange<TDerived>(ImmutableArray<TDerived> items) where TDerived : T;
|
||
|
+ public void AddRange<TDerived>(TDerived[] items) where TDerived : T;
|
||
|
+ public void Clear();
|
||
|
+ public bool Contains(T item);
|
||
|
+ public void CopyTo(T[] array, int index);
|
||
|
+ public IEnumerator<T> GetEnumerator();
|
||
|
+ public int IndexOf(T item);
|
||
|
+ public int IndexOf(T item, int startIndex);
|
||
|
+ public int IndexOf(T item, int startIndex, int count);
|
||
|
+ public int IndexOf(T item, int startIndex, int count, IEqualityComparer<T> equalityComparer);
|
||
|
+ public void Insert(int index, T item);
|
||
|
+ public ref readonly T ItemRef(int index);
|
||
|
+ public int LastIndexOf(T item);
|
||
|
+ public int LastIndexOf(T item, int startIndex);
|
||
|
+ public int LastIndexOf(T item, int startIndex, int count);
|
||
|
+ public int LastIndexOf(T item, int startIndex, int count, IEqualityComparer<T> equalityComparer);
|
||
|
+ public ImmutableArray<T> MoveToImmutable();
|
||
|
+ public bool Remove(T element);
|
||
|
+ public void RemoveAt(int index);
|
||
|
+ public void Reverse();
|
||
|
+ public void Sort();
|
||
|
+ public void Sort(IComparer<T> comparer);
|
||
|
+ public void Sort(Comparison<T> comparison);
|
||
|
+ public void Sort(int index, int count, IComparer<T> comparer);
|
||
|
+ IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
|
||
|
+ IEnumerator System.Collections.IEnumerable.GetEnumerator();
|
||
|
+ public T[] ToArray();
|
||
|
+ public ImmutableArray<T> ToImmutable();
|
||
|
+ }
|
||
|
+ public struct Enumerator {
|
||
|
+ public T Current { get; }
|
||
|
+ public bool MoveNext();
|
||
|
+ }
|
||
|
+ }
|
||
|
+ public static class ImmutableDictionary {
|
||
|
+ public static bool Contains<TKey, TValue>(this IImmutableDictionary<TKey, TValue> map, TKey key, TValue value);
|
||
|
+ public static ImmutableDictionary<TKey, TValue> Create<TKey, TValue>();
|
||
|
+ public static ImmutableDictionary<TKey, TValue> Create<TKey, TValue>(IEqualityComparer<TKey> keyComparer);
|
||
|
+ public static ImmutableDictionary<TKey, TValue> Create<TKey, TValue>(IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer);
|
||
|
+ public static ImmutableDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>();
|
||
|
+ public static ImmutableDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>(IEqualityComparer<TKey> keyComparer);
|
||
|
+ public static ImmutableDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>(IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer);
|
||
|
+ public static ImmutableDictionary<TKey, TValue> CreateRange<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>> items);
|
||
|
+ public static ImmutableDictionary<TKey, TValue> CreateRange<TKey, TValue>(IEqualityComparer<TKey> keyComparer, IEnumerable<KeyValuePair<TKey, TValue>> items);
|
||
|
+ public static ImmutableDictionary<TKey, TValue> CreateRange<TKey, TValue>(IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer, IEnumerable<KeyValuePair<TKey, TValue>> items);
|
||
|
+ public static TValue GetValueOrDefault<TKey, TValue>(this IImmutableDictionary<TKey, TValue> dictionary, TKey key);
|
||
|
+ public static TValue GetValueOrDefault<TKey, TValue>(this IImmutableDictionary<TKey, TValue> dictionary, TKey key, TValue defaultValue);
|
||
|
+ public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(this ImmutableDictionary<TKey, TValue>.Builder builder);
|
||
|
+ public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source);
|
||
|
+ public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source, IEqualityComparer<TKey> keyComparer);
|
||
|
+ public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source, IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer);
|
||
|
+ public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector);
|
||
|
+ public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector, IEqualityComparer<TKey> keyComparer);
|
||
|
+ public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector, IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer);
|
||
|
+ public static ImmutableDictionary<TKey, TSource> ToImmutableDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector);
|
||
|
+ public static ImmutableDictionary<TKey, TSource> ToImmutableDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> keyComparer);
|
||
|
+ }
|
||
|
+ public sealed class ImmutableDictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IImmutableDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
|
||
|
+ public static readonly ImmutableDictionary<TKey, TValue> Empty;
|
||
|
+ public int Count { get; }
|
||
|
+ public bool IsEmpty { get; }
|
||
|
+ public IEqualityComparer<TKey> KeyComparer { get; }
|
||
|
+ public IEnumerable<TKey> Keys { get; }
|
||
|
+ bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.IsReadOnly { get; }
|
||
|
+ TValue System.Collections.Generic.IDictionary<TKey,TValue>.this[TKey key] { get; set; }
|
||
|
+ ICollection<TKey> System.Collections.Generic.IDictionary<TKey,TValue>.Keys { get; }
|
||
|
+ ICollection<TValue> System.Collections.Generic.IDictionary<TKey,TValue>.Values { get; }
|
||
|
+ bool System.Collections.ICollection.IsSynchronized { get; }
|
||
|
+ object System.Collections.ICollection.SyncRoot { get; }
|
||
|
+ bool System.Collections.IDictionary.IsFixedSize { get; }
|
||
|
+ bool System.Collections.IDictionary.IsReadOnly { get; }
|
||
|
+ object System.Collections.IDictionary.this[object key] { get; set; }
|
||
|
+ ICollection System.Collections.IDictionary.Keys { get; }
|
||
|
+ ICollection System.Collections.IDictionary.Values { get; }
|
||
|
+ public TValue this[TKey key] { get; }
|
||
|
+ public IEqualityComparer<TValue> ValueComparer { get; }
|
||
|
+ public IEnumerable<TValue> Values { get; }
|
||
|
+ public ImmutableDictionary<TKey, TValue> Add(TKey key, TValue value);
|
||
|
+ public ImmutableDictionary<TKey, TValue> AddRange(IEnumerable<KeyValuePair<TKey, TValue>> pairs);
|
||
|
+ public ImmutableDictionary<TKey, TValue> Clear();
|
||
|
+ public bool Contains(KeyValuePair<TKey, TValue> pair);
|
||
|
+ public bool ContainsKey(TKey key);
|
||
|
+ public bool ContainsValue(TValue value);
|
||
|
+ public ImmutableDictionary<TKey, TValue>.Enumerator GetEnumerator();
|
||
|
+ public ImmutableDictionary<TKey, TValue> Remove(TKey key);
|
||
|
+ public ImmutableDictionary<TKey, TValue> RemoveRange(IEnumerable<TKey> keys);
|
||
|
+ public ImmutableDictionary<TKey, TValue> SetItem(TKey key, TValue value);
|
||
|
+ public ImmutableDictionary<TKey, TValue> SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items);
|
||
|
+ void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Add(KeyValuePair<TKey, TValue> item);
|
||
|
+ void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Clear();
|
||
|
+ void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex);
|
||
|
+ bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Remove(KeyValuePair<TKey, TValue> item);
|
||
|
+ void System.Collections.Generic.IDictionary<TKey,TValue>.Add(TKey key, TValue value);
|
||
|
+ bool System.Collections.Generic.IDictionary<TKey,TValue>.Remove(TKey key);
|
||
|
+ IEnumerator<KeyValuePair<TKey, TValue>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>.GetEnumerator();
|
||
|
+ void System.Collections.ICollection.CopyTo(Array array, int arrayIndex);
|
||
|
+ void System.Collections.IDictionary.Add(object key, object value);
|
||
|
+ void System.Collections.IDictionary.Clear();
|
||
|
+ bool System.Collections.IDictionary.Contains(object key);
|
||
|
+ IDictionaryEnumerator System.Collections.IDictionary.GetEnumerator();
|
||
|
+ void System.Collections.IDictionary.Remove(object key);
|
||
|
+ IEnumerator System.Collections.IEnumerable.GetEnumerator();
|
||
|
+ IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.Add(TKey key, TValue value);
|
||
|
+ IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.AddRange(IEnumerable<KeyValuePair<TKey, TValue>> pairs);
|
||
|
+ IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.Clear();
|
||
|
+ IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.Remove(TKey key);
|
||
|
+ IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.RemoveRange(IEnumerable<TKey> keys);
|
||
|
+ IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.SetItem(TKey key, TValue value);
|
||
|
+ IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items);
|
||
|
+ public ImmutableDictionary<TKey, TValue>.Builder ToBuilder();
|
||
|
+ public bool TryGetKey(TKey equalKey, out TKey actualKey);
|
||
|
+ public bool TryGetValue(TKey key, out TValue value);
|
||
|
+ public ImmutableDictionary<TKey, TValue> WithComparers(IEqualityComparer<TKey> keyComparer);
|
||
|
+ public ImmutableDictionary<TKey, TValue> WithComparers(IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer);
|
||
|
+ public sealed class Builder : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
|
||
|
+ public int Count { get; }
|
||
|
+ public IEqualityComparer<TKey> KeyComparer { get; set; }
|
||
|
+ public IEnumerable<TKey> Keys { get; }
|
||
|
+ bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.IsReadOnly { get; }
|
||
|
+ ICollection<TKey> System.Collections.Generic.IDictionary<TKey,TValue>.Keys { get; }
|
||
|
+ ICollection<TValue> System.Collections.Generic.IDictionary<TKey,TValue>.Values { get; }
|
||
|
+ bool System.Collections.ICollection.IsSynchronized { get; }
|
||
|
+ object System.Collections.ICollection.SyncRoot { get; }
|
||
|
+ bool System.Collections.IDictionary.IsFixedSize { get; }
|
||
|
+ bool System.Collections.IDictionary.IsReadOnly { get; }
|
||
|
+ object System.Collections.IDictionary.this[object key] { get; set; }
|
||
|
+ ICollection System.Collections.IDictionary.Keys { get; }
|
||
|
+ ICollection System.Collections.IDictionary.Values { get; }
|
||
|
+ public TValue this[TKey key] { get; set; }
|
||
|
+ public IEqualityComparer<TValue> ValueComparer { get; set; }
|
||
|
+ public IEnumerable<TValue> Values { get; }
|
||
|
+ public void Add(KeyValuePair<TKey, TValue> item);
|
||
|
+ public void Add(TKey key, TValue value);
|
||
|
+ public void AddRange(IEnumerable<KeyValuePair<TKey, TValue>> items);
|
||
|
+ public void Clear();
|
||
|
+ public bool Contains(KeyValuePair<TKey, TValue> item);
|
||
|
+ public bool ContainsKey(TKey key);
|
||
|
+ public bool ContainsValue(TValue value);
|
||
|
+ public ImmutableDictionary<TKey, TValue>.Enumerator GetEnumerator();
|
||
|
+ public TValue GetValueOrDefault(TKey key);
|
||
|
+ public TValue GetValueOrDefault(TKey key, TValue defaultValue);
|
||
|
+ public bool Remove(KeyValuePair<TKey, TValue> item);
|
||
|
+ public bool Remove(TKey key);
|
||
|
+ public void RemoveRange(IEnumerable<TKey> keys);
|
||
|
+ void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex);
|
||
|
+ IEnumerator<KeyValuePair<TKey, TValue>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>.GetEnumerator();
|
||
|
+ void System.Collections.ICollection.CopyTo(Array array, int arrayIndex);
|
||
|
+ void System.Collections.IDictionary.Add(object key, object value);
|
||
|
+ bool System.Collections.IDictionary.Contains(object key);
|
||
|
+ IDictionaryEnumerator System.Collections.IDictionary.GetEnumerator();
|
||
|
+ void System.Collections.IDictionary.Remove(object key);
|
||
|
+ IEnumerator System.Collections.IEnumerable.GetEnumerator();
|
||
|
+ public ImmutableDictionary<TKey, TValue> ToImmutable();
|
||
|
+ public bool TryGetKey(TKey equalKey, out TKey actualKey);
|
||
|
+ public bool TryGetValue(TKey key, out TValue value);
|
||
|
+ }
|
||
|
+ public struct Enumerator : IDisposable, IEnumerator, IEnumerator<KeyValuePair<TKey, TValue>> {
|
||
|
+ public KeyValuePair<TKey, TValue> Current { get; }
|
||
|
+ object System.Collections.IEnumerator.Current { get; }
|
||
|
+ public void Dispose();
|
||
|
+ public bool MoveNext();
|
||
|
+ public void Reset();
|
||
|
+ }
|
||
|
+ }
|
||
|
+ public static class ImmutableHashSet {
|
||
|
+ public static ImmutableHashSet<T> Create<T>();
|
||
|
+ public static ImmutableHashSet<T> Create<T>(IEqualityComparer<T> equalityComparer);
|
||
|
+ public static ImmutableHashSet<T> Create<T>(IEqualityComparer<T> equalityComparer, T item);
|
||
|
+ public static ImmutableHashSet<T> Create<T>(IEqualityComparer<T> equalityComparer, params T[] items);
|
||
|
+ public static ImmutableHashSet<T> Create<T>(T item);
|
||
|
+ public static ImmutableHashSet<T> Create<T>(params T[] items);
|
||
|
+ public static ImmutableHashSet<T>.Builder CreateBuilder<T>();
|
||
|
+ public static ImmutableHashSet<T>.Builder CreateBuilder<T>(IEqualityComparer<T> equalityComparer);
|
||
|
+ public static ImmutableHashSet<T> CreateRange<T>(IEnumerable<T> items);
|
||
|
+ public static ImmutableHashSet<T> CreateRange<T>(IEqualityComparer<T> equalityComparer, IEnumerable<T> items);
|
||
|
+ public static ImmutableHashSet<TSource> ToImmutableHashSet<TSource>(this ImmutableHashSet<TSource>.Builder builder);
|
||
|
+ public static ImmutableHashSet<TSource> ToImmutableHashSet<TSource>(this IEnumerable<TSource> source);
|
||
|
+ public static ImmutableHashSet<TSource> ToImmutableHashSet<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> equalityComparer);
|
||
|
+ }
|
||
|
+ public sealed class ImmutableHashSet<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IImmutableSet<T>, IReadOnlyCollection<T>, IReadOnlySet<T>, ISet<T> {
|
||
|
+ public static readonly ImmutableHashSet<T> Empty;
|
||
|
+ public int Count { get; }
|
||
|
+ public bool IsEmpty { get; }
|
||
|
+ public IEqualityComparer<T> KeyComparer { get; }
|
||
|
+ bool System.Collections.Generic.ICollection<T>.IsReadOnly { get; }
|
||
|
+ bool System.Collections.ICollection.IsSynchronized { get; }
|
||
|
+ object System.Collections.ICollection.SyncRoot { get; }
|
||
|
+ public ImmutableHashSet<T> Add(T item);
|
||
|
+ public ImmutableHashSet<T> Clear();
|
||
|
+ public bool Contains(T item);
|
||
|
+ public ImmutableHashSet<T> Except(IEnumerable<T> other);
|
||
|
+ public ImmutableHashSet<T>.Enumerator GetEnumerator();
|
||
|
+ public ImmutableHashSet<T> Intersect(IEnumerable<T> other);
|
||
|
+ public bool IsProperSubsetOf(IEnumerable<T> other);
|
||
|
+ public bool IsProperSupersetOf(IEnumerable<T> other);
|
||
|
+ public bool IsSubsetOf(IEnumerable<T> other);
|
||
|
+ public bool IsSupersetOf(IEnumerable<T> other);
|
||
|
+ public bool Overlaps(IEnumerable<T> other);
|
||
|
+ public ImmutableHashSet<T> Remove(T item);
|
||
|
+ public bool SetEquals(IEnumerable<T> other);
|
||
|
+ public ImmutableHashSet<T> SymmetricExcept(IEnumerable<T> other);
|
||
|
+ void System.Collections.Generic.ICollection<T>.Add(T item);
|
||
|
+ void System.Collections.Generic.ICollection<T>.Clear();
|
||
|
+ void System.Collections.Generic.ICollection<T>.CopyTo(T[] array, int arrayIndex);
|
||
|
+ bool System.Collections.Generic.ICollection<T>.Remove(T item);
|
||
|
+ IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
|
||
|
+ bool System.Collections.Generic.ISet<T>.Add(T item);
|
||
|
+ void System.Collections.Generic.ISet<T>.ExceptWith(IEnumerable<T> other);
|
||
|
+ void System.Collections.Generic.ISet<T>.IntersectWith(IEnumerable<T> other);
|
||
|
+ void System.Collections.Generic.ISet<T>.SymmetricExceptWith(IEnumerable<T> other);
|
||
|
+ void System.Collections.Generic.ISet<T>.UnionWith(IEnumerable<T> other);
|
||
|
+ void System.Collections.ICollection.CopyTo(Array array, int arrayIndex);
|
||
|
+ IEnumerator System.Collections.IEnumerable.GetEnumerator();
|
||
|
+ IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Add(T item);
|
||
|
+ IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Clear();
|
||
|
+ IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Except(IEnumerable<T> other);
|
||
|
+ IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Intersect(IEnumerable<T> other);
|
||
|
+ IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Remove(T item);
|
||
|
+ IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.SymmetricExcept(IEnumerable<T> other);
|
||
|
+ IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Union(IEnumerable<T> other);
|
||
|
+ public ImmutableHashSet<T>.Builder ToBuilder();
|
||
|
+ public bool TryGetValue(T equalValue, out T actualValue);
|
||
|
+ public ImmutableHashSet<T> Union(IEnumerable<T> other);
|
||
|
+ public ImmutableHashSet<T> WithComparer(IEqualityComparer<T> equalityComparer);
|
||
|
+ public sealed class Builder : ICollection<T>, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, ISet<T> {
|
||
|
+ public int Count { get; }
|
||
|
+ public IEqualityComparer<T> KeyComparer { get; set; }
|
||
|
+ bool System.Collections.Generic.ICollection<T>.IsReadOnly { get; }
|
||
|
+ public bool Add(T item);
|
||
|
+ public void Clear();
|
||
|
+ public bool Contains(T item);
|
||
|
+ public void ExceptWith(IEnumerable<T> other);
|
||
|
+ public ImmutableHashSet<T>.Enumerator GetEnumerator();
|
||
|
+ public void IntersectWith(IEnumerable<T> other);
|
||
|
+ public bool IsProperSubsetOf(IEnumerable<T> other);
|
||
|
+ public bool IsProperSupersetOf(IEnumerable<T> other);
|
||
|
+ public bool IsSubsetOf(IEnumerable<T> other);
|
||
|
+ public bool IsSupersetOf(IEnumerable<T> other);
|
||
|
+ public bool Overlaps(IEnumerable<T> other);
|
||
|
+ public bool Remove(T item);
|
||
|
+ public bool SetEquals(IEnumerable<T> other);
|
||
|
+ public void SymmetricExceptWith(IEnumerable<T> other);
|
||
|
+ void System.Collections.Generic.ICollection<T>.Add(T item);
|
||
|
+ void System.Collections.Generic.ICollection<T>.CopyTo(T[] array, int arrayIndex);
|
||
|
+ IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
|
||
|
+ IEnumerator System.Collections.IEnumerable.GetEnumerator();
|
||
|
+ public ImmutableHashSet<T> ToImmutable();
|
||
|
+ public bool TryGetValue(T equalValue, out T actualValue);
|
||
|
+ public void UnionWith(IEnumerable<T> other);
|
||
|
+ }
|
||
|
+ public struct Enumerator : IDisposable, IEnumerator, IEnumerator<T> {
|
||
|
+ public T Current { get; }
|
||
|
+ object System.Collections.IEnumerator.Current { get; }
|
||
|
+ public void Dispose();
|
||
|
+ public bool MoveNext();
|
||
|
+ public void Reset();
|
||
|
+ }
|
||
|
+ }
|
||
|
+ public static class ImmutableInterlocked {
|
||
|
+ public static TValue AddOrUpdate<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, Func<TKey, TValue> addValueFactory, Func<TKey, TValue, TValue> updateValueFactory);
|
||
|
+ public static TValue AddOrUpdate<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, TValue addValue, Func<TKey, TValue, TValue> updateValueFactory);
|
||
|
+ public static void Enqueue<T>(ref ImmutableQueue<T> location, T value);
|
||
|
+ public static TValue GetOrAdd<TKey, TValue, TArg>(ref ImmutableDictionary<TKey, TValue> location, TKey key, Func<TKey, TArg, TValue> valueFactory, TArg factoryArgument);
|
||
|
+ public static TValue GetOrAdd<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, Func<TKey, TValue> valueFactory);
|
||
|
+ public static TValue GetOrAdd<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, TValue value);
|
||
|
+ public static ImmutableArray<T> InterlockedCompareExchange<T>(ref ImmutableArray<T> location, ImmutableArray<T> value, ImmutableArray<T> comparand);
|
||
|
+ public static ImmutableArray<T> InterlockedExchange<T>(ref ImmutableArray<T> location, ImmutableArray<T> value);
|
||
|
+ public static bool InterlockedInitialize<T>(ref ImmutableArray<T> location, ImmutableArray<T> value);
|
||
|
+ public static void Push<T>(ref ImmutableStack<T> location, T value);
|
||
|
+ public static bool TryAdd<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, TValue value);
|
||
|
+ public static bool TryDequeue<T>(ref ImmutableQueue<T> location, out T value);
|
||
|
+ public static bool TryPop<T>(ref ImmutableStack<T> location, out T value);
|
||
|
+ public static bool TryRemove<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, out TValue value);
|
||
|
+ public static bool TryUpdate<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, TValue newValue, TValue comparisonValue);
|
||
|
+ public static bool Update<T, TArg>(ref ImmutableArray<T> location, Func<ImmutableArray<T>, TArg, ImmutableArray<T>> transformer, TArg transformerArgument);
|
||
|
+ public static bool Update<T, TArg>(ref T location, Func<T, TArg, T> transformer, TArg transformerArgument) where T : class;
|
||
|
+ public static bool Update<T>(ref ImmutableArray<T> location, Func<ImmutableArray<T>, ImmutableArray<T>> transformer);
|
||
|
+ public static bool Update<T>(ref T location, Func<T, T> transformer) where T : class;
|
||
|
+ }
|
||
|
+ public static class ImmutableList {
|
||
|
+ public static ImmutableList<T> Create<T>();
|
||
|
+ public static ImmutableList<T> Create<T>(T item);
|
||
|
+ public static ImmutableList<T> Create<T>(params T[] items);
|
||
|
+ public static ImmutableList<T>.Builder CreateBuilder<T>();
|
||
|
+ public static ImmutableList<T> CreateRange<T>(IEnumerable<T> items);
|
||
|
+ public static int IndexOf<T>(this IImmutableList<T> list, T item);
|
||
|
+ public static int IndexOf<T>(this IImmutableList<T> list, T item, IEqualityComparer<T> equalityComparer);
|
||
|
+ public static int IndexOf<T>(this IImmutableList<T> list, T item, int startIndex);
|
||
|
+ public static int IndexOf<T>(this IImmutableList<T> list, T item, int startIndex, int count);
|
||
|
+ public static int LastIndexOf<T>(this IImmutableList<T> list, T item);
|
||
|
+ public static int LastIndexOf<T>(this IImmutableList<T> list, T item, IEqualityComparer<T> equalityComparer);
|
||
|
+ public static int LastIndexOf<T>(this IImmutableList<T> list, T item, int startIndex);
|
||
|
+ public static int LastIndexOf<T>(this IImmutableList<T> list, T item, int startIndex, int count);
|
||
|
+ public static IImmutableList<T> Remove<T>(this IImmutableList<T> list, T value);
|
||
|
+ public static IImmutableList<T> RemoveRange<T>(this IImmutableList<T> list, IEnumerable<T> items);
|
||
|
+ public static IImmutableList<T> Replace<T>(this IImmutableList<T> list, T oldValue, T newValue);
|
||
|
+ public static ImmutableList<TSource> ToImmutableList<TSource>(this ImmutableList<TSource>.Builder builder);
|
||
|
+ public static ImmutableList<TSource> ToImmutableList<TSource>(this IEnumerable<TSource> source);
|
||
|
+ }
|
||
|
+ public sealed class ImmutableList<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IImmutableList<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
|
||
|
+ public static readonly ImmutableList<T> Empty;
|
||
|
+ public int Count { get; }
|
||
|
+ public bool IsEmpty { get; }
|
||
|
+ bool System.Collections.Generic.ICollection<T>.IsReadOnly { get; }
|
||
|
+ T System.Collections.Generic.IList<T>.this[int index] { get; set; }
|
||
|
+ bool System.Collections.ICollection.IsSynchronized { get; }
|
||
|
+ object System.Collections.ICollection.SyncRoot { get; }
|
||
|
+ bool System.Collections.IList.IsFixedSize { get; }
|
||
|
+ bool System.Collections.IList.IsReadOnly { get; }
|
||
|
+ object System.Collections.IList.this[int index] { get; set; }
|
||
|
+ public T this[int index] { get; }
|
||
|
+ public ImmutableList<T> Add(T value);
|
||
|
+ public ImmutableList<T> AddRange(IEnumerable<T> items);
|
||
|
+ public int BinarySearch(int index, int count, T item, IComparer<T> comparer);
|
||
|
+ public int BinarySearch(T item);
|
||
|
+ public int BinarySearch(T item, IComparer<T> comparer);
|
||
|
+ public ImmutableList<T> Clear();
|
||
|
+ public bool Contains(T value);
|
||
|
+ public ImmutableList<TOutput> ConvertAll<TOutput>(Func<T, TOutput> converter);
|
||
|
+ public void CopyTo(int index, T[] array, int arrayIndex, int count);
|
||
|
+ public void CopyTo(T[] array);
|
||
|
+ public void CopyTo(T[] array, int arrayIndex);
|
||
|
+ public bool Exists(Predicate<T> match);
|
||
|
+ public T Find(Predicate<T> match);
|
||
|
+ public ImmutableList<T> FindAll(Predicate<T> match);
|
||
|
+ public int FindIndex(int startIndex, int count, Predicate<T> match);
|
||
|
+ public int FindIndex(int startIndex, Predicate<T> match);
|
||
|
+ public int FindIndex(Predicate<T> match);
|
||
|
+ public T FindLast(Predicate<T> match);
|
||
|
+ public int FindLastIndex(int startIndex, int count, Predicate<T> match);
|
||
|
+ public int FindLastIndex(int startIndex, Predicate<T> match);
|
||
|
+ public int FindLastIndex(Predicate<T> match);
|
||
|
+ public void ForEach(Action<T> action);
|
||
|
+ public ImmutableList<T>.Enumerator GetEnumerator();
|
||
|
+ public ImmutableList<T> GetRange(int index, int count);
|
||
|
+ public int IndexOf(T value);
|
||
|
+ public int IndexOf(T item, int index, int count, IEqualityComparer<T> equalityComparer);
|
||
|
+ public ImmutableList<T> Insert(int index, T item);
|
||
|
+ public ImmutableList<T> InsertRange(int index, IEnumerable<T> items);
|
||
|
+ public ref readonly T ItemRef(int index);
|
||
|
+ public int LastIndexOf(T item, int index, int count, IEqualityComparer<T> equalityComparer);
|
||
|
+ public ImmutableList<T> Remove(T value);
|
||
|
+ public ImmutableList<T> Remove(T value, IEqualityComparer<T> equalityComparer);
|
||
|
+ public ImmutableList<T> RemoveAll(Predicate<T> match);
|
||
|
+ public ImmutableList<T> RemoveAt(int index);
|
||
|
+ public ImmutableList<T> RemoveRange(IEnumerable<T> items);
|
||
|
+ public ImmutableList<T> RemoveRange(IEnumerable<T> items, IEqualityComparer<T> equalityComparer);
|
||
|
+ public ImmutableList<T> RemoveRange(int index, int count);
|
||
|
+ public ImmutableList<T> Replace(T oldValue, T newValue);
|
||
|
+ public ImmutableList<T> Replace(T oldValue, T newValue, IEqualityComparer<T> equalityComparer);
|
||
|
+ public ImmutableList<T> Reverse();
|
||
|
+ public ImmutableList<T> Reverse(int index, int count);
|
||
|
+ public ImmutableList<T> SetItem(int index, T value);
|
||
|
+ public ImmutableList<T> Sort();
|
||
|
+ public ImmutableList<T> Sort(IComparer<T> comparer);
|
||
|
+ public ImmutableList<T> Sort(Comparison<T> comparison);
|
||
|
+ public ImmutableList<T> Sort(int index, int count, IComparer<T> comparer);
|
||
|
+ void System.Collections.Generic.ICollection<T>.Add(T item);
|
||
|
+ void System.Collections.Generic.ICollection<T>.Clear();
|
||
|
+ bool System.Collections.Generic.ICollection<T>.Remove(T item);
|
||
|
+ IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
|
||
|
+ void System.Collections.Generic.IList<T>.Insert(int index, T item);
|
||
|
+ void System.Collections.Generic.IList<T>.RemoveAt(int index);
|
||
|
+ void System.Collections.ICollection.CopyTo(Array array, int arrayIndex);
|
||
|
+ IEnumerator System.Collections.IEnumerable.GetEnumerator();
|
||
|
+ int System.Collections.IList.Add(object value);
|
||
|
+ void System.Collections.IList.Clear();
|
||
|
+ bool System.Collections.IList.Contains(object value);
|
||
|
+ int System.Collections.IList.IndexOf(object value);
|
||
|
+ void System.Collections.IList.Insert(int index, object value);
|
||
|
+ void System.Collections.IList.Remove(object value);
|
||
|
+ void System.Collections.IList.RemoveAt(int index);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.Add(T value);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.AddRange(IEnumerable<T> items);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.Clear();
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.Insert(int index, T item);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.InsertRange(int index, IEnumerable<T> items);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.Remove(T value, IEqualityComparer<T> equalityComparer);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.RemoveAll(Predicate<T> match);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.RemoveAt(int index);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.RemoveRange(IEnumerable<T> items, IEqualityComparer<T> equalityComparer);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.RemoveRange(int index, int count);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.Replace(T oldValue, T newValue, IEqualityComparer<T> equalityComparer);
|
||
|
+ IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.SetItem(int index, T value);
|
||
|
+ public ImmutableList<T>.Builder ToBuilder();
|
||
|
+ public bool TrueForAll(Predicate<T> match);
|
||
|
+ public sealed class Builder : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
|
||
|
+ public int Count { get; }
|
||
|
+ bool System.Collections.Generic.ICollection<T>.IsReadOnly { get; }
|
||
|
+ bool System.Collections.ICollection.IsSynchronized { get; }
|
||
|
+ object System.Collections.ICollection.SyncRoot { get; }
|
||
|
+ bool System.Collections.IList.IsFixedSize { get; }
|
||
|
+ bool System.Collections.IList.IsReadOnly { get; }
|
||
|
+ object System.Collections.IList.this[int index] { get; set; }
|
||
|
+ public T this[int index] { get; set; }
|
||
|
+ public void Add(T item);
|
||
|
+ public void AddRange(IEnumerable<T> items);
|
||
|
+ public int BinarySearch(int index, int count, T item, IComparer<T> comparer);
|
||
|
+ public int BinarySearch(T item);
|
||
|
+ public int BinarySearch(T item, IComparer<T> comparer);
|
||
|
+ public void Clear();
|
||
|
+ public bool Contains(T item);
|
||
|
+ public ImmutableList<TOutput> ConvertAll<TOutput>(Func<T, TOutput> converter);
|
||
|
+ public void CopyTo(int index, T[] array, int arrayIndex, int count);
|
||
|
+ public void CopyTo(T[] array);
|
||
|
+ public void CopyTo(T[] array, int arrayIndex);
|
||
|
+ public bool Exists(Predicate<T> match);
|
||
|
+ public T Find(Predicate<T> match);
|
||
|
+ public ImmutableList<T> FindAll(Predicate<T> match);
|
||
|
+ public int FindIndex(int startIndex, int count, Predicate<T> match);
|
||
|
+ public int FindIndex(int startIndex, Predicate<T> match);
|
||
|
+ public int FindIndex(Predicate<T> match);
|
||
|
+ public T FindLast(Predicate<T> match);
|
||
|
+ public int FindLastIndex(int startIndex, int count, Predicate<T> match);
|
||
|
+ public int FindLastIndex(int startIndex, Predicate<T> match);
|
||
|
+ public int FindLastIndex(Predicate<T> match);
|
||
|
+ public void ForEach(Action<T> action);
|
||
|
+ public ImmutableList<T>.Enumerator GetEnumerator();
|
||
|
+ public ImmutableList<T> GetRange(int index, int count);
|
||
|
+ public int IndexOf(T item);
|
||
|
+ public int IndexOf(T item, int index);
|
||
|
+ public int IndexOf(T item, int index, int count);
|
||
|
+ public int IndexOf(T item, int index, int count, IEqualityComparer<T> equalityComparer);
|
||
|
+ public void Insert(int index, T item);
|
||
|
+ public void InsertRange(int index, IEnumerable<T> items);
|
||
|
+ public ref readonly T ItemRef(int index);
|
||
|
+ public int LastIndexOf(T item);
|
||
|
+ public int LastIndexOf(T item, int startIndex);
|
||
|
+ public int LastIndexOf(T item, int startIndex, int count);
|
||
|
+ public int LastIndexOf(T item, int startIndex, int count, IEqualityComparer<T> equalityComparer);
|
||
|
+ public bool Remove(T item);
|
||
|
+ public int RemoveAll(Predicate<T> match);
|
||
|
+ public void RemoveAt(int index);
|
||
|
+ public void Reverse();
|
||
|
+ public void Reverse(int index, int count);
|
||
|
+ public void Sort();
|
||
|
+ public void Sort(IComparer<T> comparer);
|
||
|
+ public void Sort(Comparison<T> comparison);
|
||
|
+ public void Sort(int index, int count, IComparer<T> comparer);
|
||
|
+ IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
|
||
|
+ void System.Collections.ICollection.CopyTo(Array array, int arrayIndex);
|
||
|
+ IEnumerator System.Collections.IEnumerable.GetEnumerator();
|
||
|
+ int System.Collections.IList.Add(object value);
|
||
|
+ void System.Collections.IList.Clear();
|
||
|
+ bool System.Collections.IList.Contains(object value);
|
||
|
+ int System.Collections.IList.IndexOf(object value);
|
||
|
+ void System.Collections.IList.Insert(int index, object value);
|
||
|
+ void System.Collections.IList.Remove(object value);
|
||
|
+ public ImmutableList<T> ToImmutable();
|
||
|
+ public bool TrueForAll(Predicate<T> match);
|
||
|
+ }
|
||
|
+ public struct Enumerator : IDisposable, IEnumerator, IEnumerator<T> {
|
||
|
+ public T Current { get; }
|
||
|
+ object System.Collections.IEnumerator.Current { get; }
|
||
|
+ public void Dispose();
|
||
|
+ public bool MoveNext();
|
||
|
+ public void Reset();
|
||
|
+ }
|
||
|
+ }
|
||
|
+ public static class ImmutableQueue {
|
||
|
+ public static ImmutableQueue<T> Create<T>();
|
||
|
+ public static ImmutableQueue<T> Create<T>(T item);
|
||
|
+ public static ImmutableQueue<T> Create<T>(params T[] items);
|
||
|
+ public static ImmutableQueue<T> CreateRange<T>(IEnumerable<T> items);
|
||
|
+ public static IImmutableQueue<T> Dequeue<T>(this IImmutableQueue<T> queue, out T value);
|
||
|
+ }
|
||
|
+ public sealed class ImmutableQueue<T> : IEnumerable, IEnumerable<T>, IImmutableQueue<T> {
|
||
|
+ public static ImmutableQueue<T> Empty { get; }
|
||
|
+ public bool IsEmpty { get; }
|
||
|
+ public ImmutableQueue<T> Clear();
|
||
|
+ public ImmutableQueue<T> Dequeue();
|
||
|
+ public ImmutableQueue<T> Dequeue(out T value);
|
||
|
+ public ImmutableQueue<T> Enqueue(T value);
|
||
|
+ public ImmutableQueue<T>.Enumerator GetEnumerator();
|
||
|
+ public T Peek();
|
||
|
+ public ref readonly T PeekRef();
|
||
|
+ IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
|
||
|
+ IEnumerator System.Collections.IEnumerable.GetEnumerator();
|
||
|
+ IImmutableQueue<T> System.Collections.Immutable.IImmutableQueue<T>.Clear();
|
||
|
+ IImmutableQueue<T> System.Collections.Immutable.IImmutableQueue<T>.Dequeue();
|
||
|
+ IImmutableQueue<T> System.Collections.Immutable.IImmutableQueue<T>.Enqueue(T value);
|
||
|
+ public struct Enumerator {
|
||
|
+ public T Current { get; }
|
||
|
+ public bool MoveNext();
|
||
|
+ }
|
||
|
+ }
|
||
|
+ public static class ImmutableSortedDictionary {
|
||
|
+ public static ImmutableSortedDictionary<TKey, TValue> Create<TKey, TValue>();
|
||
|
+ public static ImmutableSortedDictionary<TKey, TValue> Create<TKey, TValue>(IComparer<TKey> keyComparer);
|
||
|
+ public static ImmutableSortedDictionary<TKey, TValue> Create<TKey, TValue>(IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer);
|
||
|
+ public static ImmutableSortedDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>();
|
||
|
+ public static ImmutableSortedDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>(IComparer<TKey> keyComparer);
|
||
|
+ public static ImmutableSortedDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>(IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer);
|
||
|
+ public static ImmutableSortedDictionary<TKey, TValue> CreateRange<TKey, TValue>(IComparer<TKey> keyComparer, IEnumerable<KeyValuePair<TKey, TValue>> items);
|
||
|
+ public static ImmutableSortedDictionary<TKey, TValue> CreateRange<TKey, TValue>(IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer, IEnumerable<KeyValuePair<TKey, TValue>> items);
|
||
|
+ public static ImmutableSortedDictionary<TKey, TValue> CreateRange<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>> items);
|
||
|
+ public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(this ImmutableSortedDictionary<TKey, TValue>.Builder builder);
|
||
|
+ public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source);
|
||
|
+ public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source, IComparer<TKey> keyComparer);
|
||
|
+ public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source, IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer);
|
||
|
+ public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector);
|
||
|
+ public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector, IComparer<TKey> keyComparer);
|
||
|
+ public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector, IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer);
|
||
|
+ }
|
||
|
+ public sealed class ImmutableSortedDictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IImmutableDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
|
||
|
+ public static readonly ImmutableSortedDictionary<TKey, TValue> Empty;
|
||
|
+ public int Count { get; }
|
||
|
+ public bool IsEmpty { get; }
|
||
|
+ public IComparer<TKey> KeyComparer { get; }
|
||
|
+ public IEnumerable<TKey> Keys { get; }
|
||
|
+ bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.IsReadOnly { get; }
|
||
|
+ TValue System.Collections.Generic.IDictionary<TKey,TValue>.this[TKey key] { get; set; }
|
||
|
+ ICollection<TKey> System.Collections.Generic.IDictionary<TKey,TValue>.Keys { get; }
|
||
|
+ ICollection<TValue> System.Collections.Generic.IDictionary<TKey,TValue>.Values { get; }
|
||
|
+ bool System.Collections.ICollection.IsSynchronized { get; }
|
||
|
+ object System.Collections.ICollection.SyncRoot { get; }
|
||
|
+ bool System.Collections.IDictionary.IsFixedSize { get; }
|
||
|
+ bool System.Collections.IDictionary.IsReadOnly { get; }
|
||
|
+ object System.Collections.IDictionary.this[object key] { get; set; }
|
||
|
+ ICollection System.Collections.IDictionary.Keys { get; }
|
||
|
+ ICollection System.Collections.IDictionary.Values { get; }
|
||
|
+ public TValue this[TKey key] { get; }
|
||
|
+ public IEqualityComparer<TValue> ValueComparer { get; }
|
||
|
+ public IEnumerable<TValue> Values { get; }
|
||
|
+ public ImmutableSortedDictionary<TKey, TValue> Add(TKey key, TValue value);
|
||
|
+ public ImmutableSortedDictionary<TKey, TValue> AddRange(IEnumerable<KeyValuePair<TKey, TValue>> items);
|
||
|
+ public ImmutableSortedDictionary<TKey, TValue> Clear();
|
||
|
+ public bool Contains(KeyValuePair<TKey, TValue> pair);
|
||
|
+ public bool ContainsKey(TKey key);
|
||
|
+ public bool ContainsValue(TValue value);
|
||
|
+ public ImmutableSortedDictionary<TKey, TValue>.Enumerator GetEnumerator();
|
||
|
+ public ImmutableSortedDictionary<TKey, TValue> Remove(TKey value);
|
||
|
+ public ImmutableSortedDictionary<TKey, TValue> RemoveRange(IEnumerable<TKey> keys);
|
||
|
+ public ImmutableSortedDictionary<TKey, TValue> SetItem(TKey key, TValue value);
|
||
|
+ public ImmutableSortedDictionary<TKey, TValue> SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items);
|
||
|
+ void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Add(KeyValuePair<TKey, TValue> item);
|
||
|
+ void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Clear();
|
||
|
+ void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex);
|
||
|
+ bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Remove(KeyValuePair<TKey, TValue> item);
|
||
|
+ void System.Collections.Generic.IDictionary<TKey,TValue>.Add(TKey key, TValue value);
|
||
|
+ bool System.Collections.Generic.IDictionary<TKey,TValue>.Remove(TKey key);
|
||
|
+ IEnumerator<KeyValuePair<TKey, TValue>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>.GetEnumerator();
|
||
|
+ void System.Collections.ICollection.CopyTo(Array array, int index);
|
||
|
+ void System.Collections.IDictionary.Add(object key, object value);
|
||
|
+ void System.Collections.IDictionary.Clear();
|
||
|
+ bool System.Collections.IDictionary.Contains(object key);
|
||
|
+ IDictionaryEnumerator System.Collections.IDictionary.GetEnumerator();
|
||
|
+ void System.Collections.IDictionary.Remove(object key);
|
||
|
+ IEnumerator System.Collections.IEnumerable.GetEnumerator();
|
||
|
+ IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.Add(TKey key, TValue value);
|
||
|
+ IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.AddRange(IEnumerable<KeyValuePair<TKey, TValue>> pairs);
|
||
|
+ IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.Clear();
|
||
|
+ IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.Remove(TKey key);
|
||
|
+ IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.RemoveRange(IEnumerable<TKey> keys);
|
||
|
+ IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.SetItem(TKey key, TValue value);
|
||
|
+ IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items);
|
||
|
+ public ImmutableSortedDictionary<TKey, TValue>.Builder ToBuilder();
|
||
|
+ public bool TryGetKey(TKey equalKey, out TKey actualKey);
|
||
|
+ public bool TryGetValue(TKey key, out TValue value);
|
||
|
+ public ref readonly TValue ValueRef(TKey key);
|
||
|
+ public ImmutableSortedDictionary<TKey, TValue> WithComparers(IComparer<TKey> keyComparer);
|
||
|
+ public ImmutableSortedDictionary<TKey, TValue> WithComparers(IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer);
|
||
|
+ public sealed class Builder : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
|
||
|
+ public int Count { get; }
|
||
|
+ public IComparer<TKey> KeyComparer { get; set; }
|
||
|
+ public IEnumerable<TKey> Keys { get; }
|
||
|
+ bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.IsReadOnly { get; }
|
||
|
+ ICollection<TKey> System.Collections.Generic.IDictionary<TKey,TValue>.Keys { get; }
|
||
|
+ ICollection<TValue> System.Collections.Generic.IDictionary<TKey,TValue>.Values { get; }
|
||
|
+ bool System.Collections.ICollection.IsSynchronized { get; }
|
||
|
+ object System.Collections.ICollection.SyncRoot { get; }
|
||
|
+ bool System.Collections.IDictionary.IsFixedSize { get; }
|
||
|
+ bool System.Collections.IDictionary.IsReadOnly { get; }
|
||
|
+ object System.Collections.IDictionary.this[object key] { get; set; }
|
||
|
+ ICollection System.Collections.IDictionary.Keys { get; }
|
||
|
+ ICollection System.Collections.IDictionary.Values { get; }
|
||
|
+ public TValue this[TKey key] { get; set; }
|
||
|
+ public IEqualityComparer<TValue> ValueComparer { get; set; }
|
||
|
+ public IEnumerable<TValue> Values { get; }
|
||
|
+ public void Add(KeyValuePair<TKey, TValue> item);
|
||
|
+ public void Add(TKey key, TValue value);
|
||
|
+ public void AddRange(IEnumerable<KeyValuePair<TKey, TValue>> items);
|
||
|
+ public void Clear();
|
||
|
+ public bool Contains(KeyValuePair<TKey, TValue> item);
|
||
|
+ public bool ContainsKey(TKey key);
|
||
|
+ public bool ContainsValue(TValue value);
|
||
|
+ public ImmutableSortedDictionary<TKey, TValue>.Enumerator GetEnumerator();
|
||
|
+ public TValue GetValueOrDefault(TKey key);
|
||
|
+ public TValue GetValueOrDefault(TKey key, TValue defaultValue);
|
||
|
+ public bool Remove(KeyValuePair<TKey, TValue> item);
|
||
|
+ public bool Remove(TKey key);
|
||
|
+ public void RemoveRange(IEnumerable<TKey> keys);
|
||
|
+ void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex);
|
||
|
+ IEnumerator<KeyValuePair<TKey, TValue>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>.GetEnumerator();
|
||
|
+ void System.Collections.ICollection.CopyTo(Array array, int index);
|
||
|
+ void System.Collections.IDictionary.Add(object key, object value);
|
||
|
+ bool System.Collections.IDictionary.Contains(object key);
|
||
|
+ IDictionaryEnumerator System.Collections.IDictionary.GetEnumerator();
|
||
|
+ void System.Collections.IDictionary.Remove(object key);
|
||
|
+ IEnumerator System.Collections.IEnumerable.GetEnumerator();
|
||
|
+ public ImmutableSortedDictionary<TKey, TValue> ToImmutable();
|
||
|
+ public bool TryGetKey(TKey equalKey, out TKey actualKey);
|
||
|
+ public bool TryGetValue(TKey key, out TValue value);
|
||
|
+ public ref readonly TValue ValueRef(TKey key);
|
||
|
+ }
|
||
|
+ public struct Enumerator : IDisposable, IEnumerator, IEnumerator<KeyValuePair<TKey, TValue>> {
|
||
|
+ public KeyValuePair<TKey, TValue> Current { get; }
|
||
|
+ object System.Collections.IEnumerator.Current { get; }
|
||
|
+ public void Dispose();
|
||
|
+ public bool MoveNext();
|
||
|
+ public void Reset();
|
||
|
+ }
|
||
|
+ }
|
||
|
+ public static class ImmutableSortedSet {
|
||
|
+ public static ImmutableSortedSet<T> Create<T>();
|
||
|
+ public static ImmutableSortedSet<T> Create<T>(IComparer<T> comparer);
|
||
|
+ public static ImmutableSortedSet<T> Create<T>(IComparer<T> comparer, T item);
|
||
|
+ public static ImmutableSortedSet<T> Create<T>(IComparer<T> comparer, params T[] items);
|
||
|
+ public static ImmutableSortedSet<T> Create<T>(T item);
|
||
|
+ public static ImmutableSortedSet<T> Create<T>(params T[] items);
|
||
|
+ public static ImmutableSortedSet<T>.Builder CreateBuilder<T>();
|
||
|
+ public static ImmutableSortedSet<T>.Builder CreateBuilder<T>(IComparer<T> comparer);
|
||
|
+ public static ImmutableSortedSet<T> CreateRange<T>(IComparer<T> comparer, IEnumerable<T> items);
|
||
|
+ public static ImmutableSortedSet<T> CreateRange<T>(IEnumerable<T> items);
|
||
|
+ public static ImmutableSortedSet<TSource> ToImmutableSortedSet<TSource>(this ImmutableSortedSet<TSource>.Builder builder);
|
||
|
+ public static ImmutableSortedSet<TSource> ToImmutableSortedSet<TSource>(this IEnumerable<TSource> source);
|
||
|
+ public static ImmutableSortedSet<TSource> ToImmutableSortedSet<TSource>(this IEnumerable<TSource> source, IComparer<TSource> comparer);
|
||
|
+ }
|
||
|
+ public sealed class ImmutableSortedSet<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IImmutableSet<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, IReadOnlySet<T>, ISet<T> {
|
||
|
+ public static readonly ImmutableSortedSet<T> Empty;
|
||
|
+ public int Count { get; }
|
||
|
+ public bool IsEmpty { get; }
|
||
|
+ public IComparer<T> KeyComparer { get; }
|
||
|
+ public T Max { get; }
|
||
|
+ public T Min { get; }
|
||
|
+ bool System.Collections.Generic.ICollection<T>.IsReadOnly { get; }
|
||
|
+ T System.Collections.Generic.IList<T>.this[int index] { get; set; }
|
||
|
+ bool System.Collections.ICollection.IsSynchronized { get; }
|
||
|
+ object System.Collections.ICollection.SyncRoot { get; }
|
||
|
+ bool System.Collections.IList.IsFixedSize { get; }
|
||
|
+ bool System.Collections.IList.IsReadOnly { get; }
|
||
|
+ object System.Collections.IList.this[int index] { get; set; }
|
||
|
+ public T this[int index] { get; }
|
||
|
+ public ImmutableSortedSet<T> Add(T value);
|
||
|
+ public ImmutableSortedSet<T> Clear();
|
||
|
+ public bool Contains(T value);
|
||
|
+ public ImmutableSortedSet<T> Except(IEnumerable<T> other);
|
||
|
+ public ImmutableSortedSet<T>.Enumerator GetEnumerator();
|
||
|
+ public int IndexOf(T item);
|
||
|
+ public ImmutableSortedSet<T> Intersect(IEnumerable<T> other);
|
||
|
+ public bool IsProperSubsetOf(IEnumerable<T> other);
|
||
|
+ public bool IsProperSupersetOf(IEnumerable<T> other);
|
||
|
+ public bool IsSubsetOf(IEnumerable<T> other);
|
||
|
+ public bool IsSupersetOf(IEnumerable<T> other);
|
||
|
+ public ref readonly T ItemRef(int index);
|
||
|
+ public bool Overlaps(IEnumerable<T> other);
|
||
|
+ public ImmutableSortedSet<T> Remove(T value);
|
||
|
+ public IEnumerable<T> Reverse();
|
||
|
+ public bool SetEquals(IEnumerable<T> other);
|
||
|
+ public ImmutableSortedSet<T> SymmetricExcept(IEnumerable<T> other);
|
||
|
+ void System.Collections.Generic.ICollection<T>.Add(T item);
|
||
|
+ void System.Collections.Generic.ICollection<T>.Clear();
|
||
|
+ void System.Collections.Generic.ICollection<T>.CopyTo(T[] array, int arrayIndex);
|
||
|
+ bool System.Collections.Generic.ICollection<T>.Remove(T item);
|
||
|
+ IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
|
||
|
+ void System.Collections.Generic.IList<T>.Insert(int index, T item);
|
||
|
+ void System.Collections.Generic.IList<T>.RemoveAt(int index);
|
||
|
+ bool System.Collections.Generic.ISet<T>.Add(T item);
|
||
|
+ void System.Collections.Generic.ISet<T>.ExceptWith(IEnumerable<T> other);
|
||
|
+ void System.Collections.Generic.ISet<T>.IntersectWith(IEnumerable<T> other);
|
||
|
+ void System.Collections.Generic.ISet<T>.SymmetricExceptWith(IEnumerable<T> other);
|
||
|
+ void System.Collections.Generic.ISet<T>.UnionWith(IEnumerable<T> other);
|
||
|
+ void System.Collections.ICollection.CopyTo(Array array, int index);
|
||
|
+ IEnumerator System.Collections.IEnumerable.GetEnumerator();
|
||
|
+ int System.Collections.IList.Add(object value);
|
||
|
+ void System.Collections.IList.Clear();
|
||
|
+ bool System.Collections.IList.Contains(object value);
|
||
|
+ int System.Collections.IList.IndexOf(object value);
|
||
|
+ void System.Collections.IList.Insert(int index, object value);
|
||
|
+ void System.Collections.IList.Remove(object value);
|
||
|
+ void System.Collections.IList.RemoveAt(int index);
|
||
|
+ IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Add(T value);
|
||
|
+ IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Clear();
|
||
|
+ IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Except(IEnumerable<T> other);
|
||
|
+ IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Intersect(IEnumerable<T> other);
|
||
|
+ IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Remove(T value);
|
||
|
+ IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.SymmetricExcept(IEnumerable<T> other);
|
||
|
+ IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Union(IEnumerable<T> other);
|
||
|
+ public ImmutableSortedSet<T>.Builder ToBuilder();
|
||
|
+ public bool TryGetValue(T equalValue, out T actualValue);
|
||
|
+ public ImmutableSortedSet<T> Union(IEnumerable<T> other);
|
||
|
+ public ImmutableSortedSet<T> WithComparer(IComparer<T> comparer);
|
||
|
+ public sealed class Builder : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, ISet<T> {
|
||
|
+ public int Count { get; }
|
||
|
+ public IComparer<T> KeyComparer { get; set; }
|
||
|
+ public T Max { get; }
|
||
|
+ public T Min { get; }
|
||
|
+ bool System.Collections.Generic.ICollection<T>.IsReadOnly { get; }
|
||
|
+ bool System.Collections.ICollection.IsSynchronized { get; }
|
||
|
+ object System.Collections.ICollection.SyncRoot { get; }
|
||
|
+ public T this[int index] { get; }
|
||
|
+ public bool Add(T item);
|
||
|
+ public void Clear();
|
||
|
+ public bool Contains(T item);
|
||
|
+ public void ExceptWith(IEnumerable<T> other);
|
||
|
+ public ImmutableSortedSet<T>.Enumerator GetEnumerator();
|
||
|
+ public void IntersectWith(IEnumerable<T> other);
|
||
|
+ public bool IsProperSubsetOf(IEnumerable<T> other);
|
||
|
+ public bool IsProperSupersetOf(IEnumerable<T> other);
|
||
|
+ public bool IsSubsetOf(IEnumerable<T> other);
|
||
|
+ public bool IsSupersetOf(IEnumerable<T> other);
|
||
|
+ public ref readonly T ItemRef(int index);
|
||
|
+ public bool Overlaps(IEnumerable<T> other);
|
||
|
+ public bool Remove(T item);
|
||
|
+ public IEnumerable<T> Reverse();
|
||
|
+ public bool SetEquals(IEnumerable<T> other);
|
||
|
+ public void SymmetricExceptWith(IEnumerable<T> other);
|
||
|
+ void System.Collections.Generic.ICollection<T>.Add(T item);
|
||
|
+ void System.Collections.Generic.ICollection<T>.CopyTo(T[] array, int arrayIndex);
|
||
|
+ IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
|
||
|
+ void System.Collections.ICollection.CopyTo(Array array, int arrayIndex);
|
||
|
+ IEnumerator System.Collections.IEnumerable.GetEnumerator();
|
||
|
+ public ImmutableSortedSet<T> ToImmutable();
|
||
|
+ public bool TryGetValue(T equalValue, out T actualValue);
|
||
|
+ public void UnionWith(IEnumerable<T> other);
|
||
|
+ }
|
||
|
+ public struct Enumerator : IDisposable, IEnumerator, IEnumerator<T> {
|
||
|
+ public T Current { get; }
|
||
|
+ object System.Collections.IEnumerator.Current { get; }
|
||
|
+ public void Dispose();
|
||
|
+ public bool MoveNext();
|
||
|
+ public void Reset();
|
||
|
+ }
|
||
|
+ }
|
||
|
+ public static class ImmutableStack {
|
||
|
+ public static ImmutableStack<T> Create<T>();
|
||
|
+ public static ImmutableStack<T> Create<T>(T item);
|
||
|
+ public static ImmutableStack<T> Create<T>(params T[] items);
|
||
|
+ public static ImmutableStack<T> CreateRange<T>(IEnumerable<T> items);
|
||
|
+ public static IImmutableStack<T> Pop<T>(this IImmutableStack<T> stack, out T value);
|
||
|
+ }
|
||
|
+ public sealed class ImmutableStack<T> : IEnumerable, IEnumerable<T>, IImmutableStack<T> {
|
||
|
+ public static ImmutableStack<T> Empty { get; }
|
||
|
+ public bool IsEmpty { get; }
|
||
|
+ public ImmutableStack<T> Clear();
|
||
|
+ public ImmutableStack<T>.Enumerator GetEnumerator();
|
||
|
+ public T Peek();
|
||
|
+ public ref readonly T PeekRef();
|
||
|
+ public ImmutableStack<T> Pop();
|
||
|
+ public ImmutableStack<T> Pop(out T value);
|
||
|
+ public ImmutableStack<T> Push(T value);
|
||
|
+ IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
|
||
|
+ IEnumerator System.Collections.IEnumerable.GetEnumerator();
|
||
|
+ IImmutableStack<T> System.Collections.Immutable.IImmutableStack<T>.Clear();
|
||
|
+ IImmutableStack<T> System.Collections.Immutable.IImmutableStack<T>.Pop();
|
||
|
+ IImmutableStack<T> System.Collections.Immutable.IImmutableStack<T>.Push(T value);
|
||
|
+ public struct Enumerator {
|
||
|
+ public T Current { get; }
|
||
|
+ public bool MoveNext();
|
||
|
+ }
|
||
|
+ }
|
||
|
+}
|
||
|
```
|
||
|
|