<?xml version="1.0"?>
<doc>
<assembly>
<name>Iesi.Collections</name>
</assembly>
<members>
<member name="T:Iesi.Collections.ImmutableSet">
<summary>
<p>Implements an immutable (read-only) <c>Set</c> wrapper.</p>
<p>Although this is advertised as immutable, it really isn't. Anyone with access to the
<c>basisSet</c> can still change the data-set. So <c>GetHashCode()</c> is not implemented
for this <c>Set</c>, as is the case for all <c>Set</c> implementations in this library.
This design decision was based on the efficiency of not having to <c>Clone()</c> the
<c>basisSet</c> every time you wrap a mutable <c>Set</c>.</p>
</summary>
</member>
<member name="T:Iesi.Collections.Set">
<summary><p>A collection that contains no duplicate elements. This class models the mathematical
<c>Set</c> abstraction, and is the base class for all other <c>Set</c> implementations.
The order of elements in a set is dependant on (a)the data-structure implementation, and
(b)the implementation of the various <c>Set</c> methods, and thus is not guaranteed.</p>
<p><c>Set</c> overrides the <c>Equals()</c> method to test for "equivalency": whether the
two sets contain the same elements. The "==" and "!=" operators are not overridden by
design, since it is often desirable to compare object references for equality.</p>
<p>Also, the <c>GetHashCode()</c> method is not implemented on any of the set implementations, since none
of them are truely immutable. This is by design, and it is the way almost all collections in
the .NET framework function. So as a general rule, don't store collection objects inside <c>Set</c>
instances. You would typically want to use a keyed <c>IDictionary</c> instead.</p>
<p>None of the <c>Set</c> implementations in this library are guranteed to be thread-safe
in any way unless wrapped in a <c>SynchronizedSet</c>.</p>
<p>The following table summarizes the binary operators that are supported by the <c>Set</c> class.</p>
<list type="table">
<listheader>
<term>Operation</term>
<term>Description</term>
<term>Method</term>
<term>Operator</term>
</listheader>
<item>
<term>Union (OR)</term>
<term>Element included in result if it exists in either <c>A</c> OR <c>B</c>.</term>
<term><c>Union()</c></term>
<term><c>|</c></term>
</item>
<item>
<term>Intersection (AND)</term>
<term>Element included in result if it exists in both <c>A</c> AND <c>B</c>.</term>
<term><c>InterSect()</c></term>
<term><c>&</c></term>
</item>
<item>
<term>Exclusive Or (XOR)</term>
<term>Element included in result if it exists in one, but not both, of <c>A</c> and <c>B</c>.</term>
<term><c>ExclusiveOr()</c></term>
<term><c>^</c></term>
</item>
<item>
<term>Minus (n/a)</term>
<term>Take all the elements in <c>A</c>. Now, if any of them exist in <c>B</c>, remove
them. Note that unlike the other operators, <c>A - B</c> is not the same as <c>B - A</c>.</term>
<term><c>Minus()</c></term>
<term><c>-</c></term>
</item>
</list>
</summary>
</member>
<member name="T:Iesi.Collections.ISet">
<summary>
<p>A collection that contains no duplicate elements. This interface models the mathematical
<c>Set</c> abstraction.
The order of elements in a set is dependant on (a)the data-structure implementation, and
(b)the implementation of the various <c>Set</c> methods, and thus is not guaranteed.</p>
<p>None of the <c>Set</c> implementations in this library are guranteed to be thread-safe
in any way unless wrapped in a <c>SynchronizedSet</c>.</p>
<p>The following table summarizes the binary operators that are supported by the <c>Set</c> class.</p>
<list type="table">
<listheader>
<term>Operation</term>
<term>Description</term>
<term>Method</term>
</listheader>
<item>
<term>Union (OR)</term>
<term>Element included in result if it exists in either <c>A</c> OR <c>B</c>.</term>
<term><c>Union()</c></term>
</item>
<item>
<term>Intersection (AND)</term>
<term>Element included in result if it exists in both <c>A</c> AND <c>B</c>.</term>
<term><c>InterSect()</c></term>
</item>
<item>
<term>Exclusive Or (XOR)</term>
<term>Element included in result if it exists in one, but not both, of <c>A</c> and <c>B</c>.</term>
<term><c>ExclusiveOr()</c></term>
</item>
<item>
<term>Minus (n/a)</term>
<term>Take all the elements in <c>A</c>. Now, if any of them exist in <c>B</c>, remove
them. Note that unlike the other operators, <c>A - B</c> is not the same as <c>B - A</c>.</term>
<term><c>Minus()</c></term>
</item>
</list>
</summary>
</member>
<member name="M:Iesi.Collections.ISet.Union(Iesi.Collections.ISet)">
<summary>
Performs a "union" of the two sets, where all the elements
in both sets are present. That is, the element is included if it is in either <c>a</c> or <c>b</c>.
Neither this set nor the input set are modified during the operation. The return value
is a <c>Clone()</c> of this set with the extra elements added in.
</summary>
<param name="a">A collection of elements.</param>
<returns>A new <c>Set</c> containing the union of this <c>Set</c> with the specified collection.
Neither of the input objects is modified by the union.</returns>
</member>
<member name="M:Iesi.Collections.ISet.Intersect(Iesi.Collections.ISet)">
<summary>
Performs an "intersection" of the two sets, where only the elements
that are present in both sets remain. That is, the element is included if it exists in
both sets. The <c>Intersect()</c> operation does not modify the input sets. It returns
a <c>Clone()</c> of this set with the appropriate elements removed.
</summary>
<param name="a">A set of elements.</param>
<returns>The intersection of this set with <c>a</c>.</returns>
</member>
<member name="M:Iesi.Collections.ISet.Minus(Iesi.Collections.ISet)">
<summary>
Performs a "minus" of set <c>b</c> from set <c>a</c>. This returns a set of all
the elements in set <c>a</c>, removing the elements that are also in set <c>b</c>.
The original sets are not modified during this operation. The result set is a <c>Clone()</c>
of this <c>Set</c> containing the elements from the operation.
</summary>
<param name="a">A set of elements.</param>
<returns>A set containing the elements from this set with the elements in <c>a</c> removed.</returns>
</member>
<member name="M:Iesi.Collections.ISet.ExclusiveOr(Iesi.Collections.ISet)">
<summary>
Performs an "exclusive-or" of the two sets, keeping only the elements that
are in one of the sets, but not in both. The original sets are not modified
during this operation. The result set is a <c>Clone()</c> of this set containing
the elements from the exclusive-or operation.
</summary>
<param name="a">A set of elements.</param>
<returns>A set containing the result of <c>a ^ b</c>.</returns>
</member>
<member name="M:Iesi.Collections.ISet.Contains(System.Object)">
<summary>
Returns <c>true</c> if this set contains the specified element.
</summary>
<param name="o">The element to look for.</param>
<returns><c>true</c> if this set contains the specified element, <c>false</c> otherwise.</returns>
</member>
<member name="M:Iesi.Collections.ISet.ContainsAll(System.Collections.ICollection)">
<summary>
Returns <c>true</c> if the set contains all the elements in the specified collection.
</summary>
<param name="c">A collection of objects.</param>
<returns><c>true</c> if the set contains all the elements in the specified collection, <c>false</c> otherwise.</returns>
</member>
<member name="M:Iesi.Collections.ISet.Add(System.Object)">
<summary>
Adds the specified element to this set if it is not already present.
</summary>
<param name="o">The object to add to the set.</param>
<returns><c>true</c> is the object was added, <c>false</c> if it was already present.</returns>
</member>
<member name="M:Iesi.Collections.ISet.AddAll(System.Collections.ICollection)">
<summary>
Adds all the elements in the specified collection to the set if they are not already present.
</summary>
<param name="c">A collection of objects to add to the set.</param>
<returns><c>true</c> is the set changed as a result of this operation, <c>false</c> if not.</returns>
</member>
<member name="M:Iesi.Collections.ISet.Remove(System.Object)">
<summary>
Removes the specified element from the set.
</summary>
<param name="o">The element to be removed.</param>
<returns><c>true</c> if the set contained the specified element, <c>false</c> otherwise.</returns>
</member>
<member name="M:Iesi.Collections.ISet.RemoveAll(System.Collections.ICollection)">
<summary>
Remove all the specified elements from this set, if they exist in this set.
</summary>
<param name="c">A collection of elements to remove.</param>
<returns><c>true</c> if the set was modified as a result of this operation.</returns>
</member>
<member name="M:Iesi.Collections.ISet.RetainAll(System.Collections.ICollection)">
<summary>
Retains only the elements in this set that are contained in the specified collection.
</summary>
<param name="c">Collection that defines the set of elements to be retained.</param>
<returns><c>true</c> if this set changed as a result of this operation.</returns>
</member>
<member name="M:Iesi.Collections.ISet.Clear">
<summary>
Removes all objects from the set.
</summary>
</member>
<member name="P:Iesi.Collections.ISet.IsEmpty">
<summary>
Returns <c>true</c> if this set contains no elements.
</summary>
</member>
<member name="M:Iesi.Collections.Set.Union(Iesi.Collections.ISet)">
<summary>
Performs a "union" of the two sets, where all the elements
in both sets are present. That is, the element is included if it is in either <c>a</c> or <c>b</c>.
Neither this set nor the input set are modified during the operation. The return value
is a <c>Clone()</c> of this set with the extra elements added in.
</summary>
<param name="a">A collection of elements.</param>
<returns>A new <c>Set</c> containing the union of this <c>Set</c> with the specified collection.
Neither of the input objects is modified by the union.</returns>
</member>
<member name="M:Iesi.Collections.Set.Union(Iesi.Collections.ISet,Iesi.Collections.ISet)">
<summary>
Performs a "union" of two sets, where all the elements
in both are present. That is, the element is included if it is in either <c>a</c> or <c>b</c>.
The return value is a <c>Clone()</c> of one of the sets (<c>a</c> if it is not <c>null</c>) with elements of the other set
added in. Neither of the input sets is modified by the operation.
</summary>
<param name="a">A set of elements.</param>
<param name="b">A set of elements.</param>
<returns>A set containing the union of the input sets. <c>null</c> if both sets are <c>null</c>.</returns>
</member>
<member name="M:Iesi.Collections.Set.op_BitwiseOr(Iesi.Collections.Set,Iesi.Collections.Set)">
<summary>
Performs a "union" of two sets, where all the elements
in both are present. That is, the element is included if it is in either <c>a</c> or <c>b</c>.
The return value is a <c>Clone()</c> of one of the sets (<c>a</c> if it is not <c>null</c>) with elements of the other set
added in. Neither of the input sets is modified by the operation.
</summary>
<param name="a">A set of elements.</param>
<param name="b">A set of elements.</param>
<returns>A set containing the union of the input sets. <c>null</c> if both sets are <c>null</c>.</returns>
</member>
<member name="M:Iesi.Collections.Set.Intersect(Iesi.Collections.ISet)">
<summary>
Performs an "intersection" of the two sets, where only the elements
that are present in both sets remain. That is, the element is included if it exists in
both sets. The <c>Intersect()</c> operation does not modify the input sets. It returns
a <c>Clone()</c> of this set with the appropriate elements removed.
</summary>
<param name="a">A set of elements.</param>
<returns>The intersection of this set with <c>a</c>.</returns>
</member>
<member name="M:Iesi.Collections.Set.Intersect(Iesi.Collections.ISet,Iesi.Collections.ISet)">
<summary>
Performs an "intersection" of the two sets, where only the elements
that are present in both sets remain. That is, the element is included only if it exists in
both <c>a</c> and <c>b</c>. Neither input object is modified by the operation.
The result object is a <c>Clone()</c> of one of the input objects (<c>a</c> if it is not <c>null</c>) containing the
elements from the intersect operation.
</summary>
<param name="a">A set of elements.</param>
<param name="b">A set of elements.</param>
<returns>The intersection of the two input sets. <c>null</c> if both sets are <c>null</c>.</returns>
</member>
<member name="M:Iesi.Collections.Set.op_BitwiseAnd(Iesi.Collections.Set,Iesi.Collections.Set)">
<summary>
Performs an "intersection" of the two sets, where only the elements
that are present in both sets remain. That is, the element is included only if it exists in
both <c>a</c> and <c>b</c>. Neither input object is modified by the operation.
The result object is a <c>Clone()</c> of one of the input objects (<c>a</c> if it is not <c>null</c>) containing the
elements from the intersect operation.
</summary>
<param name="a">A set of elements.</param>
<param name="b">A set of elements.</param>
<returns>The intersection of the two input sets. <c>null</c> if both sets are <c>null</c>.</returns>
</member>
<member name="M:Iesi.Collections.Set.Minus(Iesi.Collections.ISet)">
<summary>
Performs a "minus" of set <c>b</c> from set <c>a</c>. This returns a set of all
the elements in set <c>a</c>, removing the elements that are also in set <c>b</c>.
The original sets are not modified during this operation. The result set is a <c>Clone()</c>
of this <c>Set</c> containing the elements from the operation.
</summary>
<param name="a">A set of elements.</param>
<returns>A set containing the elements from this set with the elements in <c>a</c> removed.</returns>
</member>
<member name="M:Iesi.Collections.Set.Minus(Iesi.Collections.ISet,Iesi.Collections.ISet)">
<summary>
Performs a "minus" of set <c>b</c> from set <c>a</c>. This returns a set of all
the elements in set <c>a</c>, removing the elements that are also in set <c>b</c>.
The original sets are not modified during this operation. The result set is a <c>Clone()</c>
of set <c>a</c> containing the elements from the operation.
</summary>
<param name="a">A set of elements.</param>
<param name="b">A set of elements.</param>
<returns>A set containing <c>A - B</c> elements. <c>null</c> if <c>a</c> is <c>null</c>.</returns>
</member>
<member name="M:Iesi.Collections.Set.op_Subtraction(Iesi.Collections.Set,Iesi.Collections.Set)">
<summary>
Performs a "minus" of set <c>b</c> from set <c>a</c>. This returns a set of all
the elements in set <c>a</c>, removing the elements that are also in set <c>b</c>.
The original sets are not modified during this operation. The result set is a <c>Clone()</c>
of set <c>a</c> containing the elements from the operation.
</summary>
<param name="a">A set of elements.</param>
<param name="b">A set of elements.</param>
<returns>A set containing <c>A - B</c> elements. <c>null</c> if <c>a</c> is <c>null</c>.</returns>
</member>
<member name="M:Iesi.Collections.Set.ExclusiveOr(Iesi.Collections.ISet)">
<summary>
Performs an "exclusive-or" of the two sets, keeping only the elements that
are in one of the sets, but not in both. The original sets are not modified
during this operation. The result set is a <c>Clone()</c> of this set containing
the elements from the exclusive-or operation.
</summary>
<param name="a">A set of elements.</param>
<returns>A set containing the result of <c>a ^ b</c>.</returns>
</member>
<member name="M:Iesi.Collections.Set.ExclusiveOr(Iesi.Collections.ISet,Iesi.Collections.ISet)">
<summary>
Performs an "exclusive-or" of the two sets, keeping only the elements that
are in one of the sets, but not in both. The original sets are not modified
during this operation. The result set is a <c>Clone()</c> of one of the sets
(<c>a</c> if it is not <c>null</c>) containing
the elements from the exclusive-or operation.
</summary>
<param name="a">A set of elements.</param>
<param name="b">A set of elements.</param>
<returns>A set containing the result of <c>a ^ b</c>. <c>null</c> if both sets are <c>null</c>.</returns>
</member>
<member name="M:Iesi.Collections.Set.op_ExclusiveOr(Iesi.Collections.Set,Iesi.Collections.Set)">
<summary>
Performs an "exclusive-or" of the two sets, keeping only the elements that
are in one of the sets, but not in both. The original sets are not modified
during this operation. The result set is a <c>Clone()</c> of one of the sets
(<c>a</c> if it is not <c>null</c>) containing
the elements from the exclusive-or operation.
</summary>
<param name="a">A set of elements.</param>
<param name="b">A set of elements.</param>
<returns>A set containing the result of <c>a ^ b</c>. <c>null</c> if both sets are <c>null</c>.</returns>
</member>
<member name="M:Iesi.Collections.Set.Add(System.Object)">
<summary>
Adds the specified element to this set if it is not already present.
</summary>
<param name="o">The object to add to the set.</param>
<returns><c>true</c> is the object was added, <c>false</c> if it was already present.</returns>
</member>
<member name="M:Iesi.Collections.Set.AddAll(System.Collections.ICollection)">
<summary>
Adds all the elements in the specified collection to the set if they are not already present.
</summary>
<param name="c">A collection of objects to add to the set.</param>
<returns><c>true</c> is the set changed as a result of this operation, <c>false</c> if not.</returns>
</member>
<member name="M:Iesi.Collections.Set.Clear">
<summary>
Removes all objects from the set.
</summary>
</member>
<member name="M:Iesi.Collections.Set.Contains(System.Object)">
<summary>
Returns <c>true</c> if this set contains the specified element.
</summary>
<param name="o">The element to look for.</param>
<returns><c>true</c> if this set contains the specified element, <c>false</c> otherwise.</returns>
</member>
<member name="M:Iesi.Collections.Set.ContainsAll(System.Collections.ICollection)">
<summary>
Returns <c>true</c> if the set contains all the elements in the specified collection.
</summary>
<param name="c">A collection of objects.</param>
<returns><c>true</c> if the set contains all the elements in the specified collection, <c>false</c> otherwise.</returns>
</member>
<member name="M:Iesi.Collections.Set.Remove(System.Object)">
<summary>
Removes the specified element from the set.
</summary>
<param name="o">The element to be removed.</param>
<returns><c>true</c> if the set contained the specified element, <c>false</c> otherwise.</returns>
</member>
<member name="M:Iesi.Collections.Set.RemoveAll(System.Collections.ICollection)">
<summary>
Remove all the specified elements from this set, if they exist in this set.
</summary>
<param name="c">A collection of elements to remove.</param>
<returns><c>true</c> if the set was modified as a result of this operation.</returns>
</member>
<member name="M:Iesi.Collections.Set.RetainAll(System.Collections.ICollection)">
<summary>
Retains only the elements in this set that are contained in the specified collection.
</summary>
<param name="c">Collection that defines the set of elements to be retained.</param>
<returns><c>true</c> if this set changed as a result of this operation.</returns>
</member>
<member name="M:Iesi.Collections.Set.Clone">
<summary>
Returns a clone of the <c>Set</c> instance. This will work for derived <c>Set</c>
classes if the derived class implements a constructor that takes no arguments.
</summary>
<returns>A clone of this object.</returns>
</member>
<member name="M:Iesi.Collections.Set.CopyTo(System.Array,System.Int32)">
<summary>
Copies the elements in the <c>Set</c> to an array. The type of array needs
to be compatible with the objects in the <c>Set</c>, obviously.
</summary>
<param name="array">An array that will be the target of the copy operation.</param>
<param name="index">The zero-based index where copying will start.</param>
</member>
<member name="M:Iesi.Collections.Set.GetEnumerator">
<summary>
Gets an enumerator for the elements in the <c>Set</c>.
</summary>
<returns>An <c>IEnumerator</c> over the elements in the <c>Set</c>.</returns>
</member>
<member name="M:Iesi.Collections.Set.Equals(System.Object)">
<summary>
This method will test the <c>Set</c> against another <c>Set</c> for "equality".
In this case, "equality" means that the two sets contain the same elements.
The "==" and "!=" operators are not overridden by design. If you wish to check
for "equivalent" <c>Set</c> instances, use <c>Equals()</c>. If you wish to check
to see if two references are actually the same object, use "==" and "!=".
</summary>
<param name="o">A <c>Set</c> object to compare to.</param>
<returns></returns>
</member>
<member name="M:Iesi.Collections.Set.GetHashCode">
<summary>
Gets the hashcode for the object. Not implemented.
</summary>
<returns>An exception.</returns>
<exception cref="T:System.NotImplementedException">This feature is not implemented.</exception>
</member>
<member name="P:Iesi.Collections.Set.IsEmpty">
<summary>
Returns <c>true</c> if this set contains no elements.
</summary>
</member>
<member name="P:Iesi.Collections.Set.Count">
<summary>
The number of elements currently contained in this collection.
</summary>
</member>
<member name="P:Iesi.Collections.Set.IsSynchronized">
<summary>
Returns <c>true</c> if the <c>Set</c> is synchronized across threads. Note that
enumeration is inherently not thread-safe. Use the <c>SyncRoot</c> to lock the
object during enumeration.
</summary>
</member>
<member name="P:Iesi.Collections.Set.SyncRoot">
<summary>
An object that can be used to synchronize this collection to make it thread-safe.
When implementing this, if your object uses a base object, like an <c>IDictionary</c>,
or anything that has a <c>SyncRoot</c>, return that object instead of "<c>this</c>".
</summary>
</member>
<member name="M:Iesi.Collections.ImmutableSet.#ctor(Iesi.Collections.ISet)">
<summary>
Constructs an immutable (read-only) <c>Set</c> wrapper.
</summary>
<param name="basisSet">The <c>Set</c> that is wrapped.</param>
</member>
<member name="M:Iesi.Collections.ImmutableSet.Add(System.Object)">
<summary>
Adds the specified element to this set if it is not already present.
</summary>
<param name="o">The object to add to the set.</param>
<returns><c>true</c> is the object was added, <c>false</c> if it was already present.</returns>
</member>
<member name="M:Iesi.Collections.ImmutableSet.AddAll(System.Collections.ICollection)">
<summary>
Adds all the elements in the specified collection to the set if they are not already present.
</summary>
<param name="c">A collection of objects to add to the set.</param>
<returns><c>true</c> is the set changed as a result of this operation, <c>false</c> if not.</returns>
</member>
<member name="M:Iesi.Collections.ImmutableSet.Clear">
<summary>
Removes all objects from the set.
</summary>
</member>
<member name="M:Iesi.Collections.ImmutableSet.Contains(System.Object)">
<summary>
Returns <c>true</c> if this set contains the specified element.
</summary>
<param name="o">The element to look for.</param>
<returns><c>true</c> if this set contains the specified element, <c>false</c> otherwise.</returns>
</member>
<member name="M:Iesi.Collections.ImmutableSet.ContainsAll(System.Collections.ICollection)">
<summary>
Returns <c>true</c> if the set contains all the elements in the specified collection.
</summary>
<param name="c">A collection of objects.</param>
<returns><c>true</c> if the set contains all the elements in the specified collection, <c>false</c> otherwise.</returns>
</member>
<member name="M:Iesi.Collections.ImmutableSet.Remove(System.Object)">
<summary>
Removes the specified element from the set.
</summary>
<param name="o">The element to be removed.</param>
<returns><c>true</c> if the set contained the specified element, <c>false</c> otherwise.</returns>
</member>
<member name="M:Iesi.Collections.ImmutableSet.RemoveAll(System.Collections.ICollection)">
<summary>
Remove all the specified elements from this set, if they exist in this set.
</summary>
<param name="c">A collection of elements to remove.</param>
<returns><c>true</c> if the set was modified as a result of this operation.</returns>
</member>
<member name="M:Iesi.Collections.ImmutableSet.RetainAll(System.Collections.ICollection)">
<summary>
Retains only the elements in this set that are contained in the specified collection.
</summary>
<param name="c">Collection that defines the set of elements to be retained.</param>
<returns><c>true</c> if this set changed as a result of this operation.</returns>
</member>
<member name="M:Iesi.Collections.ImmutableSet.CopyTo(System.Array,System.Int32)">
<summary>
Copies the elements in the <c>Set</c> to an array. The type of array needs
to be compatible with the objects in the <c>Set</c>, obviously.
</summary>
<param name="array">An array that will be the target of the copy operation.</param>
<param name="index">The zero-based index where copying will start.</param>
</member>
<member name="M:Iesi.Collections.ImmutableSet.GetEnumerator">
<summary>
Gets an enumerator for the elements in the <c>Set</c>.
</summary>
<returns>An <c>IEnumerator</c> over the elements in the <c>Set</c>.</returns>
</member>
<member name="M:Iesi.Collections.ImmutableSet.Clone">
<summary>
Returns a clone of the <c>Set</c> instance.
</summary>
<returns>A clone of this object.</returns>
</member>
<member name="M:Iesi.Collections.ImmutableSet.Union(Iesi.Collections.ISet)">
<summary>
Performs a "union" of the two sets, where all the elements
in both sets are present. That is, the element is included if it is in either <c>a</c> or <c>b</c>.
Neither this set nor the input set are modified during the operation. The return value
is a <c>Clone()</c> of this set with the extra elements added in.
</summary>
<param name="a">A collection of elements.</param>
<returns>A new <c>Set</c> containing the union of this <c>Set</c> with the specified collection.
Neither of the input objects is modified by the union.</returns>
</member>
<member name="M:Iesi.Collections.ImmutableSet.Intersect(Iesi.Collections.ISet)">
<summary>
Performs an "intersection" of the two sets, where only the elements
that are present in both sets remain. That is, the element is included if it exists in
both sets. The <c>Intersect()</c> operation does not modify the input sets. It returns
a <c>Clone()</c> of this set with the appropriate elements removed.
</summary>
<param name="a">A set of elements.</param>
<returns>The intersection of this set with <c>a</c>.</returns>
</member>
<member name="M:Iesi.Collections.ImmutableSet.Minus(Iesi.Collections.ISet)">
<summary>
Performs a "minus" of set <c>b</c> from set <c>a</c>. This returns a set of all
the elements in set <c>a</c>, removing the elements that are also in set <c>b</c>.
The original sets are not modified during this operation. The result set is a <c>Clone()</c>
of this <c>Set</c> containing the elements from the operation.
</summary>
<param name="a">A set of elements.</param>
<returns>A set containing the elements from this set with the elements in <c>a</c> removed.</returns>
</member>
<member name="M:Iesi.Collections.ImmutableSet.ExclusiveOr(Iesi.Collections.ISet)">
<summary>
Performs an "exclusive-or" of the two sets, keeping only the elements that
are in one of the sets, but not in both. The original sets are not modified
during this operation. The result set is a <c>Clone()</c> of this set containing
the elements from the exclusive-or operation.
</summary>
<param name="a">A set of elements.</param>
<returns>A set containing the result of <c>a ^ b</c>.</returns>
</member>
<member name="P:Iesi.Collections.ImmutableSet.IsEmpty">
<summary>
Returns <c>true</c> if this set contains no elements.
</summary>
</member>
<member name="P:Iesi.Collections.ImmutableSet.Count">
<summary>
The number of elements contained in this collection.
</summary>
</member>
<member name="P:Iesi.Collections.ImmutableSet.IsSynchronized">
<summary>
Returns an object that can be used to synchronize use of the <c>Set</c> across threads.
</summary>
</member>
<member name="P:Iesi.Collections.ImmutableSet.SyncRoot">
<summary>
Returns an object that can be used to synchronize the <c>Set</c> between threads.
</summary>
</member>
<member name="T:Iesi.Collections.HybridSet">
<summary>
Implements a <c>Set</c> that automatically changes from a list to a hash table
when the size reaches a certain threshold. This is good if you are unsure about
whether you data-set will be tiny or huge. Because this uses a dual implementation,
iteration order is not guaranteed!
</summary>
</member>
<member name="T:Iesi.Collections.DictionarySet">
<summary>
<p><c>DictionarySet</c> is an abstract class that supports the creation of new <c>Set</c>
types where the underlying data store is an <c>IDictionary</c> instance.</p>
<p>You can use any object that implements the <c>IDictionary</c> interface to hold set data.
You can define your own, or you can use one of the objects provided in the Framework.
The type of <c>IDictionary</c> you choose will affect both the performance and the behavior
of the <c>Set</c> using it. </p>
<p>To make a <c>Set</c> typed based on your own <c>IDictionary</c>, simply derive a
new class with a constructor that takes no parameters. Some <c>Set</c> implmentations
cannot be defined with a default constructor. If this is the case for your class,
you will need to override <c>Clone()</c> as well.</p>
<p>It is also standard practice that at least one of your constructors takes an <c>ICollection</c> or
an <c>ISet</c> as an argument.</p>
</summary>
</member>
<member name="F:Iesi.Collections.DictionarySet.InternalDictionary">
<summary>
Provides the storage for elements in the <c>Set</c>, stored as the key-set
of the <c>IDictionary</c> object. Set this object in the constructor
if you create your own <c>Set</c> class.
</summary>
</member>
<member name="M:Iesi.Collections.DictionarySet.Add(System.Object)">
<summary>
Adds the specified element to this set if it is not already present.
</summary>
<param name="o">The object to add to the set.</param>
<returns><c>true</c> is the object was added, <c>false</c> if it was already present.</returns>
</member>
<member name="M:Iesi.Collections.DictionarySet.AddAll(System.Collections.ICollection)">
<summary>
Adds all the elements in the specified collection to the set if they are not already present.
</summary>
<param name="c">A collection of objects to add to the set.</param>
<returns><c>true</c> is the set changed as a result of this operation, <c>false</c> if not.</returns>
</member>
<member name="M:Iesi.Collections.DictionarySet.Clear">
<summary>
Removes all objects from the set.
</summary>
</member>
<member name="M:Iesi.Collections.DictionarySet.Contains(System.Object)">
<summary>
Returns <c>true</c> if this set contains the specified element.
</summary>
<param name="o">The element to look for.</param>
<returns><c>true</c> if this set contains the specified element, <c>false</c> otherwise.</returns>
</member>
<member name="M:Iesi.Collections.DictionarySet.ContainsAll(System.Collections.ICollection)">
<summary>
Returns <c>true</c> if the set contains all the elements in the specified collection.
</summary>
<param name="c">A collection of objects.</param>
<returns><c>true</c> if the set contains all the elements in the specified collection, <c>false</c> otherwise.</returns>
</member>
<member name="M:Iesi.Collections.DictionarySet.Remove(System.Object)">
<summary>
Removes the specified element from the set.
</summary>
<param name="o">The element to be removed.</param>
<returns><c>true</c> if the set contained the specified element, <c>false</c> otherwise.</returns>
</member>
<member name="M:Iesi.Collections.DictionarySet.RemoveAll(System.Collections.ICollection)">
<summary>
Remove all the specified elements from this set, if they exist in this set.
</summary>
<param name="c">A collection of elements to remove.</param>
<returns><c>true</c> if the set was modified as a result of this operation.</returns>
</member>
<member name="M:Iesi.Collections.DictionarySet.RetainAll(System.Collections.ICollection)">
<summary>
Retains only the elements in this set that are contained in the specified collection.
</summary>
<param name="c">Collection that defines the set of elements to be retained.</param>
<returns><c>true</c> if this set changed as a result of this operation.</returns>
</member>
<member name="M:Iesi.Collections.DictionarySet.CopyTo(System.Array,System.Int32)">
<summary>
Copies the elements in the <c>Set</c> to an array. The type of array needs
to be compatible with the objects in the <c>Set</c>, obviously.
</summary>
<param name="array">An array that will be the target of the copy operation.</param>
<param name="index">The zero-based index where copying will start.</param>
</member>
<member name="M:Iesi.Collections.DictionarySet.GetEnumerator">
<summary>
Gets an enumerator for the elements in the <c>Set</c>.
</summary>
<returns>An <c>IEnumerator</c> over the elements in the <c>Set</c>.</returns>
</member>
<member name="P:Iesi.Collections.DictionarySet.Placeholder">
<summary>
The placeholder object used as the value for the <c>IDictionary</c> instance.
</summary>
<remarks>
There is a single instance of this object globally, used for all <c>Sets</c>.
</remarks>
</member>
<member name="P:Iesi.Collections.DictionarySet.IsEmpty">
<summary>
Returns <c>true</c> if this set contains no elements.
</summary>
</member>
<member name="P:Iesi.Collections.DictionarySet.Count">
<summary>
The number of elements contained in this collection.
</summary>
</member>
<member name="P:Iesi.Collections.DictionarySet.IsSynchronized">
<summary>
None of the objects based on <c>DictionarySet</c> are synchronized. Use the
<c>SyncRoot</c> property instead.
</summary>
</member>
<member name="P:Iesi.Collections.DictionarySet.SyncRoot">
<summary>
Returns an object that can be used to synchronize the <c>Set</c> between threads.
</summary>
</member>
<member name="M:Iesi.Collections.HybridSet.#ctor">
<summary>
Creates a new set instance based on either a list or a hash table, depending on which
will be more efficient based on the data-set size.
</summary>
</member>
<member name="M:Iesi.Collections.HybridSet.#ctor(System.Collections.ICollection)">
<summary>
Creates a new set instance based on either a list or a hash table, depending on which
will be more efficient based on the data-set size, and
initializes it based on a collection of elements.
</summary>
<param name="initialValues">A collection of elements that defines the initial set contents.</param>
</member>
<member name="T:Iesi.Collections.SortedSet">
<summary>
Implements a <c>Set</c> based on a sorted tree. This gives good performance for operations on very
large data-sets, though not as good - asymptotically - as a <c>HashedSet</c>. However, iteration
occurs in order. Elements that you put into this type of collection must implement <c>IComparable</c>,
and they must actually be comparable. You can't mix <c>string</c> and <c>int</c> values, for example.
</summary>
</member>
<member name="M:Iesi.Collections.SortedSet.#ctor">
<summary>
Creates a new set instance based on a sorted tree.
</summary>
</member>
<member name="M:Iesi.Collections.SortedSet.#ctor(System.Collections.IComparer)">
<summary>
Creates a new set instance based on a sorted tree.
</summary>
<param name="comparer">The <see cref="T:System.Collections.IComparer"/> to use for sorting.</param>
</member>
<member name="M:Iesi.Collections.SortedSet.#ctor(System.Collections.ICollection)">
<summary>
Creates a new set instance based on a sorted tree and
initializes it based on a collection of elements.
</summary>
<param name="initialValues">A collection of elements that defines the initial set contents.</param>
</member>
<member name="M:Iesi.Collections.SortedSet.#ctor(System.Collections.ICollection,System.Collections.IComparer)">
<summary>
Creates a new set instance based on a sorted tree and
initializes it based on a collection of elements.
</summary>
<param name="initialValues">A collection of elements that defines the initial set contents.</param>
<param name="comparer">The <see cref="T:System.Collections.IComparer"/> to use for sorting.</param>
</member>
<member name="T:Iesi.Collections.HashedSet">
<summary>
Implements a <c>Set</c> based on a hash table. This will give the best lookup, add, and remove
performance for very large data-sets, but iteration will occur in no particular order.
</summary>
</member>
<member name="M:Iesi.Collections.HashedSet.#ctor">
<summary>
Creates a new set instance based on a hash table.
</summary>
</member>
<member name="M:Iesi.Collections.HashedSet.#ctor(System.Collections.ICollection)">
<summary>
Creates a new set instance based on a hash table and
initializes it based on a collection of elements.
</summary>
<param name="initialValues">A collection of elements that defines the initial set contents.</param>
</member>
<member name="T:Iesi.Collections.NamespaceDoc">
<summary>
<p>
The System.Collections namespace in the .NET Framework provides a number of collection
types that are extremely useful for manipulating data in memory. However, there is one
type of collection that is conspicuously missing from <c>System.Collections</c>: the
<c>Set</c>.
</p>
<p>
A <c>Set</c> is a collection that contains no duplicate elements, and where the order of
the elements may be arbitrary. It is loosely modelled after
the mathematical concept of a "set." This implementation is based on the Java <c>Set</c>
interface definition, so if you are also a Java programmer, this may seem familiar.
This library provides a number of "standard" <c>Set</c> operators that the Java library
neglected to include.
</p>
<p>
<c>Sets</c> come in handy when an <c>Array</c> or a <c>List</c> won't quite fit the bill.
Arrays in .NET have a fixed length, making it tedious to add and remove elements.
Lists allow you add new objects easily, but you can have numerous duplicate
elements, which is undesirable for some types of problems.
Searching Arrays or Lists for elements is just plain slow for large data sets,
requiring a linear search. You could keep the array sorted and use a binary search,
but that is often more trouble than it is worth (especially since this library,
and the .NET Framework, provide better ways that are already written for you).
</p>
<p>
With sets, adding elements, removing elements, and checking for the existence
of an element is fast and simple. You can mix and match the elements in different
sets using the supported mathematical set operators: union, intersection,
exclusive-or, and minus.
</p>
<p>
You will see some interesting side effects with different <c>Set</c>
implementations in this library, depending on the underlying search algorithm.
For example, if you choose a sort-based <c>Set</c>, the elements will come out
in sort order when you iterate using <c>foreach</c>. If you use a hash-based
<c>Set</c>, the elements will come out in no particular order, but checking
for inclusion will fastest when dealing with large data sets. If you use a
list-based <c>Set</c>, elements will come out in the order you put them in
when you iterate (although the effect of operators on element order in
<c>Set</c> instances is not well defined by design). Additionally, list-based
sets are fastest for very small data sets (up to about 10 elements),
but get slower very quickly as the number of contained elements increases.
To get the best of both worlds, the library provides a <c>Set</c> type that
uses lists for small data sets and switches to a hash-based algorithm when
the data set gets large enough to warrant it.
</p>
<p>
The following sample program demonstrates some of the features of sets:
<code>
using System;
using Iesi.Collections;
namespace RiverDemo
{
class Rivers
{
[STAThread]
static void Main(string[] args)
{
//Use Arrays (which are ICollection objects) to quickly initialize.
Set arizona
= new SortedSet(new string[] {"Colorado River"});
Set california
= new SortedSet(new string[] {"Colorado River", "Sacramento River"});
Set colorado
= new SortedSet(new string[] {"Arkansas River", "Colorado River", "Green River", "Rio Grande"});
Set kansas
= new SortedSet(new string[] {"Arkansas River", "Missouri River"});
Set nevada
= new SortedSet(new string[] {"Colorado River"});
Set newMexico
= new SortedSet(new string[] {"Rio Grande"});
Set utah
= new SortedSet(new string[] {"Colorado River", "Green River", "San Juan River"});
//Rivers by region.
Set southWest = colorado | newMexico | arizona | utah;
Set midWest = kansas;
Set west = california | nevada;
//All rivers (at least for the demo).
Set all = southWest | midWest | west;
Print("All rivers:", all);
Print("Rivers in the southwest:", southWest);
Print("Rivers in the west:", west);
Print("Rivers in the midwest:", midWest);
Console.WriteLine();
//Use the '-' operator to subtract the rivers in Colorado from
//the set of all rivers.
Print("Of all rivers, these don't pass through Colorado:", all - colorado);
//Use the '&' operator to find rivers that are in Colorado AND in Utah.
//A river must be present in both states, not just one.
Print("Rivers common to both Colorado and Utah:", colorado & utah);
//use the '^' operator to find rivers that are in Colorado OR Utah,
//but not in both.
Print("Rivers in Colorado and Utah that are not shared by both states:",
colorado ^ utah);
//Use the '&' operator to discover which rivers are present in Arizona,
// California,Colorado, Nevada, and Utah. The river must be present in
// all states to be counted.
Print("Rivers common to Arizona, California, Colorado, Nevada, and Utah:",
arizona & california & colorado & nevada & utah);
//Just to prove to you that operators always return like types, let's do a
//complex Set operation and look at the type of the result:
Console.WriteLine("The type of this complex operation is: " +
((southWest ^ colorado & california) | kansas).GetType().FullName);
}
private static void Print(string title, Set elements)
{
Console.WriteLine(title);
foreach(object o in elements)
{
Console.WriteLine("\t" + o);
Console.WriteLine();
}
}
}
</code>
</p>
<p>
Although there are other kinds of sets available in the library, the example uses
<c>SortedSet</c> throughout. This is nice for the example, since everything will
print neatly in alphabetical order. But you may be wondering what kind of <c>Set</c>
is returned when you "union," "intersect," "exclusive-or," or "minus" two <c>Set</c>
instances. The library always returns a <c>Set</c> that is the same type as
the <c>Set</c> on the left, unless the left operand is null, in which case it
returns the type of the <c>Set</c> on the right.
</p>
<p>
Here is the output from running the example:
<code>
All rivers:
Arkansas River
Colorado River
Green River
Missouri River
Rio Grande
Sacramento River
San Juan River
Rivers in the southwest:
Arkansas River
Colorado River
Green River
Rio Grande
San Juan River
Rivers in the west:
Colorado River
Sacramento River
Rivers in the midwest:
Arkansas River
Missouri River
Of all rivers, these don't pass through Colorado:
Missouri River
Sacramento River
San Juan River
Rivers common to both Colorado and Utah:
Colorado River
Green River
Rivers in Colorado and Utah that are not shared by both states:
Arkansas River
Rio Grande
San Juan River
Rivers common to Arizona, California, Colorado, Nevada, and Utah:
Colorado River
The type of this complex operation is:
Iesi.Collections.SortedSet
Press any key to continue
</code>
</p>
</summary>
</member>
<member name="T:Iesi.Collections.SynchronizedSet">
<summary>
<p>Implements a thread-safe <c>Set</c> wrapper. The implementation is extremely conservative,
serializing critical sections to prevent possible deadlocks, and locking on everything.
The one exception is for enumeration, which is inherently not thread-safe. For this, you
have to <c>lock</c> the <c>SyncRoot</c> object for the duration of the enumeration.</p>
</summary>
</member>
<member name="M:Iesi.Collections.SynchronizedSet.#ctor(Iesi.Collections.ISet)">
<summary>
Constructs a thread-safe <c>Set</c> wrapper.
</summary>
<param name="basisSet">The <c>Set</c> object that this object will wrap.</param>
</member>
<member name="M:Iesi.Collections.SynchronizedSet.Add(System.Object)">
<summary>
Adds the specified element to this set if it is not already present.
</summary>
<param name="o">The object to add to the set.</param>
<returns><c>true</c> is the object was added, <c>false</c> if it was already present.</returns>
</member>
<member name="M:Iesi.Collections.SynchronizedSet.AddAll(System.Collections.ICollection)">
<summary>
Adds all the elements in the specified collection to the set if they are not already present.
</summary>
<param name="c">A collection of objects to add to the set.</param>
<returns><c>true</c> is the set changed as a result of this operation, <c>false</c> if not.</returns>
</member>
<member name="M:Iesi.Collections.SynchronizedSet.Clear">
<summary>
Removes all objects from the set.
</summary>
</member>
<member name="M:Iesi.Collections.SynchronizedSet.Contains(System.Object)">
<summary>
Returns <c>true</c> if this set contains the specified element.
</summary>
<param name="o">The element to look for.</param>
<returns><c>true</c> if this set contains the specified element, <c>false</c> otherwise.</returns>
</member>
<member name="M:Iesi.Collections.SynchronizedSet.ContainsAll(System.Collections.ICollection)">
<summary>
Returns <c>true</c> if the set contains all the elements in the specified collection.
</summary>
<param name="c">A collection of objects.</param>
<returns><c>true</c> if the set contains all the elements in the specified collection, <c>false</c> otherwise.</returns>
</member>
<member name="M:Iesi.Collections.SynchronizedSet.Remove(System.Object)">
<summary>
Removes the specified element from the set.
</summary>
<param name="o">The element to be removed.</param>
<returns><c>true</c> if the set contained the specified element, <c>false</c> otherwise.</returns>
</member>
<member name="M:Iesi.Collections.SynchronizedSet.RemoveAll(System.Collections.ICollection)">
<summary>
Remove all the specified elements from this set, if they exist in this set.
</summary>
<param name="c">A collection of elements to remove.</param>
<returns><c>true</c> if the set was modified as a result of this operation.</returns>
</member>
<member name="M:Iesi.Collections.SynchronizedSet.RetainAll(System.Collections.ICollection)">
<summary>
Retains only the elements in this set that are contained in the specified collection.
</summary>
<param name="c">Collection that defines the set of elements to be retained.</param>
<returns><c>true</c> if this set changed as a result of this operation.</returns>
</member>
<member name="M:Iesi.Collections.SynchronizedSet.CopyTo(System.Array,System.Int32)">
<summary>
Copies the elements in the <c>Set</c> to an array. The type of array needs
to be compatible with the objects in the <c>Set</c>, obviously.
</summary>
<param name="array">An array that will be the target of the copy operation.</param>
<param name="index">The zero-based index where copying will start.</param>
</member>
<member name="M:Iesi.Collections.SynchronizedSet.GetEnumerator">
<summary>
Enumeration is, by definition, not thread-safe. Use a <c>lock</c> on the <c>SyncRoot</c>
to synchronize the entire enumeration process.
</summary>
<returns></returns>
</member>
<member name="M:Iesi.Collections.SynchronizedSet.Clone">
<summary>
Returns a clone of the <c>Set</c> instance.
</summary>
<returns>A clone of this object.</returns>
</member>
<member name="P:Iesi.Collections.SynchronizedSet.IsEmpty">
<summary>
Returns <c>true</c> if this set contains no elements.
</summary>
</member>
<member name="P:Iesi.Collections.SynchronizedSet.Count">
<summary>
The number of elements contained in this collection.
</summary>
</member>
<member name="P:Iesi.Collections.SynchronizedSet.IsSynchronized">
<summary>
Returns <c>true</c>, indicating that this object is thread-safe. The exception to this
is enumeration, which is inherently not thread-safe. Use the <c>SyncRoot</c> object to
lock this object for the entire duration of the enumeration.
</summary>
</member>
<member name="P:Iesi.Collections.SynchronizedSet.SyncRoot">
<summary>
Returns an object that can be used to synchronize the <c>Set</c> between threads.
</summary>
</member>
<member name="T:Iesi.Collections.ListSet">
<summary>
Implements a <c>Set</c> based on a list. Performance is much better for very small lists
than either <c>HashedSet</c> or <c>SortedSet</c>. However, performance degrades rapidly as
the data-set gets bigger. Use a <c>HybridSet</c> instead if you are not sure your data-set
will always remain very small. Iteration produces elements in the order they were added.
However, element order is not guaranteed to be maintained by the various <c>Set</c>
mathematical operators.
</summary>
</member>
<member name="M:Iesi.Collections.ListSet.#ctor">
<summary>
Creates a new set instance based on a list.
</summary>
</member>
<member name="M:Iesi.Collections.ListSet.#ctor(System.Collections.ICollection)">
<summary>
Creates a new set instance based on a list and
initializes it based on a collection of elements.
</summary>
<param name="initialValues">A collection of elements that defines the initial set contents.</param>
</member>
</members>
</doc>
Submit an article or tip