/// <summary>
/// Returns a new set with all of the elements of this set, plus the value given as an argument [Time: log(this.Count)]
/// </summary>
/// <param name="value">The value to add</param>
/// <returns>The new set containing <paramref name="value"/>.</returns>
public Set <T> Add(T value)
{
bool added;
LobTree <T> newElems = LobTree <T> .Insert(elems, value, false, out added);
return(added ? new Set <T>(count + 1, newElems) : this);
}
/// <summary>
/// Creates a map from the keys and values given as arguments.
/// </summary>
/// <param name="key1">The first key</param>
/// <param name="value1">The value corresponding to <paramref name="key1"/></param>
/// <param name="key2">The second key</param>
/// <param name="value2">The value corresponding to <paramref name="key2"/></param>
/// <param name="key3">The third key</param>
/// <param name="value3">The value corresponding to <paramref name="key3"/></param>
/// <param name="key4">The fourth key</param>
/// <param name="value4">The value corresponding to <paramref name="key4"/></param>
public Map(T key1, S value1, T key2, S value2, T key3, S value3, T key4, S value4)
{
LobTree <Maplet> /*?*/ newElems = null;
bool added;
int newCount = 1;
newElems = LobTree <Maplet> .Insert(newElems, new Maplet(new Pair <T, S>(key1, value1)), true, out added);
//^ assert added;
newElems = LobTree <Maplet> .Insert(newElems, new Maplet(new Pair <T, S>(key2, value2)), true, out added);
if (added)
{
newCount += 1;
}
newElems = LobTree <Maplet> .Insert(newElems, new Maplet(new Pair <T, S>(key3, value3)), true, out added);
if (added)
{
newCount += 1;
}
newElems = LobTree <Maplet> .Insert(newElems, new Maplet(new Pair <T, S>(key4, value4)), true, out added);
if (added)
{
newCount += 1;
}
this.count = newCount;
this.elems = newElems;
}
/// <summary>
/// Returns a new set containing every element of this set except the value given as a parameter.
/// If value is not in this set, then returns this set. [Time: log(this.Count)]
/// </summary>
/// <param name="value">The value to be deleted.</param>
/// <returns>The new set that does not contain <paramref name="value"/>.</returns>
public Set <T> Remove(T value)
//^ ensures !this.Contains(value) <==> ((object)this == result); // pointer equals iff value not contained
//^ ensures this.Contains(value) <==> (result.Count + 1 == this.Count);
{
bool deleted = false;
LobTree <T> /*?*/ newElems = LobTree <T> .Remove(this.elems, value, out deleted);
return(deleted ? new Set <T>(count - 1, newElems) : this);
}
/// <summary>
/// Creates a map from the key and value given as arguments.
/// </summary>
/// <param name="key1">The key</param>
/// <param name="value1">The value corresponding to <paramref name="key1"/></param>
public Map(T key1, S value1)
{
LobTree <Maplet> /*?*/ newElems = null;
bool added;
newElems = LobTree <Maplet> .Insert(newElems, new Maplet(new Pair <T, S>(key1, value1)), true, out added);
//^ assert added;
this.count = 1;
this.elems = newElems;
}
private void InPlaceRemove(T value)
{
bool deleted = false;
elems = LobTree <T> .Remove(elems, value, out deleted);
if (deleted)
{
count -= 1;
this.InvalidateCache();
}
}
/// <summary>
/// Removes the key-value pair from the map
/// </summary>
/*internal*/
private void InPlaceRemove(Pair <T, S> d)
{
bool deleted = false;
this.elems = LobTree <Maplet> .Remove(elems, new Maplet(d), out deleted);
this.InvalidateCache();
if (deleted)
{
count -= 1;
}
}
/// <summary>
/// Removes the element with the specified key from the map
/// </summary>
private void InPlaceRemoveKey(T /*!*/ key)
{
bool deleted;
this.elems = LobTree <Maplet> .Remove(elems, new Maplet(new Pair <T, S>(key, default(S))), out deleted);
this.InvalidateCache();
if (deleted)
{
count -= 1;
}
}
//private void InPlaceAdd(Maplet/*!*/ m)
//{
// bool added;
// this.elems = LobTree<Maplet>.Insert(elems, m, true, out added);
// hashCode = null;
// if (added)
// count++;
// else
// {
// throw new Exception(String.Format("Map.Add: Duplicate key '{0}'", (/*^(!)^*/m.d.First).ToString()));
// }
//}
/// <summary>
/// Adds an element with the specified key and value into the map [Time: log(this.Count)]
/// </summary>
private void InPlaceOverride(Pair <T, S> d)
{
bool added;
this.elems = LobTree <Maplet> .Insert(elems, new Maplet(d), true, out added);
this.InvalidateCache();
if (added)
{
count += 1;
}
}
private int InPlaceAdd(T value)
{
bool added;
elems = LobTree <T> .Insert(elems, value, false, out added);
if (added)
{
count += 1;
this.InvalidateCache();
}
return(count);
}
/// <summary>
/// Construct a set from the elements given in the argument list
/// </summary>
/// <param name="elements">The argument list</param>
public Set(params T[] elements)
{
int newCount = 0;
LobTree <T> /*?*/ newElems = null;
bool added = false;
foreach (T o in elements)
{
newElems = LobTree <T> .Insert(newElems, o, false, out added);
if (added)
{
newCount += 1;
}
}
this.count = newCount;
this.elems = newElems;
}
public Map(params Pair <T, S>[] keyValuePairs)
{
LobTree <Maplet> /*?*/ newElems = null;
int newCount = 0;
foreach (Pair <T, S> d in keyValuePairs)
{
bool added;
newElems = LobTree <Maplet> .Insert(newElems, new Maplet(d), true, out added);
if (added)
{
newCount += 1;
}
}
this.count = newCount;
this.elems = newElems;
}
[SuppressMessage("Microsoft.Performance", "CA1804:RemoveUnusedLocals")] // want to use "found" var
private void InPlaceAdd(T key, S value)
{
bool added;
LobTree <Maplet> newElems = LobTree <Maplet> .Insert(elems, new Maplet(new Pair <T, S>(key, value)), true, out added);
if (!added)
{
S previousValue;
bool found = this.TryGetValue(key, out previousValue);
//^ assume found;
if (!Object.Equals(value, previousValue))
{
throw new ArgumentException(MessageStrings.LocalizedFormat(MessageStrings.MapAddInvalidArgument, key.ToString()));
}
}
else
{
this.count += 1;
}
this.elems = newElems;
this.InvalidateCache();
}
private Set(int count, LobTree <T> /*?*/ elems)
{
this.count = count;
this.elems = elems;
}
private Map(int count, LobTree <Maplet> /*?*/ elems)
{
this.count = count; this.elems = elems;
}
