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));
}
