Builder(HashedAvlTree <TKey, TValue> .Node node, IEqualityComparer <TKey> equality) { _inner = node; _equality = equality; _lineage = GetNewLineage(); }
public HashedAvlTree <TKey, TValue2> .Bucket Apply <TValue2>(Func <TKey, TValue, TValue2> selector, Lineage lineage) { var newBucket = HashedAvlTree <TKey, TValue2> .Bucket.Empty; for (var cur = this; !cur.IsEmpty; cur = cur.Next) { newBucket = new HashedAvlTree <TKey, TValue2> .Bucket(cur.Key, selector(cur.Key, cur.Value), newBucket, Eq, lineage); } return(newBucket); }
public bool Remove(T item) { var res = _inner.Root_Remove(item, _lineage); if (res == null) { return(false); } _inner = res; return(true); }
public bool Add(T item) { var ret = _inner.Root_Add(item, true, _lineage, _eq, false); if (ret == null) { return(false); } _inner = ret; return(true); }
public bool Remove(TKey key) { var ret = _inner.Root_Remove(key, _lineage); if (ret == null) { return(false); } else { _inner = ret; return(true); } }
public void AddRange(IEnumerable <KeyValuePair <TKey, TValue> > items) { items.CheckNotNull("items"); ImmMap <TKey, TValue> map = items as ImmMap <TKey, TValue>; if (map != null && _equality.Equals(map._equality)) { _inner = _inner.Union(map._root, _lineage); } else { items.ForEach(x => Add(x)); } }
public void AddRange(IEnumerable <T> items) { items.CheckNotNull("items"); var set = items as ImmSet <T>; if (set != null && _eq.Equals(set.EqualityComparer)) { _inner = _inner.Union(set.Root, _lineage); } else { items.ForEach(x => { _inner = _inner.Root_Add(x, true, _lineage, _eq, false) ?? _inner; }); } }
public Node Except <TValue2>(HashedAvlTree <TKey, TValue2> .Node other, Lineage lin, ValueSelector <TKey, TValue, TValue2, Optional <TValue> > subtraction = null) { if (IsEmpty || other.IsEmpty) { return(this); } if (ReferenceEquals(this, other) && subtraction == null) { return(Empty); } Node thisLesser, thisGreater; Node central; Split(other.Hash, out thisLesser, out central, out thisGreater, lin); var thisLesserCount = thisLesser.Count; var thisGreaterCount = thisGreater.Count; var exceptLesser = thisLesser.Except(other.Left, lin, subtraction); var exceptBucket = central == null ? null : central.Bucket.Except(other.Bucket, lin, subtraction); var exceptGreater = thisGreater.Except(other.Right, lin, subtraction); var exceptLesserCount = exceptLesser.Count; var exceptGreaterCount = exceptGreater.Count; Node ret; if (exceptBucket == null || exceptBucket.IsEmpty) { ret = Concat(exceptLesser, exceptGreater, lin); } else { ret = Concat(exceptLesser, central.WithBucket(exceptBucket, lin), exceptGreater, lin); } #if ASSERTS AssertEx.AssertTrue(exceptLesserCount <= thisLesserCount); AssertEx.AssertTrue(exceptGreaterCount <= thisGreaterCount); AssertEx.AssertTrue(exceptGreaterCount + exceptLesserCount <= thisLesserCount + thisGreaterCount); AssertEx.AssertTrue(ret.IsBalanced); #endif return(ret); }
public Bucket Except <TValue2>(HashedAvlTree <TKey, TValue2> .Bucket other, Lineage lineage, ValueSelector <TKey, TValue, TValue2, Optional <TValue> > subtraction = null) { var newBucket = Empty; foreach (var item in Items) { var findOther = other.Find(item.Key); if (findOther.IsNone) { newBucket = NewBucket(item.Key, item.Value, newBucket, lineage); } else if (subtraction != null) { var newValue = subtraction(item.Key, item.Value, findOther.Value); if (newValue.IsSome) { newBucket = NewBucket(item.Key, newValue.Value, newBucket, lineage); } } } return(newBucket); }
internal ImmSet(HashedAvlTree <T, bool> .Node inner, IEqualityComparer <T> eq) { EqualityComparer = eq; Root = inner; }
internal ImmMap(HashedAvlTree <TKey, TValue> .Node root, IEqualityComparer <TKey> equality) { _root = root; _equality = equality; }
public Builder(IEqualityComparer <T> eq, HashedAvlTree <T, bool> .Node inner) { _eq = eq; _inner = inner; _lineage = Lineage.Mutable(); }
public bool Add(KeyValuePair <TKey, TValue> item) { _inner = _inner.Root_Add(item.Key, item.Value, _lineage, _equality, true) ?? _inner; return(true); }
public static ImmSet <T> Wrap <T>(this HashedAvlTree <T, bool> .Node inner, IEqualityComparer <T> eq) { return(new ImmSet <T>(inner, eq)); }
internal static ImmMap <TKey, TValue> WrapMap <TKey, TValue>(this HashedAvlTree <TKey, TValue> .Node root, IEqualityComparer <TKey> equality) { return(new ImmMap <TKey, TValue>(root, equality)); }