public TValue GetValueOrDefault(TKey key, TValue defaultValue) { Requires.NotNullAllowStructs(key, "key"); TValue value; if (this.TryGetValue(key, out value)) { return(value); } return(defaultValue); }
public static TValue GetValueOrDefault <TKey, TValue>(this IImmutableDictionary <TKey, TValue> dictionary, TKey key, TValue defaultValue) where TKey : notnull { Requires.NotNull(dictionary, nameof(dictionary)); Requires.NotNullAllowStructs(key, nameof(key)); TValue value; if (dictionary.TryGetValue(key, out value !)) { return(value); } return(defaultValue); }
internal ref readonly TValue ValueRef(TKey key, IComparer <TKey> keyComparer) { Requires.NotNullAllowStructs(key, nameof(key)); Requires.NotNull(keyComparer, nameof(keyComparer)); var match = this.Search(key, keyComparer); if (match.IsEmpty) { throw new KeyNotFoundException(SR.Format(SR.Arg_KeyNotFoundWithKey, key.ToString())); } return(ref match._value); }
/// <summary> /// Initializes a new instance of the <see cref="ImmutableSortedSet{T}.Node"/> class /// that is not yet frozen. /// </summary> /// <param name="key">The value stored by this node.</param> /// <param name="left">The left branch.</param> /// <param name="right">The right branch.</param> /// <param name="frozen">Whether this node is prefrozen.</param> private Node(T key, Node left, Node right, bool frozen = false) { Requires.NotNullAllowStructs(key, nameof(key)); Requires.NotNull(left, nameof(left)); Requires.NotNull(right, nameof(right)); Debug.Assert(!frozen || (left._frozen && right._frozen)); _key = key; _left = left; _right = right; _height = checked ((byte)(1 + Math.Max(left._height, right._height))); _count = 1 + left._count + right._count; _frozen = frozen; }
public static TValue GetValueOrDefault <TKey, TValue>(this IImmutableDictionary <TKey, TValue> dictionary, TKey key, TValue defaultValue) { Requires.NotNull(dictionary, "dictionary"); Requires.NotNullAllowStructs(key, "key"); TValue value; if (dictionary.TryGetValue(key, out value)) { return(value); } return(defaultValue); }
/// <summary> /// Gets the <typeparamref name="TValue"/> with the specified key. /// </summary> public TValue this[TKey key] { get { Requires.NotNullAllowStructs(key, nameof(key)); TValue value; if (this.TryGetValue(key, out value)) { return(value); } throw new KeyNotFoundException(); } }
internal bool Contains(KeyValuePair <TKey, TValue> pair, IComparer <TKey> keyComparer, IEqualityComparer <TValue> valueComparer) { Requires.NotNullAllowStructs(pair.Key, nameof(pair.Key)); Requires.NotNull(keyComparer, nameof(keyComparer)); Requires.NotNull(valueComparer, nameof(valueComparer)); var matchingNode = this.Search(pair.Key, keyComparer); if (matchingNode.IsEmpty) { return(false); } return(valueComparer.Equals(matchingNode._value, pair.Value)); }
public bool TryGetValue(T equalValue, out T actualValue) { Requires.NotNullAllowStructs(equalValue, "value"); int hashCode = this.equalityComparer.GetHashCode(equalValue); HashBucket bucket; if (this.root.TryGetValue(hashCode, out bucket)) { return(bucket.TryExchange(equalValue, this.equalityComparer, out actualValue)); } actualValue = equalValue; return(false); }
/// <summary> /// Gets the <typeparamref name="TValue"/> with the specified key. /// </summary> public TValue this[TKey key] { get { Requires.NotNullAllowStructs(key, nameof(key)); TValue value; if (this.TryGetValue(key, out value !)) { return(value); } throw new KeyNotFoundException(SR.Format(SR.Arg_KeyNotFoundWithKey, key.ToString())); } }
/// <summary> /// Initializes a new instance of the <see cref="ImmutableSortedDictionary{TKey, TValue}.Node"/> class /// that is not yet frozen. /// </summary> /// <param name="key">The key.</param> /// <param name="value">The value.</param> /// <param name="left">The left.</param> /// <param name="right">The right.</param> /// <param name="frozen">Whether this node is prefrozen.</param> private Node(TKey key, TValue value, Node left, Node right, bool frozen = false) { Requires.NotNullAllowStructs(key, nameof(key)); Requires.NotNull(left, nameof(left)); Requires.NotNull(right, nameof(right)); Debug.Assert(!frozen || (left._frozen && right._frozen)); _key = key; _value = value; _left = left; _right = right; _height = checked ((byte)(1 + Math.Max(left._height, right._height))); _frozen = frozen; Debug.Assert(!this.IsEmpty); }
public bool TryGetValue(T equalValue, out T actualValue) { Requires.NotNullAllowStructs(equalValue, nameof(equalValue)); Node searchResult = _root.Search(equalValue, _comparer); if (searchResult.IsEmpty) { actualValue = equalValue; return(false); } else { actualValue = searchResult.Key; return(true); } }
/// <summary> /// Performs the operation on a given data structure. /// </summary> private static MutationResult Add(TKey key, TValue value, KeyCollisionBehavior behavior, MutationInput origin) { Requires.NotNullAllowStructs(key, nameof(key)); OperationResult result; int hashCode = origin.KeyComparer.GetHashCode(key); HashBucket bucket = origin.Root.GetValueOrDefault(hashCode); var newBucket = bucket.Add(key, value, origin.KeyOnlyComparer, origin.ValueComparer, behavior, out result); if (result == OperationResult.NoChangeRequired) { return(new MutationResult(origin)); } var newRoot = UpdateRoot(origin.Root, hashCode, newBucket, origin.HashBucketComparer); return(new MutationResult(newRoot, result == OperationResult.SizeChanged ? +1 : 0)); }
internal bool TryGetKey(TKey equalKey, IComparer <TKey> keyComparer, out TKey actualKey) { Requires.NotNullAllowStructs(equalKey, nameof(equalKey)); Requires.NotNull(keyComparer, nameof(keyComparer)); var match = this.Search(equalKey, keyComparer); if (match.IsEmpty) { actualKey = equalKey; return(false); } else { actualKey = match._key; return(true); } }
internal bool TryGetValue(TKey key, IComparer <TKey> keyComparer, out TValue value) { Requires.NotNullAllowStructs(key, nameof(key)); Requires.NotNull(keyComparer, nameof(keyComparer)); var match = this.Search(key, keyComparer); if (match.IsEmpty) { value = default(TValue); return(false); } else { value = match._value; return(true); } }
/// <summary> /// Performs the set operation on a given data structure. /// </summary> private static MutationResult Add(T item, MutationInput origin) { Requires.NotNullAllowStructs(item, "item"); OperationResult result; int hashCode = origin.EqualityComparer.GetHashCode(item); HashBucket bucket = origin.Root.GetValueOrDefault(hashCode); var newBucket = bucket.Add(item, origin.EqualityComparer, out result); if (result == OperationResult.NoChangeRequired) { return(new MutationResult(origin.Root, 0)); } var newRoot = UpdateRoot(origin.Root, hashCode, newBucket); Debug.Assert(result == OperationResult.SizeChanged); return(new MutationResult(newRoot, 1 /*result == OperationResult.SizeChanged ? 1 : 0*/)); }
internal int IndexOf(T key, IComparer <T> comparer) { Requires.NotNullAllowStructs(key, nameof(key)); Requires.NotNull(comparer, nameof(comparer)); if (this.IsEmpty) { return(-1); } else { int compare = comparer.Compare(key, _key); if (compare == 0) { return(_left.Count); } else if (compare > 0) { int result = _right.IndexOf(key, comparer); bool missing = result < 0; if (missing) { result = ~result; } result = _left.Count + 1 + result; if (missing) { result = ~result; } return(result); } else { return(_left.IndexOf(key, comparer)); } } }
/// <summary> /// Adds the specified key to the tree. /// </summary> /// <param name="key">The key.</param> /// <param name="comparer">The comparer.</param> /// <param name="mutated">Receives a value indicating whether this node tree has mutated because of this operation.</param> /// <returns>The new tree.</returns> internal Node Add(T key, IComparer <T> comparer, out bool mutated) { Requires.NotNullAllowStructs(key, nameof(key)); Requires.NotNull(comparer, nameof(comparer)); if (this.IsEmpty) { mutated = true; return(new Node(key, this, this)); } else { Node result = this; int compareResult = comparer.Compare(key, _key); if (compareResult > 0) { var newRight = _right.Add(key, comparer, out mutated); if (mutated) { result = this.Mutate(right: newRight); } } else if (compareResult < 0) { var newLeft = _left.Add(key, comparer, out mutated); if (mutated) { result = this.Mutate(left: newLeft); } } else { mutated = false; return(this); } return(mutated ? MakeBalanced(result) : result); } }
/// <summary> /// Performs the set operation on a given data structure. /// </summary> private static MutationResult Remove(T item, MutationInput origin) { Requires.NotNullAllowStructs(item, "item"); var result = OperationResult.NoChangeRequired; int hashCode = origin.EqualityComparer.GetHashCode(item); HashBucket bucket; var newRoot = origin.Root; if (origin.Root.TryGetValue(hashCode, out bucket)) { var newBucket = bucket.Remove(item, origin.EqualityComparer, out result); if (result == OperationResult.NoChangeRequired) { return(new MutationResult(origin.Root, 0)); } newRoot = UpdateRoot(origin.Root, hashCode, newBucket); } return(new MutationResult(newRoot, result == OperationResult.SizeChanged ? -1 : 0)); }
/// <summary> /// Performs the operation on a given data structure. /// </summary> private static MutationResult AddRange(IEnumerable <KeyValuePair <TKey, TValue> > items, MutationInput origin, KeyCollisionBehavior collisionBehavior = KeyCollisionBehavior.ThrowIfValueDifferent) { Requires.NotNull(items, nameof(items)); int countAdjustment = 0; var newRoot = origin.Root; foreach (var pair in items) { Requires.NotNullAllowStructs(pair.Key, nameof(pair.Key)); int hashCode = origin.KeyComparer.GetHashCode(pair.Key); HashBucket bucket = newRoot.GetValueOrDefault(hashCode); OperationResult result; var newBucket = bucket.Add(pair.Key, pair.Value, origin.KeyOnlyComparer, origin.ValueComparer, collisionBehavior, out result); newRoot = UpdateRoot(newRoot, hashCode, newBucket, origin.HashBucketComparer); if (result == OperationResult.SizeChanged) { countAdjustment++; } } return(new MutationResult(newRoot, countAdjustment)); }
/// <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)); }
public static bool Contains <TKey, TValue>(this IImmutableDictionary <TKey, TValue> map, TKey key, TValue value) { Requires.NotNull(map, "map"); Requires.NotNullAllowStructs(key, "key"); return(map.Contains(new KeyValuePair <TKey, TValue>(key, value))); }
internal SecurePooledObject(T newValue) { Requires.NotNullAllowStructs(newValue, nameof(newValue)); _value = newValue; }
/// <summary> /// See the <see cref="IImmutableSet<T>"/> interface. /// </summary> public bool Contains(T item) { Requires.NotNullAllowStructs(item, "item"); return(Contains(item, this.Origin)); }
/// <summary> /// See the <see cref="IImmutableDictionary{TKey, TValue}"/> interface. /// </summary> public bool TryGetKey(TKey equalKey, out TKey actualKey) { Requires.NotNullAllowStructs(equalKey, nameof(equalKey)); return(TryGetKey(equalKey, this.Origin, out actualKey)); }
internal bool ContainsKey(TKey key, IComparer <TKey> keyComparer) { Requires.NotNullAllowStructs(key, nameof(key)); Requires.NotNull(keyComparer, nameof(keyComparer)); return(!this.Search(key, keyComparer).IsEmpty); }
/// <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(TryGetValue(key, this.Origin, out value !)); }
/// <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, nameof(key)); return(ContainsKey(key, this.Origin)); }
/// <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> /// 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)); }
/// <summary> /// See the <see cref="IImmutableDictionary{TKey, TValue}"/> interface. /// </summary> public bool TryGetValue(TKey key, out TValue value) { Requires.NotNullAllowStructs(key, nameof(key)); return(_root.TryGetValue(key, _keyComparer, out value)); }