<?xml version="1.0"?>
<doc>
    <assembly>
        <name>PowerCollections</name>
    </assembly>
    <members>
        <member name="T:Wintellect.PowerCollections.BinaryPredicate`1">
            <summary>
            The BinaryPredicate delegate type  encapsulates a method that takes two
            items of the same type, and returns a boolean value representating 
            some relationship between them. For example, checking whether two
            items are equal or equivalent is one kind of binary predicate.
            </summary>
            <param name="item1">The first item.</param>
            <param name="item2">The second item.</param>
            <returns>Whether item1 and item2 satisfy the relationship that the BinaryPredicate defines.</returns>
        </member>
        <member name="T:Wintellect.PowerCollections.Algorithms">
            <summary>
            Algorithms contains a number of static methods that implement
            algorithms that work on collections. Most of the methods deal with
            the standard generic collection interfaces such as IEnumerable&lt;T&gt;,
            ICollection&lt;T&gt; and IList&lt;T&gt;.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Range``1(System.Collections.Generic.IList{``0},System.Int32,System.Int32)">
            <summary>
            Returns a view onto a sub-range of a list. Items from <paramref name="list"/> are not copied; the
            returned IList&lt;T&gt; is simply a different view onto the same underlying items. Changes to <paramref name="list"/>
            are reflected in the view, and vice versa. Insertions and deletions in the view change the size of the 
            view, but insertions and deletions in the underlying list do not.
            </summary>
            <remarks>This method can be used to apply an algorithm to a portion of a list. For example:
            <code>Algorithms.ReverseInPlace(Algorithms.Range(list, 3, 6))</code>
            will reverse the 6 items beginning at index 3.</remarks>
            <typeparam name="T">The type of the items in the list.</typeparam>
            <param name="list">The list to view.</param>
            <param name="start">The starting index of the view.</param>
            <param name="count">The number of items in the view.</param>
            <returns>A list that is a view onto the given sub-list. </returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="list"/> is null.</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="start"/> or <paramref name="count"/> is negative.</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="start"/> + <paramref name="count"/> is greater than the
            size of <paramref name="list"/>.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Range``1(``0[],System.Int32,System.Int32)">
            <summary>
            Returns a view onto a sub-range of an array. Items from <paramref name="array"/> are not copied; the
            returned IList&lt;T&gt; is simply a different view onto the same underlying items. Changes to <paramref name="array"/>
            are reflected in the view, and vice versa. Insertions and deletions in the view change the size of the 
            view. After an insertion, the last item in <paramref name="array"/> "falls off the end". After a deletion, the
            last item in array becomes the default value (0 or null).
            </summary>
            <remarks>This method can be used to apply an algorithm to a portion of a array. For example:
            <code>Algorithms.ReverseInPlace(Algorithms.Range(array, 3, 6))</code>
            will reverse the 6 items beginning at index 3.</remarks>
            <param name="array">The array to view.</param>
            <param name="start">The starting index of the view.</param>
            <param name="count">The number of items in the view.</param>
            <returns>A list that is a view onto the given sub-array. </returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="array"/> is null.</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="start"/> or <paramref name="count"/> is negative.</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="start"/> + <paramref name="count"/> is greater than the
            size of <paramref name="array"/>.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ReadOnly``1(System.Collections.Generic.ICollection{``0})">
            <summary>
            Returns a read-only view onto a collection. The returned ICollection&lt;T&gt; interface
            only allows operations that do not change the collection: GetEnumerator, Contains, CopyTo,
            Count. The ReadOnly property returns false, indicating that the collection is read-only. All other
            methods on the interface throw a NotSupportedException.
            </summary>
            <remarks>The data in the underlying collection is not copied. If the underlying
            collection is changed, then the read-only view also changes accordingly.</remarks>
            <typeparam name="T">The type of items in the collection.</typeparam>
            <param name="collection">The collection to wrap.</param>
            <returns>A read-only view onto <paramref name="collection"/>. If <paramref name="collection"/> is null, then null is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ReadOnly``1(System.Collections.Generic.IList{``0})">
            <summary>
            Returns a read-only view onto a list. The returned IList&lt;T&gt; interface
            only allows operations that do not change the list: GetEnumerator, Contains, CopyTo,
            Count, IndexOf, and the get accessor of the indexer. 
            The IsReadOnly property returns true, indicating that the list is read-only. All other
            methods on the interface throw a NotSupportedException.
            </summary>
            <remarks>The data in the underlying list is not copied. If the underlying
            list is changed, then the read-only view also changes accordingly.</remarks>
            <typeparam name="T">The type of items in the list.</typeparam>
            <param name="list">The list to wrap.</param>
            <returns>A read-only view onto <paramref name="list"/>. Returns null if <paramref name="list"/> is null. 
            If <paramref name="list"/> is already read-only, returns <paramref name="list"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ReadOnly``2(System.Collections.Generic.IDictionary{``0,``1})">
            <summary>
            Returns a read-only view onto a dictionary. The returned IDictionary&lt;TKey,TValue&gt; interface
            only allows operations that do not change the dictionary. 
            The IsReadOnly property returns true, indicating that the dictionary is read-only. All other
            methods on the interface throw a NotSupportedException.
            </summary>
            <remarks>The data in the underlying dictionary is not copied. If the underlying
            dictionary is changed, then the read-only view also changes accordingly.</remarks>
            <param name="dictionary">The dictionary to wrap.</param>
            <returns>A read-only view onto <paramref name="dictionary"/>. Returns null if <paramref name="dictionary"/> is null. 
            If <paramref name="dictionary"/> is already read-only, returns <paramref name="dictionary"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.TypedAs``1(System.Collections.IEnumerable)">
            <summary>
            Given a non-generic IEnumerable interface, wrap a generic IEnumerable&lt;T&gt;
            interface around it. The generic interface will enumerate the same objects as the 
            underlying non-generic collection, but can be used in places that require a generic interface.
            The underlying non-generic collection must contain only items that
            are of type <paramref name="T"/> or a type derived from it. This method is useful
            when interfacing older, non-generic collections to newer code that uses generic interfaces.
            </summary>
            <remarks>Some collections implement both generic and non-generic interfaces. For efficiency,
            this method will first attempt to cast <paramref name="untypedCollection"/> to IEnumerable&lt;T&gt;. 
            If that succeeds, it is returned; otherwise, a wrapper object is created.</remarks>
            <typeparam name="T">The item type of the wrapper collection.</typeparam>
            <param name="untypedCollection">An untyped collection. This collection should only contain
            items of type <paramref name="T"/> or a type derived from it. </param>
            <returns>A generic IEnumerable&lt;T&gt; wrapper around <paramref name="untypedCollection"/>. 
            If <paramref name="untypedCollection"/> is null, then null is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.TypedAs``1(System.Collections.ICollection)">
            <summary>
            Given a non-generic ICollection interface, wrap a generic ICollection&lt;T&gt;
            interface around it. The generic interface will enumerate the same objects as the 
            underlying non-generic collection, but can be used in places that require a generic interface.
            The underlying non-generic collection must contain only items that
            are of type <paramref name="T"/> or a type derived from it. This method is useful
            when interfacing older, non-generic collections to newer code that uses generic interfaces.
            </summary>
            <remarks><para>Some collections implement both generic and non-generic interfaces. For efficiency,
            this method will first attempt to cast <paramref name="untypedCollection"/> to ICollection&lt;T&gt;. 
            If that succeeds, it is returned; otherwise, a wrapper object is created.</para>
            <para>Unlike the generic interface, the non-generic ICollection interfaces does
            not contain methods for adding or removing items from the collection. For this reason,
            the returned ICollection&lt;T&gt; will be read-only.</para></remarks>
            <typeparam name="T">The item type of the wrapper collection.</typeparam>
            <param name="untypedCollection">An untyped collection. This collection should only contain
            items of type <paramref name="T"/> or a type derived from it. </param>
            <returns>A generic ICollection&lt;T&gt; wrapper around <paramref name="untypedCollection"/>.
            If <paramref name="untypedCollection"/> is null, then null is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.TypedAs``1(System.Collections.IList)">
            <summary>
            Given a non-generic IList interface, wrap a generic IList&lt;T&gt;
            interface around it. The generic interface will enumerate the same objects as the 
            underlying non-generic list, but can be used in places that require a generic interface.
            The underlying non-generic list must contain only items that
            are of type <paramref name="T"/> or a type derived from it. This method is useful
            when interfacing older, non-generic lists to newer code that uses generic interfaces.
            </summary>
            <remarks>Some collections implement both generic and non-generic interfaces. For efficiency,
            this method will first attempt to cast <paramref name="untypedList"/> to IList&lt;T&gt;. 
            If that succeeds, it is returned; otherwise, a wrapper object is created.</remarks>
            <typeparam name="T">The item type of the wrapper list.</typeparam>
            <param name="untypedList">An untyped list. This list should only contain
            items of type <paramref name="T"/> or a type derived from it. </param>
            <returns>A generic IList&lt;T&gt; wrapper around <paramref name="untypedlist"/>.
            If <paramref name="untypedlist"/> is null, then null is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Untyped``1(System.Collections.Generic.ICollection{``0})">
            <summary>
            Given a generic ICollection&lt;T&gt; interface, wrap a non-generic (untyped)
            ICollection interface around it. The non-generic interface will contain the same objects as the 
            underlying generic collection, but can be used in places that require a non-generic interface.
            This method is useful when interfacing generic interfaces with older code that uses non-generic interfaces.
            </summary>
            <remarks>Many generic collections already implement the non-generic interfaces directly. This
            method will first attempt to simply cast <paramref name="typedCollection"/> to ICollection. If that
            succeeds, it is returned; if it fails, then a wrapper object is created.</remarks>
            <typeparam name="T">The item type of the underlying collection.</typeparam>
            <param name="typedCollection">A typed collection to wrap.</param>
            <returns>A non-generic ICollection wrapper around <paramref name="typedCollection"/>.
            If <paramref name="typedCollection"/> is null, then null is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Untyped``1(System.Collections.Generic.IList{``0})">
            <summary>
            Given a generic IList&lt;T&gt; interface, wrap a non-generic (untyped)
            IList interface around it. The non-generic interface will contain the same objects as the 
            underlying generic list, but can be used in places that require a non-generic interface.
            This method is useful when interfacing generic interfaces with older code that uses non-generic interfaces.
            </summary>
            <remarks>Many generic collections already implement the non-generic interfaces directly. This
            method will first attempt to simply cast <paramref name="typedList"/> to IList. If that
            succeeds, it is returned; if it fails, then a wrapper object is created.</remarks>
            <typeparam name="T">The item type of the underlying list.</typeparam>
            <param name="typedList">A typed list to wrap.</param>
            <returns>A non-generic IList wrapper around <paramref name="typedList"/>.
            If <paramref name="typedList"/> is null, then null is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ReadWriteList``1(``0[])">
            <summary>
            <para>Creates a read-write IList&lt;T&gt; wrapper around an array. When an array is
            implicitely converted to an IList&lt;T&gt;, changes to the items in the array cannot
            be made through the interface. This method creates a read-write IList&lt;T&gt; wrapper
            on an array that can be used to make changes to the array. </para>
            <para>Use this method when you need to pass an array to an algorithms that takes an 
            IList&lt;T&gt; and that tries to modify items in the list. Algorithms in this class generally do not
            need this method, since they have been design to operate on arrays even when they
            are passed as an IList&lt;T&gt;.</para>
            </summary>
            <remarks>Since arrays cannot be resized, inserting an item causes the last item in the array to be automatically
            removed. Removing an item causes the last item in the array to be replaced with a default value (0 or null). Clearing
            the list causes all the items to be replaced with a default value.</remarks>
            <param name="array">The array to wrap.</param>
            <returns>An IList&lt;T&gt; wrapper onto <paramref name="array"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Replace``1(System.Collections.Generic.IEnumerable{``0},``0,``0)">
            <summary>
            Replace all items in a collection equal to a particular value with another values, yielding another collection.
            </summary>
            <remarks>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</remarks>
            <param name="collection">The collection to process.</param>
            <param name="itemFind">The value to find and replace within <paramref name="collection"/>.</param>
            <param name="replaceWith">The new value to replace with.</param>
            <returns>An new collection with the items from <paramref name="collection"/>, in the same order, 
            with the appropriate replacements made.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Replace``1(System.Collections.Generic.IEnumerable{``0},``0,``0,System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Replace all items in a collection equal to a particular value with another values, yielding another collection. A passed
            IEqualityComparer is used to determine equality.
            </summary>
            <param name="collection">The collection to process.</param>
            <param name="itemFind">The value to find and replace within <paramref name="collection"/>.</param>
            <param name="replaceWith">The new value to replace with.</param>
            <param name="equalityComparer">The IEqualityComparer&lt;T&gt; used to compare items for equality. Only the Equals method will be called.</param>
            <returns>An new collection with the items from <paramref name="collection"/>, in the same order, 
            with the appropriate replacements made.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Replace``1(System.Collections.Generic.IEnumerable{``0},System.Predicate{``0},``0)">
            <summary>
            Replace all items in a collection that a predicate evalues at true with a value, yielding another collection. .
            </summary>
            <param name="collection">The collection to process.</param>
            <param name="predicate">The predicate used to evaluate items with the collection. If the predicate returns true for a particular
            item, the item is replaces with <paramref name="replaceWith"/>.</param>
            <param name="replaceWith">The new value to replace with.</param>
            <returns>An new collection with the items from <paramref name="collection"/>, in the same order, 
            with the appropriate replacements made.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ReplaceInPlace``1(System.Collections.Generic.IList{``0},``0,``0)">
            <summary>
            Replace all items in a list or array equal to a particular value with another value. The replacement is done in-place, changing
            the list.
            </summary>
            <remarks><para>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</para>
            <para>Although arrays cast to IList&lt;T&gt; are normally read-only, this method
            will work correctly and modify an array passed as <paramref name="list"/>.</para></remarks>
            <param name="list">The list or array to process.</param>
            <param name="itemFind">The value to find and replace within <paramref name="collection"/>.</param>
            <param name="replaceWith">The new value to replace with.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ReplaceInPlace``1(System.Collections.Generic.IList{``0},``0,``0,System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Replace all items in a list or array equal to a particular value with another values.
            The replacement is done in-place, changing
            the list. A passed IEqualityComparer is used to determine equality.
            </summary>
            <remarks>Although arrays cast to IList&lt;T&gt; are normally read-only, this method
            will work correctly and modify an array passed as <paramref name="list"/>.</remarks>
            <param name="list">The list or array to process.</param>
            <param name="itemFind">The value to find and replace within <paramref name="collection"/>.</param>
            <param name="replaceWith">The new value to replace with.</param>
            <param name="equalityComparer">The IEqualityComparer&lt;T&gt; used to compare items for equality. Only the Equals method will be called.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ReplaceInPlace``1(System.Collections.Generic.IList{``0},System.Predicate{``0},``0)">
            <summary>
            Replace all items in a list or array that a predicate evaluates at true with a value. The replacement is done in-place, changing
            the list.
            </summary>
            <remarks>Although arrays cast to IList&lt;T&gt; are normally read-only, this method
            will work correctly and modify an array passed as <paramref name="list"/>.</remarks>
            <param name="list">The list or array to process.</param>
            <param name="predicate">The predicate used to evaluate items with the collection. If the predicate returns true for a particular
            item, the item is replaces with <paramref name="replaceWith"/>.</param>
            <param name="replaceWith">The new value to replace with.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.RemoveDuplicates``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Remove consecutive equal items from a collection, yielding another collection. In each run of consecutive equal items
            in the collection, all items after the first item in the run are removed. 
            </summary>
            <remarks>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</remarks>
            <param name="collection">The collection to process.</param>
            <returns>An new collection with the items from <paramref name="collection"/>, in the same order, 
            with consecutive duplicates removed.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.RemoveDuplicates``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Remove consecutive equal items from a collection, yielding another collection. In each run of consecutive equal items
            in the collection, all items after the first item in the run are removed. A passed
            IEqualityComparer is used to determine equality.
            </summary>
            <param name="collection">The collection to process.</param>
            <param name="equalityComparer">The IEqualityComparer&lt;T&gt; used to compare items for equality. Only the Equals method will be called.</param>
            <returns>An new collection with the items from <paramref name="collection"/>, in the same order, 
            with consecutive duplicates removed.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> or <paramref name="equalityComparer"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.RemoveDuplicates``1(System.Collections.Generic.IEnumerable{``0},Wintellect.PowerCollections.BinaryPredicate{``0})">
            <summary>
            Remove consecutive "equal" items from a collection, yielding another collection. In each run of consecutive equal items
            in the collection, all items after the first item in the run are removed. The passed 
            BinaryPredicate is used to determine if two items are "equal".
            </summary>
            <remarks>Since an arbitrary BinaryPredicate is passed to this function, what is being removed need not be true equality. </remarks>
            <param name="collection">The collection to process.</param>
            <param name="predicate">The BinaryPredicate used to compare items for "equality". An item <c>current</c> is removed if <c>predicate(first, current)==true</c>, where
            <c>first</c> is the first item in the group of "duplicate" items.</param>
            <returns>An new collection with the items from <paramref name="collection"/>, in the same order, 
            with consecutive "duplicates" removed.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.RemoveDuplicatesInPlace``1(System.Collections.Generic.IList{``0})">
            <summary>
            Remove consecutive equal items from a list or array. In each run of consecutive equal items
            in the list, all items after the first item in the run are removed. The removal is done in-place, changing
            the list. 
            </summary>
            <remarks><para>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</para>
            <para>Although arrays cast to IList&lt;T&gt; are normally read-only, this method
            will work correctly and modify an array passed as <paramref name="list"/>.</para></remarks>
            <param name="list">The list or array to process.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.RemoveDuplicatesInPlace``1(System.Collections.Generic.IList{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Remove subsequent consecutive equal items from a list or array. In each run of consecutive equal items
            in the list, all items after the first item in the run are removed.
            The replacement is done in-place, changing
            the list. A passed IEqualityComparer is used to determine equality.
            </summary>
            <remarks>Although arrays cast to IList&lt;T&gt; are normally read-only, this method
            will work correctly and modify an array passed as <paramref name="list"/>.</remarks>
            <param name="list">The list or array to process.</param>
            <param name="equalityComparer">The IEqualityComparer&lt;T&gt; used to compare items for equality. Only the Equals method will be called.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.RemoveDuplicatesInPlace``1(System.Collections.Generic.IList{``0},Wintellect.PowerCollections.BinaryPredicate{``0})">
            <summary>
            Remove consecutive "equal" items from a list or array. In each run of consecutive equal items
            in the list, all items after the first item in the run are removed. The replacement is done in-place, changing
            the list. The passed BinaryPredicate is used to determine if two items are "equal".
            </summary>
            <remarks><para>Since an arbitrary BinaryPredicate is passed to this function, what is being tested for need not be true equality. </para>
            <para>Although arrays cast to IList&lt;T&gt; are normally read-only, this method
            will work correctly and modify an array passed as <paramref name="list"/>.</para></remarks>
            <param name="list">The list or array to process.</param>
            <param name="predicate">The BinaryPredicate used to compare items for "equality". </param>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.FirstConsecutiveEqual``1(System.Collections.Generic.IList{``0},System.Int32)">
            <summary>
            Finds the first occurence of <paramref name="count"/> consecutive equal items in the
            list.
            </summary>
            <remarks>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</remarks>
            <param name="list">The list to examine.</param>
            <param name="count">The number of consecutive equal items to look for. The count must be at least 1.</param>
            <returns>The index of the first item in the first run of <paramref name="count"/> consecutive equal items, or -1 if no such run exists..</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.FirstConsecutiveEqual``1(System.Collections.Generic.IList{``0},System.Int32,System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Finds the first occurence of <paramref name="count"/> consecutive equal items in the
            list. A passed IEqualityComparer is used to determine equality.
            </summary>
            <param name="list">The list to examine.</param>
            <param name="count">The number of consecutive equal items to look for. The count must be at least 1.</param>
            <param name="equalityComparer">The IEqualityComparer&lt;T&gt; used to compare items for equality. Only the Equals method will be called.</param>
            <returns>The index of the first item in the first run of <paramref name="count"/> consecutive equal items, or -1 if no such run exists.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.FirstConsecutiveEqual``1(System.Collections.Generic.IList{``0},System.Int32,Wintellect.PowerCollections.BinaryPredicate{``0})">
            <summary>
            Finds the first occurence of <paramref name="count"/> consecutive "equal" items in the
            list. The passed BinaryPredicate is used to determine if two items are "equal".
            </summary>
            <remarks>Since an arbitrary BinaryPredicate is passed to this function, what is being tested for need not be true equality. </remarks>
            <param name="list">The list to examine.</param>
            <param name="count">The number of consecutive equal items to look for. The count must be at least 1.</param>
            <param name="predicate">The BinaryPredicate used to compare items for "equality". </param>
            <returns>The index of the first item in the first run of <paramref name="count"/> consecutive equal items, or -1 if no such run exists.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.FirstConsecutiveWhere``1(System.Collections.Generic.IList{``0},System.Int32,System.Predicate{``0})">
            <summary>
            Finds the first occurence of <paramref name="count"/> consecutive items in the
            list for which a given predicate returns true.
            </summary>
            <param name="list">The list to examine.</param>
            <param name="count">The number of consecutive items to look for. The count must be at least 1.</param>
            <param name="predicate">The predicate used to test each item.</param>
            <returns>The index of the first item in the first run of <paramref name="count"/> items where <paramref name="predicate"/>
            returns true for all items in the run, or -1 if no such run exists.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.FindFirstWhere``1(System.Collections.Generic.IEnumerable{``0},System.Predicate{``0})">
            <summary>
            Finds the first item in a collection that satisfies the condition
            defined by <paramref name="predicate"/>.
            </summary>
            <remarks>If the default value for T could be present in the collection, and 
            would be matched by the predicate, then this method is inappropriate, because
            you cannot disguish whether the default value for T was actually present in the collection,
            or no items matched the predicate. In this case, use TryFindFirstWhere.</remarks>
            <param name="collection">The collection to search.</param>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <returns>The first item in the collection that matches the condition, or the default value for T (0 or null) if no
            item that matches the condition is found.</returns>
            <seealso cref="M:Wintellect.PowerCollections.Algorithms.TryFindFirstWhere``1(System.Collections.Generic.IEnumerable{``0},System.Predicate{``0},``0@)"/>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.TryFindFirstWhere``1(System.Collections.Generic.IEnumerable{``0},System.Predicate{``0},``0@)">
            <summary>
            Finds the first item in a collection that satisfies the condition
            defined by <paramref name="predicate"/>.
            </summary>
            <param name="collection">The collection to search.</param>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <param name="foundItem">Outputs the first item in the collection that matches the condition, if the method returns true.</param>
            <returns>True if an item satisfying the condition was found. False if no such item exists in the collection.</returns>
            <seealso cref="M:Wintellect.PowerCollections.Algorithms.FindFirstWhere``1(System.Collections.Generic.IEnumerable{``0},System.Predicate{``0})"/>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.FindLastWhere``1(System.Collections.Generic.IEnumerable{``0},System.Predicate{``0})">
            <summary>
            Finds the last item in a collection that satisfies the condition
            defined by <paramref name="predicate"/>.
            </summary>
            <remarks><para>If the collection implements IList&lt;T&gt;, then the list is scanned in reverse until a 
            matching item is found. Otherwise, the entire collection is iterated in the forward direction.</para>
            <para>If the default value for T could be present in the collection, and 
            would be matched by the predicate, then this method is inappropriate, because
            you cannot disguish whether the default value for T was actually present in the collection,
            or no items matched the predicate. In this case, use TryFindFirstWhere.</para></remarks>
            <param name="collection">The collection to search.</param>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <returns>The last item in the collection that matches the condition, or the default value for T (0 or null) if no
            item that matches the condition is found.</returns>
            <seealso cref="M:Wintellect.PowerCollections.Algorithms.TryFindLastWhere``1(System.Collections.Generic.IEnumerable{``0},System.Predicate{``0},``0@)"/>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.TryFindLastWhere``1(System.Collections.Generic.IEnumerable{``0},System.Predicate{``0},``0@)">
            <summary>
            Finds the last item in a collection that satisfies the condition
            defined by <paramref name="predicate"/>.
            </summary>
            <remarks>If the collection implements IList&lt;T&gt;, then the list is scanned in reverse until a 
            matching item is found. Otherwise, the entire collection is iterated in the forward direction.</remarks>
            <param name="collection">The collection to search.</param>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <param name="foundItem">Outputs the last item in the collection that matches the condition, if the method returns true.</param>
            <returns>True if an item satisfying the condition was found. False if no such item exists in the collection.</returns>
            <seealso cref="M:Wintellect.PowerCollections.Algorithms.FindLastWhere``1(System.Collections.Generic.IEnumerable{``0},System.Predicate{``0})"/>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.FindWhere``1(System.Collections.Generic.IEnumerable{``0},System.Predicate{``0})">
            <summary>
            Enumerates all the items in <paramref name="collection"/> that satisfy the condition defined
            by <paramref name="predicate"/>.
            </summary>
            <param name="collection">The collection to check all the items in.</param>
            <param name="predicate">A delegate that defines the condition to check for.</param>
            <returns>An IEnumerable&lt;T&gt; that enumerates the items that satisfy the condition.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.FindFirstIndexWhere``1(System.Collections.Generic.IList{``0},System.Predicate{``0})">
            <summary>
            Finds the index of the first item in a list that satisfies the condition
            defined by <paramref name="predicate"/>.
            </summary>
            <param name="list">The list to search.</param>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <returns>The index of the first item satisfying the condition. -1 if no such item exists in the list.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.FindLastIndexWhere``1(System.Collections.Generic.IList{``0},System.Predicate{``0})">
            <summary>
            Finds the index of the last item in a list that satisfies the condition
            defined by <paramref name="predicate"/>.
            </summary>
            <param name="list">The list to search.</param>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <returns>The index of the last item satisfying the condition. -1 if no such item exists in the list.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.FindIndicesWhere``1(System.Collections.Generic.IList{``0},System.Predicate{``0})">
            <summary>
            Enumerates the indices of all the items in <paramref name="list"/> that satisfy the condition defined
            by <paramref name="predicate"/>.
            </summary>
            <param name="list">The list to check all the items in.</param>
            <param name="predicate">A delegate that defines the condition to check for.</param>
            <returns>An IEnumerable&lt;T&gt; that enumerates the indices of items that satisfy the condition.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.FirstIndexOf``1(System.Collections.Generic.IList{``0},``0)">
            <summary>
            Finds the index of the first item in a list equal to a given item.
            </summary>
            <remarks>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</remarks>
            <param name="list">The list to search.</param>
            <param name="item">The item to search for.</param>
            <returns>The index of the first item equal to <paramref name="item"/>. -1 if no such item exists in the list.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.FirstIndexOf``1(System.Collections.Generic.IList{``0},``0,System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Finds the index of the first item in a list equal to a given item. A passed
            IEqualityComparer is used to determine equality.
            </summary>
            <param name="list">The list to search.</param>
            <param name="item">The item to search for.</param>
            <param name="equalityComparer">The IEqualityComparer&lt;T&gt; used to compare items for equality. Only the Equals method will be called.</param>
            <returns>The index of the first item equal to <paramref name="item"/>. -1 if no such item exists in the list.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.LastIndexOf``1(System.Collections.Generic.IList{``0},``0)">
            <summary>
            Finds the index of the last item in a list equal to a given item.
            </summary>
            <remarks>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</remarks>
            <param name="list">The list to search.</param>
            <param name="item">The item to search for.</param>
            <returns>The index of the last item equal to <paramref name="item"/>. -1 if no such item exists in the list.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.LastIndexOf``1(System.Collections.Generic.IList{``0},``0,System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Finds the index of the last item in a list equal to a given item. A passed
            IEqualityComparer is used to determine equality.
            </summary>
            <param name="list">The list to search.</param>
            <param name="item">The item to search for.</param>
            <param name="equalityComparer">The IEqualityComparer&lt;T&gt; used to compare items for equality. Only the Equals method will be called.</param>
            <returns>The index of the last item equal to <paramref name="item"/>. -1 if no such item exists in the list.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.IndicesOf``1(System.Collections.Generic.IList{``0},``0)">
            <summary>
            Enumerates the indices of all the items in a list equal to a given item.
            </summary>
            <remarks>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</remarks>
            <param name="list">The list to search.</param>
            <param name="item">The item to search for.</param>
            <returns>An IEnumerable&lt;T&gt; that enumerates the indices of items equal to <paramref name="item"/>. </returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.IndicesOf``1(System.Collections.Generic.IList{``0},``0,System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Enumerates the indices of all the items in a list equal to a given item. A passed
            IEqualityComparer is used to determine equality.
            </summary>
            <param name="list">The list to search.</param>
            <param name="item">The item to search for.</param>
            <param name="equalityComparer">The IEqualityComparer&lt;T&gt; used to compare items for equality. Only the Equals method will be called.</param>
            <returns>An IEnumerable&lt;T&gt; that enumerates the indices of items equal to <paramref name="item"/>. </returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.FirstIndexOfMany``1(System.Collections.Generic.IList{``0},System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Finds the index of the first item in a list equal to one of several given items.
            </summary>
            <remarks>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</remarks>
            <param name="list">The list to search.</param>
            <param name="itemsToLookFor">The items to search for.</param>
            <returns>The index of the first item equal to any of the items in the collection <paramref name="itemsToLookFor"/>. 
            -1 if no such item exists in the list.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.FirstIndexOfMany``1(System.Collections.Generic.IList{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Finds the index of the first item in a list equal to one of several given items. A passed
            IEqualityComparer is used to determine equality.
            </summary>
            <param name="list">The list to search.</param>
            <param name="itemsToLookFor">The items to search for.</param>
            <param name="equalityComparer">The IEqualityComparer&lt;T&gt; used to compare items for equality. 
            Only the Equals and GetHashCode methods will be called.</param>
            <returns>The index of the first item equal to any of the items in the collection <paramref name="itemsToLookFor"/>. 
            -1 if no such item exists in the list.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.FirstIndexOfMany``1(System.Collections.Generic.IList{``0},System.Collections.Generic.IEnumerable{``0},Wintellect.PowerCollections.BinaryPredicate{``0})">
            <summary>
            Finds the index of the first item in a list "equal" to one of several given items. The passed 
            BinaryPredicate is used to determine if two items are "equal".
            </summary>
            <remarks>Since an arbitrary BinaryPredicate is passed to this function, what is being removed need not be true equality. This methods finds 
            first item X which satisfies BinaryPredicate(X,Y), where Y is one of the items in <paramref name="itemsToLookFor"/></remarks>
            <param name="list">The list to search.</param>
            <param name="itemsToLookFor">The items to search for.</param>
            <param name="predicate">The BinaryPredicate used to compare items for "equality". </param>
            <returns>The index of the first item "equal" to any of the items in the collection <paramref name="itemsToLookFor"/>, using 
            <paramref name="BinaryPredicate"/> as the test for equality. 
            -1 if no such item exists in the list.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.LastIndexOfMany``1(System.Collections.Generic.IList{``0},System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Finds the index of the last item in a list equal to one of several given items.
            </summary>
            <remarks>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</remarks>
            <param name="list">The list to search.</param>
            <param name="itemsToLookFor">The items to search for.</param>
            <returns>The index of the last item equal to any of the items in the collection <paramref name="itemsToLookFor"/>. 
            -1 if no such item exists in the list.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.LastIndexOfMany``1(System.Collections.Generic.IList{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Finds the index of the last item in a list equal to one of several given items. A passed
            IEqualityComparer is used to determine equality.
            </summary>
            <param name="list">The list to search.</param>
            <param name="itemsToLookFor">The items to search for.</param>
            <param name="equalityComparer">The IEqualityComparer&lt;T&gt; used to compare items for equality.</param>
            <returns>The index of the last item equal to any of the items in the collection <paramref name="itemsToLookFor"/>. 
            -1 if no such item exists in the list.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.LastIndexOfMany``1(System.Collections.Generic.IList{``0},System.Collections.Generic.IEnumerable{``0},Wintellect.PowerCollections.BinaryPredicate{``0})">
            <summary>
            Finds the index of the last item in a list "equal" to one of several given items. The passed 
            BinaryPredicate is used to determine if two items are "equal".
            </summary>
            <remarks>Since an arbitrary BinaryPredicate is passed to this function, what is being removed need not be true equality. This methods finds 
            last item X which satisfies BinaryPredicate(X,Y), where Y is one of the items in <paramref name="itemsToLookFor"/></remarks>
            <param name="list">The list to search.</param>
            <param name="itemsToLookFor">The items to search for.</param>
            <param name="predicate">The BinaryPredicate used to compare items for "equality". </param>
            <returns>The index of the last item "equal" to any of the items in the collection <paramref name="itemsToLookFor"/>, using 
            <paramref name="BinaryPredicate"/> as the test for equality. 
            -1 if no such item exists in the list.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.IndicesOfMany``1(System.Collections.Generic.IList{``0},System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Enumerates the indices of all the items in a list equal to one of several given items. 
            </summary>
            <remarks>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</remarks>
            <param name="list">The list to search.</param>
            <param name="itemsToLookFor">A collection of items to search for.</param>
            <returns>An IEnumerable&lt;T&gt; that enumerates the indices of items equal to
            any of the items in the collection <paramref name="itemsToLookFor"/>. </returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.IndicesOfMany``1(System.Collections.Generic.IList{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Enumerates the indices of all the items in a list equal to one of several given items. A passed
            IEqualityComparer is used to determine equality.
            </summary>
            <param name="list">The list to search.</param>
            <param name="itemsToLookFor">A collection of items to search for.</param>
            <param name="equalityComparer">The IEqualityComparer&lt;T&gt; used to compare items for equality. </param>
            <returns>An IEnumerable&lt;T&gt; that enumerates the indices of items equal to
            any of the items in the collection <paramref name="itemsToLookFor"/>. </returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.IndicesOfMany``1(System.Collections.Generic.IList{``0},System.Collections.Generic.IEnumerable{``0},Wintellect.PowerCollections.BinaryPredicate{``0})">
            <summary>
            Enumerates the indices of all the items in a list equal to one of several given items. The passed 
            BinaryPredicate is used to determine if two items are "equal".
            </summary>
            <remarks>Since an arbitrary BinaryPredicate is passed to this function, what is being removed need not be true equality. This methods finds 
            last item X which satisfies BinaryPredicate(X,Y), where Y is one of the items in <paramref name="itemsToLookFor"/></remarks>
            <param name="list">The list to search.</param>
            <param name="itemsToLookFor">A collection of items to search for.</param>
            <param name="predicate">The BinaryPredicate used to compare items for "equality". </param>
            <returns>An IEnumerable&lt;T&gt; that enumerates the indices of items "equal" to any of the items 
            in the collection <paramref name="itemsToLookFor"/>, using 
            <paramref name="BinaryPredicate"/> as the test for equality. </returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.SearchForSubsequence``1(System.Collections.Generic.IList{``0},System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Searchs a list for a sub-sequence of items that match a particular pattern. A subsequence 
            of <paramref name="list"/> matches pattern at index i if list[i] is equal to the first item
            in <paramref name="pattern"/>, list[i+1] is equal to the second item in <paramref name="pattern"/>,
            and so forth for all the items in <paramref name="pattern"/>.
            </summary>
            <remarks>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</remarks>
            <typeparam name="T">The type of items in the list.</typeparam>
            <param name="list">The list to search.</param>
            <param name="pattern">The sequence of items to search for.</param>
            <returns>The first index with <paramref name="list"/> that matches the items in <paramref name="pattern"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.SearchForSubsequence``1(System.Collections.Generic.IList{``0},System.Collections.Generic.IEnumerable{``0},Wintellect.PowerCollections.BinaryPredicate{``0})">
            <summary>
            Searchs a list for a sub-sequence of items that match a particular pattern. A subsequence 
            of <paramref name="list"/> matches pattern at index i if list[i] is "equal" to the first item
            in <paramref name="pattern"/>, list[i+1] is "equal" to the second item in <paramref name="pattern"/>,
            and so forth for all the items in <paramref name="pattern"/>. The passed 
            BinaryPredicate is used to determine if two items are "equal".
            </summary>
            <remarks>Since an arbitrary BinaryPredicate is passed to this function, what is being tested
            for in the pattern need not be equality. </remarks>
            <typeparam name="T">The type of items in the list.</typeparam>
            <param name="list">The list to search.</param>
            <param name="pattern">The sequence of items to search for.</param>
            <param name="predicate">The BinaryPredicate used to compare items for "equality". </param>
            <returns>The first index with <paramref name="list"/> that matches the items in <paramref name="pattern"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.SearchForSubsequence``1(System.Collections.Generic.IList{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Searchs a list for a sub-sequence of items that match a particular pattern. A subsequence 
            of <paramref name="list"/> matches pattern at index i if list[i] is equal to the first item
            in <paramref name="pattern"/>, list[i+1] is equal to the second item in <paramref name="pattern"/>,
            and so forth for all the items in <paramref name="pattern"/>. The passed 
            instance of IEqualityComparer&lt;T&gt; is used for determining if two items are equal.
            </summary>
            <typeparam name="T">The type of items in the list.</typeparam>
            <param name="list">The list to search.</param>
            <param name="pattern">The sequence of items to search for.</param>
            <param name="equalityComparer">The IEqualityComparer&lt;T&gt; used to compare items for equality. Only the Equals method will be called.</param>
            <returns>The first index with <paramref name="list"/> that matches the items in <paramref name="pattern"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.IsSubsetOf``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Determines if one collection is a subset of another, considered as sets. The first set is a subset
            of the second set if every item in the first set also occurs in the second set. If an item appears X times in the first set,
            it must appear at least X times in the second set.
            </summary>
            <remarks>
            <para>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</para>
            <para>If both collections are Set, Bag, OrderedSet, or OrderedBag
            collections, it is more efficient to use the IsSubsetOf method on that class.</para>
            </remarks>
            <param name="collection1">The first collection.</param>
            <param name="collection2">The second collection.</param>
            <returns>True if <paramref name="collection1"/> is a subset of <paramref name="collection2"/>, considered as sets.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection1"/> or <paramref name="collection2"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.IsSubsetOf``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Determines if one collection is a subset of another, considered as sets. The first set is a subset
            of the second set if every item in the first set also occurs in the second set. If an item appears X times in the first set,
            it must appear at least X times in the second set.
            </summary>
            <remarks>
            <para>If both collections are Set, Bag, OrderedSet, or OrderedBag
            collections, it is more efficient to use the IsSubsetOf method on that class.</para>
            </remarks>
            <param name="collection1">The first collection.</param>
            <param name="collection2">The second collection.</param>
            <param name="equalityComparer">The IEqualityComparer&lt;T&gt; used to compare items for equality.</param>
            <returns>True if <paramref name="collection1"/> is a subset of <paramref name="collection2"/>, considered as sets.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection1"/> or <paramref name="collection2"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.IsProperSubsetOf``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Determines if one collection is a proper subset of another, considered as sets. The first set is a proper subset
            of the second set if every item in the first set also occurs in the second set, and the first set is strictly smaller than
            the second set. If an item appears X times in the first set,
            it must appear at least X times in the second set.
            </summary>
            <remarks>
            <para>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</para>
            <para>If both collections are Set, Bag, OrderedSet, or OrderedBag
            collections, it is more efficient to use the IsSubsetOf method on that class.</para>
            </remarks>
            <param name="collection1">The first collection.</param>
            <param name="collection2">The second collection.</param>
            <returns>True if <paramref name="collection1"/> is a subset of <paramref name="collection2"/>, considered as sets.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection1"/> or <paramref name="collection2"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.IsProperSubsetOf``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Determines if one collection is a proper subset of another, considered as sets. The first set is a proper subset
            of the second set if every item in the first set also occurs in the second set, and the first set is strictly smaller than
            the second set. If an item appears X times in the first set,
            it must appear at least X times in the second set.
            </summary>
            <remarks>
            <para>If both collections are Set, Bag, OrderedSet, or OrderedBag
            collections, it is more efficient to use the IsSubsetOf method on that class.</para>
            </remarks>
            <param name="collection1">The first collection.</param>
            <param name="collection2">The second collection.</param>
            <param name="equalityComparer">The IEqualityComparer&lt;T&gt; used to compare items for equality. 
            Only the Equals and GetHashCode member functions of this interface are called.</param>
            <returns>True if <paramref name="collection1"/> is a proper subset of <paramref name="collection2"/>, considered as sets.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection1"/> or <paramref name="collection2"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.DisjointSets``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Determines if two collections are disjoint, considered as sets. Two sets are disjoint if they
            have no common items.
            </summary>
            <remarks>
            <para>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</para>
            <para>If both collections are Set, Bag, OrderedSet, or OrderedBag
            collections, it is more efficient to use the IsDisjoint method on that class.</para>
            </remarks>
            <param name="collection1">The first collection.</param>
            <param name="collection2">The second collection.</param>
            <returns>True if <paramref name="collection1"/> are <paramref name="collection2"/> are disjoint, considered as sets.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection1"/> or <paramref name="collection2"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.DisjointSets``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Determines if two collections are disjoint, considered as sets. Two sets are disjoint if they
            have no common items.
            </summary>
            <remarks>
            <para>If both collections are Set, Bag, OrderedSet, or OrderedBag
            collections, it is more efficient to use the IsDisjoint method on that class.</para>
            </remarks>
            <param name="collection1">The first collection.</param>
            <param name="collection2">The second collection.</param>
            <param name="equalityComparer">The IEqualityComparerComparer&lt;T&gt; used to compare items for equality. 
            Only the Equals and GetHashCode member functions of this interface are called.</param>
            <returns>True if <paramref name="collection1"/> are <paramref name="collection2"/> are disjoint, considered as sets.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection1"/> or <paramref name="collection2"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.EqualSets``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Determines if two collections are equal, considered as sets. Two sets are equal if they
            have have the same items, with order not being significant.
            </summary>
            <remarks>
            <para>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</para>
            <para>If both collections are Set, Bag, OrderedSet, or OrderedBag
            collections, it is more efficient to use the EqualTo method on that class.</para>
            </remarks>
            <param name="collection1">The first collection.</param>
            <param name="collection2">The second collection.</param>
            <returns>True if <paramref name="collection1"/> are <paramref name="collection2"/> are equal, considered as sets.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection1"/> or <paramref name="collection2"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.EqualSets``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Determines if two collections are equal, considered as sets. Two sets are equal if they
            have have the same items, with order not being significant.
            </summary>
            <remarks>
            <para>If both collections are Set, Bag, OrderedSet, or OrderedBag
            collections, it is more efficient to use the EqualTo method on that class.</para>
            </remarks>
            <param name="collection1">The first collection.</param>
            <param name="collection2">The second collection.</param>
            <param name="equalityComparer">The IEqualityComparer&lt;T&gt; used to compare items for equality. 
            Only the Equals and GetHashCode member functions of this interface are called.</param>
            <returns>True if <paramref name="collection1"/> are <paramref name="collection2"/> are equal, considered as sets.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection1"/> or <paramref name="collection2"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.SetIntersection``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Computes the set-theoretic intersection of two collections. The intersection of two sets
            is all items that appear in both of the sets. If an item appears X times in one set,
            and Y times in the other set, the intersection contains the item Minimum(X,Y) times. 
            The source collections are not changed.
            A new collection is created with the intersection of the collections; the order of the
            items in this collection is undefined.
            </summary>
            <remarks>
            <para>When equal items appear in both collections, the returned collection will include an arbitrary choice of one of the
            two equal items.</para>
            <para>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</para>
            <para>If both collections are Set, Bag, OrderedSet, or OrderedBag
            collections, it is more efficient to use the Intersection or IntersectionWith methods on that class.</para>
            </remarks>
            <param name="collection1">The first collection to intersect.</param>
            <param name="collection2">The second collection to intersect.</param>
            <returns>The intersection of the two collections, considered as sets.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection1"/> or <paramref name="collection2"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.SetIntersection``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Computes the set-theoretic intersection of two collections. The intersection of two sets
            is all items that appear in both of the sets. If an item appears X times in one set,
            and Y times in the other set, the intersection contains the item Minimum(X,Y) times. 
            The source collections are not changed.
            A new collection is created with the intersection of the collections; the order of the
            items in this collection is undefined.
            </summary>
            <remarks>
            <para>When equal items appear in both collections, the returned collection will include an arbitrary choice of one of the
            two equal items.</para>
            <para>If both collections are Set, Bag, OrderedSet, or OrderedBag
            collections, it is more efficient to use the Intersection or IntersectionWith methods on that class.</para>
            </remarks>
            <param name="collection1">The first collection to intersect.</param>
            <param name="collection2">The second collection to intersect.</param>
            <param name="equalityComparer">The IEqualityComparer&lt;T&gt; used to compare items for equality. 
            Only the Equals and GetHashCode member functions of this interface are called.</param>
            <returns>The intersection of the two collections, considered as sets.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection1"/> or <paramref name="collection2"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.SetUnion``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Computes the set-theoretic union of two collections. The union of two sets
            is all items that appear in either of the sets. If an item appears X times in one set,
            and Y times in the other set, the union contains the item Maximum(X,Y) times. 
            The source collections are not changed.
            A new collection is created with the union of the collections; the order of the
            items in this collection is undefined.
            </summary>
            <remarks>
            <para>When equal items appear in both collections, the returned collection will include an arbitrary choice of one of the
            two equal items.</para>
            <para>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</para>
            <para>If both collections are Set, Bag, OrderedSet, or OrderedBag
            collections, it is more efficient to use the Union or UnionWith methods on that class.</para>
            </remarks>
            <param name="collection1">The first collection to union.</param>
            <param name="collection2">The second collection to union.</param>
            <returns>The union of the two collections, considered as sets.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection1"/> or <paramref name="collection2"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.SetUnion``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Computes the set-theoretic union of two collections. The union of two sets
            is all items that appear in either of the sets. If an item appears X times in one set,
            and Y times in the other set, the union contains the item Maximum(X,Y) times. 
            The source collections are not changed.
            A new collection is created with the union of the collections; the order of the
            items in this collection is undefined.
            </summary>
            <remarks>
            <para>When equal items appear in both collections, the returned collection will include an arbitrary choice of one of the
            two equal items.</para>
            <para>If both collections are Set, Bag, OrderedSet, or OrderedBag
            collections, it is more efficient to use the union or unionWith methods on that class.</para>
            </remarks>
            <param name="collection1">The first collection to union.</param>
            <param name="collection2">The second collection to union.</param>
            <param name="equalityComparer">The IEqualityComparer&lt;T&gt; used to compare items for equality. 
            Only the Equals and GetHashCode member functions of this interface are called.</param>
            <returns>The union of the two collections, considered as sets.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection1"/> or <paramref name="collection2"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.SetDifference``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Computes the set-theoretic difference of two collections. The difference of two sets
            is all items that appear in the first set, but not in the second. If an item appears X times in the first set,
            and Y times in the second set, the difference contains the item X - Y times (0 times if X &lt; Y). 
            The source collections are not changed.
            A new collection is created with the difference of the collections; the order of the
            items in this collection is undefined.
            </summary>
            <remarks>
            <para>When equal items appear in both collections, the returned collection will include an arbitrary choice of one of the
            two equal items.</para>
            <para>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</para>
            <para>If both collections are Set, Bag, OrderedSet, or OrderedBag
            collections, it is more efficient to use the Difference or DifferenceWith methods on that class.</para>
            </remarks>
            <param name="collection1">The first collection to difference.</param>
            <param name="collection2">The second collection to difference.</param>
            <returns>The difference of <paramref name="collection1"/> and <paramref name="collection2"/>, considered as sets.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection1"/> or <paramref name="collection2"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.SetDifference``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Computes the set-theoretic difference of two collections. The difference of two sets
            is all items that appear in the first set, but not in the second. If an item appears X times in the first set,
            and Y times in the second set, the difference contains the item X - Y times (0 times if X &lt; Y). 
            The source collections are not changed.
            A new collection is created with the difference of the collections; the order of the
            items in this collection is undefined.
            </summary>
            <remarks>
            <para>When equal items appear in both collections, the returned collection will include an arbitrary choice of one of the
            two equal items.</para>
            <para>If both collections are Set, Bag, OrderedSet, or OrderedBag
            collections, it is more efficient to use the difference or differenceWith methods on that class.</para>
            </remarks>
            <param name="collection1">The first collection to difference.</param>
            <param name="collection2">The second collection to difference.</param>
            <param name="equalityComparer">The IEqualityComparer&lt;T&gt; used to compare items for equality. 
            Only the Equals and GetHashCode member functions of this interface are called.</param>
            <returns>The difference of <paramref name="collection1"/> and <paramref name="collection2"/>, considered as sets.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection1"/> or <paramref name="collection2"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.SetSymmetricDifference``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Computes the set-theoretic symmetric difference of two collections. The symmetric difference of two sets
            is all items that appear in the one of the sets, but not in the other. If an item appears X times in the one set,
            and Y times in the other set, the symmetric difference contains the item AbsoluteValue(X - Y) times. 
            The source collections are not changed.
            A new collection is created with the symmetric difference of the collections; the order of the
            items in this collection is undefined.
            </summary>
            <remarks>
            <para>When equal items appear in both collections, the returned collection will include an arbitrary choice of one of the
            two equal items.</para>
            <para>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</para>
            <para>If both collections are Set, Bag, OrderedSet, or OrderedBag
            collections, it is more efficient to use the SymmetricDifference or SymmetricDifferenceWith methods on that class.</para>
            </remarks>
            <param name="collection1">The first collection to symmetric difference.</param>
            <param name="collection2">The second collection to symmetric difference.</param>
            <returns>The symmetric difference of <paramref name="collection1"/> and <paramref name="collection2"/>, considered as sets.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection1"/> or <paramref name="collection2"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.SetSymmetricDifference``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Computes the set-theoretic symmetric difference of two collections. The symmetric difference of two sets
            is all items that appear in the one of the sets, but not in the other. If an item appears X times in the one set,
            and Y times in the other set, the symmetric difference contains the item AbsoluteValue(X - Y) times. 
            The source collections are not changed.
            A new collection is created with the symmetric difference of the collections; the order of the
            items in this collection is undefined.
            </summary>
            <remarks>
            <para>When equal items appear in both collections, the returned collection will include an arbitrary choice of one of the
            two equal items.</para>
            <para>If both collections are Set, Bag, OrderedSet, or OrderedBag
            collections, it is more efficient to use the symmetric difference or symmetric differenceWith methods on that class.</para>
            </remarks>
            <param name="collection1">The first collection to symmetric difference.</param>
            <param name="collection2">The second collection to symmetric difference.</param>
            <param name="equalityComparer">The IEqualityComparer&lt;T&gt; used to compare items for equality. 
            Only the Equals and GetHashCode member functions of this interface are called.</param>
            <returns>The symmetric difference of <paramref name="collection1"/> and <paramref name="collection2"/>, considered as sets.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection1"/> or <paramref name="collection2"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.CartesianProduct``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1})">
            <summary>
            Computes the cartestian product of two collections: all possible pairs of items, with the first item taken from the first collection and 
            the second item taken from the second collection. If the first collection has N items, and the second collection has M items, the cartesian
            product will have N * M pairs.
            </summary>
            <typeparam name="TFirst">The type of items in the first collection.</typeparam>
            <typeparam name="TSecond">The type of items in the second collection.</typeparam>
            <param name="first">The first collection.</param>
            <param name="second">The second collection.</param>
            <returns>An IEnumerable&lt;Pair&lt;TFirst, TSecond&gt;&gt; that enumerates the cartesian product of the two collections.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ToString``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Gets a string representation of the elements in the collection.
            The string representation starts with "{", has a list of items separated
            by commas (","), and ends with "}". Each item in the collection is 
            converted to a string by calling its ToString method (null is represented by "null").
            Contained collections (except strings) are recursively converted to strings by this method.
            </summary>
            <param name="collection">A collection to get the string representation of.</param>
            <returns>The string representation of the collection. If <paramref name="collection"/> is null, then the string "null" is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ToString``1(System.Collections.Generic.IEnumerable{``0},System.Boolean,System.String,System.String,System.String)">
            <summary>
            Gets a string representation of the elements in the collection.
            The string to used at the beginning and end, and to separate items,
            and supplied by parameters. Each item in the collection is 
            converted to a string by calling its ToString method (null is represented by "null").
            </summary>
            <param name="collection">A collection to get the string representation of.</param>
            <param name="recursive">If true, contained collections (except strings) are converted to strings by a recursive call to this method, instead
            of by calling ToString.</param>
            <param name="start">The string to appear at the beginning of the output string.</param>
            <param name="separator">The string to appear between each item in the string.</param>
            <param name="end">The string to appear at the end of the output string.</param>
            <returns>The string representation of the collection. If <paramref name="collection"/> is null, then the string "null" is returned.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="start"/>, <paramref name="separator"/>, or <paramref name="end"/>
             is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ToString``2(System.Collections.Generic.IDictionary{``0,``1})">
            <summary>
            Gets a string representation of the mappings in a dictionary.
            The string representation starts with "{", has a list of mappings separated
            by commas (", "), and ends with "}". Each mapping is represented
            by "key->value". Each key and value in the dictionary is 
            converted to a string by calling its ToString method (null is represented by "null").
            Contained collections (except strings) are recursively converted to strings by this method.
            </summary>
            <param name="dictionary">A dictionary to get the string representation of.</param>
            <returns>The string representation of the collection, or "null" 
            if <paramref name="dictionary"/> is null.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.GetRandomGenerator">
            <summary>
            Return a private random number generator to use if the user
            doesn't supply one.
            </summary>
            <returns>The private random number generator. Only one is ever created
            and is always returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.RandomShuffle``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Randomly shuffles the items in a collection, yielding a new collection.
            </summary>
            <typeparam name="T">The type of the items in the collection.</typeparam>
            <param name="collection">The collection to shuffle.</param>
            <returns>An array with the same size and items as <paramref name="collection"/>, but the items in a randomly chosen order.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.RandomShuffle``1(System.Collections.Generic.IEnumerable{``0},System.Random)">
            <summary>
            Randomly shuffles the items in a collection, yielding a new collection.
            </summary>
            <typeparam name="T">The type of the items in the collection.</typeparam>
            <param name="collection">The collection to shuffle.</param>
            <param name="randomGenerator">The random number generator to use to select the random order.</param>
            <returns>An array with the same size and items as <paramref name="collection"/>, but the items in a randomly chosen order.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.RandomShuffleInPlace``1(System.Collections.Generic.IList{``0})">
            <summary>
            Randomly shuffles the items in a list or array, in place.
            </summary>
            <remarks>Although arrays cast to IList&lt;T&gt; are normally read-only, this method
            will work correctly and modify an array passed as <paramref name="list"/>.</remarks>
            <param name="list">The list or array to shuffle.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.RandomShuffleInPlace``1(System.Collections.Generic.IList{``0},System.Random)">
            <summary>
            Randomly shuffles the items in a list or array, in place.
            </summary>
            <remarks>Although arrays cast to IList&lt;T&gt; are normally read-only, this method
            will work correctly and modify an array passed as <paramref name="list"/>.</remarks>
            <param name="list">The list or array to shuffle.</param>
            <param name="randomGenerator">The random number generator to use to select the random order.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.RandomSubset``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Picks a random subset of <paramref name="count"/> items from <paramref name="collection"/>, and places
            those items into a random order. No item is selected more than once.
            </summary>
            <remarks>If the collection implements IList&lt;T&gt;, then this method takes time O(<paramref name="count"/>).
            Otherwise, this method takes time O(N), where N is the number of items in the collection.</remarks>
            <typeparam name="T">The type of items in the collection.</typeparam>
            <param name="collection">The collection of items to select from. This collection is not changed.</param>
            <param name="count">The number of items in the subset to choose.</param>
            <returns>An array of <paramref name="count"/> items, selected at random from <paramref name="collection"/>.</returns>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="count"/> is negative or greater than <paramref name="collection"/>.Count.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.RandomSubset``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Random)">
            <summary>
            Picks a random subset of <paramref name="count"/> items from <paramref name="collection"/>, and places
            those items into a random order. No item is selected more than once.
            </summary>
            <remarks>If the collection implements IList&lt;T&gt;, then this method takes time O(<paramref name="count"/>).
            Otherwise, this method takes time O(N), where N is the number of items in the collection.</remarks>
            <typeparam name="T">The type of items in the collection.</typeparam>
            <param name="collection">The collection of items to select from. This collection is not changed.</param>
            <param name="count">The number of items in the subset to choose.</param>
            <param name="randomGenerator">The random number generates used to make the selection.</param>
            <returns>An array of <paramref name="count"/> items, selected at random from <paramref name="collection"/>.</returns>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="count"/> is negative or greater than <paramref name="list"/>.Count.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="randomGenerator"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.GeneratePermutations``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Generates all the possible permutations of the items in <paramref name="collection"/>. If <paramref name="collection"/>
            has N items, then N factorial permutations will be generated. This method does not compare the items to determine if
            any of them are equal. If some items are equal, the same permutation may be generated more than once. For example,
            if the collections contains the three items A, A, and B, then this method will generate the six permutations, AAB, AAB,
            ABA, ABA, BAA, BAA (not necessarily in that order). To take equal items into account, use the GenerateSortedPermutations
            method.
            </summary>
            <typeparam name="T">The type of items to permute.</typeparam>
            <param name="collection">The collection of items to permute.</param>
            <returns>An IEnumerable&lt;T[]&gt; that enumerations all the possible permutations of the 
            items in <paramref name="collection"/>. Each permutations is returned as an array. The items in the array
            should be copied if they need to be used after the next permutation is generated; each permutation may
            reuse the same array instance.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.GenerateSortedPermutations``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Generates all the possible permutations of the items in <paramref name="collection"/>, in lexicographical order. 
            Even if some items are equal, the same permutation will not be generated more than once. For example,
            if the collections contains the three items A, A, and B, then this method will generate only the three permutations, AAB, ABA,
            BAA. 
            </summary>
            <typeparam name="T">The type of items to permute.</typeparam>
            <param name="collection">The collection of items to permute.</param>
            <returns>An IEnumerable&lt;T[]&gt; that enumerations all the possible permutations of the 
            items in <paramref name="collection"/>. Each permutations is returned as an array. The items in the array
            should be copied if they need to be used after the next permutation is generated; each permutation may
            reuse the same array instance.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.GenerateSortedPermutations``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0})">
            <summary>
            Generates all the possible permutations of the items in <paramref name="collection"/>, in lexicographical order. A
            supplied IComparer&lt;T&gt; instance is used to compare the items.
            Even if some items are equal, the same permutation will not be generated more than once. For example,
            if the collections contains the three items A, A, and B, then this method will generate only the three permutations, AAB, ABA,
            BAA. 
            </summary>
            <typeparam name="T">The type of items to permute.</typeparam>
            <param name="collection">The collection of items to permute.</param>
            <param name="comparer">The IComparer&lt;T&gt; used to compare the items.</param>
            <returns>An IEnumerable&lt;T[]&gt; that enumerations all the possible permutations of the 
            items in <paramref name="collection"/>. Each permutations is returned as an array. The items in the array
            should be copied if they need to be used after the next permutation is generated; each permutation may
            reuse the same array instance.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.GenerateSortedPermutations``1(System.Collections.Generic.IEnumerable{``0},System.Comparison{``0})">
            <summary>
            Generates all the possible permutations of the items in <paramref name="collection"/>, in lexicographical order. A
            supplied Comparison&lt;T&gt; delegate is used to compare the items.
            Even if some items are equal, the same permutation will not be generated more than once. For example,
            if the collections contains the three items A, A, and B, then this method will generate only the three permutations, AAB, ABA,
            BAA. 
            </summary>
            <typeparam name="T">The type of items to permute.</typeparam>
            <param name="collection">The collection of items to permute.</param>
            <param name="comparison">The Comparison&lt;T&gt; delegate used to compare the items.</param>
            <returns>An IEnumerable&lt;T[]&gt; that enumerations all the possible permutations of the 
            items in <paramref name="collection"/>. Each permutations is returned as an array. The items in the array
            should be copied if they need to be used after the next permutation is generated; each permutation may
            reuse the same array instance.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Maximum``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Finds the maximum value in a collection.
            </summary>
            <remarks>Values in the collection are compared by using the IComparable&lt;T&gt;
            interfaces implementation on the type T.</remarks>
            <typeparam name="T">The type of items in the collection.</typeparam>
            <param name="collection">The collection to search.</param>
            <returns>The largest item in the collection. </returns>
            <exception cref="T:System.InvalidOperationException">The collection is empty.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Maximum``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0})">
            <summary>
            Finds the maximum value in a collection. A supplied IComparer&lt;T&gt; is used
            to compare the items in the collection.
            </summary>
            <typeparam name="T">The type of items in the collection.</typeparam>
            <param name="collection">The collection to search.</param>
            <param name="comparer">The comparer instance used to compare items in the collection.</param>
            <returns>The largest item in the collection.</returns>
            <exception cref="T:System.InvalidOperationException">The collection is empty.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> or <paramref name="comparer"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Maximum``1(System.Collections.Generic.IEnumerable{``0},System.Comparison{``0})">
            <summary>
            Finds the maximum value in a collection. A supplied Comparison&lt;T&gt; delegate is used
            to compare the items in the collection.
            </summary>
            <typeparam name="T">The type of items in the collection.</typeparam>
            <param name="collection">The collection to search.</param>
            <param name="comparison">The comparison used to compare items in the collection.</param>
            <returns>The largest item in the collection.</returns>
            <exception cref="T:System.InvalidOperationException">The collection is empty.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> or <paramref name="comparison"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Minimum``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Finds the minimum value in a collection.
            </summary>
            <remarks>Values in the collection are compared by using the IComparable&lt;T&gt;
            interfaces implementation on the type T.</remarks>
            <typeparam name="T">The type of items in the collection.</typeparam>
            <param name="collection">The collection to search.</param>
            <returns>The smallest item in the collection.</returns>
            <exception cref="T:System.InvalidOperationException">The collection is empty.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Minimum``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0})">
            <summary>
            Finds the minimum value in a collection. A supplied IComparer&lt;T&gt; is used
            to compare the items in the collection.
            </summary>
            <typeparam name="T">The type of items in the collection.</typeparam>
            <param name="collection">The collection to search.</param>
            <param name="comparer">The comparer instance used to compare items in the collection.</param>
            <returns>The smallest item in the collection.</returns>
            <exception cref="T:System.InvalidOperationException">The collection is empty.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> or <paramref name="comparer"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Minimum``1(System.Collections.Generic.IEnumerable{``0},System.Comparison{``0})">
            <summary>
            Finds the minimum value in a collection. A supplied Comparison&lt;T&gt; delegate is used
            to compare the items in the collection.
            </summary>
            <typeparam name="T">The type of items in the collection.</typeparam>
            <param name="collection">The collection to search.</param>
            <param name="comparison">The comparison used to compare items in the collection.</param>
            <returns>The smallest item in the collection.</returns>
            <exception cref="T:System.InvalidOperationException">The collection is empty.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> or <paramref name="comparison"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.IndexOfMaximum``1(System.Collections.Generic.IList{``0})">
            <summary>
            Finds the index of the maximum value in a list.
            </summary>
            <remarks>Values in the list are compared by using the IComparable&lt;T&gt;
            interfaces implementation on the type T.</remarks>
            <typeparam name="T">The type of items in the list.</typeparam>
            <param name="list">The list to search.</param>
            <returns>The index of the largest item in the list. If the maximum value appears
            multiple times, the index of the first appearance is used. If the list is empty, -1 is returned.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="list"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.IndexOfMaximum``1(System.Collections.Generic.IList{``0},System.Collections.Generic.IComparer{``0})">
            <summary>
            Finds the index of the maximum value in a list. A supplied IComparer&lt;T&gt; is used
            to compare the items in the collection. 
            </summary>
            <typeparam name="T">The type of items in the list.</typeparam>
            <param name="list">The list to search.</param>
            <param name="comparer">The comparer instance used to compare items in the collection.</param>
            <returns>The index of the largest item in the list. If the maximum value appears
            multiple times, the index of the first appearance is used. If the list is empty, -1 is returned.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="list"/> or <paramref name="comparer"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.IndexOfMaximum``1(System.Collections.Generic.IList{``0},System.Comparison{``0})">
            <summary>
            Finds the index of the maximum value in a list. A supplied Comparison&lt;T&gt; delegate is used
            to compare the items in the collection.
            </summary>
            <typeparam name="T">The type of items in the list.</typeparam>
            <param name="list">The list to search.</param>
            <param name="comparison">The comparison used to compare items in the collection.</param>
            <returns>The index of the largest item in the list. If the maximum value appears
            multiple times, the index of the first appearance is used. If the list is empty, -1 is returned.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="list"/> or <paramref name="comparison"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.IndexOfMinimum``1(System.Collections.Generic.IList{``0})">
            <summary>
            Finds the index of the minimum value in a list.
            </summary>
            <remarks>Values in the list are compared by using the IComparable&lt;T&gt;
            interfaces implementation on the type T.</remarks>
            <typeparam name="T">The type of items in the list.</typeparam>
            <param name="list">The list to search.</param>
            <returns>The index of the smallest item in the list. If the minimum value appears
            multiple times, the index of the first appearance is used.</returns>
            <exception cref="T:System.InvalidOperationException">The collection is empty.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="list"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.IndexOfMinimum``1(System.Collections.Generic.IList{``0},System.Collections.Generic.IComparer{``0})">
            <summary>
            Finds the index of the minimum value in a list. A supplied IComparer&lt;T&gt; is used
            to compare the items in the collection. 
            </summary>
            <typeparam name="T">The type of items in the list.</typeparam>
            <param name="list">The list to search.</param>
            <param name="comparer">The comparer instance used to compare items in the collection.</param>
            <returns>The index of the smallest item in the list. If the minimum value appears
            multiple times, the index of the first appearance is used.</returns>
            <exception cref="T:System.InvalidOperationException">The collection is empty.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="list"/> or <paramref name="comparer"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.IndexOfMinimum``1(System.Collections.Generic.IList{``0},System.Comparison{``0})">
            <summary>
            Finds the index of the minimum value in a list. A supplied Comparison&lt;T&gt; delegate is used
            to compare the items in the collection.
            </summary>
            <typeparam name="T">The type of items in the list.</typeparam>
            <param name="list">The list to search.</param>
            <param name="comparison">The comparison delegate used to compare items in the collection.</param>
            <returns>The index of the smallest item in the list. If the minimum value appears
            multiple times, the index of the first appearance is used.</returns>
            <exception cref="T:System.InvalidOperationException">The collection is empty.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="list"/> or <paramref name="comparison"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Sort``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Creates a sorted version of a collection.
            </summary>
            <remarks>Values are compared by using the IComparable&lt;T&gt;
            interfaces implementation on the type T.</remarks>
            <param name="collection">The collection to sort.</param>
            <returns>An array containing the sorted version of the collection.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Sort``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0})">
            <summary>
            Creates a sorted version of a collection. A supplied IComparer&lt;T&gt; is used
            to compare the items in the collection. 
            </summary>
            <param name="collection">The collection to sort.</param>
            <param name="comparer">The comparer instance used to compare items in the collection. Only
            the Compare method is used.</param>
            <returns>An array containing the sorted version of the collection.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Sort``1(System.Collections.Generic.IEnumerable{``0},System.Comparison{``0})">
            <summary>
            Creates a sorted version of a collection. A supplied Comparison&lt;T&gt; delegate is used
            to compare the items in the collection.
            </summary>
            <param name="collection">The collection to sort.</param>
            <param name="comparison">The comparison delegate used to compare items in the collection.</param>
            <returns>An array containing the sorted version of the collection.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.SortInPlace``1(System.Collections.Generic.IList{``0})">
            <summary>
            Sorts a list or array in place.
            </summary>
            <remarks><para>The Quicksort algorithms is used to sort the items. In virtually all cases,
            this takes time O(N log N), where N is the number of items in the list.</para>
            <para>Values are compared by using the IComparable&lt;T&gt;
            interfaces implementation on the type T.</para>
            <para>Although arrays cast to IList&lt;T&gt; are normally read-only, this method
            will work correctly and modify an array passed as <paramref name="list"/>.</para></remarks>
            <param name="list">The list or array to sort.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.SortInPlace``1(System.Collections.Generic.IList{``0},System.Collections.Generic.IComparer{``0})">
            <summary>
            Sorts a list or array in place. A supplied IComparer&lt;T&gt; is used
            to compare the items in the list. 
            </summary>
            <remarks><para>The Quicksort algorithms is used to sort the items. In virtually all cases,
            this takes time O(N log N), where N is the number of items in the list.</para>
            <para>Although arrays cast to IList&lt;T&gt; are normally read-only, this method
            will work correctly and modify an array passed as <paramref name="list"/>.</para></remarks>
            <param name="list">The list or array to sort.</param>
            <param name="comparer">The comparer instance used to compare items in the collection. Only
            the Compare method is used.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.SortInPlace``1(System.Collections.Generic.IList{``0},System.Comparison{``0})">
            <summary>
            Sorts a list or array in place. A supplied Comparison&lt;T&gt; delegate is used
            to compare the items in the list.
            </summary>
            <remarks><para>The Quicksort algorithms is used to sort the items. In virtually all cases,
            this takes time O(N log N), where N is the number of items in the list.</para>
            <para>Although arrays cast to IList&lt;T&gt; are normally read-only, this method
            will work correctly and modify an array passed as <paramref name="list"/>.</para></remarks>
            <param name="list">The list or array to sort.</param>
            <param name="comparison">The comparison delegate used to compare items in the collection.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.StableSort``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Creates a sorted version of a collection. The sort is stable, which means that if items X and Y are equal,
            and X precedes Y in the unsorted collection, X will precede Y is the sorted collection.
            </summary>
            <remarks>Values are compared by using the IComparable&lt;T&gt;
            interfaces implementation on the type T.</remarks>
            <param name="collection">The collection to sort.</param>
            <returns>An array containing the sorted version of the collection.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.StableSort``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0})">
            <summary>
            Creates a sorted version of a collection. The sort is stable, which means that if items X and Y are equal,
            and X precedes Y in the unsorted collection, X will precede Y is the sorted collection. A supplied IComparer&lt;T&gt; is used
            to compare the items in the collection. 
            </summary>
            <param name="collection">The collection to sort.</param>
            <param name="comparer">The comparer instance used to compare items in the collection. Only
            the Compare method is used.</param>
            <returns>An array containing the sorted version of the collection.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.StableSort``1(System.Collections.Generic.IEnumerable{``0},System.Comparison{``0})">
            <summary>
            Creates a sorted version of a collection. The sort is stable, which means that if items X and Y are equal,
            and X precedes Y in the unsorted collection, X will precede Y is the sorted collection. 
            A supplied Comparison&lt;T&gt; delegate is used
            to compare the items in the collection.
            </summary>
            <remarks>Values are compared by using the IComparable&lt;T&gt;
            interfaces implementation on the type T.</remarks>
            <param name="collection">The collection to sort.</param>
            <param name="comparison">The comparison delegate used to compare items in the collection.</param>
            <returns>An array containing the sorted version of the collection.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.StableSortInPlace``1(System.Collections.Generic.IList{``0})">
            <summary>
            Sorts a list or array in place. The sort is stable, which means that if items X and Y are equal,
            and X precedes Y in the unsorted collection, X will precede Y is the sorted collection. 
            </summary>
            <remarks><para>Values are compared by using the IComparable&lt;T&gt;
            interfaces implementation on the type T.</para>
            <para>Although arrays cast to IList&lt;T&gt; are normally read-only, this method
            will work correctly and modify an array passed as <paramref name="list"/>.</para></remarks>
            <param name="list">The list or array to sort.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.StableSortInPlace``1(System.Collections.Generic.IList{``0},System.Collections.Generic.IComparer{``0})">
            <summary>
            Sorts a list or array in place. The sort is stable, which means that if items X and Y are equal,
            and X precedes Y in the unsorted collection, X will precede Y is the sorted collection. 
            A supplied IComparer&lt;T&gt; is used
            to compare the items in the list. 
            </summary>
            <remarks>Although arrays cast to IList&lt;T&gt; are normally read-only, this method
            will work correctly and modify an array passed as <paramref name="list"/>.</remarks>
            <param name="list">The list or array to sort.</param>
            <param name="comparer">The comparer instance used to compare items in the collection. Only
            the Compare method is used.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.StableSortInPlace``1(System.Collections.Generic.IList{``0},System.Comparison{``0})">
            <summary>
            Sorts a list or array in place. The sort is stable, which means that if items X and Y are equal,
            and X precedes Y in the unsorted collection, X will precede Y is the sorted collection. 
            A supplied Comparison&lt;T&gt; delegate is used
            to compare the items in the list.
            </summary>
            <remarks>Although arrays cast to IList&lt;T&gt; are normally read-only, this method
            will work correctly and modify an array passed as <paramref name="list"/>.</remarks>
            <param name="list">The list or array to sort.</param>
            <param name="comparison">The comparison delegate used to compare items in the collection.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.BinarySearch``1(System.Collections.Generic.IList{``0},``0,System.Int32@)">
            <summary>
            Searches a sorted list for an item via binary search. The list must be sorted
            by the natural ordering of the type (it's implementation of IComparable&lt;T&gt;).
            </summary>
            <param name="list">The sorted list to search.</param>
            <param name="item">The item to search for.</param>
            <param name="index">Returns the first index at which the item can be found. If the return
            value is zero, indicating that <paramref name="item"/> was not present in the list, then this
            returns the index at which <paramref name="item"/> could be inserted to maintain the sorted
            order of the list.</param>
            <returns>The number of items equal to <paramref name="item"/> that appear in the list.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.BinarySearch``1(System.Collections.Generic.IList{``0},``0,System.Collections.Generic.IComparer{``0},System.Int32@)">
            <summary>
            Searches a sorted list for an item via binary search. The list must be sorted
            by the ordering in the passed instance of IComparer&lt;T&gt;.
            </summary>
            <param name="list">The sorted list to search.</param>
            <param name="item">The item to search for.</param>
            <param name="comparer">The comparer instance used to sort the list. Only
            the Compare method is used.</param>
            <param name="index">Returns the first index at which the item can be found. If the return
            value is zero, indicating that <paramref name="item"/> was not present in the list, then this
            returns the index at which <paramref name="item"/> could be inserted to maintain the sorted
            order of the list.</param>
            <returns>The number of items equal to <paramref name="item"/> that appear in the list.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.BinarySearch``1(System.Collections.Generic.IList{``0},``0,System.Comparison{``0},System.Int32@)">
            <summary>
            Searches a sorted list for an item via binary search. The list must be sorted
            by the ordering in the passed Comparison&lt;T&gt; delegate.
            </summary>
            <param name="list">The sorted list to search.</param>
            <param name="item">The item to search for.</param>
            <param name="comparison">The comparison delegate used to sort the list.</param>
            <param name="index">Returns the first index at which the item can be found. If the return
            value is zero, indicating that <paramref name="item"/> was not present in the list, then this
            returns the index at which <paramref name="item"/> could be inserted to maintain the sorted
            order of the list.</param>
            <returns>The number of items equal to <paramref name="item"/> that appear in the list.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.MergeSorted``1(System.Collections.Generic.IEnumerable{``0}[])">
            <summary>
            Merge several sorted collections into a single sorted collection. Each input collection must be sorted
            by the natural ordering of the type (it's implementation of IComparable&lt;T&gt;). The merging
            is stable; equal items maintain their ordering, and equal items in different collections are placed
            in the order of the collections.
            </summary>
            <param name="collections">The set of collections to merge. In many languages, this parameter
            can be specified as several individual parameters.</param>
            <returns>An IEnumerable&lt;T&gt; that enumerates all the items in all the collections
            in sorted order. </returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.MergeSorted``1(System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEnumerable{``0}[])">
            <summary>
            Merge several sorted collections into a single sorted collection. Each input collection must be sorted
            by the ordering in the passed instance of IComparer&lt;T&gt;. The merging
            is stable; equal items maintain their ordering, and equal items in different collections are placed
            in the order of the collections.
            </summary>
            <param name="collections">The set of collections to merge. In many languages, this parameter
            can be specified as several individual parameters.</param>
            <param name="comparer">The comparer instance used to sort the list. Only
            the Compare method is used.</param>
            <returns>An IEnumerable&lt;T&gt; that enumerates all the items in all the collections
            in sorted order. </returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.MergeSorted``1(System.Comparison{``0},System.Collections.Generic.IEnumerable{``0}[])">
            <summary>
            Merge several sorted collections into a single sorted collection. Each input collection must be sorted
            by the ordering in the passed Comparison&lt;T&gt; delegate. The merging
            is stable; equal items maintain their ordering, and equal items in different collections are placed
            in the order of the collections.
            </summary>
            <param name="collections">The set of collections to merge. In many languages, this parameter
            can be specified as several individual parameters.</param>
            <param name="comparison">The comparison delegate used to sort the collections.</param>
            <returns>An IEnumerable&lt;T&gt; that enumerates all the items in all the collections
            in sorted order. </returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.LexicographicalCompare``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Performs a lexicographical comparison of two sequences of values. A lexicographical comparison compares corresponding
            pairs of elements from two sequences in order. If the first element of sequence1 is less than the first element of sequence2, 
            then the comparison ends and the first sequence is lexicographically less than the second. If the first elements of each sequence
            are equal, then the comparison proceeds to the second element of each sequence. If one sequence is shorter than the other,
            but corresponding elements are all equal, then the shorter sequence is considered less than the longer one.
            </summary>
            <remarks>T must implement either IComparable&lt;T&gt; and this implementation is used
            to compare the items. </remarks>
            <typeparam name="T">Types of items to compare. This type must implement IComparable&lt;T&gt; to allow 
            items to be compared.</typeparam>
            <param name="sequence1">The first sequence to compare.</param>
            <param name="sequence2">The second sequence to compare.</param>
            <returns>Less than zero if <paramref name="sequence1"/> is lexicographically less than <paramref name="sequence2"/>.
            Greater than zero if <paramref name="sequence1"/> is lexicographically greater than <paramref name="sequence2"/>.
            Zero if <paramref name="sequence1"/> is equal to <paramref name="sequence2"/>.</returns>
            <exception cref="T:System.NotSupportedException">T does not implement IComparable&lt;T&gt; or IComparable.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.LexicographicalCompare``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Comparison{``0})">
            <summary>
            Performs a lexicographical comparison of two sequences of values, using a supplied comparison delegate. A lexicographical comparison compares corresponding
            pairs of elements from two sequences in order. If the first element of sequence1 is less than the first element of sequence2, 
            then the comparison ends and the first sequence is lexicographically less than the second. If the first elements of each sequence
            are equal, then the comparison proceeds to the second element of each sequence. If one sequence is shorter than the other,
            but corresponding elements are all equal, then the shorter sequence is considered less than the longer one.
            </summary>
            <typeparam name="T">Types of items to compare.</typeparam>
            <param name="sequence1">The first sequence to compare.</param>
            <param name="sequence2">The second sequence to compare.</param>
            <param name="comparison">The IComparison&lt;T&gt; delegate to compare items. 
            Only the Compare member function of this interface is called.</param>
            <returns>Less than zero if <paramref name="sequence1"/> is lexicographically less than <paramref name="sequence2"/>.
            Greater than zero if <paramref name="sequence1"/> is lexicographically greater than <paramref name="sequence2"/>.
            Zero if <paramref name="sequence1"/> is equal to <paramref name="sequence2"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.LexicographicalCompare``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0})">
            <summary>
            Performs a lexicographical comparison of two sequences of values, using a supplied comparer interface. A lexicographical comparison compares corresponding
            pairs of elements from two sequences in order. If the first element of sequence1 is less than the first element of sequence2, 
            then the comparison ends and the first sequence is lexicographically less than the second. If the first elements of each sequence
            are equal, then the comparison proceeds to the second element of each sequence. If one sequence is shorter than the other,
            but corresponding elements are all equal, then the shorter sequence is considered less than the longer one.
            </summary>
            <typeparam name="T">Types of items to compare.</typeparam>
            <param name="sequence1">The first sequence to compare.</param>
            <param name="sequence2">The second sequence to compare.</param>
            <param name="comparer">The IComparer&lt;T&gt; used to compare items. 
            Only the Compare member function of this interface is called.</param>
            <returns>Less than zero if <paramref name="sequence1"/> is lexicographically less than <paramref name="sequence2"/>.
            Greater than zero if <paramref name="sequence1"/> is lexicographically greater than <paramref name="sequence2"/>.
            Zero if <paramref name="sequence1"/> is equal to <paramref name="sequence2"/>.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="sequence1"/>, <paramref name="sequence2"/>, or 
            <paramref name="comparer"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.GetLexicographicalComparer``1">
            <summary>
            Creates an IComparer instance that can be used for comparing ordered
            sequences of type T; that is IEnumerable&lt;Tgt;. This comparer can be used
            for collections or algorithms that use sequences of T as an item type. The Lexicographical
            ordered of sequences is for comparison.
            </summary>
            <remarks>T must implement either IComparable&lt;T&gt; and this implementation is used
            to compare the items. </remarks>
            <returns>At IComparer&lt;IEnumerable&lt;T&gt;&gt; that compares sequences of T.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.GetLexicographicalComparer``1(System.Collections.Generic.IComparer{``0})">
            <summary>
            Creates an IComparer instance that can be used for comparing ordered
            sequences of type T; that is IEnumerable&lt;Tgt;. This comparer can be uses
            for collections or algorithms that use sequences of T as an item type. The Lexicographics
            ordered of sequences is for comparison.
            </summary>
            <param name="comparer">A comparer instance used to compare individual items of type T.</param>
            <returns>At IComparer&lt;IEnumerable&lt;T&gt;&gt; that compares sequences of T.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.GetLexicographicalComparer``1(System.Comparison{``0})">
            <summary>
            Creates an IComparer instance that can be used for comparing ordered
            sequences of type T; that is IEnumerable&lt;Tgt;. This comparer can be uses
            for collections or algorithms that use sequences of T as an item type. The Lexicographics
            ordered of sequences is for comparison.
            </summary>
            <param name="comparison">A comparison delegate used to compare individual items of type T.</param>
            <returns>At IComparer&lt;IEnumerable&lt;T&gt;&gt; that compares sequences of T.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.GetReverseComparer``1(System.Collections.Generic.IComparer{``0})">
            <summary>
            Reverses the order of comparison of an IComparer&lt;T&gt;. The resulting comparer can be used,
            for example, to sort a collection in descending order. Equality and hash codes are unchanged.
            </summary>
            <typeparam name="T">The type of items thta are being compared.</typeparam>
            <param name="comparer">The comparer to reverse.</param>
            <returns>An IComparer&lt;T&gt; that compares items in the reverse order of <paramref name="comparer"/>.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="comparer"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.GetIdentityComparer``1">
            <summary>
            Gets an IEqualityComparer&lt;T&gt; instance that can be used to compare objects
            of type T for object identity only. Two objects compare equal only if they
            are references to the same object. 
            </summary>
            <returns>An IEqualityComparer&lt;T&gt; instance for identity comparison.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.GetReverseComparison``1(System.Comparison{``0})">
            <summary>
            Reverses the order of comparison of an Comparison&lt;T&gt;. The resulting comparison can be used,
            for example, to sort a collection in descending order. 
            </summary>
            <typeparam name="T">The type of items that are being compared.</typeparam>
            <param name="comparison">The comparison to reverse.</param>
            <returns>A Comparison&lt;T&gt; that compares items in the reverse order of <paramref name="comparison"/>.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="comparison"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.GetComparerFromComparison``1(System.Comparison{``0})">
            <summary>
            Given a comparison delegate that compares two items of type T, gets an
            IComparer&lt;T&gt; instance that performs the same comparison.
            </summary>
            <param name="comparison">The comparison delegate to use.</param>
            <returns>An IComparer&lt;T&gt; that performs the same comparing operation
            as <paramref name="comparison"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.GetComparisonFromComparer``1(System.Collections.Generic.IComparer{``0})">
            <summary>
            Given in IComparer&lt;T&gt; instenace that comparers two items from type T, 
            gets a Comparison delegate that performs the same comparison.
            </summary>
            <param name="comparer">The IComparer&lt;T&gt; instance to use.</param>
            <returns>A Comparison&lt;T&gt; delegate that performans the same comparing
            operation as <paramref name="comparer"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.GetCollectionEqualityComparer``1">
            <summary>
            Gets an IEqualityComparer&lt;IEnumerable&lt;T&gt;&gt; implementation 
            that can be used to compare collections of elements (of type T). Two collections
            of T's are equal if they have the same number of items, and corresponding 
            items are equal, considered in order. This is the same notion of equality as
            in Algorithms.EqualCollections, but encapsulated in an IEqualityComparer&lt;IEnumerable&lt;T&gt;&gt; implementation.
            </summary>
            <example>
            The following code creates a Dictionary where the keys are a collection of strings.
            <code>
                Dictionary&lt;IEnumerable&lt;string&gt;, int&gt; = 
                    new Dictionary&lt;IEnumerable&lt;string&gt;, int&gt;(Algorithms.GetCollectionEqualityComparer&lt;string&gt;());
            </code>
            </example>
            <returns>IEqualityComparer&lt;IEnumerable&lt;T&gt;&gt; implementation suitable for 
            comparing collections of T for equality.</returns>
            <seealso cref="M:Wintellect.PowerCollections.Algorithms.EqualCollections``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})"/>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.GetCollectionEqualityComparer``1(System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            <para>Gets an IEqualityComparer&lt;IEnumerable&lt;T&gt;&gt; implementation 
            that can be used to compare collections of elements (of type T). Two collections
            of T's are equal if they have the same number of items, and corresponding 
            items are equal, considered in order. This is the same notion of equality as
            in Algorithms.EqualCollections, but encapsulated in an IEqualityComparer&lt;IEnumerable&lt;T&gt;&gt; implementation.</para>
            <para>An IEqualityComparer&lt;T&gt; is used to determine if individual T's are equal</para>
            </summary>
            <example>
            The following code creates a Dictionary where the keys are a collection of strings, compared in a case-insensitive way
            <code>
                Dictionary&lt;IEnumerable&lt;string&gt;, int&gt; = 
                    new Dictionary&lt;IEnumerable&lt;string&gt;, int&gt;(Algorithms.GetCollectionEqualityComparer&lt;string&gt;(StringComparer.CurrentCultureIgnoreCase));
            </code>
            </example>
            <param name="equalityComparer">An IEqualityComparer&lt;T&gt; implementation used to compare individual T's.</param>
            <returns>IEqualityComparer&lt;IEnumerable&lt;T&gt;&gt; implementation suitable for 
            comparing collections of T for equality.</returns>
            <seealso cref="M:Wintellect.PowerCollections.Algorithms.EqualCollections``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})"/>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.GetSetEqualityComparer``1">
            <summary>
            <para>Gets an IEqualityComparer&lt;IEnumerable&lt;T&gt;&gt; implementation 
            that can be used to compare collections of elements (of type T). Two collections
            of T's are equal if they have the same number of items, and corresponding 
            items are equal, without regard to order. This is the same notion of equality as
            in Algorithms.EqualSets, but encapsulated in an IEqualityComparer&lt;IEnumerable&lt;T&gt;&gt; implementation.</para>
            <para>An IEqualityComparer&lt;T&gt; is used to determine if individual T's are equal</para>
            </summary>
            <example>
            The following code creates a Dictionary where the keys are a set of strings, without regard to order
            <code>
                Dictionary&lt;IEnumerable&lt;string&gt;, int&gt; = 
                    new Dictionary&lt;IEnumerable&lt;string&gt;, int&gt;(Algorithms.GetSetEqualityComparer&lt;string&gt;(StringComparer.CurrentCultureIgnoreCase));
            </code>
            </example>
            <returns>IEqualityComparer&lt;IEnumerable&lt;T&gt;&gt; implementation suitable for 
            comparing collections of T for equality, without regard to order.</returns>
            <seealso cref="M:Wintellect.PowerCollections.Algorithms.EqualSets``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})"/>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.GetSetEqualityComparer``1(System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Gets an IEqualityComparer&lt;IEnumerable&lt;T&gt;&gt; implementation 
            that can be used to compare collections of elements (of type T). Two collections
            of T's are equal if they have the same number of items, and corresponding 
            items are equal, without regard to order. This is the same notion of equality as
            in Algorithms.EqualSets, but encapsulated in an IEqualityComparer&lt;IEnumerable&lt;T&gt;&gt; implementation.
            </summary>
            <example>
            The following code creates a Dictionary where the keys are a set of strings, without regard to order
            <code>
                Dictionary&lt;IEnumerable&lt;string&gt;, int&gt; = 
                    new Dictionary&lt;IEnumerable&lt;string&gt;, int&gt;(Algorithms.GetSetEqualityComparer&lt;string&gt;());
            </code>
            </example>
            <param name="equalityComparer">An IEqualityComparer&lt;T&gt; implementation used to compare individual T's.</param>
            <returns>IEqualityComparer&lt;IEnumerable&lt;T&gt;&gt; implementation suitable for 
            comparing collections of T for equality, without regard to order.</returns>
            <seealso cref="M:Wintellect.PowerCollections.Algorithms.EqualSets``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})"/>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Exists``1(System.Collections.Generic.IEnumerable{``0},System.Predicate{``0})">
            <summary>
            Determines if a collection contains any item that satisfies the condition
            defined by <paramref name="predicate"/>.
            </summary>
            <param name="collection">The collection to check all the items in.</param>
            <param name="predicate">A delegate that defines the condition to check for.</param>
            <returns>True if the collection contains one or more items that satisfy the condition
            defined by <paramref name="predicate"/>. False if the collection does not contain
            an item that satisfies <paramref name="predicate"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.TrueForAll``1(System.Collections.Generic.IEnumerable{``0},System.Predicate{``0})">
            <summary>
            Determines if all of the items in the collection satisfy the condition
            defined by <paramref name="predicate"/>.
            </summary>
            <param name="collection">The collection to check all the items in.</param>
            <param name="predicate">A delegate that defines the condition to check for.</param>
            <returns>True if all of the items in the collection satisfy the condition
            defined by <paramref name="predicate"/>, or if the collection is empty. False if one or more items
            in the collection do not satisfy <paramref name="predicate"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.CountWhere``1(System.Collections.Generic.IEnumerable{``0},System.Predicate{``0})">
            <summary>
            Counts the number of items in the collection that satisfy the condition
            defined by <paramref name="predicate"/>.
            </summary>
            <param name="collection">The collection to count items in.</param>
            <param name="predicate">A delegate that defines the condition to check for.</param>
            <returns>The number of items in the collection that satisfy <paramref name="predicate"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.RemoveWhere``1(System.Collections.Generic.ICollection{``0},System.Predicate{``0})">
            <summary>
            Removes all the items in the collection that satisfy the condition
            defined by <paramref name="predicate"/>.
            </summary>
            <remarks>If the collection if an array or implements IList&lt;T&gt;, an efficient algorithm that
            compacts items is used. If not, then ICollection&lt;T&gt;.Remove is used
            to remove items from the collection. If the collection is an array or fixed-size list,
            the non-removed elements are placed, in order, at the beginning of
            the list, and the remaining list items are filled with a default value (0 or null).</remarks>
            <param name="collection">The collection to check all the items in.</param>
            <param name="predicate">A delegate that defines the condition to check for.</param>
            <returns>Returns a collection of the items that were removed. This collection contains the
            items in the same order that they orginally appeared in <paramref name="collection"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Convert``2(System.Collections.Generic.IEnumerable{``0},System.Converter{``0,``1})">
            <summary>
            Convert a collection of items by applying a delegate to each item in the collection. The resulting collection
            contains the result of applying <paramref name="converter"/> to each item in <paramref name="sourceCollection"/>, in
            order.
            </summary>
            <typeparam name="TSource">The type of items in the collection to convert.</typeparam>
            <typeparam name="TDest">The type each item is being converted to.</typeparam>
            <param name="sourceCollection">The collection of item being converted.</param>
            <param name="converter">A delegate to the method to call, passing each item in <paramref name="sourceCollection"/>.</param>
            <returns>The resulting collection from applying <paramref name="converter"/> to each item in <paramref name="sourceCollection"/>, in
            order.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="sourceCollection"/> or <paramref name="converter"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.GetDictionaryConverter``2(System.Collections.Generic.IDictionary{``0,``1})">
            <summary>
            Creates a delegate that converts keys to values by used a dictionary to map values. Keys
            that a not present in the dictionary are converted to the default value (zero or null).
            </summary>
            <remarks>This delegate can be used as a parameter in Convert or ConvertAll methods to convert
            entire collections.</remarks>
            <param name="dictionary">The dictionary used to perform the conversion.</param>
            <returns>A delegate to a method that converts keys to values. </returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.GetDictionaryConverter``2(System.Collections.Generic.IDictionary{``0,``1},``1)">
            <summary>
            Creates a delegate that converts keys to values by used a dictionary to map values. Keys
            that a not present in the dictionary are converted to a supplied default value.
            </summary>
            <remarks>This delegate can be used as a parameter in Convert or ConvertAll methods to convert
            entire collections.</remarks>
            <param name="dictionary">The dictionary used to perform the conversion.</param>
            <param name="defaultValue">The result of the conversion for keys that are not present in the dictionary.</param>
            <returns>A delegate to a method that converts keys to values. </returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="dictionary"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0})">
            <summary>
            Performs the specified action on each item in a collection.
            </summary>
            <param name="collection">The collection to process.</param>
            <param name="action">An Action delegate which is invoked for each item in <paramref name="collection"/>.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Partition``1(System.Collections.Generic.IList{``0},System.Predicate{``0})">
            <summary>
            Partition a list or array based on a predicate. After partitioning, all items for which
            the predicate returned true precede all items for which the predicate returned false.
            </summary>
            <remarks>Although arrays cast to IList&lt;T&gt; are normally read-only, this method
            will work correctly and modify an array passed as <paramref name="list"/>.</remarks>
            <param name="list">The list or array to partition.</param>
            <param name="predicate">A delegate that defines the partitioning condition.</param>
            <returns>The index of the first item in the second half of the partition; i.e., the first item for
            which <paramref name="predicate"/> returned false. If the predicate was true for all items
            in the list, list.Count is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.StablePartition``1(System.Collections.Generic.IList{``0},System.Predicate{``0})">
            <summary>
            Partition a list or array based on a predicate. After partitioning, all items for which
            the predicate returned true precede all items for which the predicate returned false. 
            The partition is stable, which means that if items X and Y have the same result from
            the predicate, and X precedes Y in the original list, X will precede Y in the 
            partitioned list.
            </summary>
            <remarks>Although arrays cast to IList&lt;T&gt; are normally read-only, this method
            will work correctly and modify an array passed as <paramref name="list"/>.</remarks>
            <param name="list">The list or array to partition.</param>
            <param name="predicate">A delegate that defines the partitioning condition.</param>
            <returns>The index of the first item in the second half of the partition; i.e., the first item for
            which <paramref name="predicate"/> returned false. If the predicate was true for all items
            in the list, list.Count is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Concatenate``1(System.Collections.Generic.IEnumerable{``0}[])">
            <summary>
            Concatenates all the items from several collections. The collections need not be of the same type, but
            must have the same item type.
            </summary>
            <param name="collections">The set of collections to concatenate. In many languages, this parameter
            can be specified as several individual parameters.</param>
            <returns>An IEnumerable that enumerates all the items in each of the collections, in order.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.EqualCollections``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Determines if the two collections contain equal items in the same order. The two collections do not need
            to be of the same type; it is permissible to compare an array and an OrderedBag, for instance.
            </summary>
            <remarks>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</remarks>
            <typeparam name="T">The type of items in the collections.</typeparam>
            <param name="collection1">The first collection to compare.</param>
            <param name="collection2">The second collection to compare.</param>
            <returns>True if the collections have equal items in the same order. If both collections are empty, true is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.EqualCollections``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Determines if the two collections contain equal items in the same order. The passed 
            instance of IEqualityComparer&lt;T&gt; is used for determining if two items are equal.
            </summary>
            <typeparam name="T">The type of items in the collections.</typeparam>
            <param name="collection1">The first collection to compare.</param>
            <param name="collection2">The second collection to compare.</param>
            <param name="equalityComparer">The IEqualityComparer&lt;T&gt; used to compare items for equality. 
            Only the Equals member function of this interface is called.</param>
            <returns>True if the collections have equal items in the same order. If both collections are empty, true is returned.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection1"/>, <paramref name="collection2"/>, or
            <paramref name="equalityComparer"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.EqualCollections``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},Wintellect.PowerCollections.BinaryPredicate{``0})">
            <summary>
            Determines if the two collections contain "equal" items in the same order. The passed 
            BinaryPredicate is used to determine if two items are "equal".
            </summary>
            <remarks>Since an arbitrary BinaryPredicate is passed to this function, what is being tested
            for need not be equality. For example, the following code determines if each integer in
            list1 is less than or equal to the corresponding integer in list2.
            <code>
            List&lt;int&gt; list1, list2;
            if (EqualCollections(list1, list2, delegate(int x, int y) { return x &lt;= y; }) {
                // the check is true...
            }
            </code>
            </remarks>
            <typeparam name="T">The type of items in the collections.</typeparam>
            <param name="collection1">The first collection to compare.</param>
            <param name="collection2">The second collection to compare.</param>
            <param name="predicate">The BinaryPredicate used to compare items for "equality". 
            This predicate can compute any relation between two items; it need not represent equality or an equivalence relation.</param>
            <returns>True if <paramref name="predicate"/>returns true for each corresponding pair of
            items in the two collections. If both collections are empty, true is returned.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection1"/>, <paramref name="collection2"/>, or
            <paramref name="predicate"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ToArray``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Create an array with the items in a collection.
            </summary>
            <remarks>If <paramref name="collection"/> implements ICollection&lt;T&gt;T, then 
            ICollection&lt;T&gt;.CopyTo() is used to fill the array. Otherwise, the IEnumerable&lt;T&gt;.GetEnumerator()
            is used to fill the array.</remarks>
            <typeparam name="T">Element type of the collection.</typeparam>
            <param name="collection">Collection to create array from.</param>
            <returns>An array with the items from the collection, in enumeration order.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Count``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Count the number of items in an IEnumerable&lt;T&gt; collection. If 
            a more specific collection type is being used, it is more efficient to use
            the Count property, if one is provided.
            </summary>
            <remarks>If the collection implements ICollection&lt;T&gt;, this method
            simply returns ICollection&lt;T&gt;.Count. Otherwise, it enumerates all items
            and counts them.</remarks>
            <param name="collection">The collection to count items in.</param>
            <returns>The number of items in the collection.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.CountEqual``1(System.Collections.Generic.IEnumerable{``0},``0)">
            <summary>
            Counts the number of items in the collection that are equal to <paramref name="find"/>.
            </summary>
            <remarks>The default sense of equality for T is used, as defined by T's
            implementation of IComparable&lt;T&gt;.Equals or object.Equals.</remarks>
            <param name="collection">The collection to count items in.</param>
            <param name="find">The item to compare to.</param>
            <returns>The number of items in the collection that are equal to <paramref name="find"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.CountEqual``1(System.Collections.Generic.IEnumerable{``0},``0,System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Counts the number of items in the collection that are equal to <paramref name="find"/>.
            </summary>
            <param name="collection">The collection to count items in.</param>
            <param name="find">The item to compare to.</param>
            <param name="equalityComparer">The comparer to use to determine if two items are equal. Only the Equals
            member function will be called.</param>
            <returns>The number of items in the collection that are equal to <paramref name="find"/>.</returns>
            <exception cref="T:System.ArgumentException"><paramref name="collection"/> or <paramref name="equalityComparer"/>
            is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.NCopiesOf``1(System.Int32,``0)">
            <summary>
            Creates an IEnumerator that enumerates a given item <paramref name="n"/> times.
            </summary>
            <example>
            The following creates a list consisting of 1000 copies of the double 1.0.
            <code>
            List&lt;double&gt; list = new List&lt;double&gt;(Algorithms.NCopiesOf(1000, 1.0));
            </code></example>
            <param name="n">The number of times to enumerate the item.</param>
            <param name="item">The item that should occur in the enumeration.</param>
            <returns>An IEnumerable&lt;T&gt; that yields <paramref name="n"/> copies
            of <paramref name="item"/>.</returns>
            <exception cref="T:System.ArgumentOutOfRangeException">The argument <paramref name="n"/> is less than zero.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Fill``1(System.Collections.Generic.IList{``0},``0)">
            <summary>
            Replaces each item in a list with a given value. The list does not change in size.
            </summary>
            <typeparam name="T">The type of items in the list.</typeparam>
            <param name="list">The list to modify.</param>
            <param name="value">The value to fill with.</param>
            <exception cref="T:System.ArgumentException"><paramref name="list"/> is a read-only list.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="list"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Fill``1(``0[],``0)">
            <summary>
            Replaces each item in a array with a given value. 
            </summary>
            <param name="array">The array to modify.</param>
            <param name="value">The value to fill with.</param>
            <exception cref="T:System.ArgumentNullException"><paramref name="array"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.FillRange``1(System.Collections.Generic.IList{``0},System.Int32,System.Int32,``0)">
            <summary>
            Replaces each item in a part of a list with a given value.
            </summary>
            <typeparam name="T">The type of items in the list.</typeparam>
            <param name="list">The list to modify.</param>
            <param name="start">The index at which to start filling. The first index in the list has index 0.</param>
            <param name="count">The number of items to fill.</param>
            <param name="value">The value to fill with.</param>
            <exception cref="T:System.ArgumentException"><paramref name="list"/> is a read-only list.</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="start"/> or <paramref name="count"/> is negative, or 
            <paramref name="start"/> + <paramref name="count"/> is greater than <paramref name="list"/>.Count.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="list"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.FillRange``1(``0[],System.Int32,System.Int32,``0)">
            <summary>
            Replaces each item in a part of a array with a given value.
            </summary>
            <param name="array">The array to modify.</param>
            <param name="start">The index at which to start filling. The first index in the array has index 0.</param>
            <param name="count">The number of items to fill.</param>
            <param name="value">The value to fill with.</param>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="start"/> or <paramref name="count"/> is negative, or 
            <paramref name="start"/> + <paramref name="count"/> is greater than <paramref name="array"/>.Length.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="array"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Copy``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IList{``0},System.Int32)">
            <summary>
            Copies all of the items from the collection <paramref name="source"/> to the list <paramref name="dest"/>, starting
            at the index <paramref name="destIndex"/>. If necessary, the size of the destination list is expanded.
            </summary>
            <param name="source">The collection that provide the source items. </param>
            <param name="dest">The list to store the items into.</param>
            <param name="destIndex">The index to begin copying items to.</param>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="destIndex"/> is negative or 
            greater than <paramref name="dest"/>.Count.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> or <paramref name="dest"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Copy``1(System.Collections.Generic.IEnumerable{``0},``0[],System.Int32)">
            <summary>
            Copies all of the items from the collection <paramref name="source"/> to the array <paramref name="dest"/>, starting
            at the index <paramref name="destIndex"/>. 
            </summary>
            <param name="source">The collection that provide the source items. </param>
            <param name="dest">The array to store the items into.</param>
            <param name="destIndex">The index to begin copying items to.</param>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="destIndex"/> is negative or 
            greater than <paramref name="dest"/>.Length.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> or <paramref name="dest"/> is null.</exception>
            <exception cref="T:System.ArgumentException">The collection has more items than will fit into the array. In this case, the array
            has been filled with as many items as fit before the exception is thrown.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Copy``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IList{``0},System.Int32,System.Int32)">
            <summary>
            Copies at most <paramref name="count"/> items from the collection <paramref name="source"/> to the list <paramref name="dest"/>, starting
            at the index <paramref name="destIndex"/>. If necessary, the size of the destination list is expanded. The source collection must not be
            the destination list or part thereof.
            </summary>
            <param name="source">The collection that provide the source items. </param>
            <param name="dest">The list to store the items into.</param>
            <param name="destIndex">The index to begin copying items to.</param>
            <param name="count">The maximum number of items to copy.</param>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="destIndex"/> is negative or 
            greater than <paramref name="dest"/>.Count</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="count"/> is negative.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> or <paramref name="dest"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Copy``1(System.Collections.Generic.IEnumerable{``0},``0[],System.Int32,System.Int32)">
            <summary>
            Copies at most <paramref name="count"/> items from the collection <paramref name="source"/> to the array <paramref name="dest"/>, starting
            at the index <paramref name="destIndex"/>. The source collection must not be
            the destination array or part thereof.
            </summary>
            <param name="source">The collection that provide the source items. </param>
            <param name="dest">The array to store the items into.</param>
            <param name="destIndex">The index to begin copying items to.</param>
            <param name="count">The maximum number of items to copy. The array must be large enought to fit this number of items.</param>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="destIndex"/> is negative or 
            greater than <paramref name="dest"/>.Length.</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="count"/> is negative or <paramref name="destIndex"/> + <paramref name="count"/>
            is greater than <paramref name="dest"/>.Length.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> or <paramref name="dest"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Copy``1(System.Collections.Generic.IList{``0},System.Int32,System.Collections.Generic.IList{``0},System.Int32,System.Int32)">
            <summary>
            Copies <paramref name="count"/> items from the list <paramref name="source"/>, starting at the index <paramref name="sourceIndex"/>, 
            to the list <paramref name="dest"/>, starting at the index <paramref name="destIndex"/>. If necessary, the size of the destination list is expanded.
            The source and destination lists may be the same.
            </summary>
            <param name="source">The collection that provide the source items. </param>
            <param name="sourceIndex">The index within <paramref name="source"/>to begin copying items from.</param>
            <param name="dest">The list to store the items into.</param>
            <param name="destIndex">The index within <paramref name="dest"/>to begin copying items to.</param>
            <param name="count">The maximum number of items to copy.</param>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="sourceIndex"/> is negative or 
            greater than <paramref name="source"/>.Count</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="destIndex"/> is negative or 
            greater than <paramref name="dest"/>.Count</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="count"/> is negative or too large.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> or <paramref name="dest"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Copy``1(System.Collections.Generic.IList{``0},System.Int32,``0[],System.Int32,System.Int32)">
            <summary>
            Copies <paramref name="count"/> items from the list or array <paramref name="source"/>, starting at the index <paramref name="sourceIndex"/>, 
            to the array <paramref name="dest"/>, starting at the index <paramref name="destIndex"/>. 
            The source may be the same as the destination array.
            </summary>
            <param name="source">The list or array that provide the source items. </param>
            <param name="sourceIndex">The index within <paramref name="source"/>to begin copying items from.</param>
            <param name="dest">The array to store the items into.</param>
            <param name="destIndex">The index within <paramref name="dest"/>to begin copying items to.</param>
            <param name="count">The maximum number of items to copy. The destination array must be large enough to hold this many items.</param>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="sourceIndex"/> is negative or 
            greater than <paramref name="source"/>.Count</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="destIndex"/> is negative or 
            greater than <paramref name="dest"/>.Length</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="count"/> is negative or too large.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> or <paramref name="dest"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Reverse``1(System.Collections.Generic.IList{``0})">
            <summary>
            Reverses a list and returns the reversed list, without changing the source list.
            </summary>
            <param name="source">The list to reverse.</param>
            <returns>A collection that contains the items from <paramref name="source"/> in reverse order.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ReverseInPlace``1(System.Collections.Generic.IList{``0})">
            <summary>
            Reverses a list or array in place.
            </summary>
            <remarks>Although arrays cast to IList&lt;T&gt; are normally read-only, this method
            will work correctly and modify an array passed as <paramref name="list"/>.</remarks>
            <param name="list">The list or array to reverse.</param>
            <exception cref="T:System.ArgumentNullException"><paramref name="list"/> is null.</exception>
            <exception cref="T:System.ArgumentException"><paramref name="list"/> is read only.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.Rotate``1(System.Collections.Generic.IList{``0},System.Int32)">
            <summary>
            Rotates a list and returns the rotated list, without changing the source list.
            </summary>
            <param name="source">The list to rotate.</param>
            <param name="amountToRotate">The number of elements to rotate. This value can be positive or negative. 
            For example, rotating by positive 3 means that source[3] is the first item in the returned collection.
            Rotating by negative 3 means that source[source.Count - 3] is the first item in the returned collection.</param>
            <returns>A collection that contains the items from <paramref name="source"/> in rotated order.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.RotateInPlace``1(System.Collections.Generic.IList{``0},System.Int32)">
            <summary>
            Rotates a list or array in place.
            </summary>
            <remarks>Although arrays cast to IList&lt;T&gt; are normally read-only, this method
            will work correctly and modify an array passed as <paramref name="list"/>.</remarks>
            <param name="list">The list or array to rotate.</param>
            <param name="amountToRotate">The number of elements to rotate. This value can be positive or negative. 
            For example, rotating by positive 3 means that list[3] is the first item in the resulting list.
            Rotating by negative 3 means that list[list.Count - 3] is the first item in the resulting list.</param>
            <exception cref="T:System.ArgumentNullException"><paramref name="list"/> is null.</exception>
        </member>
        <member name="T:Wintellect.PowerCollections.Algorithms.ListRange`1">
            <summary>
            The class that is used to implement IList&lt;T&gt; to view a sub-range
            of a list. The object stores a wrapped list, and a start/count indicating
            a sub-range of the list. Insertion/deletions through the sub-range view
            cause the count to change also; insertions and deletions directly on
            the wrapped list do not.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.ListBase`1">
            <summary>
            ListBase is an abstract class that can be used as a base class for a read-write collection that needs 
            to implement the generic IList&lt;T&gt; and non-generic IList collections. The derived class needs
            to override the following methods: Count, Clear, Insert, RemoveAt, and the indexer. The implementation
            of all the other methods in IList&lt;T&gt; and IList are handled by ListBase.
            </summary>
            <typeparam name="T"></typeparam>
        </member>
        <member name="T:Wintellect.PowerCollections.CollectionBase`1">
            <summary>
            CollectionBase is a base class that can be used to more easily implement the
            generic ICollection&lt;T&gt; and non-generic ICollection interfaces.
            </summary>
            <remarks>
            <para>To use CollectionBase as a base class, the derived class must override
            the Count, GetEnumerator, Add, Clear, and Remove methods. </para>
            <para>ICollection&lt;T&gt;.Contains need not be implemented by the
            derived class, but it should be strongly considered, because the CollectionBase implementation
            may not be very efficient.</para>
            </remarks>
            <typeparam name="T">The item type of the collection.</typeparam>
        </member>
        <member name="M:Wintellect.PowerCollections.CollectionBase`1.#ctor">
            <summary>
            Creates a new CollectionBase. 
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.CollectionBase`1.ToString">
            <summary>
            Shows the string representation of the collection. The string representation contains
            a list of the items in the collection. Contained collections (except string) are expanded
            recursively.
            </summary>
            <returns>The string representation of the collection.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.CollectionBase`1.Add(`0)">
            <summary>
            Must be overridden to allow adding items to this collection.
            </summary>
            <remarks><p>This method is not abstract, although derived classes should always
            override it. It is not abstract because some derived classes may wish to reimplement
            Add with a different return type (typically bool). In C#, this can be accomplished
            with code like the following:</p>
            <code>
                public class MyCollection&lt;T&gt;: CollectionBase&lt;T&gt;, ICollection&lt;T&gt;
                {
                    public new bool Add(T item) {
                        /* Add the item */
                    }
             
                    void ICollection&lt;T&gt;.Add(T item) {
                        Add(item);
                    }
                }
            </code>
            </remarks>
            <param name="item">Item to be added to the collection.</param>
            <exception cref="T:System.NotImplementedException">Always throws this exception to indicated
            that the method must be overridden or re-implemented in the derived class.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.CollectionBase`1.Clear">
            <summary>
            Must be overridden to allow clearing this collection.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.CollectionBase`1.Remove(`0)">
            <summary>
            Must be overridden to allow removing items from this collection.
            </summary>
            <returns>True if <paramref name="item"/> existed in the collection and
            was removed. False if <paramref name="item"/> did not exist in the collection.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.CollectionBase`1.Contains(`0)">
            <summary>
            Determines if the collection contains a particular item. This default implementation
            iterates all of the items in the collection via GetEnumerator, testing each item
            against <paramref name="item"/> using IComparable&lt;T&gt;.Equals or
            Object.Equals.
            </summary>
            <remarks>You should strongly consider overriding this method to provide
            a more efficient implementation, or if the default equality comparison
            is inappropriate.</remarks>
            <param name="item">The item to check for in the collection.</param>
            <returns>True if the collection contains <paramref name="item"/>, false otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.CollectionBase`1.CopyTo(`0[],System.Int32)">
            <summary>
            Copies all the items in the collection into an array. Implemented by
            using the enumerator returned from GetEnumerator to get all the items
            and copy them to the provided array.
            </summary>
            <param name="array">Array to copy to.</param>
            <param name="arrayIndex">Starting index in <paramref name="array"/> to copy to.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.CollectionBase`1.ToArray">
            <summary>
            Creates an array of the correct size, and copies all the items in the 
            collection into the array, by calling CopyTo.
            </summary>
            <returns>An array containing all the elements in the collection, in order.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.CollectionBase`1.AsReadOnly">
            <summary>
            Provides a read-only view of this collection. The returned ICollection&lt;T&gt; provides
            a view of the collection that prevents modifications to the collection. Use the method to provide
            access to the collection without allowing changes. Since the returned object is just a view,
            changes to the collection will be reflected in the view.
            </summary>
            <returns>An ICollection&lt;T&gt; that provides read-only access to the collection.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.CollectionBase`1.Exists(System.Predicate{`0})">
            <summary>
            Determines if the collection contains any item that satisfies the condition
            defined by <paramref name="predicate"/>.
            </summary>
            <param name="predicate">A delegate that defines the condition to check for.</param>
            <returns>True if the collection contains one or more items that satisfy the condition
            defined by <paramref name="predicate"/>. False if the collection does not contain
            an item that satisfies <paramref name="predicate"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.CollectionBase`1.TrueForAll(System.Predicate{`0})">
            <summary>
            Determines if all of the items in the collection satisfy the condition
            defined by <paramref name="predicate"/>.
            </summary>
            <param name="predicate">A delegate that defines the condition to check for.</param>
            <returns>True if all of the items in the collection satisfy the condition
            defined by <paramref name="predicate"/>, or if the collection is empty. False if one or more items
            in the collection do not satisfy <paramref name="predicate"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.CollectionBase`1.CountWhere(System.Predicate{`0})">
            <summary>
            Counts the number of items in the collection that satisfy the condition
            defined by <paramref name="predicate"/>.
            </summary>
            <param name="predicate">A delegate that defines the condition to check for.</param>
            <returns>The number of items in the collection that satisfy <paramref name="predicate"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.CollectionBase`1.FindAll(System.Predicate{`0})">
            <summary>
            Enumerates the items in the collection that satisfy the condition defined
            by <paramref name="predicate"/>.
            </summary>
            <param name="predicate">A delegate that defines the condition to check for.</param>
            <returns>An IEnumerable&lt;T&gt; that enumerates the items that satisfy the condition.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.CollectionBase`1.RemoveAll(System.Predicate{`0})">
            <summary>
            Removes all the items in the collection that satisfy the condition
            defined by <paramref name="predicate"/>.
            </summary>
            <param name="predicate">A delegate that defines the condition to check for.</param>
            <returns>Returns a collection of the items that were removed, in sorted order.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.CollectionBase`1.ForEach(System.Action{`0})">
            <summary>
            Performs the specified action on each item in this collection.
            </summary>
            <param name="action">An Action delegate which is invoked for each item in this collection.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.CollectionBase`1.ConvertAll``1(System.Converter{`0,``0})">
            <summary>
            Convert this collection of items by applying a delegate to each item in the collection. The resulting enumeration
            contains the result of applying <paramref name="converter"/> to each item in this collection, in
            order.
            </summary>
            <typeparam name="TOutput">The type each item is being converted to.</typeparam>
            <param name="converter">A delegate to the method to call, passing each item in this collection.</param>
            <returns>An IEnumerable&lt;TOutput^gt; that enumerates the resulting collection from applying <paramref name="converter"/> to each item in this collection in
            order.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="converter"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.CollectionBase`1.GetEnumerator">
            <summary>
            Must be overridden to enumerate all the members of the collection.
            </summary>
            <returns>A generic IEnumerator&lt;T&gt; that can be used
            to enumerate all the items in the collection.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.CollectionBase`1.System#Collections#ICollection#CopyTo(System.Array,System.Int32)">
            <summary>
            Copies all the items in the collection into an array. Implemented by
            using the enumerator returned from GetEnumerator to get all the items
            and copy them to the provided array.
            </summary>
            <param name="array">Array to copy to.</param>
            <param name="index">Starting index in <paramref name="array"/> to copy to.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.CollectionBase`1.System#Collections#IEnumerable#GetEnumerator">
            <summary>
            Provides an IEnumerator that can be used to iterate all the members of the
            collection. This implementation uses the IEnumerator&lt;T&gt; that was overridden
            by the derived classes to enumerate the members of the collection.
            </summary>
            <returns>An IEnumerator that can be used to iterate the collection.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.CollectionBase`1.DebuggerDisplayString">
            <summary>
            Display the contents of the collection in the debugger. This is intentionally private, it is called
            only from the debugger due to the presence of the DebuggerDisplay attribute. It is similar
            format to ToString(), but is limited to 250-300 characters or so, so as not to overload the debugger.
            </summary>
            <returns>The string representation of the items in the collection, similar in format to ToString().</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.CollectionBase`1.Count">
            <summary>
            Must be overridden to provide the number of items in the collection.
            </summary>
            <value>The number of items in the collection.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.CollectionBase`1.System#Collections#Generic#ICollection{T}#IsReadOnly">
            <summary>
            Indicates whether the collection is read-only. Always returns false.
            </summary>
            <value>Always returns false.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.CollectionBase`1.System#Collections#ICollection#IsSynchronized">
            <summary>
            Indicates whether the collection is synchronized.
            </summary>
            <value>Always returns false, indicating that the collection is not synchronized.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.CollectionBase`1.System#Collections#ICollection#SyncRoot">
            <summary>
            Indicates the synchronization object for this collection.
            </summary>
            <value>Always returns this.</value>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.#ctor">
            <summary>
            Creates a new ListBase.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.Clear">
            <summary>
            This method must be overridden by the derived class to empty the list
            of all items.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.Insert(System.Int32,`0)">
            <summary>
            This method must be overridden by the derived class to insert a new
            item at the given index. 
            </summary>
            <param name="index">The index in the list to insert the item at. After the
            insertion, the inserted item is located at this index. The
            first item in the list has index 0.</param>
            <param name="item">The item to insert at the given index.</param>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is
            less than zero or greater than Count.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.RemoveAt(System.Int32)">
            <summary>
            This method must be overridden by the derived class to remove the
            item at the given index. 
            </summary>
            <param name="index">The index in the list to remove the item at. The
            first item in the list has index 0.</param>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is
            less than zero or greater than or equal to Count.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.GetEnumerator">
            <summary>
            Enumerates all of the items in the list, in order. The item at index 0
            is enumerated first, then the item at index 1, and so on.
            </summary>
            <remarks>The enumerator does not check for changes made
            to the structure of the list. Thus, changes to the list during
            enumeration may cause incorrect enumeration or out of range
            exceptions. Consider overriding this method and adding checks
            for structural changes.</remarks>
            <returns>An IEnumerator&lt;T&gt; that enumerates all the
            items in the list.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.Contains(`0)">
            <summary>
            Determines if the list contains any item that compares equal to <paramref name="item"/>.
            The implementation simply checks whether IndexOf(item) returns a non-negative value.
            </summary>
            <remarks>Equality in the list is determined by the default sense of
            equality for T. If T implements IComparable&lt;T&gt;, the
            Equals method of that interface is used to determine equality. Otherwise, 
            Object.Equals is used to determine equality.</remarks>
            <param name="item">The item to search for.</param>
            <returns>True if the list contains an item that compares equal to <paramref name="item"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.Add(`0)">
            <summary>
            Adds an item to the end of the list. This method is equivalent to calling: 
            <code>Insert(Count, item)</code>
            </summary>
            <param name="item">The item to add to the list.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.Remove(`0)">
            <summary>
            Searches the list for the first item that compares equal to <paramref name="item"/>.
            If one is found, it is removed. Otherwise, the list is unchanged.
            </summary>
            <remarks>Equality in the list is determined by the default sense of
            equality for T. If T implements IComparable&lt;T&gt;, the
            Equals method of that interface is used to determine equality. Otherwise, 
            Object.Equals is used to determine equality.</remarks>
            <param name="item">The item to remove from the list.</param>
            <returns>True if an item was found and removed that compared equal to
            <paramref name="item"/>. False if no such item was in the list.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.CopyTo(`0[])">
            <summary>
            Copies all the items in the list, in order, to <paramref name="array"/>,
            starting at index 0.
            </summary>
            <param name="array">The array to copy to. This array must have a size
            that is greater than or equal to Count.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.CopyTo(`0[],System.Int32)">
            <summary>
            Copies all the items in the list, in order, to <paramref name="array"/>,
            starting at <paramref name="arrayIndex"/>.
            </summary>
            <param name="array">The array to copy to. This array must have a size
            that is greater than or equal to Count + arrayIndex.</param>
            <param name="arrayIndex">The starting index in <paramref name="array"/>
            to copy to.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.CopyTo(System.Int32,`0[],System.Int32,System.Int32)">
            <summary>
            Copies a range of elements from the list to <paramref name="array"/>,
            starting at <paramref name="arrayIndex"/>.
            </summary>
            <param name="index">The starting index in the source list of the range to copy.</param>
            <param name="array">The array to copy to. This array must have a size
            that is greater than or equal to Count + arrayIndex.</param>
            <param name="arrayIndex">The starting index in <paramref name="array"/>
            to copy to.</param>
            <param name="count">The number of items to copy.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.AsReadOnly">
            <summary>
            Provides a read-only view of this list. The returned IList&lt;T&gt; provides
            a view of the list that prevents modifications to the list. Use the method to provide
            access to the list without allowing changes. Since the returned object is just a view,
            changes to the list will be reflected in the view.
            </summary>
            <returns>An IList&lt;T&gt; that provides read-only access to the list.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.Find(System.Predicate{`0})">
            <summary>
            Finds the first item in the list that satisfies the condition
            defined by <paramref name="predicate"/>. If no item matches the condition, than
            the default value for T (null or all-zero) is returned.
            </summary>
            <remarks>If the default value for T (null or all-zero) matches the condition defined by <paramref name="predicate"/>,
            and the list might contain the default value, then it is impossible to distinguish the different between finding
            the default value and not finding any item. To distinguish these cases, use <see cref="M:Wintellect.PowerCollections.ListBase`1.TryFind(System.Predicate{`0},`0@)"/>.</remarks>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <returns>The first item that satisfies the condition <paramref name="predicate"/>. If no item satisfies that
            condition, the default value for T is returned.</returns>
            <seealso cref="M:Wintellect.PowerCollections.ListBase`1.TryFind(System.Predicate{`0},`0@)"/>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.TryFind(System.Predicate{`0},`0@)">
            <summary>
            Finds the first item in the list that satisfies the condition
            defined by <paramref name="predicate"/>. 
            </summary>
            <param name="predicate">A delegate that defines the condition to check for.</param>
            <param name="foundItem">If true is returned, this parameter receives the first item in the list
            that satifies the condition defined by <paramref name="predicate"/>.</param>
            <returns>True if an item that  satisfies the condition <paramref name="predicate"/> was found. False 
            if no item in the list satisfies that condition.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.FindLast(System.Predicate{`0})">
            <summary>
            Finds the last item in the list that satisfies the condition
            defined by <paramref name="predicate"/>. If no item matches the condition, than
            the default value for T (null or all-zero) is returned.
            </summary>
            <remarks>If the default value for T (null or all-zero) matches the condition defined by <paramref name="predicate"/>,
            and the list might contain the default value, then it is impossible to distinguish the different between finding
            the default value and not finding any item. To distinguish these cases, use <see cref="M:Wintellect.PowerCollections.ListBase`1.TryFindLast(System.Predicate{`0},`0@)"/>.</remarks>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <returns>The last item that satisfies the condition <paramref name="predicate"/>. If no item satisfies that
            condition, the default value for T is returned.</returns>
            <seealso cref="M:Wintellect.PowerCollections.ListBase`1.TryFindLast(System.Predicate{`0},`0@)"/>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.TryFindLast(System.Predicate{`0},`0@)">
            <summary>
            Finds the last item in the list that satisfies the condition
            defined by <paramref name="predicate"/>. 
            </summary>
            <param name="predicate">A delegate that defines the condition to check for.</param>
            <param name="foundItem">If true is returned, this parameter receives the last item in the list
            that satifies the condition defined by <paramref name="predicate"/>.</param>
            <returns>True if an item that  satisfies the condition <paramref name="predicate"/> was found. False 
            if no item in the list satisfies that condition.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.FindIndex(System.Predicate{`0})">
            <summary>
            Finds the index of the first item in the list that satisfies the condition
            defined by <paramref name="predicate"/>. If no item matches the condition, -1 is returned.
            </summary>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <returns>The index of the first item that satisfies the condition <paramref name="predicate"/>. If no item satisfies that
            condition, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.FindIndex(System.Int32,System.Predicate{`0})">
            <summary>
            Finds the index of the first item, in the range of items extending from <paramref name="index"/> to the end, that satisfies the condition
            defined by <paramref name="predicate"/>. If no item matches the condition, -1 is returned.
            </summary>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <param name="index">The starting index of the range to check.</param>
            <returns>The index of the first item in the given range that satisfies the condition <paramref name="predicate"/>. If no item satisfies that
            condition, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.FindIndex(System.Int32,System.Int32,System.Predicate{`0})">
            <summary>
            Finds the index of the first item, in the range of <paramref name="count"/> items starting from <paramref name="index"/>, that satisfies the condition
            defined by <paramref name="predicate"/>. If no item matches the condition, -1 is returned.
            </summary>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <param name="index">The starting index of the range to check.</param>
            <param name="count">The number of items in range to check.</param>
            <returns>The index of the first item in the given range that satisfies the condition <paramref name="predicate"/>. If no item satisfies that
            condition, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.FindLastIndex(System.Predicate{`0})">
            <summary>
            Finds the index of the last item in the list that satisfies the condition
            defined by <paramref name="predicate"/>. If no item matches the condition, -1 is returned.
            </summary>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <returns>The index of the last item that satisfies the condition <paramref name="predicate"/>. If no item satisfies that
            condition, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.FindLastIndex(System.Int32,System.Predicate{`0})">
            <summary>
            Finds the index of the last item, in the range of items extending from the beginning
            of the list to <paramref name="index"/>, that satisfies the condition
            defined by <paramref name="predicate"/>. If no item matches the condition, -1 is returned.
            </summary>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <param name="index">The ending index of the range to check.</param>
            <returns>The index of the last item in the given range that satisfies the condition <paramref name="predicate"/>. If no item satisfies that
            condition, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.FindLastIndex(System.Int32,System.Int32,System.Predicate{`0})">
            <summary>
            Finds the index of the last item, in the range of <paramref name="count"/> items ending at <paramref name="index"/>, that satisfies the condition
            defined by <paramref name="predicate"/>. If no item matches the condition, -1 is returned.
            </summary>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <param name="index">The ending index of the range to check.</param>
            <param name="count">The number of items in range to check.</param>
            <returns>The index of the last item in the given range that satisfies the condition <paramref name="predicate"/>. If no item satisfies that
            condition, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.IndexOf(`0)">
            <summary>
            Finds the index of the first item in the list that is equal to <paramref name="item"/>. 
            </summary>
            <remarks>The default implementation of equality for type T is used in the search. This is the
            equality defined by IComparable&lt;T&gt; or object.Equals.</remarks>
            <param name="item">The item to search fror.</param>
            <returns>The index of the first item in the list that that is equal to <paramref name="item"/>.  If no item is equal
            to <paramref name="item"/>, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.IndexOf(`0,System.Int32)">
            <summary>
            Finds the index of the first item, in the range of items extending from <paramref name="index"/> to the end,  
            that is equal to <paramref name="item"/>. 
            </summary>
            <remarks>The default implementation of equality for type T is used in the search. This is the
            equality defined by IComparable&lt;T&gt; or object.Equals.</remarks>
            <param name="item">The item to search fror.</param>
            <param name="index">The starting index of the range to check.</param>
            <returns>The index of the first item in the given range that that is equal to <paramref name="item"/>.  If no item is equal
            to <paramref name="item"/>, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.IndexOf(`0,System.Int32,System.Int32)">
            <summary>
            Finds the index of the first item, in the range of <paramref name="count"/> items starting from <paramref name="index"/>,  
            that is equal to <paramref name="item"/>. 
            </summary>
            <remarks>The default implementation of equality for type T is used in the search. This is the
            equality defined by IComparable&lt;T&gt; or object.Equals.</remarks>
            <param name="item">The item to search fror.</param>
            <param name="index">The starting index of the range to check.</param>
            <param name="count">The number of items in range to check.</param>
            <returns>The index of the first item in the given range that that is equal to <paramref name="item"/>.  If no item is equal
            to <paramref name="item"/>, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.LastIndexOf(`0)">
            <summary>
            Finds the index of the last item in the list that is equal to <paramref name="item"/>. 
            </summary>
            <remarks>The default implementation of equality for type T is used in the search. This is the
            equality defined by IComparable&lt;T&gt; or object.Equals.</remarks>
            <param name="item">The item to search fror.</param>
            <returns>The index of the last item in the list that that is equal to <paramref name="item"/>.  If no item is equal
            to <paramref name="item"/>, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.LastIndexOf(`0,System.Int32)">
            <summary>
            Finds the index of the last item, in the range of items extending from the beginning
            of the list to <paramref name="index"/>, that is equal to <paramref name="item"/>. 
            </summary>
            <remarks>The default implementation of equality for type T is used in the search. This is the
            equality defined by IComparable&lt;T&gt; or object.Equals.</remarks>
            <param name="item">The item to search fror.</param>
            <param name="index">The ending index of the range to check.</param>
            <returns>The index of the last item in the given range that that is equal to <paramref name="item"/>.  If no item is equal
            to <paramref name="item"/>, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.LastIndexOf(`0,System.Int32,System.Int32)">
            <summary>
            Finds the index of the last item, in the range of <paramref name="count"/> items ending at <paramref name="index"/>, 
            that is equal to <paramref name="item"/>. 
            </summary>
            <remarks>The default implementation of equality for type T is used in the search. This is the
            equality defined by IComparable&lt;T&gt; or object.Equals.</remarks>
            <param name="item">The item to search for.</param>
            <param name="index">The ending index of the range to check.</param>
            <param name="count">The number of items in range to check.</param>
            <returns>The index of the last item in the given range that that is equal to <paramref name="item"/>.  If no item is equal
            to <paramref name="item"/>, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.Range(System.Int32,System.Int32)">
            <summary>
            Returns a view onto a sub-range of this list. Items are not copied; the
            returned IList&lt;T&gt; is simply a different view onto the same underlying items. Changes to this list
            are reflected in the view, and vice versa. Insertions and deletions in the view change the size of the 
            view, but insertions and deletions in the underlying list do not.
            </summary>
            <remarks>
            <para>This method can be used to apply an algorithm to a portion of a list. For example:</para>
            <code>Algorithms.ReverseInPlace(deque.Range(3, 6))</code>
            will reverse the 6 items beginning at index 3.</remarks>
            <param name="start">The starting index of the view.</param>
            <param name="count">The number of items in the view.</param>
            <returns>A list that is a view onto the given sub-part of this list. </returns>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="start"/> or <paramref name="count"/> is negative.</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="start"/> + <paramref name="count"/> is greater than the
            size of the list.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.ConvertToItemType(System.String,System.Object)">
            <summary>
            Convert the given parameter to T. Throw an ArgumentException
            if it isn't.
            </summary>
            <param name="name">parameter name</param>
            <param name="value">parameter value</param>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.System#Collections#IList#Add(System.Object)">
            <summary>
            Adds an item to the end of the list. This method is equivalent to calling: 
            <code>Insert(Count, item)</code>
            </summary>
            <param name="value">The item to add to the list.</param>
            <exception cref="T:System.ArgumentException"><paramref name="value"/> cannot be converted to T.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.System#Collections#IList#Clear">
            <summary>
            Removes all the items from the list, resulting in an empty list.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.System#Collections#IList#Contains(System.Object)">
            <summary>
            Determines if the list contains any item that compares equal to <paramref name="value"/>.
            </summary>
            <remarks>Equality in the list is determined by the default sense of
            equality for T. If T implements IComparable&lt;T&gt;, the
            Equals method of that interface is used to determine equality. Otherwise, 
            Object.Equals is used to determine equality.</remarks>
            <param name="value">The item to search for.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.System#Collections#IList#IndexOf(System.Object)">
            <summary>
            Find the first occurrence of an item equal to <paramref name="value"/>
            in the list, and returns the index of that item.
            </summary>
            <remarks>Equality in the list is determined by the default sense of
            equality for T. If T implements IComparable&lt;T&gt;, the
            Equals method of that interface is used to determine equality. Otherwise, 
            Object.Equals is used to determine equality.</remarks>
            <param name="value">The item to search for.</param>
            <returns>The index of <paramref name="value"/>, or -1 if no item in the 
            list compares equal to <paramref name="value"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.System#Collections#IList#Insert(System.Int32,System.Object)">
            <summary>
            Insert a new
            item at the given index. 
            </summary>
            <param name="index">The index in the list to insert the item at. After the
            insertion, the inserted item is located at this index. The
            first item in the list has index 0.</param>
            <param name="value">The item to insert at the given index.</param>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is
            less than zero or greater than Count.</exception>
            <exception cref="T:System.ArgumentException"><paramref name="value"/> cannot be converted to T.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.System#Collections#IList#Remove(System.Object)">
            <summary>
            Searches the list for the first item that compares equal to <paramref name="value"/>.
            If one is found, it is removed. Otherwise, the list is unchanged.
            </summary>
            <remarks>Equality in the list is determined by the default sense of
            equality for T. If T implements IComparable&lt;T&gt;, the
            Equals method of that interface is used to determine equality. Otherwise, 
            Object.Equals is used to determine equality.</remarks>
            <param name="value">The item to remove from the list.</param>
            <exception cref="T:System.ArgumentException"><paramref name="value"/> cannot be converted to T.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ListBase`1.System#Collections#IList#RemoveAt(System.Int32)">
            <summary>
            Removes the
            item at the given index. 
            </summary>
            <param name="index">The index in the list to remove the item at. The
            first item in the list has index 0.</param>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is
            less than zero or greater than or equal to Count.</exception>
        </member>
        <member name="P:Wintellect.PowerCollections.ListBase`1.Count">
            <summary>
            The property must be overridden by the derived class to return the number of 
            items in the list.
            </summary>
            <value>The number of items in the list.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.ListBase`1.Item(System.Int32)">
            <summary>
            The indexer must be overridden by the derived class to get and set
            values of the list at a particular index.
            </summary>
            <param name="index">The index in the list to get or set an item at. The
            first item in the list has index 0, and the last has index Count-1.</param>
            <returns>The item at the given index.</returns>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is
            less than zero or greater than or equal to Count.</exception>
        </member>
        <member name="P:Wintellect.PowerCollections.ListBase`1.System#Collections#IList#IsFixedSize">
            <summary>
            Returns whether the list is a fixed size. This implementation always returns false.
            </summary>
            <value>Alway false, indicating that the list is not fixed size.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.ListBase`1.System#Collections#IList#IsReadOnly">
            <summary>
            Returns whether the list is read only. This implementation returns the value
            from ICollection&lt;T&gt;.IsReadOnly, which is by default, false.
            </summary>
            <value>By default, false, indicating that the list is not read only.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.ListBase`1.System#Collections#IList#Item(System.Int32)">
            <summary>
            Gets or sets the
            value at a particular index in the list.
            </summary>
            <param name="index">The index in the list to get or set an item at. The
            first item in the list has index 0, and the last has index Count-1.</param>
            <value>The item at the given index.</value>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is
            less than zero or greater than or equal to Count.</exception>
            <exception cref="T:System.ArgumentException"><paramref name="value"/> cannot be converted to T.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ListRange`1.#ctor(System.Collections.Generic.IList{`0},System.Int32,System.Int32)">
            <summary>
            Create a sub-range view object on the indicate part 
            of the list.
            </summary>
            <param name="wrappedList">List to wrap.</param>
            <param name="start">The start index of the view in the wrapped list.</param>
            <param name="count">The number of items in the view.</param>
        </member>
        <member name="T:Wintellect.PowerCollections.Algorithms.ArrayRange`1">
            <summary>
            The class that is used to implement IList&lt;T&gt; to view a sub-range
            of an array. The object stores a wrapped array, and a start/count indicating
            a sub-range of the array. Insertion/deletions through the sub-range view
            cause the count to change up to the size of the underlying array. Elements
            fall off the end of the underlying array.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ArrayRange`1.#ctor(`0[],System.Int32,System.Int32)">
            <summary>
            Create a sub-range view object on the indicate part 
            of the array.
            </summary>
            <param name="wrappedArray">Array to wrap.</param>
            <param name="start">The start index of the view in the wrapped list.</param>
            <param name="count">The number of items in the view.</param>
        </member>
        <member name="T:Wintellect.PowerCollections.Algorithms.ReadOnlyCollection`1">
            <summary>
            The read-only ICollection&lt;T&gt; implementation that is used by the ReadOnly method.
            Methods that modify the collection throw a NotSupportedException, methods that don't
            modify are fowarded through to the wrapped collection.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ReadOnlyCollection`1.#ctor(System.Collections.Generic.ICollection{`0})">
            <summary>
            Create a ReadOnlyCollection wrapped around the given collection.
            </summary>
            <param name="wrappedCollection">Collection to wrap.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ReadOnlyCollection`1.MethodModifiesCollection">
            <summary>
            Throws an NotSupportedException stating that this collection cannot be modified.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.Algorithms.ReadOnlyList`1">
            <summary>
            The read-only IList&lt;T&gt; implementation that is used by the ReadOnly method.
            Methods that modify the list throw a NotSupportedException, methods that don't
            modify are fowarded through to the wrapped list.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ReadOnlyList`1.#ctor(System.Collections.Generic.IList{`0})">
            <summary>
            Create a ReadOnlyList wrapped around the given list.
            </summary>
            <param name="wrappedList">List to wrap.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ReadOnlyList`1.MethodModifiesCollection">
            <summary>
            Throws an NotSupportedException stating that this collection cannot be modified.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.Algorithms.ReadOnlyDictionary`2">
            <summary>
            The private class that implements a read-only wrapped for 
            IDictionary &lt;TKey,TValue&gt;.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ReadOnlyDictionary`2.#ctor(System.Collections.Generic.IDictionary{`0,`1})">
            <summary>
            Create a read-only dictionary wrapped around the given dictionary.
            </summary>
            <param name="wrappedDictionary">The IDictionary&lt;TKey,TValue&gt; to wrap.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ReadOnlyDictionary`2.MethodModifiesCollection">
            <summary>
            Throws an NotSupportedException stating that this collection cannot be modified.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.Algorithms.TypedEnumerator`1">
            <summary>
             The class that provides a typed IEnumerator&lt;T&gt;
            view onto an untyped IEnumerator interface.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.TypedEnumerator`1.#ctor(System.Collections.IEnumerator)">
            <summary>
            Create a typed IEnumerator&lt;T&gt;
            view onto an untyped IEnumerator interface 
            </summary>
            <param name="wrappedEnumerator">IEnumerator to wrap.</param>
        </member>
        <member name="T:Wintellect.PowerCollections.Algorithms.TypedEnumerable`1">
            <summary>
            The class that provides a typed IEnumerable&lt;T&gt; view
            onto an untyped IEnumerable interface.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.TypedEnumerable`1.#ctor(System.Collections.IEnumerable)">
            <summary>
            Create a typed IEnumerable&lt;T&gt; view
            onto an untyped IEnumerable interface.
            </summary>
            <param name="wrappedEnumerable">IEnumerable interface to wrap.</param>
        </member>
        <member name="T:Wintellect.PowerCollections.Algorithms.TypedCollection`1">
            <summary>
            The class that provides a typed ICollection&lt;T&gt; view
            onto an untyped ICollection interface. The ICollection&lt;T&gt;
            is read-only.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.TypedCollection`1.#ctor(System.Collections.ICollection)">
            <summary>
            Create a typed ICollection&lt;T&gt; view
            onto an untyped ICollection interface.
            </summary>
            <param name="wrappedCollection">ICollection interface to wrap.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.TypedCollection`1.MethodModifiesCollection">
            <summary>
            Throws an NotSupportedException stating that this collection cannot be modified.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.Algorithms.TypedList`1">
            <summary>
            The class used to create a typed IList&lt;T&gt; view onto
            an untype IList interface.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.TypedList`1.#ctor(System.Collections.IList)">
            <summary>
            Create a typed IList&lt;T&gt; view onto
            an untype IList interface.
            </summary>
            <param name="wrappedList">The IList to wrap.</param>
        </member>
        <member name="T:Wintellect.PowerCollections.Algorithms.UntypedCollection`1">
            <summary>
            The class that is used to provide an untyped ICollection
            view onto a typed ICollection&lt;T&gt; interface.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.UntypedCollection`1.#ctor(System.Collections.Generic.ICollection{`0})">
            <summary>
            Create an untyped ICollection
            view onto a typed ICollection&lt;T&gt; interface.
            </summary>
            <param name="wrappedCollection">The ICollection&lt;T&gt; to wrap.</param>
        </member>
        <member name="T:Wintellect.PowerCollections.Algorithms.UntypedList`1">
            <summary>
            The class that implements a non-generic IList wrapper
            around a generic IList&lt;T&gt; interface.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.UntypedList`1.#ctor(System.Collections.Generic.IList{`0})">
            <summary>
            Create a non-generic IList wrapper
            around a generic IList&lt;T&gt; interface.
            </summary>
            <param name="wrappedList">The IList&lt;T&gt; interface to wrap.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.UntypedList`1.ConvertToItemType(System.String,System.Object)">
            <summary>
            Convert the given parameter to T. Throw an ArgumentException
            if it isn't.
            </summary>
            <param name="name">parameter name</param>
            <param name="value">parameter value</param>
        </member>
        <member name="T:Wintellect.PowerCollections.Algorithms.ArrayWrapper`1">
            <summary>
            The class that is used to implement IList&lt;T&gt; to view an array
            in a read-write way. Insertions cause the last item in the array
            to fall off, deletions replace the last item with the default value.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ArrayWrapper`1.#ctor(`0[])">
            <summary>
            Create a list wrapper object on an array.
            </summary>
            <param name="wrappedArray">Array to wrap.</param>
        </member>
        <member name="P:Wintellect.PowerCollections.Algorithms.ArrayWrapper`1.System#Collections#IList#IsFixedSize">
            <summary>
            Return true, to indicate that the list is fixed size.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.Algorithms.LexicographicalComparerClass`1">
            <summary>
            A private class used by the LexicographicalComparer method to compare sequences
            (IEnumerable) of T by there Lexicographical ordering.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.LexicographicalComparerClass`1.#ctor(System.Collections.Generic.IComparer{`0})">
            <summary>
            Creates a new instance that comparer sequences of T by their lexicographical
            ordered.
            </summary>
            <param name="itemComparer">The IComparer used to compare individual items of type T.</param>
        </member>
        <member name="T:Wintellect.PowerCollections.Algorithms.ReverseComparerClass`1">
            <summary>
            An IComparer instance that can be used to reverse the sense of 
            a wrapped IComparer instance.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Algorithms.ReverseComparerClass`1.#ctor(System.Collections.Generic.IComparer{`0})">
            <summary>
            </summary>
            <param name="comparer">The comparer to reverse.</param>
        </member>
        <member name="T:Wintellect.PowerCollections.Algorithms.IdentityComparer`1">
            <summary>
            A class, implementing IEqualityComparer&lt;T&gt;, that compares objects
            for object identity only. Only Equals and GetHashCode can be used;
            this implementation is not appropriate for ordering.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.Algorithms.CollectionEqualityComparer`1">
            <summary>
            A private class used to implement GetCollectionEqualityComparer(). This
            class implements IEqualityComparer&lt;IEnumerable&lt;T&gt;gt; to compare
            two enumerables for equality, where order is significant.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.Algorithms.SetEqualityComparer`1">
            <summary>
            A private class used to implement GetSetEqualityComparer(). This
            class implements IEqualityComparer&lt;IEnumerable&lt;T&gt;gt; to compare
            two enumerables for equality, where order is not significant.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.Bag`1">
             <summary>
             Bag&lt;T&gt; is a collection that contains items of type T. 
             Unlike a Set, duplicate items (items that compare equal to each other) are allowed in an Bag. 
             </summary>
             <remarks>
             <p>The items are compared in one of two ways. If T implements IComparable&lt;T&gt; 
             then the Equals method of that interface will be used to compare items, otherwise the Equals
             method from Object will be used. Alternatively, an instance of IComparer&lt;T&gt; can be passed
             to the constructor to use to compare items.</p>
             <p>Bag is implemented as a hash table. Inserting, deleting, and looking up an
             an element all are done in approximately constant time, regardless of the number of items in the bag.</p>
             <p>When multiple equal items are stored in the bag, they are stored as a representative item and a count. 
             If equal items can be distinguished, this may be noticable. For example, if a case-insensitive
             comparer is used with a Bag&lt;string&gt;, and both "hello", and "HELLO" are added to the bag, then the
             bag will appear to contain two copies of "hello" (the representative item).</p>
             <p><see cref="T:Wintellect.PowerCollections.OrderedBag`1"/> is similar, but uses comparison instead of hashing, maintain
             the items in sorted order, and stores distinct copies of items that compare equal.</p>
            </remarks>
            <seealso cref="T:Wintellect.PowerCollections.OrderedBag`1"/>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.NewPair(`0,System.Int32)">
            <summary>
            Helper function to create a new KeyValuePair struct with an item and a count.
            </summary>
            <param name="item">The item.</param>
            <param name="count">The number of appearances.</param>
            <returns>A new KeyValuePair.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.NewPair(`0)">
            <summary>
            Helper function to create a new KeyValuePair struct with a count of zero.
            </summary>
            <param name="item">The item.</param>
            <returns>A new KeyValuePair.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.#ctor">
             <summary>
             Creates a new Bag. 
             </summary>
            <remarks>
             Items that are null are permitted.
            </remarks>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.#ctor(System.Collections.Generic.IEqualityComparer{`0})">
            <summary>
            Creates a new Bag. The Equals and GetHashCode methods of the passed comparison object
            will be used to compare items in this bag for equality.
            </summary>
            <param name="equalityComparer">An instance of IEqualityComparer&lt;T&gt; that will be used to compare items.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.#ctor(System.Collections.Generic.IEnumerable{`0})">
             <summary>
             Creates a new Bag. The bag is
             initialized with all the items in the given collection.
             </summary>
            <remarks>
             Items that are null are permitted.
            </remarks>
             <param name="collection">A collection with items to be placed into the Bag.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.#ctor(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IEqualityComparer{`0})">
            <summary>
            Creates a new Bag. The Equals and GetHashCode methods of the passed comparison object
            will be used to compare items in this bag. The bag is
            initialized with all the items in the given collection.
            </summary>
            <param name="collection">A collection with items to be placed into the Bag.</param>
            <param name="equalityComparer">An instance of IEqualityComparer&lt;T&gt; that will be used to compare items.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.#ctor(System.Collections.Generic.IEqualityComparer{System.Collections.Generic.KeyValuePair{`0,System.Int32}},System.Collections.Generic.IEqualityComparer{`0},Wintellect.PowerCollections.Hash{System.Collections.Generic.KeyValuePair{`0,System.Int32}},System.Int32)">
            <summary>
            Creates a new Bag given a comparer and a hash that contains the data. Used
            internally for Clone.
            </summary>
            <param name="equalityComparer">IEqualityComparer for the bag.</param>
            <param name="keyEqualityComparer">IEqualityComparer for the key.</param>
            <param name="hash">Data for the bag.</param>
            <param name="count">Size of the bag.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.System#ICloneable#Clone">
            <summary>
            Makes a shallow clone of this bag; i.e., if items of the
            bag are reference types, then they are not cloned. If T is a value type,
            then each element is copied as if by simple assignment.
            </summary>
            <remarks>Cloning the bag takes time O(N), where N is the number of items in the bag.</remarks>
            <returns>The cloned bag.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.Clone">
            <summary>
            Makes a shallow clone of this bag; i.e., if items of the
            bag are reference types, then they are not cloned. If T is a value type,
            then each element is copied as if by simple assignment.
            </summary>
            <remarks>Cloning the bag takes time O(N), where N is the number of unquie items in the bag.</remarks>
            <returns>The cloned bag.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.CloneContents">
            <summary>
            Makes a deep clone of this bag. A new bag is created with a clone of
            each element of this bag, by calling ICloneable.Clone on each element. If T is
            a value type, then each element is copied as if by simple assignment.
            </summary>
            <remarks><para>If T is a reference type, it must implement
            ICloneable. Otherwise, an InvalidOperationException is thrown.</para>
            <para>Cloning the bag takes time O(N log N), where N is the number of items in the bag.</para></remarks>
            <returns>The cloned bag.</returns>
            <exception cref="T:System.InvalidOperationException">T is a reference type that does not implement ICloneable.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.NumberOfCopies(`0)">
            <summary>
            Returns the number of copies of <paramref name="item"/> in the bag. 
            </summary>
            <remarks>NumberOfCopies() takes approximately constant time, no matter how many items
            are stored in the bag.</remarks>
            <param name="item">The item to search for in the bag.</param>
            <returns>The number of items in the bag that compare equal to <paramref name="item"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.GetRepresentativeItem(`0,`0@)">
            <summary>
            Returns the representative item stored in the bag that is equal to
            the provided item. Also returns the number of copies of the item in the bag.
            </summary>
            <param name="item">Item to find in the bag.</param>
            <param name="representative">If one or more items equal to <paramref name="item"/> are present in the
            bag, returns the representative item. If no items equal to <paramref name="item"/> are stored in the bag, 
            returns <paramref name="item"/>.</param>
            <returns>The number of items equal to <paramref name="item"/> stored in the bag.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.GetEnumerator">
            <summary>
            Returns an enumerator that enumerates all the items in the bag. 
            If an item is present multiple times in the bag, the representative item is yielded by the
            enumerator multiple times. The order of enumeration is haphazard and may change.
            </summary>
            <remarks>
            <p>Typically, this method is not called directly. Instead the "foreach" statement is used
            to enumerate the items, which uses this method implicitly.</p>
            <p>If an item is added to or deleted from the bag while it is being enumerated, then 
            the enumeration will end with an InvalidOperationException.</p>
            <p>Enumeration all the items in the bag takes time O(N), where N is the number
            of items in the bag.</p>
            </remarks>
            <returns>An enumerator for enumerating all the items in the Bag.</returns>		
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.Contains(`0)">
            <summary>
            Determines if this bag contains an item equal to <paramref name="item"/>. The bag
            is not changed.
            </summary>
            <remarks>Searching the bag for an item takes time O(log N), where N is the number of items in the bag.</remarks>
            <param name="item">The item to search for.</param>
            <returns>True if the bag contains <paramref name="item"/>. False if the bag does not contain <paramref name="item"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.DistinctItems">
            <summary>
            Enumerates all the items in the bag, but enumerates equal items
            just once, even if they occur multiple times in the bag.
            </summary>
            <remarks>If the bag is changed while items are being enumerated, the
            enumeration will terminate with an InvalidOperationException.</remarks>
            <returns>An IEnumerable&lt;T&gt; that enumerates the unique items.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.Add(`0)">
            <summary>
            Adds a new item to the bag. Since bags can contain duplicate items, the item 
            is added even if the bag already contains an item equal to <paramref name="item"/>. In
            this case, the count of items for the representative item is increased by one, but the existing
            represetative item is unchanged.
            </summary>
            <remarks>
            <para>Adding an item takes approximately constant time, regardless of the number of items in the bag.</para></remarks>
            <param name="item">The item to add to the bag.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.AddRepresentative(`0)">
            <summary>
            Adds a new item to the bag. Since bags can contain duplicate items, the item 
            is added even if the bag already contains an item equal to <paramref name="item"/>. In
            this case (unlike Add), the new item becomes the representative item.
            </summary>
            <remarks>
            <para>Adding an item takes approximately constant time, regardless of the number of items in the bag.</para></remarks>
            <param name="item">The item to add to the bag.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.ChangeNumberOfCopies(`0,System.Int32)">
            <summary>
            Changes the number of copies of an existing item in the bag, or adds the indicated number
            of copies of the item to the bag. 
            </summary>
            <remarks>
            <para>Changing the number of copies takes approximately constant time, regardless of the number of items in the bag.</para></remarks>
            <param name="item">The item to change the number of copies of. This may or may not already be present in the bag.</param>
            <param name="numCopies">The new number of copies of the item.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.AddMany(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Adds all the items in <paramref name="collection"/> to the bag. 
            </summary>
            <remarks>
            <para>Adding the collection takes time O(M log N), where N is the number of items in the bag, and M is the 
            number of items in <paramref name="collection"/>.</para></remarks>
            <param name="collection">A collection of items to add to the bag.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.Remove(`0)">
            <summary>
            Searches the bag for one item equal to <paramref name="item"/>, and if found,
            removes it from the bag. If not found, the bag is unchanged. 
            </summary>
            <remarks>
            <para>Equality between items is determined by the comparison instance or delegate used
            to create the bag.</para>
            <para>Removing an item from the bag takes approximated constant time,
            regardless of the number of items in the bag.</para></remarks>
            <param name="item">The item to remove.</param>
            <returns>True if <paramref name="item"/> was found and removed. False if <paramref name="item"/> was not in the bag.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.RemoveAllCopies(`0)">
            <summary>
            Searches the bag for all items equal to <paramref name="item"/>, and 
            removes all of them from the bag. If not found, the bag is unchanged.
            </summary>
            <remarks>
            <para>Equality between items is determined by the comparer instance used
            to create the bag.</para>
            <para>RemoveAllCopies() takes time O(M log N), where N is the total number of items in the bag, and M is
            the number of items equal to <paramref name="item"/>.</para></remarks>
            <param name="item">The item to remove.</param>
            <returns>The number of copies of <paramref name="item"/> that were found and removed. </returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.RemoveMany(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Removes all the items in <paramref name="collection"/> from the bag. Items that
            are not present in the bag are ignored.
            </summary>
            <remarks>
            <para>Equality between items is determined by the comparer instance used
            to create the bag.</para>
            <para>Removing the collection takes time O(M), where M is the 
            number of items in <paramref name="collection"/>.</para></remarks>
            <param name="collection">A collection of items to remove from the bag.</param>
            <returns>The number of items removed from the bag.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.Clear">
            <summary>
            Removes all items from the bag.
            </summary>
            <remarks>Clearing the bag takes a constant amount of time, regardless of the number of items in it.</remarks>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.CheckConsistentComparison(Wintellect.PowerCollections.Bag{`0})">
            <summary>
            Check that this bag and another bag were created with the same comparison
            mechanism. Throws exception if not compatible.
            </summary>
            <param name="otherBag">Other bag to check comparision mechanism.</param>
            <exception cref="T:System.InvalidOperationException">If otherBag and this bag don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.IsEqualTo(Wintellect.PowerCollections.Bag{`0})">
            <summary>
            Determines if this bag is equal to another bag. This bag is equal to
            <paramref name="otherBag"/> if they contain the same number of 
            of copies of equal elements.
            </summary>
            <remarks>IsSupersetOf is computed in time O(N), where N is the number of unique items in 
            this bag.</remarks>
            <param name="otherBag">Bag to compare to</param>
            <returns>True if this bag is equal to <paramref name="otherBag"/>, false otherwise.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.IsSupersetOf(Wintellect.PowerCollections.Bag{`0})">
            <summary>
            Determines if this bag is a superset of another bag. Neither bag is modified.
            This bag is a superset of <paramref name="otherBag"/> if every element in
            <paramref name="otherBag"/> is also in this bag, at least the same number of
            times.
            </summary>
            <remarks>IsSupersetOf is computed in time O(M), where M is the number of unique items in 
            <paramref name="otherBag"/>.</remarks>
            <param name="otherBag">Bag to compare to.</param>
            <returns>True if this is a superset of <paramref name="otherBag"/>.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.IsProperSupersetOf(Wintellect.PowerCollections.Bag{`0})">
            <summary>
            Determines if this bag is a proper superset of another bag. Neither bag is modified.
            This bag is a proper superset of <paramref name="otherBag"/> if every element in
            <paramref name="otherBag"/> is also in this bag, at least the same number of
            times. Additional, this bag must have strictly more items than <paramref name="otherBag"/>.
            </summary>
            <remarks>IsProperSupersetOf is computed in time O(M), where M is the number of unique items in 
            <paramref name="otherBag"/>.</remarks>
            <param name="otherBag">Set to compare to.</param>
            <returns>True if this is a proper superset of <paramref name="otherBag"/>.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.IsSubsetOf(Wintellect.PowerCollections.Bag{`0})">
            <summary>
            Determines if this bag is a subset of another ba11 items in this bag.
            </summary>
            <param name="otherBag">Bag to compare to.</param>
            <returns>True if this is a subset of <paramref name="otherBag"/>.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.IsProperSubsetOf(Wintellect.PowerCollections.Bag{`0})">
            <summary>
            Determines if this bag is a proper subset of another bag. Neither bag is modified.
            This bag is a subset of <paramref name="otherBag"/> if every element in this bag
            is also in <paramref name="otherBag"/>, at least the same number of
            times. Additional, this bag must have strictly fewer items than <paramref name="otherBag"/>.
            </summary>
            <remarks>IsProperSubsetOf is computed in time O(N), where N is the number of unique items in this bag.</remarks>
            <param name="otherBag">Bag to compare to.</param>
            <returns>True if this is a proper subset of <paramref name="otherBag"/>.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.IsDisjointFrom(Wintellect.PowerCollections.Bag{`0})">
            <summary>
            Determines if this bag is disjoint from another bag. Two bags are disjoint
            if no item from one set is equal to any item in the other bag.
            </summary>
            <remarks>
            <para>The answer is computed in time O(N), where N is the size of the smaller set.</para>
            </remarks>
            <param name="otherBag">Bag to check disjointness with.</param>
            <returns>True if the two bags are disjoint, false otherwise.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.UnionWith(Wintellect.PowerCollections.Bag{`0})">
            <summary>
            Computes the union of this bag with another bag. The union of two bags
            is all items from both of the bags. If an item appears X times in one bag,
            and Y times in the other bag, the union contains the item Maximum(X,Y) times. This bag receives
            the union of the two bags, the other bag is unchanged.
            </summary>
            <remarks>
            <para>The union of two bags is computed in time O(M+N), where M and N are the size of the 
            two bags.</para>
            </remarks>
            <param name="otherBag">Bag to union with.</param>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.Union(Wintellect.PowerCollections.Bag{`0})">
            <summary>
            Computes the union of this bag with another bag. The union of two bags
            is all items from both of the bags.  If an item appears X times in one bag,
            and Y times in the other bag, the union contains the item Maximum(X,Y) times. A new bag is 
            created with the union of the bags and is returned. This bag and the other bag 
            are unchanged.
            </summary>
            <remarks>
            <para>The union of two bags is computed in time O(M+N), where M and N are the size of the two bags.</para>
            </remarks>
            <param name="otherBag">Bag to union with.</param>
            <returns>The union of the two bags.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.SumWith(Wintellect.PowerCollections.Bag{`0})">
            <summary>
            Computes the sum of this bag with another bag. The sum of two bags
            is all items from both of the bags. If an item appears X times in one bag,
            and Y times in the other bag, the sum contains the item (X+Y) times. This bag receives
            the sum of the two bags, the other bag is unchanged.
            </summary>
            <remarks>
            <para>The sum of two bags is computed in time O(M), where M is the size of the 
            other bag..</para>
            </remarks>
            <param name="otherBag">Bag to sum with.</param>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.Sum(Wintellect.PowerCollections.Bag{`0})">
            <summary>
            Computes the sum of this bag with another bag. he sum of two bags
            is all items from both of the bags.  If an item appears X times in one bag,
            and Y times in the other bag, the sum contains the item (X+Y) times. A new bag is 
            created with the sum of the bags and is returned. This bag and the other bag 
            are unchanged.
            </summary>
            <remarks>
            <para>The sum of two bags is computed in time O(M + N log M), where M is the size of the 
            larger bag, and N is the size of the smaller bag.</para>
            </remarks>
            <param name="otherBag">Bag to sum with.</param>
            <returns>The sum of the two bags.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.IntersectionWith(Wintellect.PowerCollections.Bag{`0})">
            <summary>
            Computes the intersection of this bag with another bag. The intersection of two bags
            is all items that appear in both of the bags. If an item appears X times in one bag,
            and Y times in the other bag, the sum contains the item Minimum(X,Y) times. This bag receives
            the intersection of the two bags, the other bag is unchanged.
            </summary>
            <remarks>
            <para>When equal items appear in both bags, the intersection will include an arbitrary choice of one of the
            two equal items.</para>
            <para>The intersection of two bags is computed in time O(N), where N is the size of the smaller bag.</para>
            </remarks>
            <param name="otherBag">Bag to intersection with.</param>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.Intersection(Wintellect.PowerCollections.Bag{`0})">
            <summary>
            Computes the intersection of this bag with another bag. The intersection of two bags
            is all items that appear in both of the bags. If an item appears X times in one bag,
            and Y times in the other bag, the intersection contains the item Minimum(X,Y) times. A new bag is 
            created with the intersection of the bags and is returned. This bag and the other bag 
            are unchanged.
            </summary>
            <remarks>
            <para>When equal items appear in both bags, the intersection will include an arbitrary choice of one of the
            two equal items.</para>
            <para>The intersection of two bags is computed in time O(N), where N is the size of the smaller bag.</para>
            </remarks>
            <param name="otherBag">Bag to intersection with.</param>
            <returns>The intersection of the two bags.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.DifferenceWith(Wintellect.PowerCollections.Bag{`0})">
            <summary>
            Computes the difference of this bag with another bag. The difference of these two bags
            is all items that appear in this bag, but not in <paramref name="otherBag"/>. If an item appears X times in this bag,
            and Y times in the other bag, the difference contains the item X - Y times (zero times if Y &gt;= X). This bag receives
            the difference of the two bags; the other bag is unchanged.
            </summary>
            <remarks>
            <para>The difference of two bags is computed in time O(M), where M is the size of the 
            other bag.</para>
            </remarks>
            <param name="otherBag">Bag to difference with.</param>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.Difference(Wintellect.PowerCollections.Bag{`0})">
            <summary>
            Computes the difference of this bag with another bag. The difference of these two bags
            is all items that appear in this bag, but not in <paramref name="otherBag"/>. If an item appears X times in this bag,
            and Y times in the other bag, the difference contains the item X - Y times (zero times if Y &gt;= X).  A new bag is 
            created with the difference of the bags and is returned. This bag and the other bag 
            are unchanged.
            </summary>
            <remarks>
            <para>The difference of two bags is computed in time O(M + N), where M and N are the size
            of the two bags.</para>
            </remarks>
            <param name="otherBag">Bag to difference with.</param>
            <returns>The difference of the two bags.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.SymmetricDifferenceWith(Wintellect.PowerCollections.Bag{`0})">
            <summary>
            Computes the symmetric difference of this bag with another bag. The symmetric difference of two bags
            is all items that appear in either of the bags, but not both. If an item appears X times in one bag,
            and Y times in the other bag, the symmetric difference contains the item AbsoluteValue(X - Y) times. This bag receives
            the symmetric difference of the two bags; the other bag is unchanged.
            </summary>
            <remarks>
            <para>The symmetric difference of two bags is computed in time O(M + N), where M is the size of the 
            larger bag, and N is the size of the smaller bag.</para>
            </remarks>
            <param name="otherBag">Bag to symmetric difference with.</param>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Bag`1.SymmetricDifference(Wintellect.PowerCollections.Bag{`0})">
            <summary>
            Computes the symmetric difference of this bag with another bag. The symmetric difference of two bags
            is all items that appear in either of the bags, but not both. If an item appears X times in one bag,
            and Y times in the other bag, the symmetric difference contains the item AbsoluteValue(X - Y) times. A new bag is 
            created with the symmetric difference of the bags and is returned. This bag and the other bag 
            are unchanged.
            </summary>
            <remarks>
            <para>The symmetric difference of two bags is computed in time O(M + N), where M is the size of the 
            larger bag, and N is the size of the smaller bag.</para>
            </remarks>
            <param name="otherBag">Bag to symmetric difference with.</param>
            <returns>The symmetric difference of the two bags.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="P:Wintellect.PowerCollections.Bag`1.Comparer">
            <summary>
            Returns the IEqualityComparer&lt;T&gt; used to compare items in this bag. 
            </summary>
            <value>If the bag was created using a comparer, that comparer is returned. Otherwise
            the default comparer for T (EqualityComparer&lt;T&gt;.Default) is returned.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.Bag`1.Count">
            <summary>
            Returns the number of items in the bag.
            </summary>
            <remarks>The size of the bag is returned in constant time.</remarks>
            <value>The number of items in the bag.</value>
        </member>
        <member name="T:Wintellect.PowerCollections.Deque`1">
            <summary>
            <para>The Deque class implements a type of list known as a Double Ended Queue. A Deque
            is quite similar to a List, in that items have indices (starting at 0), and the item at any
            index can be efficiently retrieved. The difference between a List and a Deque lies in the
            efficiency of inserting elements at the beginning. In a List, items can be efficiently added
            to the end, but inserting an item at the beginning of the List is slow, taking time 
            proportional to the size of the List. In a Deque, items can be added to the beginning 
            or end equally efficiently, regardless of the number of items in the Deque. As a trade-off
            for this increased flexibility, Deque is somewhat slower than List (but still constant time) when
            being indexed to get or retrieve elements. </para>
            </summary>
            <remarks>
            <para>The Deque class can also be used as a more flexible alternative to the Queue 
            and Stack classes. Deque is as efficient as Queue and Stack for adding or removing items, 
            but is more flexible: it allows access
            to all items in the queue, and allows adding or removing from either end.</para>
            <para>Deque is implemented as a ring buffer, which is grown as necessary. The size
            of the buffer is doubled whenever the existing capacity is too small to hold all the
            elements.</para>
            </remarks>
            <typeparam name="T">The type of items stored in the Deque.</typeparam>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.StopEnumerations">
            <summary>
            Must be called whenever there is a structural change in the tree. Causes
            changeStamp to be changed, which causes any in-progress enumerations
            to throw exceptions.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.CheckEnumerationStamp(System.Int32)">
            <summary>
            Checks the given stamp against the current change stamp. If different, the
            collection has changed during enumeration and an InvalidOperationException
            must be thrown
            </summary>
            <param name="startStamp">changeStamp at the start of the enumeration.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.#ctor">
            <summary>
            Create a new Deque that is initially empty.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.#ctor(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Create a new Deque initialized with the items from the passed collection,
            in order.
            </summary>
            <param name="collection">A collection of items to initialize the Deque with.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.CopyTo(`0[],System.Int32)">
            <summary>
            Copies all the items in the Deque into an array.
            </summary>
            <param name="array">Array to copy to.</param>
            <param name="arrayIndex">Starting index in <paramref name="array"/> to copy to.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.TrimToSize">
            <summary>
            Trims the amount of memory used by the Deque by changing
            the Capacity to be equal to Count. If no more items will be added
            to the Deque, calling TrimToSize will reduce the amount of memory
            used by the Deque.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.Clear">
            <summary>
            Removes all items from the Deque.
            </summary>
            <remarks>Clearing the Deque takes a small constant amount of time, regardless of
            how many items are currently in the Deque.</remarks>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.GetEnumerator">
            <summary>
            Enumerates all of the items in the list, in order. The item at index 0
            is enumerated first, then the item at index 1, and so on. If the items
            are added to or removed from the Deque during enumeration, the 
            enumeration ends with an InvalidOperationException.
            </summary>
            <returns>An IEnumerator&lt;T&gt; that enumerates all the
            items in the list.</returns>
            <exception cref="T:System.InvalidOperationException">The Deque has an item added or deleted during the enumeration.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.CreateInitialBuffer(`0)">
            <summary>
            Creates the initial buffer and initialized the Deque to contain one initial
            item.
            </summary>
            <param name="firstItem">First and only item for the Deque.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.Insert(System.Int32,`0)">
            <summary>
            Inserts a new item at the given index in the Deque. All items at indexes 
            equal to or greater than <paramref name="index"/> move up one index
            in the Deque.
            </summary>
            <remarks>The amount of time to insert an item in the Deque is proportional
            to the distance of index from the closest end of the Deque: 
            O(Min(<paramref name="index"/>, Count - <paramref name="index"/>)).
            Thus, inserting an item at the front or end of the Deque is always fast; the middle of
            of the Deque is the slowest place to insert.
            </remarks>
            <param name="index">The index in the Deque to insert the item at. After the
            insertion, the inserted item is located at this index. The
            front item in the Deque has index 0.</param>
            <param name="item">The item to insert at the given index.</param>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is
            less than zero or greater than Count.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Inserts a collection of items at the given index in the Deque. All items at indexes 
            equal to or greater than <paramref name="index"/> increase their indices in the Deque
            by the number of items inserted.
            </summary>
            <remarks>The amount of time to insert a collection in the Deque is proportional
            to the distance of index from the closest end of the Deque, plus the number of items
            inserted (M): 
            O(M + Min(<paramref name="index"/>, Count - <paramref name="index"/>)).
            </remarks>
            <param name="index">The index in the Deque to insert the collection at. After the
            insertion, the first item of the inserted collection is located at this index. The
            front item in the Deque has index 0.</param>
            <param name="collection">The collection of items to insert at the given index.</param>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is
            less than zero or greater than Count.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.RemoveAt(System.Int32)">
            <summary>
            Removes the item at the given index in the Deque. All items at indexes 
            greater than <paramref name="index"/> move down one index
            in the Deque.
            </summary>
            <remarks>The amount of time to delete an item in the Deque is proportional
            to the distance of index from the closest end of the Deque: 
            O(Min(<paramref name="index"/>, Count - 1 - <paramref name="index"/>)).
            Thus, deleting an item at the front or end of the Deque is always fast; the middle of
            of the Deque is the slowest place to delete.
            </remarks>
            <param name="index">The index in the list to remove the item at. The
            first item in the list has index 0.</param>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is
            less than zero or greater than or equal to Count.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.RemoveRange(System.Int32,System.Int32)">
            <summary>
            Removes a range of items at the given index in the Deque. All items at indexes 
            greater than <paramref name="index"/> move down <paramref name="count"/> indices
            in the Deque.
            </summary>
            <remarks>The amount of time to delete <paramref name="count"/> items in the Deque is proportional
            to the distance to the closest end of the Deque: 
            O(Min(<paramref name="index"/>, Count - <paramref name="index"/> - <paramref name="count"/>)).
            </remarks>
            <param name="index">The index in the list to remove the range at. The
            first item in the list has index 0.</param>
            <param name="count">The number of items to remove.</param>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is
            less than zero or greater than or equal to Count, or <paramref name="count"/> is less than zero
            or too large.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.IncreaseBuffer">
            <summary>
            Increase the amount of buffer space. When calling this method, the Deque
            must not be empty. If start and end are equal, that indicates a completely
            full Deque.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.AddToFront(`0)">
            <summary>
            Adds an item to the front of the Deque. The indices of all existing items
            in the Deque are increased by 1. This method is 
            equivalent to <c>Insert(0, item)</c> but is a little more
            efficient.
            </summary>
            <remarks>Adding an item to the front of the Deque takes
            a small constant amount of time, regardless of how many items are in the Deque.</remarks>
            <param name="item">The item to add.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.AddManyToFront(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Adds a collection of items to the front of the Deque. The indices of all existing items
            in the Deque are increased by the number of items inserted. The first item in the added collection becomes the
            first item in the Deque. 
            </summary>
            <remarks>This method takes time O(M), where M is the number of items in the 
            <paramref name="collection"/>.</remarks>
            <param name="collection">The collection of items to add.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.AddToBack(`0)">
            <summary>
            Adds an item to the back of the Deque. The indices of all existing items
            in the Deque are unchanged. This method is 
            equivalent to <c>Insert(Count, item)</c> but is a little more
            efficient.
            </summary>
            <remarks>Adding an item to the back of the Deque takes
            a small constant amount of time, regardless of how many items are in the Deque.</remarks>
            <param name="item">The item to add.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.Add(`0)">
            <summary>
            Adds an item to the back of the Deque. The indices of all existing items
            in the Deque are unchanged. This method is 
            equivalent to <c>AddToBack(item)</c>.
            </summary>
            <remarks>Adding an item to the back of the Deque takes
            a small constant amount of time, regardless of how many items are in the Deque.</remarks>
            <param name="item">The item to add.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.AddManyToBack(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Adds a collection of items to the back of the Deque. The indices of all existing items
            in the Deque are unchanged. The last item in the added collection becomes the
            last item in the Deque.
            </summary>
            <remarks>This method takes time O(M), where M is the number of items in the 
            <paramref name="collection"/>.</remarks>
            <param name="collection">The collection of item to add.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.RemoveFromFront">
            <summary>
            Removes an item from the front of the Deque. The indices of all existing items
            in the Deque are decreased by 1. This method is 
            equivalent to <c>RemoveAt(0)</c> but is a little more
            efficient.
            </summary>
            <remarks>Removing an item from the front of the Deque takes
            a small constant amount of time, regardless of how many items are in the Deque.</remarks>
            <returns>The item that was removed.</returns>
            <exception cref="T:System.InvalidOperationException">The Deque is empty.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.RemoveFromBack">
            <summary>
            Removes an item from the back of the Deque. The indices of all existing items
            in the Deque are unchanged. This method is 
            equivalent to <c>RemoveAt(Count-1)</c> but is a little more
            efficient.
            </summary>
            <remarks>Removing an item from the back of the Deque takes
            a small constant amount of time, regardless of how many items are in the Deque.</remarks>
            <exception cref="T:System.InvalidOperationException">The Deque is empty.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.GetAtFront">
            <summary>
            Retreives the item currently at the front of the Deque. The Deque is 
            unchanged. This method is 
            equivalent to <c>deque[0]</c> (except that a different exception is thrown).
            </summary>
            <remarks>Retreiving the item at the front of the Deque takes
            a small constant amount of time, regardless of how many items are in the Deque.</remarks>
            <returns>The item at the front of the Deque.</returns>
            <exception cref="T:System.InvalidOperationException">The Deque is empty.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.GetAtBack">
            <summary>
            Retreives the item currently at the back of the Deque. The Deque is 
            unchanged. This method is 
            equivalent to <c>deque[deque.Count - 1]</c> (except that a different exception is thrown).
            </summary>
            <remarks>Retreiving the item at the back of the Deque takes
            a small constant amount of time, regardless of how many items are in the Deque.</remarks>
            <returns>The item at the back of the Deque.</returns>
            <exception cref="T:System.InvalidOperationException">The Deque is empty.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.Clone">
            <summary>
            Creates a new Deque that is a copy of this one.
            </summary>
            <remarks>Copying a Deque takes O(N) time, where N is the number of items in this Deque..</remarks>
            <returns>A copy of the current deque.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.System#ICloneable#Clone">
            <summary>
            Creates a new Deque that is a copy of this one.
            </summary>
            <remarks>Copying a Deque takes O(N) time, where N is the number of items in this Deque..</remarks>
            <returns>A copy of the current deque.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Deque`1.CloneContents">
            <summary>
            Makes a deep clone of this Deque. A new Deque is created with a clone of
            each element of this set, by calling ICloneable.Clone on each element. If T is
            a value type, then each element is copied as if by simple assignment.
            </summary>
            <remarks><para>If T is a reference type, it must implement
            ICloneable. Otherwise, an InvalidOperationException is thrown.</para>
            <para>Cloning the Deque takes time O(N), where N is the number of items in the Deque.</para></remarks>
            <returns>The cloned Deque.</returns>
            <exception cref="T:System.InvalidOperationException">T is a reference type that does not implement ICloneable.</exception>
        </member>
        <member name="P:Wintellect.PowerCollections.Deque`1.Count">
            <summary>
            Gets the number of items currently stored in the Deque. The last item
            in the Deque has index Count-1.
            </summary>
            <remarks>Getting the count of items in the Deque takes a small constant
            amount of time.</remarks>
            <value>The number of items stored in this Deque.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.Deque`1.Capacity">
            <summary>
            Gets or sets the capacity of the Deque. The Capacity is the number of
            items that this Deque can hold without expanding its internal buffer. Since
            Deque will automatically expand its buffer when necessary, in almost all cases
            it is unnecessary to worry about the capacity. However, if it is known that a
            Deque will contain exactly 1000 items eventually, it can slightly improve 
            efficiency to set the capacity to 1000 up front, so that the Deque does not
            have to expand automatically.
            </summary>
            <value>The number of items that this Deque can hold without expanding its
            internal buffer.</value>
            <exception cref="T:System.ArgumentOutOfRangeException">The capacity is being set
            to less than Count, or to too large a value.</exception>
        </member>
        <member name="P:Wintellect.PowerCollections.Deque`1.Item(System.Int32)">
            <summary>
            Gets or sets an item at a particular index in the Deque. 
            </summary>
            <remarks>Getting or setting the item at a particular index takes a small constant amount
            of time, no matter what index is used.</remarks>
            <param name="index">The index of the item to retrieve or change. The front item has index 0, and
            the back item has index Count-1.</param>
            <returns>The value at the indicated index.</returns>
            <exception cref="T:System.ArgumentOutOfRangeException">The index is less than zero or greater than or equal
            to Count.</exception>
        </member>
        <member name="T:Wintellect.PowerCollections.DictionaryBase`2">
            <summary>
            DictionaryBase is a base class that can be used to more easily implement the
            generic IDictionary&lt;T&gt; and non-generic IDictionary interfaces.
            </summary>
            <remarks>
            <para>To use DictionaryBase as a base class, the derived class must override
            Count, GetEnumerator, TryGetValue, Clear, Remove, and the indexer set accessor. </para>
            </remarks>
            <typeparam name="TKey">The key type of the dictionary.</typeparam>
            <typeparam name="TValue">The value type of the dictionary.</typeparam>
        </member>
        <member name="M:Wintellect.PowerCollections.DictionaryBase`2.#ctor">
            <summary>
            Creates a new DictionaryBase. 
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.DictionaryBase`2.Clear">
            <summary>
            Clears the dictionary. This method must be overridden in the derived class.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.DictionaryBase`2.Remove(`0)">
            <summary>
            Removes a key from the dictionary. This method must be overridden in the derived class.
            </summary>
            <param name="key">Key to remove from the dictionary.</param>
            <returns>True if the key was found, false otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.DictionaryBase`2.TryGetValue(`0,`1@)">
            <summary>
            Determines if this dictionary contains a key equal to <paramref name="key"/>. If so, the value
            associated with that key is returned through the value parameter. This method must be
            overridden by the derived class.
            </summary>
            <param name="key">The key to search for.</param>
            <param name="value">Returns the value associated with key, if true was returned.</param>
            <returns>True if the dictionary contains key. False if the dictionary does not contain key.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.DictionaryBase`2.Add(`0,`1)">
            <summary>
            Adds a new key-value pair to the dictionary. 
            </summary>
            <remarks>The default implementation of this method
            checks to see if the key already exists using 
            ContainsKey, then calls the indexer setter if the key doesn't
            already exist. </remarks>
            <param name="key">Key to add.</param>
            <param name="value">Value to associated with the key.</param>
            <exception cref="T:System.ArgumentException">key is already present in the dictionary</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.DictionaryBase`2.ContainsKey(`0)">
            <summary>
            Determines whether a given key is found
            in the dictionary.
            </summary>
            <remarks>The default implementation simply calls TryGetValue and returns
            what it returns.</remarks>
            <param name="key">Key to look for in the dictionary.</param>
            <returns>True if the key is present in the dictionary.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.DictionaryBase`2.ToString">
            <summary>
            Shows the string representation of the dictionary. The string representation contains
            a list of the mappings in the dictionary.
            </summary>
            <returns>The string representation of the dictionary.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.DictionaryBase`2.AsReadOnly">
            <summary>
            Provides a read-only view of this dictionary. The returned IDictionary&lt;TKey,TValue&gt; provides
            a view of the dictionary that prevents modifications to the dictionary. Use the method to provide
            access to the dictionary without allowing changes. Since the returned object is just a view,
            changes to the dictionary will be reflected in the view.
            </summary>
            <returns>An IIDictionary&lt;TKey,TValue&gt; that provides read-only access to the dictionary.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.DictionaryBase`2.Add(System.Collections.Generic.KeyValuePair{`0,`1})">
            <summary>
            Adds a key-value pair to the collection. This implementation calls the Add method
            with the Key and Value from the item.
            </summary>
            <param name="item">A KeyValuePair contains the Key and Value to add.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.DictionaryBase`2.Contains(System.Collections.Generic.KeyValuePair{`0,`1})">
            <summary>
            Determines if a dictionary contains a given KeyValuePair. This implementation checks to see if the
            dictionary contains the given key, and if the value associated with the key is equal to (via object.Equals)
            the value.
            </summary>
            <param name="item">A KeyValuePair containing the Key and Value to check for.</param>
            <returns></returns>
        </member>
        <member name="M:Wintellect.PowerCollections.DictionaryBase`2.Remove(System.Collections.Generic.KeyValuePair{`0,`1})">
            <summary>
            Determines if a dictionary contains a given KeyValuePair, and if so, removes it. This implementation checks to see if the
            dictionary contains the given key, and if the value associated with the key is equal to (via object.Equals)
            the value. If so, the key-value pair is removed.
            </summary>
            <param name="item">A KeyValuePair containing the Key and Value to check for.</param>
            <returns>True if the item was found and removed. False otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.DictionaryBase`2.CheckGenericType``1(System.String,System.Object)">
            <summary>
            Check that the given parameter is of the expected generic type. Throw an ArgumentException
            if it isn't.
            </summary>
            <typeparam name="ExpectedType">Expected type of the parameter</typeparam>
            <param name="name">parameter name</param>
            <param name="value">parameter value</param>
        </member>
        <member name="M:Wintellect.PowerCollections.DictionaryBase`2.System#Collections#IDictionary#Add(System.Object,System.Object)">
            <summary>
            Adds a key-value pair to the collection. If key or value are not of the expected types, an
            ArgumentException is thrown. If both key and value are of the expected types, the (overridden)
            Add method is called with the key and value to add.
            </summary>
            <param name="key">Key to add to the dictionary.</param>
            <param name="value">Value to add to the dictionary.</param>
            <exception cref="T:System.ArgumentException">key or value are not of the expected type for this dictionary.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.DictionaryBase`2.System#Collections#IDictionary#Clear">
            <summary>
            Clears this dictionary. Calls the (overridden) Clear method.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.DictionaryBase`2.System#Collections#IDictionary#Contains(System.Object)">
            <summary>
            Determines if this dictionary contains a key equal to <paramref name="key"/>. The dictionary
            is not changed. Calls the (overridden) ContainsKey method. If key is not of the correct
            TKey for the dictionary, false is returned.
            </summary>
            <param name="key">The key to search for.</param>
            <returns>True if the dictionary contains key. False if the dictionary does not contain key.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.DictionaryBase`2.System#Collections#IDictionary#Remove(System.Object)">
            <summary>
            Removes the key (and associated value) from the collection that is equal to the passed in key. If
            no key in the dictionary is equal to the passed key, the 
            dictionary is unchanged. Calls the (overridden) Remove method. If key is not of the correct
            TKey for the dictionary, the dictionary is unchanged.
            </summary>
            <param name="key">The key to remove.</param>
            <exception cref="T:System.ArgumentException">key could not be converted to TKey.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.DictionaryBase`2.System#Collections#IDictionary#GetEnumerator">
            <summary>
            Returns an enumerator that enumerates all the entries in the dictionary. Each entry is 
            returned as a DictionaryEntry.
            The entries are enumerated in the same orders as the (overridden) GetEnumerator
            method.
            </summary>
            <returns>An enumerator for enumerating all the elements in the OrderedDictionary.</returns>		
        </member>
        <member name="M:Wintellect.PowerCollections.DictionaryBase`2.System#Collections#IEnumerable#GetEnumerator">
            <summary>
            Returns an enumerator that enumerates all the entries in the dictionary. Each entry is 
            returned as a DictionaryEntry.
            The entries are enumerated in the same orders as the (overridden) GetEnumerator
            method.
            </summary>
            <returns>An enumerator for enumerating all the elements in the OrderedDictionary.</returns>		
        </member>
        <member name="M:Wintellect.PowerCollections.DictionaryBase`2.DebuggerDisplayString">
            <summary>
            Display the contents of the dictionary in the debugger. This is intentionally private, it is called
            only from the debugger due to the presence of the DebuggerDisplay attribute. It is similar
            format to ToString(), but is limited to 250-300 characters or so, so as not to overload the debugger.
            </summary>
            <returns>The string representation of the items in the collection, similar in format to ToString().</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.DictionaryBase`2.Item(`0)">
            <summary>
            The indexer of the dictionary. This is used to store keys and values and
            retrieve values from the dictionary. The setter
            accessor must be overridden in the derived class.
            </summary>
            <param name="key">Key to find in the dictionary.</param>
            <returns>The value associated with the key.</returns>
            <exception cref="T:System.Collections.Generic.KeyNotFoundException">Thrown from the get accessor if the key
            was not found in the dictionary.</exception>
        </member>
        <member name="P:Wintellect.PowerCollections.DictionaryBase`2.Keys">
            <summary>
            Returns a collection of the keys in this dictionary. 
            </summary>
            <value>A read-only collection of the keys in this dictionary.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.DictionaryBase`2.Values">
            <summary>
            Returns a collection of the values in this dictionary. The ordering of 
            values in this collection is the same as that in the Keys collection.
            </summary>
            <value>A read-only collection of the values in this dictionary.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.DictionaryBase`2.System#Collections#IDictionary#IsFixedSize">
            <summary>
            Returns whether this dictionary is fixed size. This implemented always returns false.
            </summary>
            <value>Always returns false.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.DictionaryBase`2.System#Collections#IDictionary#IsReadOnly">
            <summary>
            Returns if this dictionary is read-only. This implementation always returns false.
            </summary>
            <value>Always returns false.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.DictionaryBase`2.System#Collections#IDictionary#Keys">
            <summary>
            Returns a collection of all the keys in the dictionary. The values in this collection will
            be enumerated in the same order as the (overridden) GetEnumerator method.
            </summary>
            <value>The collection of keys.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.DictionaryBase`2.System#Collections#IDictionary#Values">
            <summary>
            Returns a collection of all the values in the dictionary. The values in this collection will
            be enumerated in the same order as the (overridden) GetEnumerator method.
            </summary>
            <value>The collection of values.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.DictionaryBase`2.System#Collections#IDictionary#Item(System.Object)">
            <summary>
            Gets or sets the value associated with a given key. When getting a value, if this
            key is not found in the collection, then null is returned. When setting
            a value, the value replaces any existing value in the dictionary. If either the key or value
            are not of the correct type for this dictionary, an ArgumentException is thrown.
            </summary>
            <value>The value associated with the key, or null if the key was not present.</value>
            <exception cref="T:System.ArgumentException">key could not be converted to TKey, or value could not be converted to TValue.</exception>
        </member>
        <member name="T:Wintellect.PowerCollections.DictionaryBase`2.KeysCollection">
            <summary>
            A private class that implements ICollection&lt;TKey&gt; and ICollection for the
            Keys collection. The collection is read-only.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.ReadOnlyCollectionBase`1">
            <summary>
            ReadOnlyCollectionBase is a base class that can be used to more easily implement the
            generic ICollection&lt;T&gt; and non-generic ICollection interfaces for a read-only collection:
            a collection that does not allow adding or removing elements.
            </summary>
            <remarks>
            <para>To use ReadOnlyCollectionBase as a base class, the derived class must override
            the Count and GetEnumerator methods. </para>
            <para>ICollection&lt;T&gt;.Contains need not be implemented by the
            derived class, but it should be strongly considered, because the ReadOnlyCollectionBase implementation
            may not be very efficient.</para>
            </remarks>
            <typeparam name="T">The item type of the collection.</typeparam>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.#ctor">
            <summary>
            Creates a new ReadOnlyCollectionBase. 
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.MethodModifiesCollection">
            <summary>
            Throws an NotSupportedException stating that this collection cannot be modified.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.ToString">
            <summary>
            Shows the string representation of the collection. The string representation contains
            a list of the items in the collection.
            </summary>
            <returns>The string representation of the collection.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.Exists(System.Predicate{`0})">
            <summary>
            Determines if the collection contains any item that satisfies the condition
            defined by <paramref name="predicate"/>.
            </summary>
            <param name="predicate">A delegate that defines the condition to check for.</param>
            <returns>True if the collection contains one or more items that satisfy the condition
            defined by <paramref name="predicate"/>. False if the collection does not contain
            an item that satisfies <paramref name="predicate"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.TrueForAll(System.Predicate{`0})">
            <summary>
            Determines if all of the items in the collection satisfy the condition
            defined by <paramref name="predicate"/>.
            </summary>
            <param name="predicate">A delegate that defines the condition to check for.</param>
            <returns>True if all of the items in the collection satisfy the condition
            defined by <paramref name="predicate"/>, or if the collection is empty. False if one or more items
            in the collection do not satisfy <paramref name="predicate"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.CountWhere(System.Predicate{`0})">
            <summary>
            Counts the number of items in the collection that satisfy the condition
            defined by <paramref name="predicate"/>.
            </summary>
            <param name="predicate">A delegate that defines the condition to check for.</param>
            <returns>The number of items in the collection that satisfy <paramref name="predicate"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.FindAll(System.Predicate{`0})">
            <summary>
            Enumerates the items in the collection that satisfy the condition defined
            by <paramref name="predicate"/>.
            </summary>
            <param name="predicate">A delegate that defines the condition to check for.</param>
            <returns>An IEnumerable&lt;T&gt; that enumerates the items that satisfy the condition.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.ForEach(System.Action{`0})">
            <summary>
            Performs the specified action on each item in this collection.
            </summary>
            <param name="action">An Action delegate which is invoked for each item in this collection.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.ConvertAll``1(System.Converter{`0,``0})">
            <summary>
            Convert this collection of items by applying a delegate to each item in the collection. The resulting enumeration
            contains the result of applying <paramref name="converter"/> to each item in this collection, in
            order.
            </summary>
            <typeparam name="TOutput">The type each item is being converted to.</typeparam>
            <param name="converter">A delegate to the method to call, passing each item in this collection.</param>
            <returns>An IEnumerable&lt;TOutput^gt; that enumerates the resulting collection from applying <paramref name="converter"/> to each item in this collection in
            order.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="converter"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.System#Collections#Generic#ICollection{T}#Add(`0)">
            <summary>
            This method throws an NotSupportedException
            stating the collection is read-only.
            </summary>
            <param name="item">Item to be added to the collection.</param>
            <exception cref="T:System.NotSupportedException">Always thrown.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.System#Collections#Generic#ICollection{T}#Clear">
            <summary>
            This method throws an NotSupportedException
            stating the collection is read-only.
            </summary>
            <exception cref="T:System.NotSupportedException">Always thrown.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.System#Collections#Generic#ICollection{T}#Remove(`0)">
            <summary>
            This method throws an NotSupportedException
            stating the collection is read-only.
            </summary>
            <param name="item">Item to be removed from the collection.</param>
            <exception cref="T:System.NotSupportedException">Always thrown.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.Contains(`0)">
            <summary>
            Determines if the collection contains a particular item. This default implementation
            iterates all of the items in the collection via GetEnumerator, testing each item
            against <paramref name="item"/> using IComparable&lt;T&gt;.Equals or
            Object.Equals.
            </summary>
            <remarks>You should strongly consider overriding this method to provide
            a more efficient implementation.</remarks>
            <param name="item">The item to check for in the collection.</param>
            <returns>True if the collection contains <paramref name="item"/>, false otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.CopyTo(`0[],System.Int32)">
            <summary>
            Copies all the items in the collection into an array. Implemented by
            using the enumerator returned from GetEnumerator to get all the items
            and copy them to the provided array.
            </summary>
            <param name="array">Array to copy to.</param>
            <param name="arrayIndex">Starting index in <paramref name="array"/> to copy to.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.ToArray">
            <summary>
            Creates an array of the correct size, and copies all the items in the 
            collection into the array, by calling CopyTo.
            </summary>
            <returns>An array containing all the elements in the collection, in order.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.GetEnumerator">
            <summary>
            Must be overridden to enumerate all the members of the collection.
            </summary>
            <returns>A generic IEnumerator&lt;T&gt; that can be used
            to enumerate all the items in the collection.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.System#Collections#ICollection#CopyTo(System.Array,System.Int32)">
            <summary>
            Copies all the items in the collection into an array. Implemented by
            using the enumerator returned from GetEnumerator to get all the items
            and copy them to the provided array.
            </summary>
            <param name="array">Array to copy to.</param>
            <param name="index">Starting index in <paramref name="array"/> to copy to.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.System#Collections#IEnumerable#GetEnumerator">
            <summary>
            Provides an IEnumerator that can be used to iterate all the members of the
            collection. This implementation uses the IEnumerator&lt;T&gt; that was overridden
            by the derived classes to enumerate the members of the collection.
            </summary>
            <returns>An IEnumerator that can be used to iterate the collection.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.DebuggerDisplayString">
            <summary>
            Display the contents of the collection in the debugger. This is intentionally private, it is called
            only from the debugger due to the presence of the DebuggerDisplay attribute. It is similar
            format to ToString(), but is limited to 250-300 characters or so, so as not to overload the debugger.
            </summary>
            <returns>The string representation of the items in the collection, similar in format to ToString().</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.Count">
            <summary>
            Must be overridden to provide the number of items in the collection.
            </summary>
            <value>The number of items in the collection.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.System#Collections#Generic#ICollection{T}#IsReadOnly">
            <summary>
            Indicates whether the collection is read-only. Returns the value
            of readOnly that was provided to the constructor.
            </summary>
            <value>Always true.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.System#Collections#ICollection#IsSynchronized">
            <summary>
            Indicates whether the collection is synchronized.
            </summary>
            <value>Always returns false, indicating that the collection is not synchronized.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyCollectionBase`1.System#Collections#ICollection#SyncRoot">
            <summary>
            Indicates the synchronization object for this collection.
            </summary>
            <value>Always returns this.</value>
        </member>
        <member name="M:Wintellect.PowerCollections.DictionaryBase`2.KeysCollection.#ctor(Wintellect.PowerCollections.DictionaryBase{`0,`1})">
            <summary>
            Constructor.
            </summary>
            <param name="myDictionary">The dictionary this is associated with.</param>
        </member>
        <member name="T:Wintellect.PowerCollections.DictionaryBase`2.ValuesCollection">
            <summary>
            A private class that implements ICollection&lt;TValue&gt; and ICollection for the
            Values collection. The collection is read-only.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.DictionaryBase`2.DictionaryEnumeratorWrapper">
            <summary>
            A class that wraps a IDictionaryEnumerator around an IEnumerator that
            enumerates KeyValuePairs. This is useful in implementing IDictionary, because
            IEnumerator can be implemented with an iterator, but IDictionaryEnumerator cannot.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.DictionaryBase`2.DictionaryEnumeratorWrapper.#ctor(System.Collections.Generic.IEnumerator{System.Collections.Generic.KeyValuePair{`0,`1}})">
            <summary>
            Constructor.
            </summary>
            <param name="enumerator">The enumerator of KeyValuePairs that is being wrapped.</param>
        </member>
        <member name="T:Wintellect.PowerCollections.Hash`1">
             <summary>
             The base implementation for various collections classes that use hash tables
             as part of their implementation. This class should not (and can not) be 
             used directly by end users; it's only for internal use by the collections package. The Hash
             does not handle duplicate values.
             </summary>
             <remarks>
             The Hash manages items of type T, and uses a IComparer&lt;ItemTYpe&gt; that
             hashes compares items to hash items into the table.  
            </remarks>
        </member>
        <member name="M:Wintellect.PowerCollections.Hash`1.#ctor(System.Collections.Generic.IEqualityComparer{`0})">
            <summary>
            Constructor. Create a new hash table.
            </summary>
            <param name="equalityComparer">The comparer to use to compare items. </param>
        </member>
        <member name="M:Wintellect.PowerCollections.Hash`1.GetEnumerationStamp">
            <summary>
            Gets the current enumeration stamp. Call CheckEnumerationStamp later
            with this value to throw an exception if the hash table is changed.
            </summary>
            <returns>The current enumeration stamp.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Hash`1.StopEnumerations">
            <summary>
            Must be called whenever there is a structural change in the tree. Causes
            changeStamp to be changed, which causes any in-progress enumerations
            to throw exceptions.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Hash`1.CheckEnumerationStamp(System.Int32)">
            <summary>
            Checks the given stamp against the current change stamp. If different, the
            collection has changed during enumeration and an InvalidOperationException
            must be thrown
            </summary>
            <param name="startStamp">changeStamp at the start of the enumeration.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Hash`1.GetFullHash(`0)">
            <summary>
            Gets the full hash code for an item.
            </summary>
            <param name="item">Item to get hash code for.</param>
            <returns>The full hash code. It is never zero.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Hash`1.GetHashValuesFromFullHash(System.Int32,System.Int32@,System.Int32@)">
            <summary>
            Get the initial bucket number and skip amount from the full hash value.
            </summary>
            <param name="hash">The full hash value.</param>
            <param name="initialBucket">Returns the initial bucket. Always in the range 0..(totalSlots - 1).</param>
            <param name="skip">Returns the skip values. Always odd in the range 0..(totalSlots - 1).</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Hash`1.GetHashValues(`0,System.Int32@,System.Int32@)">
            <summary>
            Gets the full hash value, initial bucket number, and skip amount for an item.
            </summary>
            <param name="item">Item to get hash value of.</param>
            <param name="initialBucket">Returns the initial bucket. Always in the range 0..(totalSlots - 1).</param>
            <param name="skip">Returns the skip values. Always odd in the range 0..(totalSlots - 1).</param>
            <returns>The full hash value. This is never zero.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Hash`1.EnsureEnoughSlots(System.Int32)">
            <summary>
            Make sure there are enough slots in the hash table that <paramref name="additionalItems"/>
            items can be inserted into the table.
            </summary>
            <param name="additionalItems">Number of additional items we are inserting.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Hash`1.ShrinkIfNeeded">
            <summary>
            Check if the number of items in the table is small enough that
            we should shrink the table again.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Hash`1.GetSecondaryShift(System.Int32)">
            <summary>
            Given the size of a hash table, compute the "secondary shift" value -- the shift
            that is used to determine the skip amount for collision resolution.
            </summary>
            <param name="newSize">The new size of the table.</param>
            <returns>The secondary skip amount.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Hash`1.ResizeTable(System.Int32)">
            <summary>
            Resize the hash table to the given new size, moving all items into the
            new hash table.
            </summary>
            <param name="newSize">The new size of the hash table. Must be a power
            of two.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Hash`1.Insert(`0,System.Boolean,`0@)">
            <summary>
            Insert a new item into the hash table. If a duplicate item exists, can replace or
            do nothing.
            </summary>
            <param name="item">The item to insert.</param>
            <param name="replaceOnDuplicate">If true, duplicate items are replaced. If false, nothing
            is done if a duplicate already exists.</param>
            <param name="previous">If a duplicate was found, returns it (whether replaced or not).</param>
            <returns>True if no duplicate existed, false if a duplicate was found.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Hash`1.Delete(`0,`0@)">
            <summary>
            Deletes an item from the hash table. 
            </summary>
            <param name="item">Item to search for and delete.</param>
            <param name="itemDeleted">If true returned, the actual item stored in the hash table (must be 
            equal to <paramref name="item"/>, but may not be identical.</param>
            <returns>True if item was found and deleted, false if item wasn't found.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Hash`1.Find(`0,System.Boolean,`0@)">
            <summary>
            Find an item in the hash table. If found, optionally replace it with the
            finding item.
            </summary>
            <param name="find">Item to find.</param>
            <param name="replace">If true, replaces the equal item in the hash table
            with <paramref name="item"/>.</param>
            <param name="item">Returns the equal item found in the table, if true was returned.</param>
            <returns>True if the item was found, false otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Hash`1.GetEnumerator">
            <summary>
            Enumerate all of the items in the hash table. The items
            are enumerated in a haphazard, unpredictable order.
            </summary>
            <returns>An IEnumerator&lt;T&gt; that enumerates the items
            in the hash table.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Hash`1.System#Collections#IEnumerable#GetEnumerator">
            <summary>
            Enumerate all of the items in the hash table. The items
            are enumerated in a haphazard, unpredictable order.
            </summary>
            <returns>An IEnumerator that enumerates the items
            in the hash table.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Hash`1.Clone(System.Converter{`0,`0})">
            <summary>
            Creates a clone of this hash table.
            </summary>
            <param name="cloneItem">If non-null, this function is applied to each item when cloning. It must be the 
            case that this function does not modify the hash code or equality function.</param>
            <returns>A shallow clone that contains the same items.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Hash`1.System#Runtime#Serialization#ISerializable#GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Serialize the hash table. Called from the serialization infrastructure.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Hash`1.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Called on deserialization. We cannot deserialize now, because hash codes
            might not be correct now. We do real deserialization in the OnDeserialization call.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Hash`1.System#Runtime#Serialization#IDeserializationCallback#OnDeserialization(System.Object)">
            <summary>
            Deserialize the hash table. Called from the serialization infrastructure when 
            the object graph has finished deserializing.
            </summary>
        </member>
        <member name="P:Wintellect.PowerCollections.Hash`1.ElementCount">
            <summary>
            Get the number of items in the hash table.
            </summary>
            <value>The number of items stored in the hash table.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.Hash`1.SlotCount">
            <summary>
            Get the number of slots in the hash table. Exposed internally
            for testing purposes.
            </summary>
            <value>The number of slots in the hash table.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.Hash`1.LoadFactor">
            <summary>
            Get or change the load factor. Changing the load factor may cause
            the size of the table to grow or shrink accordingly.
            </summary>
            <value></value>
        </member>
        <member name="T:Wintellect.PowerCollections.Hash`1.Slot">
            <summary>
            The structure that has each slot in the hash table. Each slot has three parts:
            1. The collision bit. Indicates whether some item visited this slot but had to
            keep looking because the slot was full. 
            2. 31-bit full hash value of the item. If zero, the slot is empty.
            3. The item itself.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Hash`1.Slot.Clear">
            <summary>
            Clear this slot, leaving the collision bit alone.
            </summary>
        </member>
        <member name="P:Wintellect.PowerCollections.Hash`1.Slot.HashValue">
            <summary>
            The full hash value associated with the value in this slot, or zero
            if the slot is empty.
            </summary>
        </member>
        <member name="P:Wintellect.PowerCollections.Hash`1.Slot.Empty">
            <summary>
            Is this slot empty?
            </summary>
        </member>
        <member name="P:Wintellect.PowerCollections.Hash`1.Slot.Collision">
            <summary>
            The "Collision" bit indicates that some value hit this slot and
            collided, so had to try another slot.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.MultiDictionary`2">
             <summary>
             <para>The MultiDictionary class that associates values with a key. Unlike an Dictionary,
             each key can have multiple values associated with it. When indexing an MultiDictionary, instead
             of a single value associated with a key, you retrieve an enumeration of values.</para>
             <para>When constructed, you can chose to allow the same value to be associated with a key multiple
             times, or only one time. </para>
             </summary>
             <typeparam name="TKey">The type of the keys.</typeparam>
             <typeparam name="TValue">The of values associated with the keys.</typeparam>
            <seealso cref="T:System.Collections.Generic.Dictionary`2"/>
            <seealso cref="T:Wintellect.PowerCollections.OrderedMultiDictionary`2"/>
        </member>
        <member name="T:Wintellect.PowerCollections.MultiDictionaryBase`2">
            <summary>
            MultiDictionaryBase is a base class that can be used to more easily implement a class
            that associates multiple values to a single key. The class implements the generic
            IDictionary&lt;TKey, ICollection&lt;TValue&gt;&gt; interface.
            </summary>
            <remarks>
            <para>To use MultiDictionaryBase as a base class, the derived class must override
            Count, Clear, Add, Remove(TKey), Remove(TKey,TValue), Contains(TKey,TValue), 
            EnumerateKeys, and TryEnumerateValuesForKey. </para>
            <para>It may wish consider overriding CountValues, CountAllValues, ContainsKey,
            and EqualValues, but these are not required.
            </para>
            </remarks>
            <typeparam name="TKey">The key type of the dictionary.</typeparam>
            <typeparam name="TValue">The value type of the dictionary.</typeparam>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.#ctor">
            <summary>
            Creates a new MultiDictionaryBase. 
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.Clear">
            <summary>
            Clears the dictionary. This method must be overridden in the derived class.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.EnumerateKeys">
            <summary>
            Enumerate all the keys in the dictionary. This method must be overridden by a derived
            class.
            </summary>
            <returns>An IEnumerator&lt;TKey&gt; that enumerates all of the keys in the collection that
            have at least one value associated with them.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.TryEnumerateValuesForKey(`0,System.Collections.Generic.IEnumerator{`1}@)">
            <summary>
            Enumerate all of the values associated with a given key. This method must be overridden
            by the derived class. If the key exists and has values associated with it, an enumerator for those
            values is returned throught <paramref name="values"/>. If the key does not exist, false is returned.
            </summary>
            <param name="key">The key to get values for.</param>
            <param name="values">If true is returned, this parameter receives an enumerators that
            enumerates the values associated with that key.</param>
            <returns>True if the key exists and has values associated with it. False otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.Add(System.Collections.Generic.KeyValuePair{`0,System.Collections.Generic.ICollection{`1}})">
            <summary>
            Adds a key-value pair to the collection. The value part of the pair must be a collection
            of values to associate with the key. If values are already associated with the given
            key, the new values are added to the ones associated with that key.
            </summary>
            <param name="item">A KeyValuePair contains the Key and Value collection to add.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.System#Collections#Generic#IDictionary{TKey@System#Collections#Generic#ICollection{TValue}}#Add(`0,System.Collections.Generic.ICollection{`1})">
            <summary>
            Implements IDictionary&lt;TKey, IEnumerable&lt;TValue&gt;&gt;.Add. If the 
            key is already present, and ArgumentException is thrown. Otherwise, a
            new key is added, and new values are associated with that key.
            </summary>
            <param name="key">Key to add.</param>
            <param name="values">Values to associate with that key.</param>
            <exception cref="T:System.ArgumentException">The key is already present in the dictionary.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.AddMany(`0,System.Collections.Generic.IEnumerable{`1})">
            <summary>
            <para>Adds new values to be associated with a key. If duplicate values are permitted, this
            method always adds new key-value pairs to the dictionary.</para>
            <para>If duplicate values are not permitted, and <paramref name="key"/> already has a value
            equal to one of <paramref name="values"/> associated with it, then that value is replaced,
            and the number of values associate with <paramref name="key"/> is unchanged.</para>
            </summary>
            <param name="key">The key to associate with.</param>
            <param name="values">A collection of values to associate with <paramref name="key"/>.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.Add(`0,`1)">
            <summary>
            Adds a new key-value pair to the dictionary.  This method must be overridden in the derived class.
            </summary>
            <param name="key">Key to add.</param>
            <param name="value">Value to associated with the key.</param>
            <exception cref="T:System.ArgumentException">key is already present in the dictionary</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.Remove(`0)">
            <summary>
            Removes a key from the dictionary. This method must be overridden in the derived class.
            </summary>
            <param name="key">Key to remove from the dictionary.</param>
            <returns>True if the key was found, false otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.Remove(`0,`1)">
            <summary>
            Removes a key-value pair from the dictionary. This method must be overridden in the derived class.
            </summary>
            <param name="key">Key to remove from the dictionary.</param>
            <param name="value">Associated value to remove from the dictionary.</param>
            <returns>True if the key-value pair was found, false otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.Remove(System.Collections.Generic.KeyValuePair{`0,System.Collections.Generic.ICollection{`1}})">
            <summary>
            Removes a set of values from a given key. If all values associated with a key are
            removed, then the key is removed also.
            </summary>
            <param name="pair">A KeyValuePair contains a key and a set of values to remove from that key.</param>
            <returns>True if at least one values was found and removed.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.RemoveMany(`0,System.Collections.Generic.IEnumerable{`1})">
            <summary>
            Removes a collection of values from the values associated with a key. If the
            last value is removed from a key, the key is removed also.
            </summary>
            <param name="key">A key to remove values from.</param>
            <param name="values">A collection of values to remove.</param>
            <returns>The number of values that were present and removed. </returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.RemoveMany(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Remove all of the keys (and any associated values) in a collection
            of keys. If a key is not present in the dictionary, nothing happens.
            </summary>
            <param name="keyCollection">A collection of key values to remove.</param>
            <returns>The number of keys from the collection that were present and removed.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.System#Collections#Generic#IDictionary{TKey@System#Collections#Generic#ICollection{TValue}}#TryGetValue(`0,System.Collections.Generic.ICollection{`1}@)">
            <summary>
            Determines if this dictionary contains a key equal to <paramref name="key"/>. If so, all the values
            associated with that key are returned through the values parameter. This method must be
            overridden by the derived class.
            </summary>
            <param name="key">The key to search for.</param>
            <param name="values">Returns all values associated with key, if true was returned.</param>
            <returns>True if the dictionary contains key. False if the dictionary does not contain key.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.ContainsKey(`0)">
            <summary>
            Determines whether a given key is found in the dictionary.
            </summary>
            <remarks>The default implementation simply calls TryEnumerateValuesForKey.
            It may be appropriate to override this method to 
            provide a more efficient implementation.</remarks>
            <param name="key">Key to look for in the dictionary.</param>
            <returns>True if the key is present in the dictionary.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.Contains(`0,`1)">
            <summary>
            Determines if this dictionary contains a key-value pair equal to <paramref name="key"/> and 
            <paramref name="value"/>. The dictionary is not changed. This method must be overridden in the derived class.
            </summary>
            <param name="key">The key to search for.</param>
            <param name="value">The value to search for.</param>
            <returns>True if the dictionary has associated <paramref name="value"/> with <paramref name="key"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.Contains(System.Collections.Generic.KeyValuePair{`0,System.Collections.Generic.ICollection{`1}})">
            <summary>
            Determines if this dictionary contains the given key and all of the values associated with that key..
            </summary>
            <param name="pair">A key and collection of values to search for.</param>
            <returns>True if the dictionary has associated all of the values in <paramref name="pair"/>.Value with <paramref name="pair"/>.Key.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.EqualValues(`1,`1)">
            <summary>
            If the derived class does not use the default comparison for values, this
            methods should be overridden to compare two values for equality. This is
            used for the correct implementation of ICollection.Contains on the Values
            and KeyValuePairs collections.
            </summary>
            <param name="value1">First value to compare.</param>
            <param name="value2">Second value to compare.</param>
            <returns>True if the values are equal.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.CountValues(`0)">
            <summary>
            Gets a count of the number of values associated with a key. The
            default implementation is slow; it enumerators all of the values
            (using TryEnumerateValuesForKey) to count them. A derived class
            may be able to supply a more efficient implementation.
            </summary>
            <param name="key">The key to count values for.</param>
            <returns>The number of values associated with <paramref name="key"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.CountAllValues">
            <summary>
            Gets a total count of values in the collection. This default implementation
            is slow; it enumerates all of the keys in the dictionary and calls CountValues on each.
            A derived class may be able to supply a more efficient implementation.
            </summary>
            <returns>The total number of values associated with all keys in the dictionary.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.Replace(`0,`1)">
            <summary>
            Replaces all values associated with <paramref name="key"/> with the single value <paramref name="value"/>.
            </summary>
            <remarks>This implementation simply calls Remove, followed by Add.</remarks>
            <param name="key">The key to associate with.</param>
            <param name="value">The new values to be associated with <paramref name="key"/>.</param>
            <returns>Returns true if some values were removed. Returns false if <paramref name="key"/> was not
            present in the dictionary before Replace was called.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.ReplaceMany(`0,System.Collections.Generic.IEnumerable{`1})">
            <summary>
            Replaces all values associated with <paramref name="key"/> with a new collection
            of values. If the collection does not permit duplicate values, and <paramref name="values"/> has duplicate
            items, then only the last of duplicates is added.
            </summary>
            <param name="key">The key to associate with.</param>
            <param name="values">The new values to be associated with <paramref name="key"/>.</param>
            <returns>Returns true if some values were removed. Returns false if <paramref name="key"/> was not
            present in the dictionary before Replace was called.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.ToString">
            <summary>
            Shows the string representation of the dictionary. The string representation contains
            a list of the mappings in the dictionary.
            </summary>
            <returns>The string representation of the dictionary.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.DebuggerDisplayString">
            <summary>
            Display the contents of the dictionary in the debugger. This is intentionally private, it is called
            only from the debugger due to the presence of the DebuggerDisplay attribute. It is similar
            format to ToString(), but is limited to 250-300 characters or so, so as not to overload the debugger.
            </summary>
            <returns>The string representation of the items in the collection, similar in format to ToString().</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.GetEnumerator">
            <summary>
            Enumerate all the keys in the dictionary, and for each key, the collection of values for that key.
            </summary>
            <returns>An enumerator to enumerate all the key, ICollection&lt;value&gt; pairs in the dictionary.</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.MultiDictionaryBase`2.Count">
            <summary>
            Gets the number of keys in the dictionary. This property must be overridden
            in the derived class.
            </summary>
        </member>
        <member name="P:Wintellect.PowerCollections.MultiDictionaryBase`2.Keys">
            <summary>
            Gets a read-only collection all the keys in this dictionary.
            </summary>
            <value>An readonly ICollection&lt;TKey&gt; of all the keys in this dictionary.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.MultiDictionaryBase`2.Values">
            <summary>
            Gets a read-only collection of all the values in the dictionary. 
            </summary>
            <returns>A read-only ICollection&lt;TValue&gt; of all the values in the dictionary.</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.MultiDictionaryBase`2.System#Collections#Generic#IDictionary{TKey@System#Collections#Generic#ICollection{TValue}}#Values">
            <summary>
            Gets a read-only collection of all the value collections in the dictionary. 
            </summary>
            <returns>A read-only ICollection&lt;IEnumerable&lt;TValue&gt;&gt; of all the values in the dictionary.</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.MultiDictionaryBase`2.KeyValuePairs">
            <summary>
            Gets a read-only collection of all key-value pairs in the dictionary. If a key has multiple
            values associated with it, then a key-value pair is present for each value associated
            with the key.
            </summary>
        </member>
        <member name="P:Wintellect.PowerCollections.MultiDictionaryBase`2.Item(`0)">
            <summary>
            Returns a collection of all of the values in the dictionary associated with <paramref name="key"/>,
            or changes the set of values associated with <paramref name="key"/>.
            If the key is not present in the dictionary, an ICollection enumerating no
            values is returned. The returned collection of values is read-write, and can be used to 
            modify the collection of values associated with the key.
            </summary>
            <param name="key">The key to get the values associated with.</param>
            <value>An ICollection&lt;TValue&gt; with all the values associated with <paramref name="key"/>.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.MultiDictionaryBase`2.System#Collections#Generic#IDictionary{TKey@System#Collections#Generic#ICollection{TValue}}#Item(`0)">
            <summary>
            Gets a collection of all the values in the dictionary associated with <paramref name="key"/>,
            or changes the set of values associated with <paramref name="key"/>.
            If the key is not present in the dictionary, a KeyNotFound exception is thrown.
            </summary>
            <param name="key">The key to get the values associated with.</param>
            <value>An IEnumerable&lt;TValue&gt; that enumerates all the values associated with <paramref name="key"/>.</value>
            <exception cref="T:System.Collections.Generic.KeyNotFoundException">The given key is not present in the dictionary.</exception>
        </member>
        <member name="T:Wintellect.PowerCollections.MultiDictionaryBase`2.ValuesForKeyCollection">
            <summary>
            A private class that provides the ICollection&lt;TValue&gt; for a particular key. This is the collection
            that is returned from the indexer. The collections is read-write, live, and can be used to add, remove,
            etc. values from the multi-dictionary.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.ValuesForKeyCollection.#ctor(Wintellect.PowerCollections.MultiDictionaryBase{`0,`1},`0)">
            <summary>
            Constructor. Initializes this collection.
            </summary>
            <param name="myDictionary">Dictionary we're using.</param>
            <param name="key">The key we're looking at.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.ValuesForKeyCollection.Clear">
            <summary>
            Remove the key and all values associated with it.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.ValuesForKeyCollection.Add(`1)">
            <summary>
            Add a new values to this key.
            </summary>
            <param name="item">New values to add.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.ValuesForKeyCollection.Remove(`1)">
            <summary>
            Remove a value currently associated with key.
            </summary>
            <param name="item">Value to remove.</param>
            <returns>True if item was assocaited with key, false otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.ValuesForKeyCollection.NoValues">
            <summary>
            A simple function that returns an IEnumerator&lt;TValue&gt; that
            doesn't yield any values. A helper.
            </summary>
            <returns>An IEnumerator&lt;TValue&gt; that yields no values.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.ValuesForKeyCollection.GetEnumerator">
            <summary>
            Enumerate all the values associated with key.
            </summary>
            <returns>An IEnumerator&lt;TValue&gt; that enumerates all the values associated with key.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.ValuesForKeyCollection.Contains(`1)">
            <summary>
            Determines if the given values is associated with key.
            </summary>
            <param name="item">Value to check for.</param>
            <returns>True if value is associated with key, false otherwise.</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.MultiDictionaryBase`2.ValuesForKeyCollection.Count">
            <summary>
            Get the number of values associated with the key.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.MultiDictionaryBase`2.KeysCollection">
            <summary>
            A private class that implements ICollection&lt;TKey&gt; and ICollection for the
            Keys collection. The collection is read-only.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionaryBase`2.KeysCollection.#ctor(Wintellect.PowerCollections.MultiDictionaryBase{`0,`1})">
            <summary>
            Constructor.
            </summary>
            <param name="myDictionary">The dictionary this is associated with.</param>
        </member>
        <member name="T:Wintellect.PowerCollections.MultiDictionaryBase`2.ValuesCollection">
            <summary>
            A private class that implements ICollection&lt;TValue&gt; and ICollection for the
            Values collection. The collection is read-only.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.MultiDictionaryBase`2.EnumerableValuesCollection">
            <summary>
            A private class that implements ICollection&lt;ICollection&lt;TValue&gt;&gt; and ICollection for the
            Values collection on IDictionary. The collection is read-only.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.MultiDictionaryBase`2.KeyValuePairsCollection">
            <summary>
            A private class that implements ICollection&lt;KeyValuePair&lt;TKey,TValue&gt;&gt; and ICollection for the
            KeyValuePairs collection. The collection is read-only.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionary`2.#ctor(System.Boolean)">
            <summary>
            Create a new MultiDictionary. The default ordering of keys and values are used. If duplicate values
            are allowed, multiple copies of the same value can be associated with the same key. For example, the key "foo"
            could have "a", "a", and "b" associated with it. If duplicate values are not allowed, only one copies of a given value can
            be associated with the same key, although different keys can have the same value. For example, the key "foo" could
            have "a" and "b" associated with it, which key "bar" has values "b" and "c" associated with it.
            </summary>
            <remarks>The default ordering of keys and values will be used, as defined by TKey and TValue's implementation
            of IComparable&lt;T&gt; (or IComparable if IComparable&lt;T&gt; is not implemented). If a different ordering should be
            used, other constructors allow a custom Comparer or IComparer to be passed to changed the ordering.</remarks>
            <param name="allowDuplicateValues">Can the same value be associated with a key multiple times?</param>
            <exception cref="T:System.InvalidOperationException">TKey or TValue does not implement either IComparable&lt;T&gt; or IComparable.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionary`2.#ctor(System.Boolean,System.Collections.Generic.IEqualityComparer{`0})">
            <summary>
            Create a new MultiDictionary. If duplicate values
            are allowed, multiple copies of the same value can be associated with the same key. For example, the key "foo"
            could have "a", "a", and "b" associated with it. If duplicate values are not allowed, only one copies of a given value can
            be associated with the same key, although different keys can have the same value. For example, the key "foo" could
            have "a" and "b" associated with it, which key "bar" has values "b" and "c" associated with it.
            </summary>
            <param name="allowDuplicateValues">Can the same value be associated with a key multiple times?</param>
            <param name="keyEqualityComparer">An IEqualityComparer&lt;TKey&gt; instance that will be used to compare keys.</param>
            <exception cref="T:System.InvalidOperationException">TValue does not implement either IComparable&lt;TValue&gt; or IComparable.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionary`2.#ctor(System.Boolean,System.Collections.Generic.IEqualityComparer{`0},System.Collections.Generic.IEqualityComparer{`1})">
            <summary>
            Create a new MultiDictionary. If duplicate values
            are allowed, multiple copies of the same value can be associated with the same key. For example, the key "foo"
            could have "a", "a", and "b" associated with it. If duplicate values are not allowed, only one copies of a given value can
            be associated with the same key, although different keys can have the same value. For example, the key "foo" could
            have "a" and "b" associated with it, which key "bar" has values "b" and "c" associated with it.
            </summary>
            <param name="allowDuplicateValues">Can the same value be associated with a key multiple times?</param>
            <param name="keyEqualityComparer">An IEqualityComparer&lt;TKey&gt; instance that will be used to compare keys.</param>
            <param name="valueEqualityComparer">An IEqualityComparer&lt;TValue&gt; instance that will be used to compare values.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionary`2.#ctor(System.Boolean,System.Collections.Generic.IEqualityComparer{`0},System.Collections.Generic.IEqualityComparer{`1},System.Collections.Generic.IEqualityComparer{Wintellect.PowerCollections.MultiDictionary{`0,`1}.KeyAndValues},Wintellect.PowerCollections.Hash{Wintellect.PowerCollections.MultiDictionary{`0,`1}.KeyAndValues})">
            <summary>
            Create a new MultiDictionary. Private constructor, for use by Clone().
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionary`2.Add(`0,`1)">
            <summary>
            <para>Adds a new value to be associated with a key. If duplicate values are permitted, this
            method always adds a new key-value pair to the dictionary.</para>
            <para>If duplicate values are not permitted, and <paramref name="key"/> already has a value
            equal to <paramref name="value"/> associated with it, then that value is replaced with <paramref name="value"/>,
            and the number of values associate with <paramref name="key"/> is unchanged.</para>
            </summary>
            <param name="key">The key to associate with.</param>
            <param name="value">The value to associated with <paramref name="key"/>.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionary`2.Remove(`0,`1)">
            <summary>
            Removes a given value from the values associated with a key. If the
            last value is removed from a key, the key is removed also.
            </summary>
            <param name="key">A key to remove a value from.</param>
            <param name="value">The value to remove.</param>
            <returns>True if <paramref name="value"/> was associated with <paramref name="key"/> (and was
            therefore removed). False if <paramref name="value"/> was not associated with <paramref name="key"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionary`2.Remove(`0)">
            <summary>
            Removes a key and all associated values from the dictionary. If the
            key is not present in the dictionary, it is unchanged and false is returned.
            </summary>
            <param name="key">The key to remove.</param>
            <returns>True if the key was present and was removed. Returns 
            false if the key was not present.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionary`2.Clear">
            <summary>
            Removes all keys and values from the dictionary.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionary`2.EqualValues(`1,`1)">
            <summary>
            Determine if two values are equal.
            </summary>
            <param name="value1">First value to compare.</param>
            <param name="value2">Second value to compare.</param>
            <returns>True if the values are equal.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionary`2.Contains(`0,`1)">
            <summary>
            Checks to see if <paramref name="value"/> is associated with <paramref name="key"/>
            in the dictionary.
            </summary>
            <param name="key">The key to check.</param>
            <param name="value">The value to check.</param>
            <returns>True if <paramref name="value"/> is associated with <paramref name="key"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionary`2.ContainsKey(`0)">
            <summary>
            Checks to see if the key is present in the dictionary and has
            at least one value associated with it.
            </summary>
            <param name="key">The key to check.</param>
            <returns>True if <paramref name="key"/> is present and has at least
            one value associated with it. Returns false otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionary`2.EnumerateKeys">
            <summary>
            Enumerate all the keys in the dictionary. 
            </summary>
            <returns>An IEnumerator&lt;TKey&gt; that enumerates all of the keys in the dictionary that
            have at least one value associated with them.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionary`2.EnumerateValues(Wintellect.PowerCollections.MultiDictionary{`0,`1}.KeyAndValues)">
            <summary>
             Enumerate the values in the a KeyAndValues structure. Can't return
            the array directly because:
              a) The array might be larger than the count.
              b) We can't allow clients to down-cast to the array and modify it.
              c) We have to abort enumeration if the hash changes.
            </summary>
            <param name="keyAndValues">Item with the values to enumerate..</param>
            <returns>An enumerable that enumerates the items in the KeyAndValues structure.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionary`2.TryEnumerateValuesForKey(`0,System.Collections.Generic.IEnumerator{`1}@)">
            <summary>
            Determines if this dictionary contains a key equal to <paramref name="key"/>. If so, all the values
            associated with that key are returned through the values parameter. 
            </summary>
            <param name="key">The key to search for.</param>
            <param name="values">Returns all values associated with key, if true was returned.</param>
            <returns>True if the dictionary contains key. False if the dictionary does not contain key.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionary`2.CountValues(`0)">
            <summary>
            Gets the number of values associated with a given key.
            </summary>
            <param name="key">The key to count values of.</param>
            <returns>The number of values associated with <paramref name="key"/>. If <paramref name="key"/>
            is not present in the dictionary, zero is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionary`2.Clone">
            <summary>
            Makes a shallow clone of this dictionary; i.e., if keys or values of the
            dictionary are reference types, then they are not cloned. If TKey or TValue is a value type,
            then each element is copied as if by simple assignment.
            </summary>
            <remarks>Cloning the dictionary takes time O(N), where N is the number of key-value pairs in the dictionary.</remarks>
            <returns>The cloned dictionary.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionary`2.System#ICloneable#Clone">
            <summary>
            Implements ICloneable.Clone. Makes a shallow clone of this dictionary; i.e., if keys or values are reference types, then they are not cloned.
            </summary>
            <returns>The cloned dictionary.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionary`2.NonCloneableType(System.Type)">
            <summary>
            Throw an InvalidOperationException indicating that this type is not cloneable.
            </summary>
            <param name="t">Type to test.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionary`2.CloneContents">
            <summary>
            Makes a deep clone of this dictionary. A new dictionary is created with a clone of
            each entry of this dictionary, by calling ICloneable.Clone on each element. If TKey or TValue is
            a value type, then each element is copied as if by simple assignment.
            </summary>
            <remarks><para>If TKey or TValue is a reference type, it must implement
            ICloneable. Otherwise, an InvalidOperationException is thrown.</para>
            <para>Cloning the dictionary takes time O(N log N), where N is the number of key-value pairs in the dictionary.</para></remarks>
            <returns>The cloned dictionary.</returns>
            <exception cref="T:System.InvalidOperationException">TKey or TValue is a reference type that does not implement ICloneable.</exception>
        </member>
        <member name="P:Wintellect.PowerCollections.MultiDictionary`2.KeyComparer">
            <summary>
            Returns the IEqualityComparer&lt;T&gt; used to compare keys in this dictionary. 
            </summary>
            <value>If the dictionary was created using a comparer, that comparer is returned. Otherwise
            the default comparer for TKey (EqualityComparer&lt;TKey&gt;.Default) is returned.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.MultiDictionary`2.ValueComparer">
            <summary>
            Returns the IEqualityComparer&lt;T&gt; used to compare values in this dictionary. 
            </summary>
            <value>If the dictionary was created using a comparer, that comparer is returned. Otherwise
            the default comparer for TValue (EqualityComparer&lt;TValue&gt;.Default) is returned.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.MultiDictionary`2.Count">
            <summary>
            Gets the number of key-value pairs in the dictionary. Each value associated
            with a given key is counted. If duplicate values are permitted, each duplicate
            value is included in the count.
            </summary>
            <value>The number of key-value pairs in the dictionary.</value>
        </member>
        <member name="T:Wintellect.PowerCollections.MultiDictionary`2.KeyAndValues">
            <summary>
            A structure to hold the key and the values associated with the key.
            The number of values must always be 1 or greater in a version that is stored, but 
            can be zero in a dummy version used only for lookups.
            </summary>
        </member>
        <member name="F:Wintellect.PowerCollections.MultiDictionary`2.KeyAndValues.Key">
            <summary>
            The key.
            </summary>
        </member>
        <member name="F:Wintellect.PowerCollections.MultiDictionary`2.KeyAndValues.Count">
            <summary>
            The number of values. Always at least 1 except in a dummy version for lookups.
            </summary>
        </member>
        <member name="F:Wintellect.PowerCollections.MultiDictionary`2.KeyAndValues.Values">
            <summary>
            An array of values. 
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionary`2.KeyAndValues.#ctor(`0)">
            <summary>
            Create a dummy KeyAndValues with just the key, for lookups.
            </summary>
            <param name="key">The key to use.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.MultiDictionary`2.KeyAndValues.Copy(Wintellect.PowerCollections.MultiDictionary{`0,`1}.KeyAndValues)">
            <summary>
            Make a copy of a KeyAndValues, copying the array.
            </summary>
            <param name="x">KeyAndValues to copy.</param>
            <returns>A copied version.</returns>
        </member>
        <member name="T:Wintellect.PowerCollections.MultiDictionary`2.KeyAndValuesEqualityComparer">
            <summary>
            This class implements IEqualityComparer for KeysAndValues, allowing them to be
            compared by their keys. An IEqualityComparer on keys is required.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.OrderedBag`1">
             <summary>
             OrderedBag&lt;T&gt; is a collection that contains items of type T. 
             The item are maintained in a sorted order. Unlike a OrderedSet, duplicate items (items that
             compare equal to each other) are allows in an OrderedBag.
             </summary>
             <remarks>
             <p>The items are compared in one of three ways. If T implements IComparable&lt;TKey&gt; or IComparable,
             then the CompareTo method of that interface will be used to compare items. Alternatively, a comparison
             function can be passed in either as a delegate, or as an instance of IComparer&lt;TKey&gt;.</p>
             <p>OrderedBag is implemented as a balanced binary tree. Inserting, deleting, and looking up an
             an element all are done in log(N) + M time, where N is the number of keys in the tree, and M is the current number
             of copies of the element being handled.</p>
             <p><see cref="T:Wintellect.PowerCollections.Bag`1"/> is similar, but uses hashing instead of comparison, and does not maintain
             the keys in sorted order.</p>
            </remarks>
            <seealso cref="T:Wintellect.PowerCollections.Bag`1"/>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.#ctor">
             <summary>
             Creates a new OrderedBag. The T must implement IComparable&lt;T&gt;
             or IComparable. 
             The CompareTo method of this interface will be used to compare items in this bag.
             </summary>
            <remarks>
             Items that are null are permitted, and will be sorted before all other items.
            </remarks>
             <exception cref="T:System.InvalidOperationException">T does not implement IComparable&lt;TKey&gt;.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.#ctor(System.Comparison{`0})">
            <summary>
            Creates a new OrderedBag. The passed delegate will be used to compare items in this bag.
            </summary>
            <param name="comparison">A delegate to a method that will be used to compare items.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.#ctor(System.Collections.Generic.IComparer{`0})">
            <summary>
            Creates a new OrderedBag. The Compare method of the passed comparison object
            will be used to compare items in this bag.
            </summary>
            <remarks>
            The GetHashCode and Equals methods of the provided IComparer&lt;T&gt; will never
            be called, and need not be implemented.
            </remarks>
            <param name="comparer">An instance of IComparer&lt;T&gt; that will be used to compare items.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.#ctor(System.Collections.Generic.IEnumerable{`0})">
             <summary>
             Creates a new OrderedBag. The T must implement IComparable&lt;T&gt;
             or IComparable. 
             The CompareTo method of this interface will be used to compare items in this bag. The bag is
             initialized with all the items in the given collection.
             </summary>
            <remarks>
             Items that are null are permitted, and will be sorted before all other items.
            </remarks>
             <param name="collection">A collection with items to be placed into the OrderedBag.</param>
             <exception cref="T:System.InvalidOperationException">T does not implement IComparable&lt;TKey&gt;.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.#ctor(System.Collections.Generic.IEnumerable{`0},System.Comparison{`0})">
            <summary>
            Creates a new OrderedBag. The passed delegate will be used to compare items in this bag.
            The bag is initialized with all the items in the given collection.
            </summary>
            <param name="collection">A collection with items to be placed into the OrderedBag.</param>
            <param name="comparison">A delegate to a method that will be used to compare items.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.#ctor(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IComparer{`0})">
            <summary>
            Creates a new OrderedBag. The Compare method of the passed comparison object
            will be used to compare items in this bag. The bag is
            initialized with all the items in the given collection.
            </summary>
            <remarks>
            The GetHashCode and Equals methods of the provided IComparer&lt;T&gt; will never
            be called, and need not be implemented.
            </remarks>
            <param name="collection">A collection with items to be placed into the OrderedBag.</param>
            <param name="comparer">An instance of IComparer&lt;T&gt; that will be used to compare items.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.#ctor(System.Collections.Generic.IComparer{`0},Wintellect.PowerCollections.RedBlackTree{`0})">
            <summary>
            Creates a new OrderedBag given a comparer and a tree that contains the data. Used
            internally for Clone.
            </summary>
            <param name="comparer">Comparer for the bag.</param>
            <param name="tree">Data for the bag.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.System#ICloneable#Clone">
            <summary>
            Makes a shallow clone of this bag; i.e., if items of the
            bag are reference types, then they are not cloned. If T is a value type,
            then each element is copied as if by simple assignment.
            </summary>
            <remarks>Cloning the bag takes time O(N), where N is the number of items in the bag.</remarks>
            <returns>The cloned bag.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.Clone">
            <summary>
            Makes a shallow clone of this bag; i.e., if items of the
            bag are reference types, then they are not cloned. If T is a value type,
            then each element is copied as if by simple assignment.
            </summary>
            <remarks>Cloning the bag takes time O(N), where N is the number of items in the bag.</remarks>
            <returns>The cloned bag.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.CloneContents">
            <summary>
            Makes a deep clone of this bag. A new bag is created with a clone of
            each element of this bag, by calling ICloneable.Clone on each element. If T is
            a value type, then each element is copied as if by simple assignment.
            </summary>
            <remarks><para>If T is a reference type, it must implement
            ICloneable. Otherwise, an InvalidOperationException is thrown.</para>
            <para>Cloning the bag takes time O(N log N), where N is the number of items in the bag.</para></remarks>
            <returns>The cloned bag.</returns>
            <exception cref="T:System.InvalidOperationException">T is a reference type that does not implement ICloneable.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.NumberOfCopies(`0)">
            <summary>
            Returns the number of copies of <paramref name="item"/> in the bag. More precisely, returns
            the number of items in the bag that compare equal to <paramref name="item"/>.
            </summary>
            <remarks>NumberOfCopies() takes time O(log N + M), where N is the total number of items in the
            bag, and M is the number of copies of <paramref name="item"/> in the bag.</remarks>
            <param name="item">The item to search for in the bag.</param>
            <returns>The number of items in the bag that compare equal to <paramref name="item"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.GetEnumerator">
            <summary>
            Returns an enumerator that enumerates all the items in the bag. 
            The items are enumerated in sorted order.
            </summary>
            <remarks>
            <p>Typically, this method is not called directly. Instead the "foreach" statement is used
            to enumerate the items, which uses this method implicitly.</p>
            <p>If an item is added to or deleted from the bag while it is being enumerated, then 
            the enumeration will end with an InvalidOperationException.</p>
            <p>Enumeration all the items in the bag takes time O(N), where N is the number
            of items in the bag.</p>
            </remarks>
            <returns>An enumerator for enumerating all the items in the OrderedBag.</returns>		
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.Contains(`0)">
            <summary>
            Determines if this bag contains an item equal to <paramref name="item"/>. The bag
            is not changed.
            </summary>
            <remarks>Searching the bag for an item takes time O(log N), where N is the number of items in the bag.</remarks>
            <param name="item">The item to search for.</param>
            <returns>True if the bag contains <paramref name="item"/>. False if the bag does not contain <paramref name="item"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.GetEqualItems(`0)">
            <summary>
            <para>Enumerates all of the items in this bag that are equal to <paramref name="item"/>, according to the 
            comparison mechanism that was used when the bag was created. The bag
            is not changed.</para>
            <para>If the bag does contain an item equal to <paramref name="item"/>, then the enumeration contains
            no items.</para>
            </summary>
            <remarks>Enumeration the items in the bag equal to <paramref name="item"/> takes time O(log N + M), where N 
            is the total number of items in the bag, and M is the number of items equal to <paramref name="item"/>.</remarks>
            <param name="item">The item to search for.</param>
            <returns>An IEnumerable&lt;T&gt; that enumerates all the items in the bag equal to <paramref name="item"/>. </returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.DistinctItems">
            <summary>
            Enumerates all the items in the bag, but enumerates equal items
            just once, even if they occur multiple times in the bag.
            </summary>
            <remarks>If the bag is changed while items are being enumerated, the
            enumeration will terminate with an InvalidOperationException.</remarks>
            <returns>An IEnumerable&lt;T&gt; that enumerates the unique items.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.LastIndexOf(`0)">
            <summary>
            Get the index of the given item in the sorted order. The smallest item has index 0,
            the next smallest item has index 1, and the largest item has index Count-1. If multiple
            equal items exist, the largest index of the equal items is returned.
            </summary>
            <remarks>Finding the index takes time O(log N), which N is the number of items in 
            the set.</remarks>
            <param name="item">The item to get the index of.</param>
            <returns>The index of the last item in the sorted bag equal to <paramref name="item"/>, or -1 if the item is not present
            in the set.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.IndexOf(`0)">
            <summary>
            Get the index of the given item in the sorted order. The smallest item has index 0,
            the next smallest item has index 1, and the largest item has index Count-1. If multiple
            equal items exist, the smallest index of the equal items is returned.
            </summary>
            <remarks>Finding the index takes time O(log N), which N is the number of items in 
            the set.</remarks>
            <param name="item">The item to get the index of.</param>
            <returns>The index of the first item in the sorted bag equal to <paramref name="item"/>, or -1 if the item is not present
            in the set.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.Add(`0)">
            <summary>
            Adds a new item to the bag. Since bags can contain duplicate items, the item 
            is added even if the bag already contains an item equal to <paramref name="item"/>. In
            this case, the new item is placed after all equal items already present in the bag.
            </summary>
            <remarks>
            <para>Adding an item takes time O(log N), where N is the number of items in the bag.</para></remarks>
            <param name="item">The item to add to the bag.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.AddMany(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Adds all the items in <paramref name="collection"/> to the bag. 
            </summary>
            <remarks>
            <para>Adding the collection takes time O(M log N), where N is the number of items in the bag, and M is the 
            number of items in <paramref name="collection"/>.</para></remarks>
            <param name="collection">A collection of items to add to the bag.</param>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.Remove(`0)">
            <summary>
            Searches the bag for one item equal to <paramref name="item"/>, and if found,
            removes it from the bag. If not found, the bag is unchanged. If more than one item
            equal to <paramref name="item"/>, the item that was last inserted is removed.
            </summary>
            <remarks>
            <para>Equality between items is determined by the comparison instance or delegate used
            to create the bag.</para>
            <para>Removing an item from the bag takes time O(log N), where N is the number of items in the bag.</para></remarks>
            <param name="item">The item to remove.</param>
            <returns>True if <paramref name="item"/> was found and removed. False if <paramref name="item"/> was not in the bag.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.RemoveAllCopies(`0)">
            <summary>
            Searches the bag for all items equal to <paramref name="item"/>, and 
            removes all of them from the bag. If not found, the bag is unchanged.
            </summary>
            <remarks>
            <para>Equality between items is determined by the comparison instance or delegate used
            to create the bag.</para>
            <para>RemoveAllCopies() takes time O(M log N), where N is the total number of items in the bag, and M is
            the number of items equal to <paramref name="item"/>.</para></remarks>
            <param name="item">The item to remove.</param>
            <returns>The number of copies of <paramref name="item"/> that were found and removed. </returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.RemoveMany(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Removes all the items in <paramref name="collection"/> from the bag. Items not
            present in the bag are ignored.
            </summary>
            <remarks>
            <para>Equality between items is determined by the comparison instance or delegate used
            to create the bag.</para>
            <para>Removing the collection takes time O(M log N), where N is the number of items in the bag, and M is the 
            number of items in <paramref name="collection"/>.</para></remarks>
            <param name="collection">A collection of items to remove from the bag.</param>
            <returns>The number of items removed from the bag.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.Clear">
            <summary>
            Removes all items from the bag.
            </summary>
            <remarks>Clearing the bag takes a constant amount of time, regardless of the number of items in it.</remarks>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.CheckEmpty">
            <summary>
            If the collection is empty, throw an invalid operation exception.
            </summary>
            <exception cref="T:System.InvalidOperationException">The bag is empty.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.GetFirst">
            <summary>
            Returns the first item in the bag: the item
            that would appear first if the bag was enumerated. This is also
            the smallest item in the bag.
            </summary>
            <remarks>GetFirst() takes time O(log N), where N is the number of items in the bag.</remarks>
            <returns>The first item in the bag. If more than one item
            is smallest, the first one added is returned.</returns>
            <exception cref="T:System.InvalidOperationException">The bag is empty.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.GetLast">
            <summary>
            Returns the last item in the bag: the item
            that would appear last if the bag was enumerated. This is also the largest
            item in the bag.
            </summary>
            <remarks>GetLast() takes time O(log N), where N is the number of items in the bag.</remarks>
            <returns>The last item in the bag. If more than one item
            is largest, the last one added is returned.</returns>
            <exception cref="T:System.InvalidOperationException">The bag is empty.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.RemoveFirst">
            <summary>
            Removes the first item in the bag. This is also the smallest
            item in the bag.
            </summary>
            <remarks>RemoveFirst() takes time O(log N), where N is the number of items in the bag.</remarks>
            <returns>The item that was removed, which was the smallest item in the bag. </returns>
            <exception cref="T:System.InvalidOperationException">The bag is empty.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.RemoveLast">
            <summary>
            Removes the last item in the bag. This is also the largest item in the bag.
            </summary>
            <remarks>RemoveLast() takes time O(log N), where N is the number of items in the bag.</remarks>
            <returns>The item that was removed, which was the largest item in the bag. </returns>
            <exception cref="T:System.InvalidOperationException">The bag is empty.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.CheckConsistentComparison(Wintellect.PowerCollections.OrderedBag{`0})">
            <summary>
            Check that this bag and another bag were created with the same comparison
            mechanism. Throws exception if not compatible.
            </summary>
            <param name="otherBag">Other bag to check comparision mechanism.</param>
            <exception cref="T:System.InvalidOperationException">If otherBag and this bag don't use the same method for comparing items.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="otherBag"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.IsSupersetOf(Wintellect.PowerCollections.OrderedBag{`0})">
            <summary>
            Determines if this bag is a superset of another bag. Neither bag is modified.
            This bag is a superset of <paramref name="otherBag"/> if every element in
            <paramref name="otherBag"/> is also in this bag, at least the same number of
            times.
            </summary>
            <remarks>IsSupersetOf is computed in time O(M log N), where M is the size of the 
            <paramref name="otherSet"/>, and N is the size of the this set.</remarks>
            <param name="otherBag">OrderedBag to compare to.</param>
            <returns>True if this is a superset of <paramref name="otherBag"/>.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="otherBag"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.IsProperSupersetOf(Wintellect.PowerCollections.OrderedBag{`0})">
            <summary>
            Determines if this bag is a proper superset of another bag. Neither bag is modified.
            This bag is a proper superset of <paramref name="otherBag"/> if every element in
            <paramref name="otherBag"/> is also in this bag, at least the same number of
            times. Additional, this bag must have strictly more items than <paramref name="otherBag"/>.
            </summary>
            <remarks>IsProperSupersetOf is computed in time O(M log N), where M is the number of unique items in 
            <paramref name="otherBag"/>.</remarks>
            <param name="otherBag">OrderedBag to compare to.</param>
            <returns>True if this is a proper superset of <paramref name="otherBag"/>.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="otherBag"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.IsSubsetOf(Wintellect.PowerCollections.OrderedBag{`0})">
            <summary>
            Determines if this bag is a subset of another bag. Neither bag is modified.
            This bag is a subset of <paramref name="otherBag"/> if every element in this bag
            is also in <paramref name="otherBag"/>, at least the same number of
            times.
            </summary>
            <remarks>IsSubsetOf is computed in time O(N log M), where M is the size of the 
            <paramref name="otherBag"/>, and N is the size of the this bag.</remarks>
            <param name="otherBag">OrderedBag to compare to.</param>
            <returns>True if this is a subset of <paramref name="otherBag"/>.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="otherBag"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.IsProperSubsetOf(Wintellect.PowerCollections.OrderedBag{`0})">
            <summary>
            Determines if this bag is a proper subset of another bag. Neither bag is modified.
            This bag is a subset of <paramref name="otherBag"/> if every element in this bag
            is also in <paramref name="otherBag"/>, at least the same number of
            times. Additional, this bag must have strictly fewer items than <paramref name="otherBag"/>.
            </summary>
            <remarks>IsSubsetOf is computed in time O(N log M), where M is the size of the 
            <paramref nameb="otherBag"/>, and N is the size of the this bag.</remarks>
            <param name="otherBag">OrderedBag to compare to.</param>
            <returns>True if this is a proper subset of <paramref name="otherBag"/>.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="otherBag"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.IsDisjointFrom(Wintellect.PowerCollections.OrderedBag{`0})">
            <summary>
            Determines if this bag is disjoint from another bag. Two bags are disjoint
            if no item from one set is equal to any item in the other bag.
            </summary>
            <remarks>
            <para>The answer is computed in time O(N), where N is the size of the smaller set.</para>
            </remarks>
            <param name="otherBag">Bag to check disjointness with.</param>
            <returns>True if the two bags are disjoint, false otherwise.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.IsEqualTo(Wintellect.PowerCollections.OrderedBag{`0})">
            <summary>
            Determines if this bag is equal to another bag. This bag is equal to
            <paramref name="otherBag"/> if they contain the same items, each the
            same number of times.
            </summary>
            <remarks>IsEqualTo is computed in time O(N), where N is the number of items in 
            this bag.</remarks>
            <param name="otherBag">OrderedBag to compare to</param>
            <returns>True if this bag is equal to <paramref name="otherBag"/>, false otherwise.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.UnionWith(Wintellect.PowerCollections.OrderedBag{`0})">
            <summary>
            Computes the union of this bag with another bag. The union of two bags
            is all items from both of the bags. If an item appears X times in one bag,
            and Y times in the other bag, the union contains the item Maximum(X,Y) times. This bag receives
            the union of the two bags, the other bag is unchanged.
            </summary>
            <remarks>
            <para>The union of two bags is computed in time O(M + N log M), where M is the size of the 
            larger bag, and N is the size of the smaller bag.</para>
            </remarks>
            <param name="otherBag">Bag to union with.</param>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="otherBag"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.Union(Wintellect.PowerCollections.OrderedBag{`0})">
            <summary>
            Computes the union of this bag with another bag. The union of two bags
            is all items from both of the bags.  If an item appears X times in one bag,
            and Y times in the other bag, the union contains the item Maximum(X,Y) times. A new bag is 
            created with the union of the bags and is returned. This bag and the other bag 
            are unchanged.
            </summary>
            <remarks>
            <para>The union of two bags is computed in time O(M + N log M), where M is the size of the 
            larger bag, and N is the size of the smaller bag.</para>
            </remarks>
            <param name="otherBag">Bag to union with.</param>
            <returns>The union of the two bags.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="otherBag"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.SumWith(Wintellect.PowerCollections.OrderedBag{`0})">
            <summary>
            Computes the sum of this bag with another bag. The sum of two bags
            is all items from both of the bags. If an item appears X times in one bag,
            and Y times in the other bag, the sum contains the item (X+Y) times. This bag receives
            the sum of the two bags, the other bag is unchanged.
            </summary>
            <remarks>
            <para>The sum of two bags is computed in time O(M + N log M), where M is the size of the 
            larger bag, and N is the size of the smaller bag.</para>
            </remarks>
            <param name="otherBag">Bag to sum with.</param>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="otherBag"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.Sum(Wintellect.PowerCollections.OrderedBag{`0})">
            <summary>
            Computes the sum of this bag with another bag. he sum of two bags
            is all items from both of the bags.  If an item appears X times in one bag,
            and Y times in the other bag, the sum contains the item (X+Y) times. A new bag is 
            created with the sum of the bags and is returned. This bag and the other bag 
            are unchanged.
            </summary>
            <remarks>
            <para>The sum of two bags is computed in time O(M + N log M), where M is the size of the 
            larger bag, and N is the size of the smaller bag.</para>
            </remarks>
            <param name="otherBag">Bag to sum with.</param>
            <returns>The sum of the two bags.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="otherBag"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.IntersectionWith(Wintellect.PowerCollections.OrderedBag{`0})">
            <summary>
            Computes the intersection of this bag with another bag. The intersection of two bags
            is all items that appear in both of the bags. If an item appears X times in one bag,
            and Y times in the other bag, the sum contains the item Minimum(X,Y) times. This bag receives
            the intersection of the two bags, the other bag is unchanged.
            </summary>
            <remarks>
            <para>When equal items appear in both bags, the intersection will include an arbitrary choice of one of the
            two equal items.</para>
            <para>The intersection of two bags is computed in time O(N log M), where M is the size of the 
            larger bag, and N is the size of the smaller bag.</para>
            </remarks>
            <param name="otherBag">Bag to intersection with.</param>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="otherBag"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.Intersection(Wintellect.PowerCollections.OrderedBag{`0})">
            <summary>
            Computes the intersection of this bag with another bag. The intersection of two bags
            is all items that appear in both of the bags. If an item appears X times in one bag,
            and Y times in the other bag, the sum contains the item Minimum(X,Y) times. A new bag is 
            created with the intersection of the bags and is returned. This bag and the other bag 
            are unchanged.
            </summary>
            <remarks>
            <para>When equal items appear in both bags, the intersection will include an arbitrary choice of one of the
            two equal items.</para>
            <para>The intersection of two bags is computed in time O(N log M), where M is the size of the 
            larger bag, and N is the size of the smaller bag.</para>
            </remarks>
            <param name="otherBag">Bag to intersection with.</param>
            <returns>The intersection of the two bags.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="otherBag"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.DifferenceWith(Wintellect.PowerCollections.OrderedBag{`0})">
            <summary>
            Computes the difference of this bag with another bag. The difference of these two bags
            is all items that appear in this bag, but not in <paramref name="otherBag"/>. If an item appears X times in this bag,
            and Y times in the other bag, the difference contains the item X - Y times (zero times if Y &gt;= X). This bag receives
            the difference of the two bags; the other bag is unchanged.
            </summary>
            <remarks>
            <para>The difference of two bags is computed in time O(M + N log M), where M is the size of the 
            larger bag, and N is the size of the smaller bag.</para>
            </remarks>
            <param name="otherBag">Bag to difference with.</param>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="otherBag"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.Difference(Wintellect.PowerCollections.OrderedBag{`0})">
            <summary>
            Computes the difference of this bag with another bag. The difference of these two bags
            is all items that appear in this bag, but not in <paramref name="otherBag"/>. If an item appears X times in this bag,
            and Y times in the other bag, the difference contains the item X - Y times (zero times if Y &gt;= X).  A new bag is 
            created with the difference of the bags and is returned. This bag and the other bag 
            are unchanged.
            </summary>
            <remarks>
            <para>The difference of two bags is computed in time O(M + N log M), where M is the size of the 
            larger bag, and N is the size of the smaller bag.</para>
            </remarks>
            <param name="otherBag">Bag to difference with.</param>
            <returns>The difference of the two bags.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="otherBag"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.SymmetricDifferenceWith(Wintellect.PowerCollections.OrderedBag{`0})">
            <summary>
            Computes the symmetric difference of this bag with another bag. The symmetric difference of two bags
            is all items that appear in either of the bags, but not both. If an item appears X times in one bag,
            and Y times in the other bag, the symmetric difference contains the item AbsoluteValue(X - Y times). This bag receives
            the symmetric difference of the two bags; the other bag is unchanged.
            </summary>
            <remarks>
            <para>The symmetric difference of two bags is computed in time O(M + N), where M is the size of the 
            larger bag, and N is the size of the smaller bag.</para>
            </remarks>
            <param name="otherBag">Bag to symmetric difference with.</param>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="otherBag"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.SymmetricDifference(Wintellect.PowerCollections.OrderedBag{`0})">
            <summary>
            Computes the symmetric difference of this bag with another bag. The symmetric difference of two bags
            is all items that appear in either of the bags, but not both. If an item appears X times in one bag,
            and Y times in the other bag, the symmetric difference contains the item AbsoluteValue(X - Y times). A new bag is 
            created with the symmetric difference of the bags and is returned. This bag and the other bag 
            are unchanged.
            </summary>
            <remarks>
            <para>The symmetric difference of two bags is computed in time O(M + N), where M is the size of the 
            larger bag, and N is the size of the smaller bag.</para>
            </remarks>
            <param name="otherBag">Bag to symmetric difference with.</param>
            <returns>The symmetric difference of the two bags.</returns>
            <exception cref="T:System.InvalidOperationException">This bag and <paramref name="otherBag"/> don't use the same method for comparing items.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="otherBag"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.AsList">
            <summary>
            Get a read-only list view of the items in this ordered bag. The
            items in the list are in sorted order, with the smallest item
            at index 0. This view does not copy any data, and reflects any
            changes to the underlying OrderedBag.
            </summary>
            <returns>A read-only IList&lt;T&gt; view onto this OrderedBag.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.Reversed">
             <summary>
             Returns a View collection that can be used for enumerating the items in the bag in 
             reversed order.
             </summary>
            <remarks>
            <p>Typically, this method is used in conjunction with a foreach statement. For example:
            <code>
             foreach(T item in bag.Reversed()) {
                // process item
             }
            </code></p>
             <p>If an item is added to or deleted from the bag while the View is being enumerated, then 
             the enumeration will end with an InvalidOperationException.</p>
            <p>Calling Reverse does not copy the data in the tree, and the operation takes constant time.</p>
            </remarks>
             <returns>An OrderedBag.View of items in reverse order.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.Range(`0,System.Boolean,`0,System.Boolean)">
             <summary>
             Returns a View collection that can be used for enumerating a range of the items in the bag.
             Only items that are greater than <paramref name="from"/> and 
             less than <paramref name="to"/> are included. The items are enumerated in sorted order.
             Items equal to the end points of the range can be included or excluded depending on the
             <paramref name="fromInclusive"/> and <paramref name="toInclusive"/> parameters.
             </summary>
            <remarks>
            <p>If <paramref name="from"/> is greater than or equal to <paramref name="to"/>, the returned collection is empty. </p>
            <p>Typically, this method is used in conjunction with a foreach statement. For example:
            <code>
             foreach(T item in bag.Range(from, true, to, false)) {
                // process item
             }
            </code></p>
             <p>If an item is added to or deleted from the bag while the View is being enumerated, then 
             the enumeration will end with an InvalidOperationException.</p>
            <p>Calling Range does not copy the data in the tree, and the operation takes constant time.</p>
            </remarks>
             <param name="from">The lower bound of the range.</param>
             <param name="fromInclusive">If true, the lower bound is inclusive--items equal to the lower bound will
             be included in the range. If false, the lower bound is exclusive--items equal to the lower bound will not
             be included in the range.</param>
             <param name="to">The upper bound of the range. </param>
             <param name="toInclusive">If true, the upper bound is inclusive--items equal to the upper bound will
             be included in the range. If false, the upper bound is exclusive--items equal to the upper bound will not
             be included in the range.</param>
             <returns>An OrderedBag.View of items in the given range.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.RangeFrom(`0,System.Boolean)">
             <summary>
             Returns a View collection that can be used for enumerating a range of the items in the bag.
             Only items that are greater than (and optionally, equal to) <paramref name="from"/> are included. 
             The items are enumerated in sorted order. Items equal to <paramref name="from"/> can be included
             or excluded depending on the <paramref name="fromInclusive"/> parameter.
             </summary>
            <remarks>
            <p>Typically, this method is used in conjunction with a foreach statement. For example:
            <code>
             foreach(T item in bag.RangeFrom(from, true)) {
                // process item
             }
            </code></p>
             <p>If an item is added to or deleted from the bag while the View is being enumerated, then 
             the enumeration will end with an InvalidOperationException.</p>
            <p>Calling RangeFrom does not copy the data in the tree, and the operation takes constant time.</p>
            </remarks>
             <param name="from">The lower bound of the range.</param>
             <param name="fromInclusive">If true, the lower bound is inclusive--items equal to the lower bound will
             be included in the range. If false, the lower bound is exclusive--items equal to the lower bound will not
             be included in the range.</param>
             <returns>An OrderedBag.View of items in the given range.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.RangeTo(`0,System.Boolean)">
             <summary>
             Returns a View collection that can be used for enumerating a range of the items in the bag.
             Only items that are less than (and optionally, equal to) <paramref name="to"/> are included. 
             The items are enumerated in sorted order. Items equal to <paramref name="to"/> can be included
             or excluded depending on the <paramref name="toInclusive"/> parameter.
             </summary>
            <remarks>
            <p>Typically, this method is used in conjunction with a foreach statement. For example:
            <code>
             foreach(T item in bag.RangeTo(to, false)) {
                // process item
             }
            </code></p>
             <p>If an item is added to or deleted from the bag while the View is being enumerated, then 
             the enumeration will end with an InvalidOperationException.</p>
            <p>Calling RangeTo does not copy the data in the tree, and the operation takes constant time.</p>
            </remarks>
             <param name="to">The upper bound of the range. </param>
             <param name="toInclusive">If true, the upper bound is inclusive--items equal to the upper bound will
             be included in the range. If false, the upper bound is exclusive--items equal to the upper bound will not
             be included in the range.</param>
             <returns>An OrderedBag.View of items in the given range.</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.OrderedBag`1.Comparer">
            <summary>
            Returns the IComparer&lt;T&gt; used to compare items in this bag. 
            </summary>
            <value>If the bag was created using a comparer, that comparer is returned. If the bag was
            created using a comparison delegate, then a comparer equivalent to that delegate
            is returned. Otherwise
            the default comparer for T (Comparer&lt;T&gt;.Default) is returned.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.OrderedBag`1.Count">
            <summary>
            Returns the number of items in the bag.
            </summary>
            <remarks>The size of the bag is returned in constant time.</remarks>
            <value>The number of items in the bag.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.OrderedBag`1.Item(System.Int32)">
            <summary>
            Get the item by its index in the sorted order. The smallest item has index 0,
            the next smallest item has index 1, and the largest item has index Count-1. 
            </summary>
            <remarks>The indexer takes time O(log N), which N is the number of items in 
            the set.</remarks>
            <param name="index">The index to get the item by.</param>
            <returns>The item at the given index.</returns>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is
            less than zero or greater than or equal to Count.</exception>
        </member>
        <member name="T:Wintellect.PowerCollections.OrderedBag`1.ListView">
            <summary>
            The nested class that provides a read-only list view
            of all or part of the collection.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.ReadOnlyListBase`1">
            <summary>
            ReadOnlyListBase is an abstract class that can be used as a base class for a read-only collection that needs 
            to implement the generic IList&lt;T&gt; and non-generic IList collections. The derived class needs
            to override the Count property and the get part of the indexer. The implementation
            of all the other methods in IList&lt;T&gt; and IList are handled by ListBase.
            </summary>
            <typeparam name="T"></typeparam>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.#ctor">
            <summary>
            Creates a new ReadOnlyListBase.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.MethodModifiesCollection">
            <summary>
            Throws an NotSupportedException stating that this collection cannot be modified.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.GetEnumerator">
            <summary>
            Enumerates all of the items in the list, in order. The item at index 0
            is enumerated first, then the item at index 1, and so on.
            </summary>
            <returns>An IEnumerator&lt;T&gt; that enumerates all the
            items in the list.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.Contains(`0)">
            <summary>
            Determines if the list contains any item that compares equal to <paramref name="item"/>.
            The implementation simply checks whether IndexOf(item) returns a non-negative value.
            </summary>
            <remarks>Equality in the list is determined by the default sense of
            equality for T. If T implements IComparable&lt;T&gt;, the
            Equals method of that interface is used to determine equality. Otherwise, 
            Object.Equals is used to determine equality.</remarks>
            <param name="item">The item to search for.</param>
            <returns>True if the list contains an item that compares equal to <paramref name="item"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.CopyTo(`0[])">
            <summary>
            Copies all the items in the list, in order, to <paramref name="array"/>,
            starting at index 0.
            </summary>
            <param name="array">The array to copy to. This array must have a size
            that is greater than or equal to Count.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.CopyTo(`0[],System.Int32)">
            <summary>
            Copies all the items in the list, in order, to <paramref name="array"/>,
            starting at <paramref name="arrayIndex"/>.
            </summary>
            <param name="array">The array to copy to. This array must have a size
            that is greater than or equal to Count + arrayIndex.</param>
            <param name="arrayIndex">The starting index in <paramref name="array"/>
            to copy to.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.CopyTo(System.Int32,`0[],System.Int32,System.Int32)">
            <summary>
            Copies a range of elements from the list to <paramref name="array"/>,
            starting at <paramref name="arrayIndex"/>.
            </summary>
            <param name="index">The starting index in the source list of the range to copy.</param>
            <param name="array">The array to copy to. This array must have a size
            that is greater than or equal to Count + arrayIndex.</param>
            <param name="arrayIndex">The starting index in <paramref name="array"/>
            to copy to.</param>
            <param name="count">The number of items to copy.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.Find(System.Predicate{`0})">
            <summary>
            Finds the first item in the list that satisfies the condition
            defined by <paramref name="predicate"/>. If no item matches the condition, than
            the default value for T (null or all-zero) is returned.
            </summary>
            <remarks>If the default value for T (null or all-zero) matches the condition defined by <paramref name="predicate"/>,
            and the list might contain the default value, then it is impossible to distinguish the different between finding
            the default value and not finding any item. To distinguish these cases, use <see cref="M:Wintellect.PowerCollections.ReadOnlyListBase`1.TryFind(System.Predicate{`0},`0@)"/>.</remarks>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <returns>The first item that satisfies the condition <paramref name="predicate"/>. If no item satisfies that
            condition, the default value for T is returned.</returns>
            <seealso cref="M:Wintellect.PowerCollections.ReadOnlyListBase`1.TryFind(System.Predicate{`0},`0@)"/>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.TryFind(System.Predicate{`0},`0@)">
            <summary>
            Finds the first item in the list that satisfies the condition
            defined by <paramref name="predicate"/>. 
            </summary>
            <param name="predicate">A delegate that defines the condition to check for.</param>
            <param name="foundItem">If true is returned, this parameter receives the first item in the list
            that satifies the condition defined by <paramref name="predicate"/>.</param>
            <returns>True if an item that  satisfies the condition <paramref name="predicate"/> was found. False 
            if no item in the list satisfies that condition.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.FindLast(System.Predicate{`0})">
            <summary>
            Finds the last item in the list that satisfies the condition
            defined by <paramref name="predicate"/>. If no item matches the condition, than
            the default value for T (null or all-zero) is returned.
            </summary>
            <remarks>If the default value for T (null or all-zero) matches the condition defined by <paramref name="predicate"/>,
            and the list might contain the default value, then it is impossible to distinguish the different between finding
            the default value and not finding any item. To distinguish these cases, use <see cref="M:Wintellect.PowerCollections.ReadOnlyListBase`1.TryFindLast(System.Predicate{`0},`0@)"/>.</remarks>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <returns>The last item that satisfies the condition <paramref name="predicate"/>. If no item satisfies that
            condition, the default value for T is returned.</returns>
            <seealso cref="M:Wintellect.PowerCollections.ReadOnlyListBase`1.TryFindLast(System.Predicate{`0},`0@)"/>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.TryFindLast(System.Predicate{`0},`0@)">
            <summary>
            Finds the last item in the list that satisfies the condition
            defined by <paramref name="predicate"/>. 
            </summary>
            <param name="predicate">A delegate that defines the condition to check for.</param>
            <param name="foundItem">If true is returned, this parameter receives the last item in the list
            that satifies the condition defined by <paramref name="predicate"/>.</param>
            <returns>True if an item that  satisfies the condition <paramref name="predicate"/> was found. False 
            if no item in the list satisfies that condition.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.FindIndex(System.Predicate{`0})">
            <summary>
            Finds the index of the first item in the list that satisfies the condition
            defined by <paramref name="predicate"/>. If no item matches the condition, -1 is returned.
            </summary>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <returns>The index of the first item that satisfies the condition <paramref name="predicate"/>. If no item satisfies that
            condition, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.FindIndex(System.Int32,System.Predicate{`0})">
            <summary>
            Finds the index of the first item, in the range of items extending from <paramref name="index"/> to the end, that satisfies the condition
            defined by <paramref name="predicate"/>. If no item matches the condition, -1 is returned.
            </summary>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <param name="index">The starting index of the range to check.</param>
            <returns>The index of the first item in the given range that satisfies the condition <paramref name="predicate"/>. If no item satisfies that
            condition, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.FindIndex(System.Int32,System.Int32,System.Predicate{`0})">
            <summary>
            Finds the index of the first item, in the range of <paramref name="count"/> items starting from <paramref name="index"/>, that satisfies the condition
            defined by <paramref name="predicate"/>. If no item matches the condition, -1 is returned.
            </summary>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <param name="index">The starting index of the range to check.</param>
            <param name="count">The number of items in range to check.</param>
            <returns>The index of the first item in the given range that satisfies the condition <paramref name="predicate"/>. If no item satisfies that
            condition, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.FindLastIndex(System.Predicate{`0})">
            <summary>
            Finds the index of the last item in the list that satisfies the condition
            defined by <paramref name="predicate"/>. If no item matches the condition, -1 is returned.
            </summary>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <returns>The index of the last item that satisfies the condition <paramref name="predicate"/>. If no item satisfies that
            condition, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.FindLastIndex(System.Int32,System.Predicate{`0})">
            <summary>
            Finds the index of the last item, in the range of items extending from the beginning
            of the list to <paramref name="index"/>, that satisfies the condition
            defined by <paramref name="predicate"/>. If no item matches the condition, -1 is returned.
            </summary>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <param name="index">The ending index of the range to check.</param>
            <returns>The index of the last item in the given range that satisfies the condition <paramref name="predicate"/>. If no item satisfies that
            condition, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.FindLastIndex(System.Int32,System.Int32,System.Predicate{`0})">
            <summary>
            Finds the index of the last item, in the range of <paramref name="count"/> items ending at <paramref name="index"/>, that satisfies the condition
            defined by <paramref name="predicate"/>. If no item matches the condition, -1 is returned.
            </summary>
            <param name="predicate">A delegate that defined the condition to check for.</param>
            <param name="index">The ending index of the range to check.</param>
            <param name="count">The number of items in range to check.</param>
            <returns>The index of the last item in the given range that satisfies the condition <paramref name="predicate"/>. If no item satisfies that
            condition, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.IndexOf(`0)">
            <summary>
            Finds the index of the first item in the list that is equal to <paramref name="item"/>. 
            </summary>
            <remarks>The default implementation of equality for type T is used in the search. This is the
            equality defined by IComparable&lt;T&gt; or object.Equals.</remarks>
            <param name="item">The item to search fror.</param>
            <returns>The index of the first item in the list that that is equal to <paramref name="item"/>.  If no item is equal
            to <paramref name="item"/>, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.IndexOf(`0,System.Int32)">
            <summary>
            Finds the index of the first item, in the range of items extending from <paramref name="index"/> to the end,  
            that is equal to <paramref name="item"/>. 
            </summary>
            <remarks>The default implementation of equality for type T is used in the search. This is the
            equality defined by IComparable&lt;T&gt; or object.Equals.</remarks>
            <param name="item">The item to search fror.</param>
            <param name="index">The starting index of the range to check.</param>
            <returns>The index of the first item in the given range that that is equal to <paramref name="item"/>.  If no item is equal
            to <paramref name="item"/>, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.IndexOf(`0,System.Int32,System.Int32)">
            <summary>
            Finds the index of the first item, in the range of <paramref name="count"/> items starting from <paramref name="index"/>,  
            that is equal to <paramref name="item"/>. 
            </summary>
            <remarks>The default implementation of equality for type T is used in the search. This is the
            equality defined by IComparable&lt;T&gt; or object.Equals.</remarks>
            <param name="item">The item to search fror.</param>
            <param name="index">The starting index of the range to check.</param>
            <param name="count">The number of items in range to check.</param>
            <returns>The index of the first item in the given range that that is equal to <paramref name="item"/>.  If no item is equal
            to <paramref name="item"/>, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.LastIndexOf(`0)">
            <summary>
            Finds the index of the last item in the list that is equal to <paramref name="item"/>. 
            </summary>
            <remarks>The default implementation of equality for type T is used in the search. This is the
            equality defined by IComparable&lt;T&gt; or object.Equals.</remarks>
            <param name="item">The item to search fror.</param>
            <returns>The index of the last item in the list that that is equal to <paramref name="item"/>.  If no item is equal
            to <paramref name="item"/>, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.LastIndexOf(`0,System.Int32)">
            <summary>
            Finds the index of the last item, in the range of items extending from the beginning
            of the list to <paramref name="index"/>, that is equal to <paramref name="item"/>. 
            </summary>
            <remarks>The default implementation of equality for type T is used in the search. This is the
            equality defined by IComparable&lt;T&gt; or object.Equals.</remarks>
            <param name="item">The item to search fror.</param>
            <param name="index">The ending index of the range to check.</param>
            <returns>The index of the last item in the given range that that is equal to <paramref name="item"/>.  If no item is equal
            to <paramref name="item"/>, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.LastIndexOf(`0,System.Int32,System.Int32)">
            <summary>
            Finds the index of the last item, in the range of <paramref name="count"/> items ending at <paramref name="index"/>, 
            that is equal to <paramref name="item"/>. 
            </summary>
            <remarks>The default implementation of equality for type T is used in the search. This is the
            equality defined by IComparable&lt;T&gt; or object.Equals.</remarks>
            <param name="item">The item to search for.</param>
            <param name="index">The ending index of the range to check.</param>
            <param name="count">The number of items in range to check.</param>
            <returns>The index of the last item in the given range that that is equal to <paramref name="item"/>.  If no item is equal
            to <paramref name="item"/>, -1 is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.Range(System.Int32,System.Int32)">
            <summary>
            Returns a view onto a sub-range of this list. Items are not copied; the
            returned IList&lt;T&gt; is simply a different view onto the same underlying items. 
            </summary>
            <remarks>
            <para>This method can be used to apply an algorithm to a portion of a list. For example:</para>
            <code>Algorithms.Reverse(deque.Range(3, 6))</code>
            will return the reverse opf the 6 items beginning at index 3.</remarks>
            <param name="start">The starting index of the view.</param>
            <param name="count">The number of items in the view.</param>
            <returns>A list that is a view onto the given sub-part of this list. </returns>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="start"/> or <paramref name="count"/> is negative.</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="start"/> + <paramref name="count"/> is greater than the
            size of the list.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.System#Collections#Generic#IList{T}#Insert(System.Int32,`0)">
            <summary>
            Inserts a new item at the given index. This implementation throws a NotSupportedException
            indicating that the list is read-only.
            </summary>
            <param name="index">The index in the list to insert the item at. After the
            insertion, the inserted item is located at this index. The
            first item in the list has index 0.</param>
            <param name="item">The item to insert at the given index.</param>
            <exception cref="T:System.NotSupportedException">Always thrown.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.System#Collections#Generic#IList{T}#RemoveAt(System.Int32)">
            <summary>
            Removes the item at the given index.  This implementation throws a NotSupportedException
            indicating that the list is read-only.
            </summary>
            <param name="index">The index in the list to remove the item at. The
            first item in the list has index 0.</param>
            <exception cref="T:System.NotSupportedException">Always thrown.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.System#Collections#IList#Add(System.Object)">
            <summary>
            Adds an item to the end of the list. This implementation throws a NotSupportedException
            indicating that the list is read-only.
            </summary>
            <param name="value">The item to add to the list.</param>
            <exception cref="T:System.NotSupportedException">Always thrown.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.System#Collections#IList#Clear">
            <summary>
            Removes all the items from the list, resulting in an empty list. This implementation throws a NotSupportedException
            indicating that the list is read-only.
            </summary>
            <exception cref="T:System.NotSupportedException">Always thrown.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.System#Collections#IList#Contains(System.Object)">
            <summary>
            Determines if the list contains any item that compares equal to <paramref name="value"/>.
            </summary>
            <remarks>Equality in the list is determined by the default sense of
            equality for T. If T implements IComparable&lt;T&gt;, the
            Equals method of that interface is used to determine equality. Otherwise, 
            Object.Equals is used to determine equality.</remarks>
            <param name="value">The item to search for.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.System#Collections#IList#IndexOf(System.Object)">
            <summary>
            Find the first occurrence of an item equal to <paramref name="value"/>
            in the list, and returns the index of that item.
            </summary>
            <remarks>Equality in the list is determined by the default sense of
            equality for T. If T implements IComparable&lt;T&gt;, the
            Equals method of that interface is used to determine equality. Otherwise, 
            Object.Equals is used to determine equality.</remarks>
            <param name="value">The item to search for.</param>
            <returns>The index of <paramref name="value"/>, or -1 if no item in the 
            list compares equal to <paramref name="value"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.System#Collections#IList#Insert(System.Int32,System.Object)">
            <summary>
            Insert a new item at the given index. This implementation throws a NotSupportedException
            indicating that the list is read-only.
            </summary>
            <param name="index">The index in the list to insert the item at. After the
            insertion, the inserted item is located at this index. The
            first item in the list has index 0.</param>
            <param name="value">The item to insert at the given index.</param>
            <exception cref="T:System.NotSupportedException">Always thrown.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.System#Collections#IList#Remove(System.Object)">
            <summary>
            Searches the list for the first item that compares equal to <paramref name="value"/>.
            If one is found, it is removed. Otherwise, the list is unchanged.  This implementation throws a NotSupportedException
            indicating that the list is read-only.
            </summary>
            <remarks>Equality in the list is determined by the default sense of
            equality for T. If T implements IComparable&lt;T&gt;, the
            Equals method of that interface is used to determine equality. Otherwise, 
            Object.Equals is used to determine equality.</remarks>
            <param name="value">The item to remove from the list.</param>
            <exception cref="T:System.NotSupportedException">Always thrown.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyListBase`1.System#Collections#IList#RemoveAt(System.Int32)">
            <summary>
            Removes the item at the given index. This implementation throws a NotSupportedException
            indicating that the list is read-only.
            </summary>
            <param name="index">The index in the list to remove the item at. The
            first item in the list has index 0.</param>
            <exception cref="T:System.NotSupportedException">Always thrown.</exception>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyListBase`1.Count">
            <summary>
            The property must be overridden by the derived class to return the number of 
            items in the list.
            </summary>
            <value>The number of items in the list.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyListBase`1.Item(System.Int32)">
            <summary>
            The get part of the indexer must be overridden by the derived class to get 
            values of the list at a particular index.
            </summary>
            <param name="index">The index in the list to get or set an item at. The
            first item in the list has index 0, and the last has index Count-1.</param>
            <returns>The item at the given index.</returns>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is
            less than zero or greater than or equal to Count.</exception>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyListBase`1.System#Collections#IList#IsFixedSize">
            <summary>
            Returns whether the list is a fixed size. This implementation always returns true.
            </summary>
            <value>Alway true, indicating that the list is fixed size.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyListBase`1.System#Collections#IList#IsReadOnly">
            <summary>
            Returns whether the list is read only. This implementation always returns true.
            </summary>
            <value>Alway true, indicating that the list is read-only.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyListBase`1.System#Collections#IList#Item(System.Int32)">
            <summary>
            Gets or sets the value at a particular index in the list.
            </summary>
            <param name="index">The index in the list to get or set an item at. The
            first item in the list has index 0, and the last has index Count-1.</param>
            <value>The item at the given index.</value>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is
            less than zero or greater than or equal to Count.</exception>
            <exception cref="T:System.ArgumentException"><paramref name="value"/> cannot be converted to T.</exception>
            <exception cref="T:System.NotSupportedException">Always thrown from the setter, indicating that the list
            is read-only.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.ListView.#ctor(Wintellect.PowerCollections.OrderedBag{`0},Wintellect.PowerCollections.RedBlackTree{`0}.RangeTester,System.Boolean,System.Boolean)">
            <summary>
            Create a new list view wrapped the given set.
            </summary>
            <param name="myBag">The ordered bag to wrap.</param>
            <param name="rangeTester">Range tester that defines the range being used.</param>
            <param name="entireTree">If true, then rangeTester defines the entire tree. Used to optimize some operations.</param>
            <param name="reversed">Is the view enuemerated in reverse order?</param>
        </member>
        <member name="T:Wintellect.PowerCollections.OrderedBag`1.View">
             <summary>
             The OrderedBag&lt;T&gt;.View class is used to look at a subset of the items
             inside an ordered bag. It is returned from the Range, RangeTo, RangeFrom, and Reversed methods. 
             </summary>
            <remarks>
             <p>Views are dynamic. If the underlying bag changes, the view changes in sync. If a change is made
             to the view, the underlying bag changes accordingly.</p>
            <p>Typically, this class is used in conjunction with a foreach statement to enumerate the items 
             in a subset of the OrderedBag. For example:</p>
            <code>
             foreach(T item in bag.Range(from, to)) {
                // process item
             }
            </code>
            </remarks>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.View.#ctor(Wintellect.PowerCollections.OrderedBag{`0},Wintellect.PowerCollections.RedBlackTree{`0}.RangeTester,System.Boolean,System.Boolean)">
            <summary>
            Initialize the view.
            </summary>
            <param name="myBag">OrderedBag being viewed</param>
            <param name="rangeTester">Range tester that defines the range being used.</param>
            <param name="entireTree">If true, then rangeTester defines the entire tree.</param>
            <param name="reversed">Is the view enuemerated in reverse order?</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.View.ItemInView(`0)">
            <summary>
            Determine if the given item lies within the bounds of this view.
            </summary>
            <param name="item">Item to test.</param>
            <returns>True if the item is within the bounds of this view.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.View.GetEnumerator">
            <summary>
            Enumerate all the items in this view.
            </summary>
            <returns>An IEnumerator&lt;T&gt; with the items in this view.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.View.Clear">
            <summary>
            Removes all the items within this view from the underlying bag.
            </summary>
            <example>The following removes all the items that start with "A" from an OrderedBag.
            <code>
            bag.Range("A", "B").Clear();
            </code>
            </example>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.View.Add(`0)">
            <summary>
            Adds a new item to the bag underlying this View. If the bag already contains an item equal to
            <paramref name="item"/>, that item is replaces with <paramref name="item"/>. If
            <paramref name="item"/> is outside the range of this view, an InvalidOperationException
            is thrown.
            </summary>
            <remarks>
            <para>Equality between items is determined by the comparison instance or delegate used
            to create the bag.</para>
            <para>Adding an item takes time O(log N), where N is the number of items in the bag.</para></remarks>
            <param name="item">The item to add.</param>
            <returns>True if the bag already contained an item equal to <paramref name="item"/> (which was replaced), false 
            otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.View.Remove(`0)">
            <summary>
            Searches the underlying bag for an item equal to <paramref name="item"/>, and if found,
            removes it from the bag. If not found, the bag is unchanged. If the item is outside
            the range of this view, the bag is unchanged.
            </summary>
            <remarks>
            <para>Equality between items is determined by the comparison instance or delegate used
            to create the bag.</para>
            <para>Removing an item from the bag takes time O(log N), where N is the number of items in the bag.</para></remarks>
            <param name="item">The item to remove.</param>
            <returns>True if <paramref name="item"/> was found and removed. False if <paramref name="item"/> was not in the bag, or
            was outside the range of this view.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.View.Contains(`0)">
            <summary>
            Determines if this view of the bag contains an item equal to <paramref name="item"/>. The bag
            is not changed. If 
            </summary>
            <remarks>Searching the bag for an item takes time O(log N), where N is the number of items in the bag.</remarks>
            <param name="item">The item to search for.</param>
            <returns>True if the bag contains <paramref name="item"/>, and <paramref name="item"/> is within
            the range of this view. False otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.View.IndexOf(`0)">
            <summary>
            Get the first index of the given item in the view. The smallest item in the view has index 0,
            the next smallest item has index 1, and the largest item has index Count-1. 
            </summary>
            <remarks>Finding the index takes time O(log N), which N is the number of items in 
            the set.</remarks>
            <param name="item">The item to get the index of.</param>
            <returns>The index of the first item in the view equal to <paramref name="item"/>, or -1 if the item is not present
            in the view.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.View.LastIndexOf(`0)">
            <summary>
            Get the last index of the given item in the view. The smallest item in the view has index 0,
            the next smallest item has index 1, and the largest item has index Count-1. 
            </summary>
            <remarks>Finding the index takes time O(log N), which N is the number of items in 
            the set.</remarks>
            <param name="item">The item to get the index of.</param>
            <returns>The index of the last item in the view equal to <paramref name="item"/>, or -1 if the item is not present
            in the view.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.View.AsList">
            <summary>
            Get a read-only list view of the items in this view. The
            items in the list are in sorted order, with the smallest item
            at index 0. This view does not copy any data, and reflects any
            changes to the underlying OrderedSet.
            </summary>
            <returns>A read-only IList&lt;T&gt; view onto this view.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.View.Reversed">
            <summary>
            Creates a new View that has the same items as this view, in the reversed order.
            </summary>
            <returns>A new View that has the reversed order of this view, with the same upper 
            and lower bounds.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.View.GetFirst">
            <summary>
            Returns the first item in this view: the item
            that would appear first if the view was enumerated. 
            </summary>
            <remarks>GetFirst() takes time O(log N), where N is the number of items in the bag.</remarks>
            <returns>The first item in the view. </returns>
            <exception cref="T:System.InvalidOperationException">The view has no items in it.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedBag`1.View.GetLast">
            <summary>
            Returns the last item in the view: the item
            that would appear last if the view was enumerated. 
            </summary>
            <remarks>GetLast() takes time O(log N), where N is the number of items in the bag.</remarks>
            <returns>The last item in the view. </returns>
            <exception cref="T:System.InvalidOperationException">The view has no items in it.</exception>
        </member>
        <member name="P:Wintellect.PowerCollections.OrderedBag`1.View.Count">
            <summary>
            Number of items in this view.
            </summary>
            <value>Number of items that lie within the bounds the view.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.OrderedBag`1.View.Item(System.Int32)">
            <summary>
            Get the item by its index in the sorted order. The smallest item in the view has index 0,
            the next smallest item has index 1, and the largest item has index Count-1. 
            </summary>
            <remarks>The indexer takes time O(log N), which N is the number of items in 
            the set.</remarks>
            <param name="index">The index to get the item by.</param>
            <returns>The item at the given index.</returns>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is
            less than zero or greater than or equal to Count.</exception>
        </member>
        <member name="T:Wintellect.PowerCollections.OrderedMultiDictionary`2">
             <summary>
             <para>The OrderedMultiDictionary class that associates values with a key. Unlike an OrderedDictionary,
             each key can have multiple values associated with it. When indexing an OrderedMultidictionary, instead
             of a single value associated with a key, you retrieve an enumeration of values.</para>
             <para>All of the key are stored in sorted order. Also, the values associated with a given key 
             are kept in sorted order as well.</para>
             <para>When constructed, you can chose to allow the same value to be associated with a key multiple
             times, or only one time. </para>
             </summary>
             <typeparam name="TKey">The type of the keys.</typeparam>
             <typeparam name="TValue">The of values associated with the keys.</typeparam>
            <seealso cref="T:Wintellect.PowerCollections.MultiDictionary`2"/>
            <seealso cref="T:Wintellect.PowerCollections.OrderedDictionary`2"/>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.NewPair(`0,`1)">
            <summary>
            Helper function to create a new KeyValuePair struct.
            </summary>
            <param name="key">The key.</param>
            <param name="value">The value.</param>
            <returns>A new KeyValuePair.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.NewPair(`0)">
            <summary>
            Helper function to create a new KeyValuePair struct with a default value.
            </summary>
            <param name="key">The key.</param>
            <returns>A new KeyValuePair.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.KeyRange(`0)">
            <summary>
            Get a RangeTester that maps to the range of all items with the 
            given key.
            </summary>
            <param name="key">Key in the given range.</param>
            <returns>A RangeTester delegate that selects the range of items with that range.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.DoubleBoundedKeyRangeTester(`0,System.Boolean,`0,System.Boolean)">
            <summary>
            Gets a range tester that defines a range by first and last items.
            </summary>
            <param name="first">The lower bound.</param>
            <param name="firstInclusive">True if the lower bound is inclusive, false if exclusive.</param>
            <param name="last">The upper bound.</param>
            <param name="lastInclusive">True if the upper bound is inclusive, false if exclusive.</param>
            <returns>A RangeTester delegate that tests for a key in the given range.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.LowerBoundedKeyRangeTester(`0,System.Boolean)">
            <summary>
            Gets a range tester that defines a range by a lower bound.
            </summary>
            <param name="first">The lower bound.</param>
            <param name="inclusive">True if the lower bound is inclusive, false if exclusive.</param>
            <returns>A RangeTester delegate that tests for a key in the given range.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.UpperBoundedKeyRangeTester(`0,System.Boolean)">
            <summary>
            Gets a range tester that defines a range by upper bound.
            </summary>
            <param name="last">The upper bound.</param>
            <param name="inclusive">True if the upper bound is inclusive, false if exclusive.</param>
            <returns>A RangeTester delegate that tests for a key in the given range.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.#ctor(System.Boolean)">
            <summary>
            Create a new OrderedMultiDictionary. The default ordering of keys and values are used. If duplicate values
            are allowed, multiple copies of the same value can be associated with the same key. For example, the key "foo"
            could have "a", "a", and "b" associated with it. If duplicate values are not allowed, only one copies of a given value can
            be associated with the same key, although different keys can have the same value. For example, the key "foo" could
            have "a" and "b" associated with it, which key "bar" has values "b" and "c" associated with it.
            </summary>
            <remarks>The default ordering of keys and values will be used, as defined by TKey and TValue's implementation
            of IComparable&lt;T&gt; (or IComparable if IComparable&lt;T&gt; is not implemented). If a different ordering should be
            used, other constructors allow a custom Comparer or IComparer to be passed to changed the ordering.</remarks>
            <param name="allowDuplicateValues">Can the same value be associated with a key multiple times?</param>
            <exception cref="T:System.InvalidOperationException">TKey or TValue does not implement either IComparable&lt;T&gt; or IComparable.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.#ctor(System.Boolean,System.Comparison{`0})">
            <summary>
            Create a new OrderedMultiDictionary. If duplicate values
            are allowed, multiple copies of the same value can be associated with the same key. For example, the key "foo"
            could have "a", "a", and "b" associated with it. If duplicate values are not allowed, only one copies of a given value can
            be associated with the same key, although different keys can have the same value. For example, the key "foo" could
            have "a" and "b" associated with it, which key "bar" has values "b" and "c" associated with it.
            </summary>
            <param name="allowDuplicateValues">Can the same value be associated with a key multiple times?</param>
            <param name="keyComparison">A delegate to a method that will be used to compare keys.</param>
            <exception cref="T:System.InvalidOperationException">TValue does not implement either IComparable&lt;TValue&gt; or IComparable.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.#ctor(System.Boolean,System.Comparison{`0},System.Comparison{`1})">
            <summary>
            Create a new OrderedMultiDictionary. If duplicate values
            are allowed, multiple copies of the same value can be associated with the same key. For example, the key "foo"
            could have "a", "a", and "b" associated with it. If duplicate values are not allowed, only one copies of a given value can
            be associated with the same key, although different keys can have the same value. For example, the key "foo" could
            have "a" and "b" associated with it, which key "bar" has values "b" and "c" associated with it.
            </summary>
            <param name="allowDuplicateValues">Can the same value be associated with a key multiple times?</param>
            <param name="keyComparison">A delegate to a method that will be used to compare keys.</param>
            <param name="valueComparison">A delegate to a method that will be used to compare values.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.#ctor(System.Boolean,System.Collections.Generic.IComparer{`0})">
            <summary>
            Create a new OrderedMultiDictionary. If duplicate values
            are allowed, multiple copies of the same value can be associated with the same key. For example, the key "foo"
            could have "a", "a", and "b" associated with it. If duplicate values are not allowed, only one copies of a given value can
            be associated with the same key, although different keys can have the same value. For example, the key "foo" could
            have "a" and "b" associated with it, which key "bar" has values "b" and "c" associated with it.
            </summary>
            <param name="allowDuplicateValues">Can the same value be associated with a key multiple times?</param>
            <param name="keyComparer">An IComparer&lt;TKey&gt; instance that will be used to compare keys.</param>
            <exception cref="T:System.InvalidOperationException">TValue does not implement either IComparable&lt;TValue&gt; or IComparable.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.#ctor(System.Boolean,System.Collections.Generic.IComparer{`0},System.Collections.Generic.IComparer{`1})">
            <summary>
            Create a new OrderedMultiDictionary. If duplicate values
            are allowed, multiple copies of the same value can be associated with the same key. For example, the key "foo"
            could have "a", "a", and "b" associated with it. If duplicate values are not allowed, only one copies of a given value can
            be associated with the same key, although different keys can have the same value. For example, the key "foo" could
            have "a" and "b" associated with it, which key "bar" has values "b" and "c" associated with it.
            </summary>
            <param name="allowDuplicateValues">Can the same value be associated with a key multiple times?</param>
            <param name="keyComparer">An IComparer&lt;TKey&gt; instance that will be used to compare keys.</param>
            <param name="valueComparer">An IComparer&lt;TValue&gt; instance that will be used to compare values.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.#ctor(System.Boolean,System.Int32,System.Collections.Generic.IComparer{`0},System.Collections.Generic.IComparer{`1},System.Collections.Generic.IComparer{System.Collections.Generic.KeyValuePair{`0,`1}},Wintellect.PowerCollections.RedBlackTree{System.Collections.Generic.KeyValuePair{`0,`1}})">
            <summary>
            Create a new OrderedMultiDictionary. Used internally for cloning.
            </summary>
            <param name="allowDuplicateValues">Can the same value be associated with a key multiple times?</param>
            <param name="keyCount">Number of keys.</param>
            <param name="keyComparer">An IComparer&lt;TKey&gt; instance that will be used to compare keys.</param>
            <param name="valueComparer">An IComparer&lt;TValue&gt; instance that will be used to compare values.</param>
            <param name="comparer">Comparer of key-value pairs.</param>
            <param name="tree">The red-black tree used to store the data.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.Add(`0,`1)">
            <summary>
            <para>Adds a new value to be associated with a key. If duplicate values are permitted, this
            method always adds a new key-value pair to the dictionary.</para>
            <para>If duplicate values are not permitted, and <paramref name="key"/> already has a value
            equal to <paramref name="value"/> associated with it, then that value is replaced with <paramref name="value"/>,
            and the number of values associate with <paramref name="key"/> is unchanged.</para>
            </summary>
            <param name="key">The key to associate with.</param>
            <param name="value">The value to associated with <paramref name="key"/>.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.Remove(`0,`1)">
            <summary>
            Removes a given value from the values associated with a key. If the
            last value is removed from a key, the key is removed also.
            </summary>
            <param name="key">A key to remove a value from.</param>
            <param name="value">The value to remove.</param>
            <returns>True if <paramref name="value"/> was associated with <paramref name="key"/> (and was
            therefore removed). False if <paramref name="value"/> was not associated with <paramref name="key"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.Remove(`0)">
            <summary>
            Removes a key and all associated values from the dictionary. If the
            key is not present in the dictionary, it is unchanged and false is returned.
            </summary>
            <param name="key">The key to remove.</param>
            <returns>True if the key was present and was removed. Returns 
            false if the key was not present.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.Clear">
            <summary>
            Removes all keys and values from the dictionary.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.EqualValues(`1,`1)">
            <summary>
            Determine if two values are equal.
            </summary>
            <param name="value1">First value to compare.</param>
            <param name="value2">Second value to compare.</param>
            <returns>True if the values are equal.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.Contains(`0,`1)">
            <summary>
            Checks to see if <paramref name="value"/> is associated with <paramref name="key"/>
            in the dictionary.
            </summary>
            <param name="key">The key to check.</param>
            <param name="value">The value to check.</param>
            <returns>True if <paramref name="value"/> is associated with <paramref name="key"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.ContainsKey(`0)">
            <summary>
            Checks to see if the key is present in the dictionary and has
            at least one value associated with it.
            </summary>
            <param name="key">The key to check.</param>
            <returns>True if <paramref name="key"/> is present and has at least
            one value associated with it. Returns false otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.EnumerateKeys(Wintellect.PowerCollections.RedBlackTree{System.Collections.Generic.KeyValuePair{`0,`1}}.RangeTester,System.Boolean)">
            <summary>
            A private helper method that returns an enumerable that
            enumerates all the keys in a range.
            </summary>
            <param name="rangeTester">Defines the range to enumerate.</param>
            <param name="reversed">Should the keys be enumerated in reverse order?</param>
            <returns>An IEnumerable&lt;TKey&gt; that enumerates the keys in the given range.
            in the dictionary.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.EnumerateValuesForKey(`0)">
            <summary>
            A private helper method for the indexer to return an enumerable that
            enumerates all the values for a key. This is separate method because indexers
            can't use the yield return construct.
            </summary>
            <param name="key"></param>
            <returns>An IEnumerable&lt;TValue&gt; that can be used to enumerate all the
            values associated with <paramref name="key"/>. If <paramref name="key"/> is not present,
            an enumerable that enumerates no items is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.TryEnumerateValuesForKey(`0,System.Collections.Generic.IEnumerator{`1}@)">
            <summary>
            Determines if this dictionary contains a key equal to <paramref name="key"/>. If so, all the values
            associated with that key are returned through the values parameter. 
            </summary>
            <param name="key">The key to search for.</param>
            <param name="values">Returns all values associated with key, if true was returned.</param>
            <returns>True if the dictionary contains key. False if the dictionary does not contain key.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.EnumerateKeys">
            <summary>
            Enumerate all of the keys in the dictionary.
            </summary>
            <returns>An IEnumerator&lt;TKey&gt; of all of the keys in the dictionary.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.CountValues(`0)">
            <summary>
            Gets the number of values associated with a given key.
            </summary>
            <param name="key">The key to count values of.</param>
            <returns>The number of values associated with <paramref name="key"/>. If <paramref name="key"/>
            is not present in the dictionary, zero is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.CountAllValues">
            <summary>
            Gets a total count of values in the collection. 
            </summary>
            <returns>The total number of values associated with all keys in the dictionary.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.Clone">
            <summary>
            Makes a shallow clone of this dictionary; i.e., if keys or values of the
            dictionary are reference types, then they are not cloned. If TKey or TValue is a value type,
            then each element is copied as if by simple assignment.
            </summary>
            <remarks>Cloning the dictionary takes time O(N), where N is the number of key-value pairs in the dictionary.</remarks>
            <returns>The cloned dictionary.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.System#ICloneable#Clone">
            <summary>
            Implements ICloneable.Clone. Makes a shallow clone of this dictionary; i.e., if keys or values are reference types, then they are not cloned.
            </summary>
            <returns>The cloned dictionary.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.NonCloneableType(System.Type)">
            <summary>
            Throw an InvalidOperationException indicating that this type is not cloneable.
            </summary>
            <param name="t">Type to test.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.CloneContents">
            <summary>
            Makes a deep clone of this dictionary. A new dictionary is created with a clone of
            each entry of this dictionary, by calling ICloneable.Clone on each element. If TKey or TValue is
            a value type, then each element is copied as if by simple assignment.
            </summary>
            <remarks><para>If TKey or TValue is a reference type, it must implement
            ICloneable. Otherwise, an InvalidOperationException is thrown.</para>
            <para>Cloning the dictionary takes time O(N log N), where N is the number of key-value pairs in the dictionary.</para></remarks>
            <returns>The cloned dictionary.</returns>
            <exception cref="T:System.InvalidOperationException">TKey or TValue is a reference type that does not implement ICloneable.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.Reversed">
             <summary>
             Returns a View collection that can be used for enumerating the keys and values in the collection in 
             reversed order.
             </summary>
            <remarks>
            <p>Typically, this method is used in conjunction with a foreach statement. For example:
            <code>
             foreach(KeyValuePair&lt;TKey, TValue&gt; pair in dictionary.Reversed()) {
                // process pair
             }
            </code></p>
             <p>If an entry is added to or deleted from the dictionary while the View is being enumerated, then 
             the enumeration will end with an InvalidOperationException.</p>
            <p>Calling Reverse does not copy the data in the dictionary, and the operation takes constant time.</p>
            </remarks>
             <returns>An OrderedDictionary.View of key-value pairs in reverse order.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.Range(`0,System.Boolean,`0,System.Boolean)">
             <summary>
             Returns a collection that can be used for enumerating some of the keys and values in the collection. 
             Only keys that are greater than <paramref name="from"/> and 
             less than <paramref name="to"/> are included. The keys are enumerated in sorted order.
             Keys equal to the end points of the range can be included or excluded depending on the
             <paramref name="fromInclusive"/> and <paramref name="toInclusive"/> parameters.
             </summary>
            <remarks>
            <p>If <paramref name="from"/> is greater than or equal to <paramref name="to"/>, the returned collection is empty. </p>
            <p>The sorted order of the keys is determined by the comparison instance or delegate used
             to create the dictionary.</p>
            <p>Typically, this property is used in conjunction with a foreach statement. For example:</p>
            <code>
             foreach(KeyValuePair&lt;TKey, TValue&gt; pair in dictionary.Range(from, true, to, false)) {
                // process pair
             }
            </code>
            <p>Calling Range does not copy the data in the dictionary, and the operation takes constant time.</p></remarks>
             <param name="from">The lower bound of the range.</param>
             <param name="fromInclusive">If true, the lower bound is inclusive--keys equal to the lower bound will
             be included in the range. If false, the lower bound is exclusive--keys equal to the lower bound will not
             be included in the range.</param>
             <param name="to">The upper bound of the range. </param>
             <param name="toInclusive">If true, the upper bound is inclusive--keys equal to the upper bound will
             be included in the range. If false, the upper bound is exclusive--keys equal to the upper bound will not
             be included in the range.</param>
             <returns>An OrderedMultiDictionary.View of key-value pairs in the given range.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.RangeFrom(`0,System.Boolean)">
             <summary>
             Returns a collection that can be used for enumerating some of the keys and values in the collection. 
             Only keys that are greater than (and optionally, equal to) <paramref name="from"/> are included. 
             The keys are enumerated in sorted order. Keys equal to <paramref name="from"/> can be included
             or excluded depending on the <paramref name="fromInclusive"/> parameter.
             </summary>
            <remarks>
            <p>The sorted order of the keys is determined by the comparison instance or delegate used
             to create the dictionary.</p>
            <p>Typically, this property is used in conjunction with a foreach statement. For example:</p>
            <code>
             foreach(KeyValuePair&lt;TKey, TValue&gt; pair in dictionary.RangeFrom(from, true)) {
                // process pair
             }
            </code>
            <p>Calling RangeFrom does not copy of the data in the dictionary, and the operation takes constant time.</p>
            </remarks>
             <param name="from">The lower bound of the range.</param>
             <param name="fromInclusive">If true, the lower bound is inclusive--keys equal to the lower bound will
             be included in the range. If false, the lower bound is exclusive--keys equal to the lower bound will not
             be included in the range.</param>
             <returns>An OrderedMultiDictionary.View of key-value pairs in the given range.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.RangeTo(`0,System.Boolean)">
             <summary>
             Returns a collection that can be used for enumerating some of the keys and values in the collection. 
             Only items that are less than (and optionally, equal to) <paramref name="to"/> are included. 
             The items are enumerated in sorted order. Items equal to <paramref name="to"/> can be included
             or excluded depending on the <paramref name="toInclusive"/> parameter.
             </summary>
            <remarks>
            <p>The sorted order of the keys is determined by the comparison instance or delegate used
             to create the dictionary.</p>
            <p>Typically, this property is used in conjunction with a foreach statement. For example:</p>
            <code>
             foreach(KeyValuePair&lt;TKey, TValue&gt; pair in dictionary.RangeFrom(from, false)) {
                // process pair
             }
            </code>
            <p>Calling RangeTo does not copy the data in the dictionary, and the operation takes constant time.</p>
            </remarks>
             <param name="to">The upper bound of the range. </param>
             <param name="toInclusive">If true, the upper bound is inclusive--keys equal to the upper bound will
             be included in the range. If false, the upper bound is exclusive--keys equal to the upper bound will not
             be included in the range.</param>
             <returns>An OrderedMultiDictionary.View of key-value pairs in the given range.</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.OrderedMultiDictionary`2.KeyComparer">
            <summary>
            Returns the IComparer&lt;T&gt; used to compare keys in this dictionary. 
            </summary>
            <value>If the dictionary was created using a comparer, that comparer is returned. If the dictionary was
            created using a comparison delegate, then a comparer equivalent to that delegate
            is returned. Otherwise
            the default comparer for TKey (Comparer&lt;TKey&gt;.Default) is returned.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.OrderedMultiDictionary`2.ValueComparer">
            <summary>
            Returns the IComparer&lt;T&gt; used to compare values in this dictionary. 
            </summary>
            <value>If the dictionary was created using a comparer, that comparer is returned. If the dictionary was
            created using a comparison delegate, then a comparer equivalent to that delegate
            is returned. Otherwise
            the default comparer for TValue (Comparer&lt;TValue&gt;.Default) is returned.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.OrderedMultiDictionary`2.Count">
            <summary>
            Gets the number of key-value pairs in the dictionary. Each value associated
            with a given key is counted. If duplicate values are permitted, each duplicate
            value is included in the count.
            </summary>
            <value>The number of key-value pairs in the dictionary.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.OrderedMultiDictionary`2.KeyValuePairs">
            <summary>
            Gets a read-only collection of all key-value pairs in the dictionary. If a key has multiple
            values associated with it, then a key-value pair is present for each value associated
            with the key.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.OrderedMultiDictionary`2.KeyValuePairsCollection">
            <summary>
            A private class that implements ICollection&lt;KeyValuePair&lt;TKey,TValue&gt;&gt; and ICollection for the
            KeyValuePairs collection. The collection is read-only.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.OrderedMultiDictionary`2.View">
             <summary>
             The OrderedMultiDictionary&lt;TKey,TValue&gt;.View class is used to look at a subset of the keys and values
             inside an ordered multi-dictionary. It is returned from the Range, RangeTo, RangeFrom, and Reversed methods. 
             </summary>
            <remarks>
             <p>Views are dynamic. If the underlying dictionary changes, the view changes in sync. If a change is made
             to the view, the underlying dictionary changes accordingly.</p>
            <p>Typically, this class is used in conjunction with a foreach statement to enumerate the keys
             and values in a subset of the OrderedMultiDictionary. For example:</p>
            <code>
             foreach(KeyValuePair&lt;TKey, TValue&gt; pair in dictionary.Range(from, to)) {
                // process pair
             }
            </code>
            </remarks>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.View.#ctor(Wintellect.PowerCollections.OrderedMultiDictionary{`0,`1},Wintellect.PowerCollections.RedBlackTree{System.Collections.Generic.KeyValuePair{`0,`1}}.RangeTester,System.Boolean,System.Boolean)">
            <summary>
            Initialize the View.
            </summary>
            <param name="myDictionary">Associated OrderedMultiDictionary to be viewed.</param>
            <param name="rangeTester">Range tester that defines the range being used.</param>
            <param name="entireTree">If true, then rangeTester defines the entire tree.</param>
            <param name="reversed">Is the view enuemerated in reverse order?</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.View.KeyInView(`0)">
            <summary>
            Determine if the given key lies within the bounds of this view.
            </summary>
            <param name="key">Key to test.</param>
            <returns>True if the key is within the bounds of this view.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.View.EnumerateKeys">
            <summary>
            Enumerate all the keys in the dictionary. 
            </summary>
            <returns>An IEnumerator&lt;TKey&gt; that enumerates all of the keys in the collection that
            have at least one value associated with them.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.View.TryEnumerateValuesForKey(`0,System.Collections.Generic.IEnumerator{`1}@)">
            <summary>
            Enumerate all of the values associated with a given key. If the key exists and has values associated with it, an enumerator for those
            values is returned throught <paramref name="values"/>. If the key does not exist, false is returned.
            </summary>
            <param name="key">The key to get values for.</param>
            <param name="values">If true is returned, this parameter receives an enumerators that
            enumerates the values associated with that key.</param>
            <returns>True if the key exists and has values associated with it. False otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.View.ContainsKey(`0)">
            <summary>
            Tests if the key is present in the part of the dictionary being viewed.
            </summary>
            <param name="key">Key to check</param>
            <returns>True if the key is within this view. </returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.View.Contains(`0,`1)">
            <summary>
            Tests if the key-value pair is present in the part of the dictionary being viewed.
            </summary>
            <param name="key">Key to check for.</param>
            <param name="value">Value to check for.</param>
            <returns>True if the key-value pair is within this view. </returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.View.CountValues(`0)">
            <summary>
            Gets the number of values associated with a given key.
            </summary>
            <param name="key">The key to count values of.</param>
            <returns>The number of values associated with <paramref name="key"/>. If <paramref name="key"/>
            is not present in this view, zero is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.View.Add(`0,`1)">
            <summary>
            Adds the given key-value pair to the underlying dictionary of this view.
            If <paramref name="key"/> is not within the range of this view, an
            ArgumentException is thrown.
            </summary>
            <param name="key"></param>
            <param name="value"></param>
            <exception cref="T:System.ArgumentException"><paramref name="key"/> is not 
            within the range of this view.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.View.Remove(`0)">
            <summary>
            Removes the key (and associated value) from the underlying dictionary of this view. If
            no key in the view is equal to the passed key, the dictionary and view are unchanged.
            </summary>
            <param name="key">The key to remove.</param>
            <returns>True if the key was found and removed. False if the key was not found.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.View.Remove(`0,`1)">
            <summary>
            Removes the key and value from the underlying dictionary of this view. that is equal to the passed in key. If
            no key in the view is equal to the passed key, or has the given value associated with it, the dictionary and view are unchanged.
            </summary>
            <param name="key">The key to remove.</param>
            <param name="value">The value to remove.</param>
            <returns>True if the key-value pair was found and removed. False if the key-value pair was not found.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.View.Clear">
            <summary>
            Removes all the keys and values within this view from the underlying OrderedMultiDictionary.
            </summary>
            <example>The following removes all the keys that start with "A" from an OrderedMultiDictionary.
            <code>
            dictionary.Range("A", "B").Clear();
            </code>
            </example>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedMultiDictionary`2.View.Reversed">
            <summary>
            Creates a new View that has the same keys and values as this, in the reversed order.
            </summary>
            <returns>A new View that has the reversed order of this view.</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.OrderedMultiDictionary`2.View.Count">
            <summary>
            Number of keys in this view.
            </summary>
            <value>Number of keys that lie within the bounds the view.</value>
        </member>
        <member name="T:Wintellect.PowerCollections.OrderedSet`1">
             <summary>
             OrderedSet&lt;T&gt; is a collection that contains items of type T. 
             The item are maintained in a sorted order, and duplicate items are not allowed. Each item has
             an index in the set: the smallest item has index 0, the next smallest item has index 1,
             and so forth.
             </summary>
             <remarks>
             <p>The items are compared in one of three ways. If T implements IComparable&lt;TKey&gt; or IComparable,
             then the CompareTo method of that interface will be used to compare items. Alternatively, a comparison
             function can be passed in either as a delegate, or as an instance of IComparer&lt;TKey&gt;.</p>
             <p>OrderedSet is implemented as a balanced binary tree. Inserting, deleting, and looking up an
             an element all are done in log(N) type, where N is the number of keys in the tree.</p>
             <p><see cref="T:Wintellect.PowerCollections.Set`1"/> is similar, but uses hashing instead of comparison, and does not maintain
             the items in sorted order.</p>
            </remarks>
            <seealso cref="T:Wintellect.PowerCollections.Set`1"/>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.#ctor">
             <summary>
             Creates a new OrderedSet. The T must implement IComparable&lt;T&gt;
             or IComparable. 
             The CompareTo method of this interface will be used to compare items in this set.
             </summary>
            <remarks>
             Items that are null are permitted, and will be sorted before all other items.
            </remarks>
             <exception cref="T:System.InvalidOperationException">T does not implement IComparable&lt;TKey&gt;.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.#ctor(System.Comparison{`0})">
            <summary>
            Creates a new OrderedSet. The passed delegate will be used to compare items in this set.
            </summary>
            <param name="comparison">A delegate to a method that will be used to compare items.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.#ctor(System.Collections.Generic.IComparer{`0})">
            <summary>
            Creates a new OrderedSet. The Compare method of the passed comparison object
            will be used to compare items in this set.
            </summary>
            <remarks>
            The GetHashCode and Equals methods of the provided IComparer&lt;T&gt; will never
            be called, and need not be implemented.
            </remarks>
            <param name="comparer">An instance of IComparer&lt;T&gt; that will be used to compare items.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.#ctor(System.Collections.Generic.IEnumerable{`0})">
             <summary>
             Creates a new OrderedSet. The T must implement IComparable&lt;T&gt;
             or IComparable. 
             The CompareTo method of this interface will be used to compare items in this set. The set is
             initialized with all the items in the given collection.
             </summary>
            <remarks>
             Items that are null are permitted, and will be sorted before all other items.
            </remarks>
             <param name="collection">A collection with items to be placed into the OrderedSet.</param>
             <exception cref="T:System.InvalidOperationException">T does not implement IComparable&lt;TKey&gt;.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.#ctor(System.Collections.Generic.IEnumerable{`0},System.Comparison{`0})">
            <summary>
            Creates a new OrderedSet. The passed delegate will be used to compare items in this set.
            The set is initialized with all the items in the given collection.
            </summary>
            <param name="collection">A collection with items to be placed into the OrderedSet.</param>
            <param name="comparison">A delegate to a method that will be used to compare items.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.#ctor(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IComparer{`0})">
            <summary>
            Creates a new OrderedSet. The Compare method of the passed comparison object
            will be used to compare items in this set. The set is
            initialized with all the items in the given collection.
            </summary>
            <remarks>
            The GetHashCode and Equals methods of the provided IComparer&lt;T&gt; will never
            be called, and need not be implemented.
            </remarks>
            <param name="collection">A collection with items to be placed into the OrderedSet.</param>
            <param name="comparer">An instance of IComparer&lt;T&gt; that will be used to compare items.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.#ctor(System.Collections.Generic.IComparer{`0},Wintellect.PowerCollections.RedBlackTree{`0})">
            <summary>
            Creates a new OrderedSet given a comparer and a tree that contains the data. Used
            internally for Clone.
            </summary>
            <param name="comparer">Comparer for the set.</param>
            <param name="tree">Data for the set.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.System#ICloneable#Clone">
            <summary>
            Makes a shallow clone of this set; i.e., if items of the
            set are reference types, then they are not cloned. If T is a value type,
            then each element is copied as if by simple assignment.
            </summary>
            <remarks>Cloning the set takes time O(N), where N is the number of items in the set.</remarks>
            <returns>The cloned set.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.Clone">
            <summary>
            Makes a shallow clone of this set; i.e., if items of the
            set are reference types, then they are not cloned. If T is a value type,
            then each element is copied as if by simple assignment.
            </summary>
            <remarks>Cloning the set takes time O(N), where N is the number of items in the set.</remarks>
            <returns>The cloned set.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.CloneContents">
            <summary>
            Makes a deep clone of this set. A new set is created with a clone of
            each element of this set, by calling ICloneable.Clone on each element. If T is
            a value type, then each element is copied as if by simple assignment.
            </summary>
            <remarks><para>If T is a reference type, it must implement
            ICloneable. Otherwise, an InvalidOperationException is thrown.</para>
            <para>Cloning the set takes time O(N log N), where N is the number of items in the set.</para></remarks>
            <returns>The cloned set.</returns>
            <exception cref="T:System.InvalidOperationException">T is a reference type that does not implement ICloneable.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.GetEnumerator">
            <summary>
            Returns an enumerator that enumerates all the items in the set. 
            The items are enumerated in sorted order.
            </summary>
            <remarks>
            <p>Typically, this method is not called directly. Instead the "foreach" statement is used
            to enumerate the items, which uses this method implicitly.</p>
            <p>If an item is added to or deleted from the set while it is being enumerated, then 
            the enumeration will end with an InvalidOperationException.</p>
            <p>Enumeration all the items in the set takes time O(N log N), where N is the number
            of items in the set.</p>
            </remarks>
            <returns>An enumerator for enumerating all the items in the OrderedSet.</returns>		
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.Contains(`0)">
            <summary>
            Determines if this set contains an item equal to <paramref name="item"/>. The set
            is not changed.
            </summary>
            <remarks>Searching the set for an item takes time O(log N), where N is the number of items in the set.</remarks>
            <param name="item">The item to search for.</param>
            <returns>True if the set contains <paramref name="item"/>. False if the set does not contain <paramref name="item"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.TryGetItem(`0,`0@)">
            <summary>
            <para>Determines if this set contains an item equal to <paramref name="item"/>, according to the 
            comparison mechanism that was used when the set was created. The set
            is not changed.</para>
            <para>If the set does contain an item equal to <paramref name="item"/>, then the item from the set is returned.</para>
            </summary>
            <remarks>Searching the set for an item takes time O(log N), where N is the number of items in the set.</remarks>
            <example>
            In the following example, the set contains strings which are compared in a case-insensitive manner. 
            <code>
            OrderedSet&lt;string&gt; set = new OrderedSet&lt;string&gt;(StringComparer.CurrentCultureIgnoreCase);
            set.Add("HELLO");
            string s;
            bool b = set.TryGetItem("Hello", out s);   // b receives true, s receives "HELLO".
            </code>
            </example>
            <param name="item">The item to search for.</param>
            <param name="foundItem">Returns the item from the set that was equal to <paramref name="item"/>.</param>
            <returns>True if the set contains <paramref name="item"/>. False if the set does not contain <paramref name="item"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.IndexOf(`0)">
            <summary>
            Get the index of the given item in the sorted order. The smallest item has index 0,
            the next smallest item has index 1, and the largest item has index Count-1. 
            </summary>
            <remarks>Finding the index takes time O(log N), which N is the number of items in 
            the set.</remarks>
            <param name="item">The item to get the index of.</param>
            <returns>The index of the item in the sorted set, or -1 if the item is not present
            in the set.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.Add(`0)">
            <summary>
            Adds a new item to the set. If the set already contains an item equal to
            <paramref name="item"/>, that item is replaced with <paramref name="item"/>.
            </summary>
            <remarks>
            <para>Equality between items is determined by the comparison instance or delegate used
            to create the set.</para>
            <para>Adding an item takes time O(log N), where N is the number of items in the set.</para></remarks>
            <param name="item">The item to add to the set.</param>
            <returns>True if the set already contained an item equal to <paramref name="item"/> (which was replaced), false 
            otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.System#Collections#Generic#ICollection{T}#Add(`0)">
            <summary>
            Adds a new item to the set. If the set already contains an item equal to
            <paramref name="item"/>, that item is replaces with <paramref name="item"/>.
            </summary>
            <remarks>
            <para>Equality between items is determined by the comparison instance or delegate used
            to create the set.</para>
            <para>Adding an item takes time O(log N), where N is the number of items in the set.</para></remarks>
            <param name="item">The item to add to the set.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.AddMany(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Adds all the items in <paramref name="collection"/> to the set. If the set already contains an item equal to
            one of the items in <paramref name="collection"/>, that item will be replaced.
            </summary>
            <remarks>
            <para>Equality between items is determined by the comparison instance or delegate used
            to create the set.</para>
            <para>Adding the collection takes time O(M log N), where N is the number of items in the set, and M is the 
            number of items in <paramref name="collection"/>.</para></remarks>
            <param name="collection">A collection of items to add to the set.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.Remove(`0)">
            <summary>
            Searches the set for an item equal to <paramref name="item"/>, and if found,
            removes it from the set. If not found, the set is unchanged.
            </summary>
            <remarks>
            <para>Equality between items is determined by the comparison instance or delegate used
            to create the set.</para>
            <para>Removing an item from the set takes time O(log N), where N is the number of items in the set.</para></remarks>
            <param name="item">The item to remove.</param>
            <returns>True if <paramref name="item"/> was found and removed. False if <paramref name="item"/> was not in the set.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.RemoveMany(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Removes all the items in <paramref name="collection"/> from the set. Items
            not present in the set are ignored.
            </summary>
            <remarks>
            <para>Equality between items is determined by the comparison instance or delegate used
            to create the set.</para>
            <para>Removing the collection takes time O(M log N), where N is the number of items in the set, and M is the 
            number of items in <paramref name="collection"/>.</para></remarks>
            <param name="collection">A collection of items to remove from the set.</param>
            <returns>The number of items removed from the set.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.Clear">
            <summary>
            Removes all items from the set.
            </summary>
            <remarks>Clearing the sets takes a constant amount of time, regardless of the number of items in it.</remarks>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.CheckEmpty">
            <summary>
            If the collection is empty, throw an invalid operation exception.
            </summary>
            <exception cref="T:System.InvalidOperationException">The set is empty.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.GetFirst">
            <summary>
            Returns the first item in the set: the item
            that would appear first if the set was enumerated. This is also
            the smallest item in the set.
            </summary>
            <remarks>GetFirst() takes time O(log N), where N is the number of items in the set.</remarks>
            <returns>The first item in the set. </returns>
            <exception cref="T:System.InvalidOperationException">The set is empty.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.GetLast">
            <summary>
            Returns the lastl item in the set: the item
            that would appear last if the set was enumerated. This is also the
            largest item in the set.
            </summary>
            <remarks>GetLast() takes time O(log N), where N is the number of items in the set.</remarks>
            <returns>The lastl item in the set. </returns>
            <exception cref="T:System.InvalidOperationException">The set is empty.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.RemoveFirst">
            <summary>
            Removes the first item in the set. This is also the smallest item in the set.
            </summary>
            <remarks>RemoveFirst() takes time O(log N), where N is the number of items in the set.</remarks>
            <returns>The item that was removed, which was the smallest item in the set. </returns>
            <exception cref="T:System.InvalidOperationException">The set is empty.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.RemoveLast">
            <summary>
            Removes the last item in the set. This is also the largest item in the set.
            </summary>
            <remarks>RemoveLast() takes time O(log N), where N is the number of items in the set.</remarks>
            <returns>The item that was removed, which was the largest item in the set. </returns>
            <exception cref="T:System.InvalidOperationException">The set is empty.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.CheckConsistentComparison(Wintellect.PowerCollections.OrderedSet{`0})">
            <summary>
            Check that this set and another set were created with the same comparison
            mechanism. Throws exception if not compatible.
            </summary>
            <param name="otherSet">Other set to check comparision mechanism.</param>
            <exception cref="T:System.InvalidOperationException">If otherSet and this set don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.IsSupersetOf(Wintellect.PowerCollections.OrderedSet{`0})">
            <summary>
            Determines if this set is a superset of another set. Neither set is modified.
            This set is a superset of <paramref name="otherSet"/> if every element in
            <paramref name="otherSet"/> is also in this set.
            <remarks>IsSupersetOf is computed in time O(M log N), where M is the size of the 
            <paramref name="otherSet"/>, and N is the size of the this set.</remarks>
            </summary>
            <param name="otherSet">OrderedSet to compare to.</param>
            <returns>True if this is a superset of <paramref name="otherSet"/>.</returns>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.IsProperSupersetOf(Wintellect.PowerCollections.OrderedSet{`0})">
            <summary>
            Determines if this set is a proper superset of another set. Neither set is modified.
            This set is a proper superset of <paramref name="otherSet"/> if every element in
            <paramref name="otherSet"/> is also in this set.
            Additionally, this set must have strictly more items than <paramref name="otherSet"/>.
            </summary>
            <remarks>IsProperSupersetOf is computed in time O(M log N), where M is the number of unique items in 
            <paramref name="otherSet"/>.</remarks>
            <param name="otherSet">OrderedSet to compare to.</param>
            <returns>True if this is a proper superset of <paramref name="otherSet"/>.</returns>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.IsSubsetOf(Wintellect.PowerCollections.OrderedSet{`0})">
            <summary>
            Determines if this set is a subset of another set. Neither set is modified.
            This set is a subset of <paramref name="otherSet"/> if every element in this set
            is also in <paramref name="otherSet"/>.
            </summary>
            <remarks>IsSubsetOf is computed in time O(N log M), where M is the size of the 
            <paramref name="otherSet"/>, and N is the size of the this set.</remarks>
            <param name="otherSet">Set to compare to.</param>
            <returns>True if this is a subset of <paramref name="otherSet"/>.</returns>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.IsProperSubsetOf(Wintellect.PowerCollections.OrderedSet{`0})">
            <summary>
            Determines if this set is a proper subset of another set. Neither set is modified.
            This set is a subset of <paramref name="otherSet"/> if every element in this set
            is also in <paramref name="otherSet"/>. Additionally, this set must have strictly 
            fewer items than <paramref name="otherSet"/>.
            </summary>
            <remarks>IsSubsetOf is computed in time O(N log M), where M is the size of the 
            <paramref name="otherSet"/>, and N is the size of the this set.</remarks>
            <param name="otherSet">Set to compare to.</param>
            <returns>True if this is a proper subset of <paramref name="otherSet"/>.</returns>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.IsEqualTo(Wintellect.PowerCollections.OrderedSet{`0})">
            <summary>
            Determines if this set is equal to another set. This set is equal to
            <paramref name="otherSet"/> if they contain the same items.
            </summary>
            <remarks>IsEqualTo is computed in time O(N), where N is the number of items in 
            this set.</remarks>
            <param name="otherSet">Set to compare to</param>
            <returns>True if this set is equal to <paramref name="otherSet"/>, false otherwise.</returns>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.UnionWith(Wintellect.PowerCollections.OrderedSet{`0})">
            <summary>
            Computes the union of this set with another set. The union of two sets
            is all items that appear in either or both of the sets. This set receives
            the union of the two sets, the other set is unchanged.
            </summary>
            <remarks>
            <para>If equal items appear in both sets, the union will include an arbitrary choice of one of the
            two equal items.</para>
            <para>The union of two sets is computed in time O(M + N log M), where M is the size of the 
            larger set, and N is the size of the smaller set.</para>
            </remarks>
            <param name="otherSet">Set to union with.</param>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.IsDisjointFrom(Wintellect.PowerCollections.OrderedSet{`0})">
            <summary>
            Determines if this set is disjoint from another set. Two sets are disjoint
            if no item from one set is equal to any item in the other set.
            </summary>
            <remarks>
            <para>The answer is computed in time O(N log M), where M is the size of the 
            larger set, and N is the size of the smaller set.</para>
            </remarks>
            <param name="otherSet">Set to check disjointness with.</param>
            <returns>True if the two sets are disjoint, false otherwise.</returns>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.Union(Wintellect.PowerCollections.OrderedSet{`0})">
            <summary>
            Computes the union of this set with another set. The union of two sets
            is all items that appear in either or both of the sets. A new set is 
            created with the union of the sets and is returned. This set and the other set 
            are unchanged.
            </summary>
            <remarks>
            <para>If equal items appear in both sets, the union will include an arbitrary choice of one of the
            two equal items.</para>
            <para>The union of two sets is computed in time O(M + N log M), where M is the size of the 
            larger set, and N is the size of the smaller set.</para>
            </remarks>
            <param name="otherSet">Set to union with.</param>
            <returns>The union of the two sets.</returns>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.IntersectionWith(Wintellect.PowerCollections.OrderedSet{`0})">
            <summary>
            Computes the intersection of this set with another set. The intersection of two sets
            is all items that appear in both of the sets. This set receives
            the intersection of the two sets, the other set is unchanged.
            </summary>
            <remarks>
            <para>When equal items appear in both sets, the intersection will include an arbitrary choice of one of the
            two equal items.</para>
            <para>The intersection of two sets is computed in time O(N log M), where M is the size of the 
            larger set, and N is the size of the smaller set.</para>
            </remarks>
            <param name="otherSet">Set to intersection with.</param>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.Intersection(Wintellect.PowerCollections.OrderedSet{`0})">
            <summary>
            Computes the intersection of this set with another set. The intersection of two sets
            is all items that appear in both of the sets. A new set is 
            created with the intersection of the sets and is returned. This set and the other set 
            are unchanged.
            </summary>
            <remarks>
            <para>When equal items appear in both sets, the intersection will include an arbitrary choice of one of the
            two equal items.</para>
            <para>The intersection of two sets is computed in time O(N log M), where M is the size of the 
            larger set, and N is the size of the smaller set.</para>
            </remarks>
            <param name="otherSet">Set to intersection with.</param>
            <returns>The intersection of the two sets.</returns>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.DifferenceWith(Wintellect.PowerCollections.OrderedSet{`0})">
            <summary>
            Computes the difference of this set with another set. The difference of these two sets
            is all items that appear in this set, but not in <paramref name="otherSet"/>. This set receives
            the difference of the two sets; the other set is unchanged.
            </summary>
            <remarks>
            <para>The difference of two sets is computed in time O(M + N log M), where M is the size of the 
            larger set, and N is the size of the smaller set.</para>
            </remarks>
            <param name="otherSet">Set to difference with.</param>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.Difference(Wintellect.PowerCollections.OrderedSet{`0})">
            <summary>
            Computes the difference of this set with another set. The difference of these two sets
            is all items that appear in this set, but not in <paramref name="otherSet"/>. A new set is 
            created with the difference of the sets and is returned. This set and the other set 
            are unchanged.
            </summary>
            <remarks>
            <para>The difference of two sets is computed in time O(M + N log M), where M is the size of the 
            larger set, and N is the size of the smaller set.</para>
            </remarks>
            <param name="otherSet">Set to difference with.</param>
            <returns>The difference of the two sets.</returns>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.SymmetricDifferenceWith(Wintellect.PowerCollections.OrderedSet{`0})">
            <summary>
            Computes the symmetric difference of this set with another set. The symmetric difference of two sets
            is all items that appear in either of the sets, but not both. This set receives
            the symmetric difference of the two sets; the other set is unchanged.
            </summary>
            <remarks>
            <para>The symmetric difference of two sets is computed in time O(M + N log M), where M is the size of the 
            larger set, and N is the size of the smaller set.</para>
            </remarks>
            <param name="otherSet">Set to symmetric difference with.</param>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.SymmetricDifference(Wintellect.PowerCollections.OrderedSet{`0})">
            <summary>
            Computes the symmetric difference of this set with another set. The symmetric difference of two sets
            is all items that appear in either of the sets, but not both. A new set is 
            created with the symmetric difference of the sets and is returned. This set and the other set 
            are unchanged.
            </summary>
            <remarks>
            <para>The symmetric difference of two sets is computed in time O(M + N log M), where M is the size of the 
            larger set, and N is the size of the smaller set.</para>
            </remarks>
            <param name="otherSet">Set to symmetric difference with.</param>
            <returns>The symmetric difference of the two sets.</returns>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.AsList">
            <summary>
            Get a read-only list view of the items in this ordered set. The
            items in the list are in sorted order, with the smallest item
            at index 0. This view does not copy any data, and reflects any
            changes to the underlying OrderedSet.
            </summary>
            <returns>A read-only IList&lt;T&gt; view onto this OrderedSet.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.Reversed">
             <summary>
             Returns a View collection that can be used for enumerating the items in the set in 
             reversed order.
             </summary>
            <remarks>
            <p>Typically, this method is used in conjunction with a foreach statement. For example:
            <code>
             foreach(T item in set.Reversed()) {
                // process item
             }
            </code></p>
             <p>If an item is added to or deleted from the set while the View is being enumerated, then 
             the enumeration will end with an InvalidOperationException.</p>
            <p>Calling Reverse does not copy the data in the tree, and the operation takes constant time.</p>
            </remarks>
             <returns>An OrderedSet.View of items in reverse order.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.Range(`0,System.Boolean,`0,System.Boolean)">
             <summary>
             Returns a View collection that can be used for enumerating a range of the items in the set..
             Only items that are greater than <paramref name="from"/> and 
             less than <paramref name="to"/> are included. The items are enumerated in sorted order.
             Items equal to the end points of the range can be included or excluded depending on the
             <paramref name="fromInclusive"/> and <paramref name="toInclusive"/> parameters.
             </summary>
            <remarks>
            <p>If <paramref name="from"/> is greater than <paramref name="to"/>, the returned collection is empty. </p>
            <p>Typically, this method is used in conjunction with a foreach statement. For example:
            <code>
             foreach(T item in set.Range(from, true, to, false)) {
                // process item
             }
            </code></p>
             <p>If an item is added to or deleted from the set while the View is being enumerated, then 
             the enumeration will end with an InvalidOperationException.</p>
            <p>Calling Range does not copy the data in the tree, and the operation takes constant time.</p>
            </remarks>
             <param name="from">The lower bound of the range.</param>
             <param name="fromInclusive">If true, the lower bound is inclusive--items equal to the lower bound will
             be included in the range. If false, the lower bound is exclusive--items equal to the lower bound will not
             be included in the range.</param>
             <param name="to">The upper bound of the range. </param>
             <param name="toInclusive">If true, the upper bound is inclusive--items equal to the upper bound will
             be included in the range. If false, the upper bound is exclusive--items equal to the upper bound will not
             be included in the range.</param>
             <returns>An OrderedSet.View of items in the given range.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.RangeFrom(`0,System.Boolean)">
             <summary>
             Returns a View collection that can be used for enumerating a range of the items in the set..
             Only items that are greater than (and optionally, equal to) <paramref name="from"/> are included. 
             The items are enumerated in sorted order. Items equal to <paramref name="from"/> can be included
             or excluded depending on the <paramref name="fromInclusive"/> parameter.
             </summary>
            <remarks>
            <p>Typically, this method is used in conjunction with a foreach statement. For example:
            <code>
             foreach(T item in set.RangeFrom(from, true)) {
                // process item
             }
            </code></p>
             <p>If an item is added to or deleted from the set while the View is being enumerated, then 
             the enumeration will end with an InvalidOperationException.</p>
            <p>Calling RangeFrom does not copy the data in the tree, and the operation takes constant time.</p>
            </remarks>
             <param name="from">The lower bound of the range.</param>
             <param name="fromInclusive">If true, the lower bound is inclusive--items equal to the lower bound will
             be included in the range. If false, the lower bound is exclusive--items equal to the lower bound will not
             be included in the range.</param>
             <returns>An OrderedSet.View of items in the given range.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.RangeTo(`0,System.Boolean)">
             <summary>
             Returns a View collection that can be used for enumerating a range of the items in the set..
             Only items that are less than (and optionally, equal to) <paramref name="to"/> are included. 
             The items are enumerated in sorted order. Items equal to <paramref name="to"/> can be included
             or excluded depending on the <paramref name="toInclusive"/> parameter.
             </summary>
            <remarks>
            <p>Typically, this method is used in conjunction with a foreach statement. For example:
            <code>
             foreach(T item in set.RangeTo(to, false)) {
                // process item
             }
            </code></p>
             <p>If an item is added to or deleted from the set while the View is being enumerated, then 
             the enumeration will end with an InvalidOperationException.</p>
            <p>Calling RangeTo does not copy the data in the tree, and the operation takes constant time.</p>
            </remarks>
             <param name="to">The upper bound of the range. </param>
             <param name="toInclusive">If true, the upper bound is inclusive--items equal to the upper bound will
             be included in the range. If false, the upper bound is exclusive--items equal to the upper bound will not
             be included in the range.</param>
             <returns>An OrderedSet.View of items in the given range.</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.OrderedSet`1.Comparer">
            <summary>
            Returns the IComparer&lt;T&gt; used to compare items in this set. 
            </summary>
            <value>If the set was created using a comparer, that comparer is returned. If the set was
            created using a comparison delegate, then a comparer equivalent to that delegate
            is returned. Otherwise
            the default comparer for T (Comparer&lt;T&gt;.Default) is returned.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.OrderedSet`1.Count">
            <summary>
            Returns the number of items in the set.
            </summary>
            <remarks>The size of the set is returned in constant time.</remarks>
            <value>The number of items in the set.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.OrderedSet`1.Item(System.Int32)">
            <summary>
            Get the item by its index in the sorted order. The smallest item has index 0,
            the next smallest item has index 1, and the largest item has index Count-1. 
            </summary>
            <remarks>The indexer takes time O(log N), which N is the number of items in 
            the set.</remarks>
            <param name="index">The index to get the item by.</param>
            <returns>The item at the given index.</returns>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is
            less than zero or greater than or equal to Count.</exception>
        </member>
        <member name="T:Wintellect.PowerCollections.OrderedSet`1.ListView">
            <summary>
            The nested class that provides a read-only list view
            of all or part of the collection.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.ListView.#ctor(Wintellect.PowerCollections.OrderedSet{`0},Wintellect.PowerCollections.RedBlackTree{`0}.RangeTester,System.Boolean,System.Boolean)">
            <summary>
            Create a new list view wrapped the given set.
            </summary>
            <param name="mySet"></param>
            <param name="rangeTester">Range tester that defines the range being used.</param>
            <param name="entireTree">If true, then rangeTester defines the entire tree. Used to optimize some operations.</param>
            <param name="reversed">Is the view enuemerated in reverse order?</param>
        </member>
        <member name="T:Wintellect.PowerCollections.OrderedSet`1.View">
             <summary>
             The OrderedSet&lt;T&gt;.View class is used to look at a subset of the Items
             inside an ordered set. It is returned from the Range, RangeTo, RangeFrom, and Reversed methods. 
             </summary>
            <remarks>
             <p>Views are dynamic. If the underlying set changes, the view changes in sync. If a change is made
             to the view, the underlying set changes accordingly.</p>
            <p>Typically, this class is used in conjunction with a foreach statement to enumerate the items 
             in a subset of the OrderedSet. For example:</p>
            <code>
             foreach(T item in set.Range(from, to)) {
                // process item
             }
            </code>
            </remarks>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.View.#ctor(Wintellect.PowerCollections.OrderedSet{`0},Wintellect.PowerCollections.RedBlackTree{`0}.RangeTester,System.Boolean,System.Boolean)">
            <summary>
            Initialize the view.
            </summary>
            <param name="mySet">OrderedSet being viewed</param>
            <param name="rangeTester">Range tester that defines the range being used.</param>
            <param name="entireTree">If true, then rangeTester defines the entire tree. Used to optimize some operations.</param>
            <param name="reversed">Is the view enuemerated in reverse order?</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.View.ItemInView(`0)">
            <summary>
            Determine if the given item lies within the bounds of this view.
            </summary>
            <param name="item">Item to test.</param>
            <returns>True if the item is within the bounds of this view.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.View.GetEnumerator">
            <summary>
            Enumerate all the items in this view.
            </summary>
            <returns>An IEnumerator&lt;T&gt; with the items in this view.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.View.Clear">
            <summary>
            Removes all the items within this view from the underlying set.
            </summary>
            <example>The following removes all the items that start with "A" from an OrderedSet.
            <code>
            set.Range("A", "B").Clear();
            </code>
            </example>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.View.Add(`0)">
            <summary>
            Adds a new item to the set underlying this View. If the set already contains an item equal to
            <paramref name="item"/>, that item is replaces with <paramref name="item"/>. If
            <paramref name="item"/> is outside the range of this view, an InvalidOperationException
            is thrown.
            </summary>
            <remarks>
            <para>Equality between items is determined by the comparison instance or delegate used
            to create the set.</para>
            <para>Adding an item takes time O(log N), where N is the number of items in the set.</para></remarks>
            <param name="item">The item to add.</param>
            <returns>True if the set already contained an item equal to <paramref name="item"/> (which was replaced), false 
            otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.View.System#Collections#Generic#ICollection{T}#Add(`0)">
            <summary>
            Adds a new item to the set underlying this View. If the set already contains an item equal to
            <paramref name="item"/>, that item is replaces with <paramref name="item"/>. If
            <paramref name="item"/> is outside the range of this view, an InvalidOperationException
            is thrown.
            </summary>
            <remarks>
            <para>Equality between items is determined by the comparison instance or delegate used
            to create the set.</para>
            <para>Adding an item takes time O(log N), where N is the number of items in the set.</para></remarks>
            <param name="item">The item to add.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.View.Remove(`0)">
            <summary>
            Searches the underlying set for an item equal to <paramref name="item"/>, and if found,
            removes it from the set. If not found, the set is unchanged. If the item is outside
            the range of this view, the set is unchanged.
            </summary>
            <remarks>
            <para>Equality between items is determined by the comparison instance or delegate used
            to create the set.</para>
            <para>Removing an item from the set takes time O(log N), where N is the number of items in the set.</para></remarks>
            <param name="item">The item to remove.</param>
            <returns>True if <paramref name="item"/> was found and removed. False if <paramref name="item"/> was not in the set, or
            was outside the range of this view.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.View.Contains(`0)">
            <summary>
            Determines if this view of the set contains an item equal to <paramref name="item"/>. The set
            is not changed. If 
            </summary>
            <remarks>Searching the set for an item takes time O(log N), where N is the number of items in the set.</remarks>
            <param name="item">The item to search for.</param>
            <returns>True if the set contains <paramref name="item"/>, and <paramref name="item"/> is within
            the range of this view. False otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.View.IndexOf(`0)">
            <summary>
            Get the index of the given item in the view. The smallest item in the view has index 0,
            the next smallest item has index 1, and the largest item has index Count-1. 
            </summary>
            <remarks>Finding the index takes time O(log N), which N is the number of items in 
            the set.</remarks>
            <param name="item">The item to get the index of.</param>
            <returns>The index of the item in the view, or -1 if the item is not present
            in the view.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.View.AsList">
            <summary>
            Get a read-only list view of the items in this view. The
            items in the list are in sorted order, with the smallest item
            at index 0. This view does not copy any data, and reflects any
            changes to the underlying OrderedSet.
            </summary>
            <returns>A read-only IList&lt;T&gt; view onto this view.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.View.Reversed">
            <summary>
            Creates a new View that has the same items as this view, in the reversed order.
            </summary>
            <returns>A new View that has the reversed order of this view, with the same upper 
            and lower bounds.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.View.GetFirst">
            <summary>
            Returns the first item in this view: the item
            that would appear first if the view was enumerated. 
            </summary>
            <remarks>GetFirst() takes time O(log N), where N is the number of items in the set.</remarks>
            <returns>The first item in the view. </returns>
            <exception cref="T:System.InvalidOperationException">The view has no items in it.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedSet`1.View.GetLast">
            <summary>
            Returns the last item in the view: the item
            that would appear last if the view was enumerated. 
            </summary>
            <remarks>GetLast() takes time O(log N), where N is the number of items in the set.</remarks>
            <returns>The last item in the view. </returns>
            <exception cref="T:System.InvalidOperationException">The view has no items in it.</exception>
        </member>
        <member name="P:Wintellect.PowerCollections.OrderedSet`1.View.Count">
            <summary>
            Number of items in this view.
            </summary>
            <value>Number of items that lie within the bounds the view.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.OrderedSet`1.View.Item(System.Int32)">
            <summary>
            Get the item by its index in the sorted order. The smallest item in the view has index 0,
            the next smallest item has index 1, and the largest item has index Count-1. 
            </summary>
            <remarks>The indexer takes time O(log N), which N is the number of items in 
            the set.</remarks>
            <param name="index">The index to get the item by.</param>
            <returns>The item at the given index.</returns>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is
            less than zero or greater than or equal to Count.</exception>
        </member>
        <member name="T:Wintellect.PowerCollections.Pair`2">
            <summary>
            Stores a pair of objects within a single struct. This struct is useful to use as the
            T of a collection, or as the TKey or TValue of a dictionary.
            </summary>
        </member>
        <member name="F:Wintellect.PowerCollections.Pair`2.firstComparer">
            <summary>
            Comparers for the first and second type that are used to compare
            values.
            </summary>
        </member>
        <member name="F:Wintellect.PowerCollections.Pair`2.First">
            <summary>
            The first element of the pair.
            </summary>
        </member>
        <member name="F:Wintellect.PowerCollections.Pair`2.Second">
            <summary>
            The second element of the pair.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Pair`2.#ctor(`0,`1)">
            <summary>
            Creates a new pair with given first and second elements.
            </summary>
            <param name="first">The first element of the pair.</param>
            <param name="second">The second element of the pair.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Pair`2.#ctor(System.Collections.Generic.KeyValuePair{`0,`1})">
            <summary>
            Creates a new pair using elements from a KeyValuePair structure. The
            First element gets the Key, and the Second elements gets the Value.
            </summary>
            <param name="keyAndValue">The KeyValuePair to initialize the Pair with .</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Pair`2.Equals(System.Object)">
            <summary>
            Determines if this pair is equal to another object. The pair is equal to another object 
            if that object is a Pair, both element types are the same, and the first and second elements
            both compare equal using object.Equals.
            </summary>
            <param name="obj">Object to compare for equality.</param>
            <returns>True if the objects are equal. False if the objects are not equal.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Pair`2.Equals(Wintellect.PowerCollections.Pair{`0,`1})">
            <summary>
            Determines if this pair is equal to another pair. The pair is equal if  the first and second elements
            both compare equal using IComparable&lt;T&gt;.Equals or object.Equals.
            </summary>
            <param name="other">Pair to compare with for equality.</param>
            <returns>True if the pairs are equal. False if the pairs are not equal.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Pair`2.GetHashCode">
            <summary>
            Returns a hash code for the pair, suitable for use in a hash-table or other hashed collection.
            Two pairs that compare equal (using Equals) will have the same hash code. The hash code for
            the pair is derived by combining the hash codes for each of the two elements of the pair.
            </summary>
            <returns>The hash code.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Pair`2.CompareTo(Wintellect.PowerCollections.Pair{`0,`1})">
            <summary>
            <para> Compares this pair to another pair of the some type. The pairs are compared by using
            the IComparable&lt;T&gt; or IComparable interface on TFirst and TSecond. The pairs
            are compared by their first elements first, if their first elements are equal, then they
            are compared by their second elements.</para>
            <para>If either TFirst or TSecond does not implement IComparable&lt;T&gt; or IComparable, then
            an NotSupportedException is thrown, because the pairs cannot be compared.</para>
            </summary>
            <param name="other">The pair to compare to.</param>
            <returns>An integer indicating how this pair compares to <paramref name="other"/>. Less
            than zero indicates this pair is less than <paramref name="other"/>. Zero indicate this pair is
            equals to <paramref name="other"/>. Greater than zero indicates this pair is greater than
            <paramref name="other"/>.</returns>
            <exception cref="T:System.NotSupportedException">Either FirstSecond or TSecond is not comparable
            via the IComparable&lt;T&gt; or IComparable interfaces.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Pair`2.System#IComparable#CompareTo(System.Object)">
            <summary>
            <para> Compares this pair to another pair of the some type. The pairs are compared by using
            the IComparable&lt;T&gt; or IComparable interface on TFirst and TSecond. The pairs
            are compared by their first elements first, if their first elements are equal, then they
            are compared by their second elements.</para>
            <para>If either TFirst or TSecond does not implement IComparable&lt;T&gt; or IComparable, then
            an NotSupportedException is thrown, because the pairs cannot be compared.</para>
            </summary>
            <param name="obj">The pair to compare to.</param>
            <returns>An integer indicating how this pair compares to <paramref name="obj"/>. Less
            than zero indicates this pair is less than <paramref name="other"/>. Zero indicate this pair is
            equals to <paramref name="obj"/>. Greater than zero indicates this pair is greater than
            <paramref name="obj"/>.</returns>
            <exception cref="T:System.ArgumentException"><paramref name="obj"/> is not of the correct type.</exception>
            <exception cref="T:System.NotSupportedException">Either FirstSecond or TSecond is not comparable
            via the IComparable&lt;T&gt; or IComparable interfaces.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Pair`2.ToString">
            <summary>
            Returns a string representation of the pair. The string representation of the pair is
            of the form:
            <c>First: {0}, Second: {1}</c>
            where {0} is the result of First.ToString(), and {1} is the result of Second.ToString() (or
            "null" if they are null.)
            </summary>
            <returns> The string representation of the pair.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Pair`2.op_Equality(Wintellect.PowerCollections.Pair{`0,`1},Wintellect.PowerCollections.Pair{`0,`1})">
            <summary>
            Determines if two pairs are equal. Two pairs are equal if  the first and second elements
            both compare equal using IComparable&lt;T&gt;.Equals or object.Equals.
            </summary>
            <param name="pair1">First pair to compare.</param>
            <param name="pair2">Second pair to compare.</param>
            <returns>True if the pairs are equal. False if the pairs are not equal.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Pair`2.op_Inequality(Wintellect.PowerCollections.Pair{`0,`1},Wintellect.PowerCollections.Pair{`0,`1})">
            <summary>
            Determines if two pairs are not equal. Two pairs are equal if  the first and second elements
            both compare equal using IComparable&lt;T&gt;.Equals or object.Equals.
            </summary>
            <param name="pair1">First pair to compare.</param>
            <param name="pair2">Second pair to compare.</param>
            <returns>True if the pairs are not equal. False if the pairs are equal.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Pair`2.op_Explicit(Wintellect.PowerCollections.Pair{`0,`1})~System.Collections.Generic.KeyValuePair{`0,`1}">
            <summary>
            Converts a Pair to a KeyValuePair. The Key part of the KeyValuePair gets
            the First element, and the Value part of the KeyValuePair gets the Second 
            elements.
            </summary>
            <param name="pair">Pair to convert.</param>
            <returns>The KeyValuePair created from <paramref name="pair"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Pair`2.ToKeyValuePair">
            <summary>
            Converts this Pair to a KeyValuePair. The Key part of the KeyValuePair gets
            the First element, and the Value part of the KeyValuePair gets the Second 
            elements.
            </summary>
            <returns>The KeyValuePair created from this Pair.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Pair`2.op_Explicit(System.Collections.Generic.KeyValuePair{`0,`1})~Wintellect.PowerCollections.Pair{`0,`1}">
            <summary>
            Converts a KeyValuePair structure into a Pair. The
            First element gets the Key, and the Second element gets the Value.
            </summary>
            <param name="keyAndValue">The KeyValuePair to convert.</param>
            <returns>The Pair created by converted the KeyValuePair into a Pair.</returns>
        </member>
        <member name="T:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2">
            <summary>
            ReadOnlyDictionaryBase is a base class that can be used to more easily implement the
            generic IDictionary&lt;T&gt; and non-generic IDictionary interfaces.
            </summary>
            <remarks>
            <para>To use ReadOnlyDictionaryBase as a base class, the derived class must override
            Count, TryGetValue, GetEnumerator. </para>
            </remarks>
            <typeparam name="TKey">The key type of the dictionary.</typeparam>
            <typeparam name="TValue">The value type of the dictionary.</typeparam>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.#ctor">
            <summary>
            Creates a new DictionaryBase. This must be called from the constructor of the
            derived class to specify whether the dictionary is read-only and the name of the
            collection.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.MethodModifiesCollection">
            <summary>
            Throws an NotSupportedException stating that this collection cannot be modified.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.System#Collections#Generic#IDictionary{TKey@TValue}#Add(`0,`1)">
            <summary>
            Adds a new key-value pair to the dictionary. Always throws an exception
            indicating that this method is not supported in a read-only dictionary.
            </summary>
            <param name="key">Key to add.</param>
            <param name="value">Value to associated with the key.</param>
            <exception cref="T:System.NotSupportedException">Always thrown.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.Remove(`0)">
            <summary>
            Removes a key from the dictionary. Always throws an exception
            indicating that this method is not supported in a read-only dictionary.
            </summary>
            <param name="key">Key to remove from the dictionary.</param>
            <returns>True if the key was found, false otherwise.</returns>
            <exception cref="T:System.NotSupportedException">Always thrown.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.ContainsKey(`0)">
            <summary>
            Determines whether a given key is found
            in the dictionary.
            </summary>
            <remarks>The default implementation simply calls TryGetValue and returns
            what it returns.</remarks>
            <param name="key">Key to look for in the dictionary.</param>
            <returns>True if the key is present in the dictionary.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.TryGetValue(`0,`1@)">
            <summary>
            Determines if this dictionary contains a key equal to <paramref name="key"/>. If so, the value
            associated with that key is returned through the value parameter. This method must be overridden 
            in the derived class.
            </summary>
            <param name="key">The key to search for.</param>
            <param name="value">Returns the value associated with key, if true was returned.</param>
            <returns>True if the dictionary contains key. False if the dictionary does not contain key.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.ToString">
            <summary>
            Shows the string representation of the dictionary. The string representation contains
            a list of the mappings in the dictionary.
            </summary>
            <returns>The string representation of the dictionary.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.Contains(System.Collections.Generic.KeyValuePair{`0,`1})">
            <summary>
            Determines if a dictionary contains a given KeyValuePair. This implementation checks to see if the
            dictionary contains the given key, and if the value associated with the key is equal to (via object.Equals)
            the value.
            </summary>
            <param name="item">A KeyValuePair containing the Key and Value to check for.</param>
            <returns></returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.System#Collections#IDictionary#Add(System.Object,System.Object)">
            <summary>
            Adds a key-value pair to the collection. Always throws an exception
            indicating that this method is not supported in a read-only dictionary.
            </summary>
            <param name="key">Key to add to the dictionary.</param>
            <param name="value">Value to add to the dictionary.</param>
            <exception cref="T:System.NotSupportedException">Always thrown.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.System#Collections#IDictionary#Clear">
            <summary>
            Clears this dictionary. Always throws an exception
            indicating that this method is not supported in a read-only dictionary.
            </summary>
            <exception cref="T:System.NotSupportedException">Always thrown.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.System#Collections#IDictionary#Contains(System.Object)">
            <summary>
            Determines if this dictionary contains a key equal to <paramref name="key"/>. The dictionary
            is not changed. Calls the (overridden) ContainsKey method. If key is not of the correct
            TKey for the dictionary, false is returned.
            </summary>
            <param name="key">The key to search for.</param>
            <returns>True if the dictionary contains key. False if the dictionary does not contain key.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.System#Collections#IDictionary#Remove(System.Object)">
            <summary>
            Removes the key (and associated value) from the collection that is equal to the passed in key. Always throws an exception
            indicating that this method is not supported in a read-only dictionary.
            </summary>
            <param name="key">The key to remove.</param>
            <exception cref="T:System.NotSupportedException">Always thrown.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.System#Collections#IDictionary#GetEnumerator">
            <summary>
            Returns an enumerator that enumerates all the entries in the dictionary. Each entry is 
            returned as a DictionaryEntry.
            The entries are enumerated in the same orders as the (overridden) GetEnumerator
            method.
            </summary>
            <returns>An enumerator for enumerating all the elements in the OrderedDictionary.</returns>		
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.System#Collections#IEnumerable#GetEnumerator">
            <summary>
            Returns an enumerator that enumerates all the entries in the dictionary. Each entry is 
            returned as a DictionaryEntry.
            The entries are enumerated in the same orders as the (overridden) GetEnumerator
            method.
            </summary>
            <returns>An enumerator for enumerating all the elements in the OrderedDictionary.</returns>		
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.DebuggerDisplayString">
            <summary>
            Display the contents of the dictionary in the debugger. This is intentionally private, it is called
            only from the debugger due to the presence of the DebuggerDisplay attribute. It is similar
            format to ToString(), but is limited to 250-300 characters or so, so as not to overload the debugger.
            </summary>
            <returns>The string representation of the items in the collection, similar in format to ToString().</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.Item(`0)">
            <summary>
            The indexer of the dictionary. The set accessor throws an NotSupportedException
            stating the dictionary is read-only.
            </summary>
            <remarks>The get accessor is implemented by calling TryGetValue.</remarks>
            <param name="key">Key to find in the dictionary.</param>
            <returns>The value associated with the key.</returns>
            <exception cref="T:System.NotSupportedException">Always thrown from the set accessor, indicating
            that the dictionary is read only.</exception>
            <exception cref="T:System.Collections.Generic.KeyNotFoundException">Thrown from the get accessor if the key
            was not found.</exception>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.Keys">
            <summary>
            Returns a collection of the keys in this dictionary. 
            </summary>
            <value>A read-only collection of the keys in this dictionary.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.Values">
            <summary>
            Returns a collection of the values in this dictionary. The ordering of 
            values in this collection is the same as that in the Keys collection.
            </summary>
            <value>A read-only collection of the values in this dictionary.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.System#Collections#IDictionary#IsFixedSize">
            <summary>
            Returns whether this dictionary is fixed size. 
            </summary>
            <value>Always returns true.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.System#Collections#IDictionary#IsReadOnly">
            <summary>
            Returns if this dictionary is read-only. 
            </summary>
            <value>Always returns true.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.System#Collections#IDictionary#Keys">
            <summary>
            Returns a collection of all the keys in the dictionary. The values in this collection will
            be enumerated in the same order as the (overridden) GetEnumerator method.
            </summary>
            <value>The collection of keys.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.System#Collections#IDictionary#Values">
            <summary>
            Returns a collection of all the values in the dictionary. The values in this collection will
            be enumerated in the same order as the (overridden) GetEnumerator method.
            </summary>
            <value>The collection of values.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.System#Collections#IDictionary#Item(System.Object)">
            <summary>
            Gets the value associated with a given key. When getting a value, if this
            key is not found in the collection, then null is returned. If the key is not of the correct type 
            for this dictionary, null is returned.
            </summary>
            <value>The value associated with the key, or null if the key was not present.</value>
            <exception cref="T:System.NotSupportedException">Always thrown from the set accessor, indicating
            that the dictionary is read only.</exception>
        </member>
        <member name="T:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.KeysCollection">
            <summary>
            A private class that implements ICollection&lt;TKey&gt; and ICollection for the
            Keys collection. The collection is read-only.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.KeysCollection.#ctor(Wintellect.PowerCollections.ReadOnlyDictionaryBase{`0,`1})">
            <summary>
            Constructor.
            </summary>
            <param name="myDictionary">The dictionary this is associated with.</param>
        </member>
        <member name="T:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.ValuesCollection">
            <summary>
            A private class that implements ICollection&lt;TKey&gt; and ICollection for the
            Values collection. The collection is read-only.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.DictionaryEnumeratorWrapper">
            <summary>
            A class that wraps a IDictionaryEnumerator around an IEnumerator that
            enumerates KeyValuePairs. This is useful in implementing IDictionary, because
            IEnumerator can be implemented with an iterator, but IDictionaryEnumerator cannot.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyDictionaryBase`2.DictionaryEnumeratorWrapper.#ctor(System.Collections.Generic.IEnumerator{System.Collections.Generic.KeyValuePair{`0,`1}})">
            <summary>
            Constructor.
            </summary>
            <param name="enumerator">The enumerator of KeyValuePairs that is being wrapped.</param>
        </member>
        <member name="T:Wintellect.PowerCollections.BigList`1">
            <summary>
            BigList&lt;T&gt; provides a list of items, in order, with indices of the items ranging from 0 to one less
            than the count of items in the collection. BigList&lt;T&gt; is optimized for efficient operations on large (&gt;100 items)
            lists, especially for insertions, deletions, copies, and concatinations.
            </summary>
            <remarks>
            <para>BigList&lt;T&gt; class is similar in functionality to the standard List&lt;T&gt; class. Both classes
            provide a collection that stores an set of items in order, with indices of the items ranging from 0 to one less
            than the count of items in the collection. Both classes provide the ability to add and remove items from any index,
            and the get or set the item at any index.</para> 
            <para>BigList&lt;T&gt; differs significantly from List&lt;T&gt; in the performance of various operations, 
            especially when the lists become large (several hundred items or more). With List&lt;T&gt;, inserting or removing
            elements from anywhere in a large list except the end is very inefficient -- every item after the point of inserting
            or deletion has to be moved in the list. The BigList&lt;T&gt; class, however, allows for fast insertions
            and deletions anywhere in the list. Furthermore, BigList&lt;T&gt; allows copies of a list, sub-parts
            of a list, and concatinations of two lists to be very fast. When a copy is made of part or all of a BigList,
            two lists shared storage for the parts of the lists that are the same. Only when one of the lists is changed is additional
            memory allocated to store the distinct parts of the lists.</para>
            <para>Of course, there is a small price to pay for this extra flexibility. Although still quite efficient, using an 
            index to get or change one element of a BigList, while still reasonably efficient, is significantly slower than using
            a plain List. Because of this, if you want to process every element of a BigList, using a foreach loop is a lot
            more efficient than using a for loop and indexing the list.</para>
            <para>In general, use a List when the only operations you are using are Add (to the end), foreach,
            or indexing, or you are very sure the list will always remain small (less than 100 items). For large (&gt;100 items) lists
            that do insertions, removals, copies, concatinations, or sub-ranges, BigList will be more efficient than List. 
            In almost all cases, BigList is more efficient and easier to use than LinkedList.</para>
            </remarks>
            <typeparam name="T">The type of items to store in the BigList.</typeparam>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.StopEnumerations">
            <summary>
            Must be called whenever there is a structural change in the tree. Causes
            changeStamp to be changed, which causes any in-progress enumerations
            to throw exceptions.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.CheckEnumerationStamp(System.Int32)">
            <summary>
            Checks the given stamp against the current change stamp. If different, the
            collection has changed during enumeration and an InvalidOperationException
            must be thrown
            </summary>
            <param name="startStamp">changeStamp at the start of the enumeration.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.#ctor">
            <summary>
            Creates a new BigList. The BigList is initially empty.
            </summary>
            <remarks>Creating a empty BigList takes constant time and consumes a very small amount of memory.</remarks>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.#ctor(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Creates a new BigList initialized with the items from <paramref name="collection"/>, in order.
            </summary>
            <remarks>Initializing the tree list with the elements of collection takes time O(N), where N is the number of
            items in <paramref name="collection"/>.</remarks>
            <param name="collection">The collection used to initialize the BigList. </param>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.#ctor(System.Collections.Generic.IEnumerable{`0},System.Int32)">
            <summary>
            Creates a new BigList initialized with a given number of copies of the items from <paramref name="collection"/>, in order. 
            </summary>
            <remarks>Initializing the tree list with the elements of collection takes time O(N + log K), where N is the number of
            items in <paramref name="collection"/>, and K is the number of copies.</remarks>
            <param name="copies">Number of copies of the collection to use.</param>
            <param name="collection">The collection used to initialize the BigList. </param>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="copies"/> is negative.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.#ctor(Wintellect.PowerCollections.BigList{`0})">
            <summary>
            Creates a new BigList that is a copy of <paramref name="list"/>.
            </summary>
            <remarks>Copying a BigList takes constant time, and little 
            additional memory, since the storage for the items of the two lists is shared. However, changing
            either list will take additional time and memory. Portions of the list are copied when they are changed.</remarks>
            <param name="list">The BigList to copy. </param>
            <exception cref="T:System.ArgumentNullException"><paramref name="list"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.#ctor(Wintellect.PowerCollections.BigList{`0},System.Int32)">
            <summary>
            Creates a new BigList that is several copies of <paramref name="list"/>.
            </summary>
            <remarks>Creating K copies of a BigList takes time O(log K), and O(log K) 
            additional memory, since the storage for the items of the two lists is shared. However, changing
            either list will take additional time and memory. Portions of the list are copied when they are changed.</remarks>
            <param name="copies">Number of copies of the collection to use.</param>
            <param name="list">The BigList to copy. </param>
            <exception cref="T:System.ArgumentNullException"><paramref name="list"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.#ctor(Wintellect.PowerCollections.BigList{`0}.Node)">
            <summary>
            Creates a new BigList from the indicated Node.
            </summary>
            <param name="node">Node that becomes the new root. If null, the new BigList is empty.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Clear">
            <summary>
            Removes all of the items from the BigList.
            </summary>
            <remarks>Clearing a BigList takes constant time.</remarks>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Insert(System.Int32,`0)">
            <summary>
            Inserts a new item at the given index in the BigList. All items at indexes 
            equal to or greater than <paramref name="index"/> move up one index.
            </summary>
            <remarks>The amount of time to insert an item is O(log N), no matter where
            in the list the insertion occurs. Inserting an item at the beginning or end of the 
            list is O(N). 
            </remarks>
            <param name="index">The index to insert the item at. After the
            insertion, the inserted item is located at this index. The
            first item has index 0.</param>
            <param name="item">The item to insert at the given index.</param>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is
            less than zero or greater than Count.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.InsertRange(System.Int32,System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Inserts a collection of items at the given index in the BigList. All items at indexes 
            equal to or greater than <paramref name="index"/> increase their indices 
            by the number of items inserted.
            </summary>
            <remarks>The amount of time to insert an arbitrary collection in the BigList is O(M + log N), 
            where M is the number of items inserted, and N is the number of items in the list.
            </remarks>
            <param name="index">The index to insert the collection at. After the
            insertion, the first item of the inserted collection is located at this index. The
            first item has index 0.</param>
            <param name="collection">The collection of items to insert at the given index.</param>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is
            less than zero or greater than Count.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.InsertRange(System.Int32,Wintellect.PowerCollections.BigList{`0})">
            <summary>
            Inserts a BigList of items at the given index in the BigList. All items at indexes 
            equal to or greater than <paramref name="index"/> increase their indices 
            by the number of items inserted.
            </summary>
            <remarks>The amount of time to insert another BigList is O(log N), 
            where N is the number of items in the list, regardless of the number of items in the 
            inserted list. Storage is shared between the two lists until one of them is changed.
            </remarks>
            <param name="index">The index to insert the collection at. After the
            insertion, the first item of the inserted collection is located at this index. The
            first item has index 0.</param>
            <param name="list">The BigList of items to insert at the given index.</param>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is
            less than zero or greater than Count.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="list"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.RemoveAt(System.Int32)">
            <summary>
            Removes the item at the given index in the BigList. All items at indexes 
            greater than <paramref name="index"/> move down one index.
            </summary>
            <remarks>The amount of time to delete an item in the BigList is O(log N),
            where N is the number of items in the list. 
            </remarks>
            <param name="index">The index in the list to remove the item at. The
            first item in the list has index 0.</param>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is
            less than zero or greater than or equal to Count.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.RemoveRange(System.Int32,System.Int32)">
            <summary>
            Removes a range of items at the given index in the Deque. All items at indexes 
            greater than <paramref name="index"/> move down <paramref name="count"/> indices
            in the Deque.
            </summary>
            <remarks>The amount of time to delete <paramref name="count"/> items in the Deque is proportional
            to the distance of index from the closest end of the Deque, plus <paramref name="count"/>: 
            O(count + Min(<paramref name="index"/>, Count - 1 - <paramref name="index"/>)).
            </remarks>
            <param name="index">The index in the list to remove the range at. The
            first item in the list has index 0.</param>
            <param name="count">The number of items to remove.</param>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is
            less than zero or greater than or equal to Count, or <paramref name="count"/> is less than zero
            or too large.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Add(`0)">
            <summary>
            Adds an item to the end of the BigList. The indices of all existing items
            in the Deque are unchanged. 
            </summary>
            <remarks>Adding an item takes, on average, constant time.</remarks>
            <param name="item">The item to add.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.AddToFront(`0)">
            <summary>
            Adds an item to the beginning of the BigList. The indices of all existing items
            in the Deque are increased by one, and the new item has index zero. 
            </summary>
            <remarks>Adding an item takes, on average, constant time.</remarks>
            <param name="item">The item to add.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.AddRange(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Adds a collection of items to the end of BigList. The indices of all existing items
            are unchanged. The last item in the added collection becomes the
            last item in the BigList.
            </summary>
            <remarks>This method takes time O(M + log N), where M is the number of items in the 
            <paramref name="collection"/>, and N is the size of the BigList.</remarks>
            <param name="collection">The collection of items to add.</param>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.AddRangeToFront(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Adds a collection of items to the front of BigList. The indices of all existing items
            in the are increased by the number of items in <paramref name="collection"/>. 
            The first item in the added collection becomes the first item in the BigList.
            </summary>
            <remarks>This method takes time O(M + log N), where M is the number of items in the 
            <paramref name="collection"/>, and N is the size of the BigList.</remarks>
            <param name="collection">The collection of items to add.</param>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Clone">
            <summary>
            Creates a new BigList that is a copy of this list.
            </summary>
            <remarks>Copying a BigList takes constant time, and little 
            additional memory, since the storage for the items of the two lists is shared. However, changing
            either list will take additional time and memory. Portions of the list are copied when they are changed.</remarks>
            <returns>A copy of the current list</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.System#ICloneable#Clone">
            <summary>
            Creates a new BigList that is a copy of this list.
            </summary>
            <remarks>Copying a BigList takes constant time, and little 
            additional memory, since the storage for the items of the two lists is shared. However, changing
            either list will take additional time and memory. Portions of the list are copied when they are changed.</remarks>
            <returns>A copy of the current list</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.CloneContents">
            <summary>
            Makes a deep clone of this BigList. A new BigList is created with a clone of
            each element of this set, by calling ICloneable.Clone on each element. If T is
            a value type, then this method is the same as Clone.
            </summary>
            <remarks><para>If T is a reference type, it must implement
            ICloneable. Otherwise, an InvalidOperationException is thrown.</para>
            <para>If T is a reference type, cloning the list takes time approximate O(N), where N is the number of items in the list.</para></remarks>
            <returns>The cloned set.</returns>
            <exception cref="T:System.InvalidOperationException">T is a reference type that does not implement ICloneable.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.AddRange(Wintellect.PowerCollections.BigList{`0})">
            <summary>
            Adds a BigList of items to the end of BigList. The indices of all existing items
            are unchanged. The last item in <paramref name="list"/> becomes the
            last item in this list. The added list <paramref name="list"/> is unchanged.
            </summary>
            <remarks>This method takes, on average, constant time, regardless of the size
            of either list. Although conceptually all of the items in <paramref name="list"/> are
            copied, storage is shared between the two lists until changes are made to the 
            shared sections.</remarks>
            <param name="list">The list of items to add.</param>
            <exception cref="T:System.ArgumentNullException"><paramref name="list"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.AddRangeToFront(Wintellect.PowerCollections.BigList{`0})">
            <summary>
            Adds a BigList of items to the front of BigList. The indices of all existing items
            are increased by the number of items in <paramref name="list"/>. The first item in <paramref name="list"/> 
            becomes the first item in this list. The added list <paramref name="list"/> is unchanged.
            </summary>
            <remarks>This method takes, on average, constant time, regardless of the size
            of either list. Although conceptually all of the items in <paramref name="list"/> are
            copied, storage is shared between the two lists until changes are made to the 
            shared sections.</remarks>
            <param name="list">The list of items to add.</param>
            <exception cref="T:System.ArgumentNullException"><paramref name="list"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.op_Addition(Wintellect.PowerCollections.BigList{`0},Wintellect.PowerCollections.BigList{`0})">
            <summary>
            Concatenates two lists together to create a new list. Both lists being concatenated
            are unchanged. The resulting list contains all the items in <paramref name="first"/>, followed
            by all the items in <paramref name="second"/>.
            </summary>
            <remarks>This method takes, on average, constant time, regardless of the size
            of either list. Although conceptually all of the items in both lists are
            copied, storage is shared until changes are made to the 
            shared sections.</remarks>
            <param name="first">The first list to concatenate.</param>
            <param name="second">The second list to concatenate.</param>
            <exception cref="T:System.ArgumentNullException"><paramref name="first"/> or <paramref name="second"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.GetRange(System.Int32,System.Int32)">
            <summary>
            Creates a new list that contains a subrange of elements from this list. The
            current list is unchanged.
            </summary>
            <remarks>This method takes take O(log N), where N is the size of the current list. Although
            the sub-range is conceptually copied, storage is shared between the two lists until a change
            is made to the shared items.</remarks>
            <remarks>If a view of a sub-range is desired, instead of a copy, use the
            more efficient <see cref="M:Wintellect.PowerCollections.BigList`1.Range(System.Int32,System.Int32)"/> method, which provides a view onto a sub-range of items.</remarks>
            <param name="index">The starting index of the sub-range.</param>
            <param name="count">The number of items in the sub-range. If this is zero,
            the returned list is empty.</param>
            <returns>A new list with the <paramref name="count"/> items that start at <paramref name="index"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Range(System.Int32,System.Int32)">
            <summary>
            Returns a view onto a sub-range of this list. Items are not copied; the
            returned IList&lt;T&gt; is simply a different view onto the same underlying items. Changes to this list
            are reflected in the view, and vice versa. Insertions and deletions in the view change the size of the 
            view, but insertions and deletions in the underlying list do not.
            </summary>
            <remarks>
            <para>If a copy of the sub-range is desired, use the <see cref="M:Wintellect.PowerCollections.BigList`1.GetRange(System.Int32,System.Int32)"/> method instead.</para>
            <para>This method can be used to apply an algorithm to a portion of a list. For example:</para>
            <code>Algorithms.ReverseInPlace(list.Range(3, 6))</code>
            will reverse the 6 items beginning at index 3.</remarks>
            <param name="index">The starting index of the view.</param>
            <param name="count">The number of items in the view.</param>
            <returns>A list that is a view onto the given sub-list. </returns>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> or <paramref name="count"/> is negative.</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> + <paramref name="count"/> is greater than the
            size of this list.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.GetEnumerator(System.Int32,System.Int32)">
            <summary>
            Enumerates a range of the items in the list, in order. The item at <paramref name="start"/>
            is enumerated first, then the next item at index 1, and so on. At most <paramref name="maxItems"/>
            items are enumerated. 
            </summary>
            <remarks>Enumerating all of the items in the list take time O(N), where
            N is the number of items being enumerated. Using GetEnumerator() or foreach
            is much more efficient than accessing all items by index.</remarks>
            <param name="start">Index to start enumerating at.</param>
            <param name="maxItems">Max number of items to enumerate.</param>
            <returns>An IEnumerator&lt;T&gt; that enumerates all the
            items in the given range.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.GetEnumerator">
            <summary>
            Enumerates all of the items in the list, in order. The item at index 0
            is enumerated first, then the item at index 1, and so on. Usually, the
            foreach statement is used to call this method implicitly.
            </summary>
            <remarks>Enumerating all of the items in the list take time O(N), where
            N is the number of items in the list. Using GetEnumerator() or foreach
            is much more efficient than accessing all items by index.</remarks>
            <returns>An IEnumerator&lt;T&gt; that enumerates all the
            items in the list.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.NodeFromEnumerable(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Given an IEnumerable&lt;T&gt;, create a new Node with all of the 
            items in the enumerable. Returns null if the enumerable has no items.
            </summary>
            <param name="collection">The collection to copy.</param>
            <returns>Returns a Node, not shared or with any shared children, 
            with the items from the collection. If the collection was empty,
            null is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.LeafFromEnumerator(System.Collections.Generic.IEnumerator{`0})">
            <summary>
            Consumes up to MAXLEAF items from an Enumerator and places them in a leaf
            node. If the enumerator is at the end, null is returned.
            </summary>
            <param name="enumerator">The enumerator to take items from.</param>
            <returns>A LeafNode with items taken from the enumerator. </returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.NCopiesOfNode(System.Int32,Wintellect.PowerCollections.BigList{`0}.Node)">
            <summary>
            Create a node that has N copies of the given node. 
            </summary>
            <param name="copies">Number of copies. Must be non-negative.</param>
            <param name="node">Node to make copies of.</param>
            <returns>null if node is null or copies is 0. Otherwise, a node consisting of <paramref name="copies"/> copies
            of node.</returns>
            <exception cref="T:System.ArgumentOutOfRangeException">copies is negative.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.CheckBalance">
            <summary>
            Check the balance of the current tree and rebalance it if it is more than BALANCEFACTOR
            levels away from fully balanced. Note that rebalancing a tree may leave it two levels away from 
            fully balanced.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Rebalance">
            <summary>
            Rebalance the current tree. Once rebalanced, the depth of the current tree is no more than
            two levels from fully balanced, where fully balanced is defined as having Fibonacci(N+2) or more items
            in a tree of depth N.
            </summary>
            <remarks>The rebalancing algorithm is from "Ropes: an Alternative to Strings", by 
            Boehm, Atkinson, and Plass, in SOFTWARE--PRACTICE AND EXPERIENCE, VOL. 25(12), 1315–1330 (DECEMBER 1995).
            </remarks>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.AddNodeToRebalanceArray(Wintellect.PowerCollections.BigList{`0}.Node[],Wintellect.PowerCollections.BigList{`0}.Node,System.Boolean)">
            <summary>
            Part of the rebalancing algorithm. Adds a node to the rebalance array. If it is already balanced, add it directly, otherwise
            add its children.
            </summary>
            <param name="rebalanceArray">Rebalance array to insert into.</param>
            <param name="node">Node to add.</param>
            <param name="shared">If true, mark the node as shared before adding, because one
            of its parents was shared.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.AddBalancedNodeToRebalanceArray(Wintellect.PowerCollections.BigList{`0}.Node[],Wintellect.PowerCollections.BigList{`0}.Node)">
            <summary>
            Part of the rebalancing algorithm. Adds a balanced node to the rebalance array. 
            </summary>
            <param name="rebalanceArray">Rebalance array to insert into.</param>
            <param name="balancedNode">Node to add.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.ConvertAll``1(System.Converter{`0,``0})">
            <summary>
            Convert the list to a new list by applying a delegate to each item in the collection. The resulting list
            contains the result of applying <paramref name="converter"/> to each item in the list, in
            order. The current list is unchanged.
            </summary>
            <typeparam name="TDest">The type each item is being converted to.</typeparam>
            <param name="converter">A delegate to the method to call, passing each item in <paramref name="sourceCollection"/>.</param>
            <returns>The resulting BigList from applying <paramref name="converter"/> to each item in this list.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="converter"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Reverse">
            <summary>
            Reverses the current list in place.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Reverse(System.Int32,System.Int32)">
            <summary>
            Reverses the items in the range of <paramref name="count"/> items starting from <paramref name="startIndex"/>, in place.
            </summary>
            <param name="start">The starting index of the range to reverse.</param>
            <param name="count">The number of items in range to reverse.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Sort">
            <summary>
            Sorts the list in place.
            </summary>
            <remarks><para>The Quicksort algorithm is used to sort the items. In virtually all cases,
            this takes time O(N log N), where N is the number of items in the list.</para>
            <para>Values are compared by using the IComparable or IComparable&lt;T&gt;
            interface implementation on the type T.</para></remarks>
            <exception cref="T:System.InvalidOperationException">The type T does not implement either the IComparable or
            IComparable&lt;T&gt; interfaces.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Sort(System.Collections.Generic.IComparer{`0})">
            <summary>
            Sorts the list in place. A supplied IComparer&lt;T&gt; is used
            to compare the items in the list. 
            </summary>
            <remarks>The Quicksort algorithms is used to sort the items. In virtually all cases,
            this takes time O(N log N), where N is the number of items in the list.</remarks>
            <param name="comparer">The comparer instance used to compare items in the collection. Only
            the Compare method is used.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Sort(System.Comparison{`0})">
            <summary>
            Sorts the list in place. A supplied Comparison&lt;T&gt; delegate is used
            to compare the items in the list.
            </summary>
            <remarks>The Quicksort algorithms is used to sort the items. In virtually all cases,
            this takes time O(N log N), where N is the number of items in the list.</remarks>
            <param name="comparison">The comparison delegate used to compare items in the collection.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.BinarySearch(`0)">
            <summary>
            Searches a sorted list for an item via binary search. The list must be sorted
            in the order defined by the default ordering of the item type; otherwise, 
            incorrect results will be returned.
            </summary>
            <param name="item">The item to search for.</param>
            <returns>Returns the index of the first occurence of <paramref name="item"/> in the list. If the item does not occur
            in the list, the bitwise complement of the first item larger than <paramref name="item"/> in the list is returned. If no item is 
            larger than <paramref name="item"/>, the bitwise complement of Count is returned.</returns>
            <exception cref="T:System.InvalidOperationException">The type T does not implement either the IComparable or
            IComparable&lt;T&gt; interfaces.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.BinarySearch(`0,System.Collections.Generic.IComparer{`0})">
            <summary>
            Searches a sorted list for an item via binary search. The list must be sorted
            by the ordering defined by the passed IComparer&lt;T&gt; interface; otherwise, 
            incorrect results will be returned.
            </summary>
            <param name="item">The item to search for.</param>
            <param name="comparer">The IComparer&lt;T&gt; interface used to sort the list.</param>
            <returns>Returns the index of the first occurence of <paramref name="item"/> in the list. If the item does not occur
            in the list, the bitwise complement of the first item larger than <paramref name="item"/> in the list is returned. If no item is 
            larger than <paramref name="item"/>, the bitwise complement of Count is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.BinarySearch(`0,System.Comparison{`0})">
            <summary>
            Searches a sorted list for an item via binary search. The list must be sorted
            by the ordering defined by the passed Comparison&lt;T&gt; delegate; otherwise, 
            incorrect results will be returned.
            </summary>
            <param name="item">The item to search for.</param>
            <param name="comparison">The comparison delegate used to sort the list.</param>
            <returns>Returns the index of the first occurence of <paramref name="item"/> in the list. If the item does not occur
            in the list, the bitwise complement of the first item larger than <paramref name="item"/> in the list is returned. If no item is 
            larger than <paramref name="item"/>, the bitwise complement of Count is returned.</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.BigList`1.Count">
            <summary>
            Gets the number of items stored in the BigList. The indices of the items
            range from 0 to Count-1.
            </summary>
            <remarks>Getting the number of items in the BigList takes constant time.</remarks>
            <value>The number of items in the BigList.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.BigList`1.Item(System.Int32)">
            <summary>
            Gets or sets an item in the list, by index.
            </summary>
            <remarks><para> Gettingor setting an item takes time O(log N), where N is the number of items
            in the list.</para>
            <para>To process each of the items in the list, using GetEnumerator() or a foreach loop is more efficient
            that accessing each of the elements by index.</para></remarks>
            <param name="index">The index of the item to get or set. The first item in the list
            has index 0, the last item has index Count-1.</param>
            <returns>The value of the item at the given index.</returns>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="index"/> is less than zero or 
            greater than or equal to Count.</exception>
        </member>
        <member name="T:Wintellect.PowerCollections.BigList`1.Node">
            <summary>
            The base class for the two kinds of nodes in the tree: Concat nodes
            and Leaf nodes.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Node.MarkShared">
            <summary>
            Marks this node as shared by setting the shared variable.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Node.GetAt(System.Int32)">
            <summary>
            Returns the items at the given index in this node.
            </summary>
            <param name="index">0-based index, relative to this node.</param>
            <returns>Item at that index.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Node.Subrange(System.Int32,System.Int32)">
            <summary>
            Returns a node that has a sub-range of items from this node. The
            sub-range may not be empty, but may extend outside the node. 
            In other words, first might be less than zero or last might be greater
            than count. But, last can't be less than zero and first can't be
            greater than count. Also, last must be greater than or equal to last.
            </summary>
            <param name="first">Inclusive first element, relative to this node.</param>
            <param name="last">Inclusize last element, relative to this node.</param>
            <returns>Node with the given sub-range.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Node.SetAt(System.Int32,`0)">
            <summary>
            Changes the item at the given index. Never changes this node,
            but always returns a new node with the given item changed.
            </summary>
            <param name="index">Index, relative to this node, to change.</param>
            <param name="item">New item to place at the given index.</param>
            <returns>A new node with the given item changed.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Node.SetAtInPlace(System.Int32,`0)">
            <summary>
            Changes the item at the given index. May change this node,
            or return a new node with the given item changed.
            </summary>
            <param name="index">Index, relative to this node, to change.</param>
            <param name="item">New item to place at the given index.</param>
            <returns>A node with the give item changed. If it can be done in place
            then "this" is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Node.Append(Wintellect.PowerCollections.BigList{`0}.Node,System.Boolean)">
            <summary>
            Append a node after this node. Never changes this node, but returns
            a new node with the given appending done.
            </summary>
            <param name="node">Node to append.</param>
            <param name="nodeIsUnused">If true, the given node is not used
            in any current list, so it may be change, overwritten, or destroyed
            if convenient. If false, the given node is in use. It should be marked
            as shared if is is used within the return value.</param>
            <returns>A new node with the give node appended to this node.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Node.AppendInPlace(Wintellect.PowerCollections.BigList{`0}.Node,System.Boolean)">
            <summary>
            Append a node after this node. May change this node, or return 
            a new node.
            </summary>
            <param name="node">Node to append.</param>
            <param name="nodeIsUnused">If true, the given node is not used
            in any current list, so it may be change, overwritten, or destroyed
            if convenient. If false, the given node is in use. It should be marked
            as shared if is is used within the return value.</param>
            <returns>A node with the give node appended to this node. May be a new
            node or the current node.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Node.AppendInPlace(`0)">
            <summary>
            Append a item after this node. May change this node, or return 
            a new node. Equivalent to AppendInPlace(new LeafNode(item), true), but
            may be more efficient because a new LeafNode might not be allocated.
            </summary>
            <param name="item">Item to append.</param>
            <returns>A node with the given item appended to this node. May be a new
            node or the current node.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Node.RemoveRange(System.Int32,System.Int32)">
            <summary>
            Remove a range of items from this node. Never changes this node, but returns
            a new node with the removing done. The
            sub-range may not be empty, but may extend outside the node. 
            In other words, first might be less than zero or last might be greater
            than count. But, last can't be less than zero and first can't be
            greater than count. Also, last must be greater than or equal to last.
            </summary>
            <param name="first">Inclusive index of first item in sub-range, relative
            to this node.</param>
            <param name="last">Inclusize index of last item in sub-range, relative
            to this node.</param>
            <returns>A new node with the sub-range removed.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Node.RemoveRangeInPlace(System.Int32,System.Int32)">
            <summary>
            Remove a range of items from this node. May change this node, or returns
            a new node with the given appending done. The
            sub-range may not be empty, but may extend outside the node. 
            In other words, first might be less than zero or last might be greater
            than count. But, last can't be less than zero and first can't be
            greater than count. Also, last must be greater than or equal to last.
            </summary>
            <param name="first">Inclusive index of first item in sub-range, relative
            to this node.</param>
            <param name="last">Inclusize index of last item in sub-range, relative
            to this node.</param>
            <returns>A node with the sub-range removed. If done in-place, returns
            "this".</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Node.Insert(System.Int32,Wintellect.PowerCollections.BigList{`0}.Node,System.Boolean)">
            <summary>
            Inserts a node inside this node. Never changes this node, but returns
            a new node with the given appending done.
            </summary>
            <param name="index">Index, relative to this node, to insert at. Must 
            be in bounds.</param>
            <param name="node">Node to insert.</param>
            <param name="nodeIsUnused">If true, the given node is not used
            in any current list, so it may be change, overwritten, or destroyed
            if convenient. If false, the given node is in use. It should be marked
            as shared if is is used within the return value.</param>
            <returns>A new node with the give node inserted.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Node.InsertInPlace(System.Int32,`0)">
            <summary>
            Inserts an item inside this node. May change this node, or return
            a new node with the given appending done. Equivalent to 
            InsertInPlace(new LeafNode(item), true), but may be more efficient.
            </summary>
            <param name="index">Index, relative to this node, to insert at. Must 
            be in bounds.</param>
            <param name="item">Item to insert.</param>
            <returns>A node with the give item inserted. If done in-place, returns
            "this".</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Node.InsertInPlace(System.Int32,Wintellect.PowerCollections.BigList{`0}.Node,System.Boolean)">
            <summary>
            Inserts a node inside this node. May change this node, or return
            a new node with the given appending done.
            </summary>
            <param name="index">Index, relative to this node, to insert at. Must 
            be in bounds.</param>
            <param name="node">Node to insert.</param>
            <param name="nodeIsUnused">If true, the given node is not used
            in any current list, so it may be change, overwritten, or destroyed
            if convenient. If false, the given node is in use. It should be marked
            as shared if is is used within the return value.</param>
            <returns>A node with the given item inserted. If done in-place, returns
            "this".</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Node.Prepend(Wintellect.PowerCollections.BigList{`0}.Node,System.Boolean)">
            <summary>
            Prefpend a node before this node. Never changes this node, but returns
            a new node with the given prepending done.
            </summary>
            <param name="node">Node to prepend.</param>
            <param name="nodeIsUnused">If true, the given node is not used
            in any current list, so it may be change, overwritten, or destroyed
            if convenient. If false, the given node is in use. It should be marked
            as shared if is is used within the return value.</param>
            <returns>A new node with the give node prepended to this node.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Node.PrependInPlace(Wintellect.PowerCollections.BigList{`0}.Node,System.Boolean)">
            <summary>
            Prepend a node before this node. May change this node, or return 
            a new node.
            </summary>
            <param name="node">Node to prepend.</param>
            <param name="nodeIsUnused">If true, the given node is not used
            in any current list, so it may be change, overwritten, or destroyed
            if convenient. If false, the given node is in use. It should be marked
            as shared if is is used within the return value.</param>
            <returns>A node with the give node prepended to this node. May be a new
            node or the current node.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Node.PrependInPlace(`0)">
            <summary>
            Prepend a item before this node. May change this node, or return 
            a new node. Equivalent to PrependInPlace(new LeafNode(item), true), but
            may be more efficient because a new LeafNode might not be allocated.
            </summary>
            <param name="item">Item to prepend.</param>
            <returns>A node with the given item prepended to this node. May be a new
            node or the current node.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Node.IsBalanced">
            <summary>
            Determine if this node is balanced. A node is balanced if the number
            of items is greater than
            Fibonacci(Depth+2). Balanced nodes are never rebalanced unless
            they go out of balance again.
            </summary>
            <returns>True if the node is balanced by this definition.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.Node.IsAlmostBalanced">
            <summary>
            Determine if this node is almost balanced. A node is almost balanced if t
            its depth is at most one greater than a fully balanced node with the same count.
            </summary>
            <returns>True if the node is almost balanced by this definition.</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.BigList`1.Node.Count">
            <summary>
            The number of items stored in the node (or below it).
            </summary>
            <value>The number of items in the node or below.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.BigList`1.Node.Shared">
            <summary>
            Is this node shared by more that one list (or within a single)
            lists. If true, indicates that this node, and any nodes below it,
            may never be modified. Never becomes false after being set to 
            true.
            </summary>
            <value></value>
        </member>
        <member name="P:Wintellect.PowerCollections.BigList`1.Node.Depth">
            <summary>
            Gets the depth of this node. A leaf node has depth 0, 
            a concat node with two leaf children has depth 1, etc.
            </summary>
            <value>The depth of this node.</value>
        </member>
        <member name="T:Wintellect.PowerCollections.BigList`1.LeafNode">
            <summary>
            The LeafNode class is the type of node that lives at the leaf of a tree and holds
            the actual items stored in the list. Each leaf holds at least 1, and at most MAXLEAF
            items in the items array. The number of items stored is found in "count", which may
            be less than "items.Length".
            </summary>
        </member>
        <member name="F:Wintellect.PowerCollections.BigList`1.LeafNode.items">
            <summary>
            Array that stores the items in the nodes. Always has a least "count" elements,
            but may have more as padding.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.LeafNode.#ctor(`0)">
            <summary>
            Creates a LeafNode that holds a single item.
            </summary>
            <param name="item">Item to place into the leaf node.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.LeafNode.#ctor(System.Int32,`0[])">
            <summary>
            Creates a new leaf node with the indicates count of item and the
            </summary>
            <param name="count">Number of items. Can't be zero.</param>
            <param name="newItems">The array of items. The LeafNode takes
            possession of this array.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.LeafNode.GetAt(System.Int32)">
            <summary>
            Returns the items at the given index in this node.
            </summary>
            <param name="index">0-based index, relative to this node.</param>
            <returns>Item at that index.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.LeafNode.SetAtInPlace(System.Int32,`0)">
            <summary>
            Changes the item at the given index. May change this node,
            or return a new node with the given item changed.
            </summary>
            <param name="index">Index, relative to this node, to change.</param>
            <param name="item">New item to place at the given index.</param>
            <returns>A node with the give item changed. If it can be done in place
            then "this" is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.LeafNode.SetAt(System.Int32,`0)">
            <summary>
            Changes the item at the given index. Never changes this node,
            but always returns a new node with the given item changed.
            </summary>
            <param name="index">Index, relative to this node, to change.</param>
            <param name="item">New item to place at the given index.</param>
            <returns>A new node with the given item changed.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.LeafNode.MergeLeafInPlace(Wintellect.PowerCollections.BigList{`0}.Node)">
            <summary>
            If other is a leaf node, and the resulting size would be less than MAXLEAF, merge
            the other leaf node into this one (after this one) and return true.
            </summary>
            <param name="other">Other node to possible merge.</param>
            <returns>If <paramref name="other"/> could be merged into this node, returns
            true. Otherwise returns false and the current node is unchanged.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.LeafNode.MergeLeaf(Wintellect.PowerCollections.BigList{`0}.Node)">
            <summary>
            If other is a leaf node, and the resulting size would be less than MAXLEAF, merge
            the other leaf node with this one (after this one) and return a new node with 
            the merged items. Does not modify this.
            If no merging, return null.
            </summary>
            <param name="other">Other node to possible merge.</param>
            <returns>If the nodes could be merged, returns the new node. Otherwise
            returns null.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.LeafNode.PrependInPlace(`0)">
            <summary>
            Prepend a item before this node. May change this node, or return 
            a new node. Equivalent to PrependInPlace(new LeafNode(item), true), but
            may be more efficient because a new LeafNode might not be allocated.
            </summary>
            <param name="item">Item to prepend.</param>
            <returns>A node with the given item prepended to this node. May be a new
            node or the current node.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.LeafNode.AppendInPlace(`0)">
            <summary>
            Append a item after this node. May change this node, or return 
            a new node. Equivalent to AppendInPlace(new LeafNode(item), true), but
            may be more efficient because a new LeafNode might not be allocated.
            </summary>
            <param name="item">Item to append.</param>
            <returns>A node with the given item appended to this node. May be a new
            node or the current node.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.LeafNode.AppendInPlace(Wintellect.PowerCollections.BigList{`0}.Node,System.Boolean)">
            <summary>
            Append a node after this node. May change this node, or return 
            a new node.
            </summary>
            <param name="node">Node to append.</param>
            <param name="nodeIsUnused">If true, the given node is not used
            in any current list, so it may be change, overwritten, or destroyed
            if convenient. If false, the given node is in use. It should be marked
            as shared if is is used within the return value.</param>
            <returns>A node with the give node appended to this node. May be a new
            node or the current node.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.LeafNode.InsertInPlace(System.Int32,`0)">
            <summary>
            Inserts an item inside this node. May change this node, or return
            a new node with the given appending done. Equivalent to 
            InsertInPlace(new LeafNode(item), true), but may be more efficient.
            </summary>
            <param name="index">Index, relative to this node, to insert at. Must 
            be in bounds.</param>
            <param name="item">Item to insert.</param>
            <returns>A node with the give item inserted. If done in-place, returns
            "this".</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.LeafNode.InsertInPlace(System.Int32,Wintellect.PowerCollections.BigList{`0}.Node,System.Boolean)">
            <summary>
            Inserts a node inside this node. May change this node, or return
            a new node with the given appending done.
            </summary>
            <param name="index">Index, relative to this node, to insert at. Must 
            be in bounds.</param>
            <param name="node">Node to insert.</param>
            <param name="nodeIsUnused">If true, the given node is not used
            in any current list, so it may be change, overwritten, or destroyed
            if convenient. If false, the given node is in use. It should be marked
            as shared if is is used within the return value.</param>
            <returns>A node with the given item inserted. If done in-place, returns
            "this".</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.LeafNode.Insert(System.Int32,Wintellect.PowerCollections.BigList{`0}.Node,System.Boolean)">
            <summary>
            Inserts a node inside this node. Never changes this node, but returns
            a new node with the given appending done.
            </summary>
            <param name="index">Index, relative to this node, to insert at. Must 
            be in bounds.</param>
            <param name="node">Node to insert.</param>
            <param name="nodeIsUnused">If true, the given node is not used
            in any current list, so it may be change, overwritten, or destroyed
            if convenient. If false, the given node is in use. It should be marked
            as shared if is is used within the return value.</param>
            <returns>A new node with the give node inserted.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.LeafNode.RemoveRangeInPlace(System.Int32,System.Int32)">
            <summary>
            Remove a range of items from this node. May change this node, or returns
            a new node with the given appending done. The
            sub-range may not be empty, but may extend outside the node. 
            In other words, first might be less than zero or last might be greater
            than count. But, last can't be less than zero and first can't be
            greater than count. Also, last must be greater than or equal to last.
            </summary>
            <param name="first">Inclusive index of first item in sub-range, relative
            to this node.</param>
            <param name="last">Inclusize index of last item in sub-range, relative
            to this node.</param>
            <returns>A node with the sub-range removed. If done in-place, returns
            "this".</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.LeafNode.RemoveRange(System.Int32,System.Int32)">
            <summary>
            Remove a range of items from this node. Never changes this node, but returns
            a new node with the removing done. The
            sub-range may not be empty, but may extend outside the node. 
            In other words, first might be less than zero or last might be greater
            than count. But, last can't be less than zero and first can't be
            greater than count. Also, last must be greater than or equal to last.
            </summary>
            <param name="first">Inclusive index of first item in sub-range, relative
            to this node.</param>
            <param name="last">Inclusize index of last item in sub-range, relative
            to this node.</param>
            <returns>A new node with the sub-range removed.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.LeafNode.Subrange(System.Int32,System.Int32)">
            <summary>
            Returns a node that has a sub-range of items from this node. The
            sub-range may not be empty, but may extend outside the node. 
            In other words, first might be less than zero or last might be greater
            than count. But, last can't be less than zero and first can't be
            greater than count. Also, last must be greater than or equal to last.
            </summary>
            <param name="first">Inclusive first element, relative to this node.</param>
            <param name="last">Inclusize last element, relative to this node.</param>
            <returns>Node with the given sub-range.</returns>
        </member>
        <member name="T:Wintellect.PowerCollections.BigList`1.ConcatNode">
            <summary>
            A ConcatNode is an interior (non-leaf) node that represents the concatination of
            the left and right child nodes. Both children must always be non-null.
            </summary>
        </member>
        <member name="F:Wintellect.PowerCollections.BigList`1.ConcatNode.left">
            <summary>
            The left and right child nodes. They are never null.
            </summary>
        </member>
        <member name="F:Wintellect.PowerCollections.BigList`1.ConcatNode.right">
            <summary>
            The left and right child nodes. They are never null.
            </summary>
        </member>
        <member name="F:Wintellect.PowerCollections.BigList`1.ConcatNode.depth">
            <summary>
            The depth of this node -- the maximum length path to 
            a leaf. If this node has two children that are leaves, the
            depth in 1.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.ConcatNode.#ctor(Wintellect.PowerCollections.BigList{`0}.Node,Wintellect.PowerCollections.BigList{`0}.Node)">
            <summary>
            Create a new ConcatNode with the given children.
            </summary>
            <param name="left">The left child. May not be null.</param>
            <param name="right">The right child. May not be null.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.ConcatNode.NewNode(Wintellect.PowerCollections.BigList{`0}.Node,Wintellect.PowerCollections.BigList{`0}.Node)">
            <summary>
            Create a new node with the given children. Mark unchanged
            children as shared. There are four
            possible cases:
            1. If one of the new children is null, the other new child is returned.
            2. If neither child has changed, then this is marked as shared as returned.
            3. If one child has changed, the other child is marked shared an a new node is returned.
            4. If both children have changed, a new node is returned.
            </summary>
            <param name="newLeft">New left child.</param>
            <param name="newRight">New right child.</param>
            <returns>New node with the given children. Returns null if and only if both
            new children are null.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.ConcatNode.NewNodeInPlace(Wintellect.PowerCollections.BigList{`0}.Node,Wintellect.PowerCollections.BigList{`0}.Node)">
            <summary>
            Updates a node with the given new children. If one of the new children is
            null, the other is returned. If both are null, null is returned.
            </summary>
            <param name="newLeft">New left child.</param>
            <param name="newRight">New right child.</param>
            <returns>Node with the given children. Usually, but not always, this. Returns
            null if and only if both new children are null.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.ConcatNode.GetAt(System.Int32)">
            <summary>
            Returns the items at the given index in this node.
            </summary>
            <param name="index">0-based index, relative to this node.</param>
            <returns>Item at that index.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.ConcatNode.SetAtInPlace(System.Int32,`0)">
            <summary>
            Changes the item at the given index. May change this node,
            or return a new node with the given item changed.
            </summary>
            <param name="index">Index, relative to this node, to change.</param>
            <param name="item">New item to place at the given index.</param>
            <returns>A node with the give item changed. If it can be done in place
            then "this" is returned.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.ConcatNode.SetAt(System.Int32,`0)">
            <summary>
            Changes the item at the given index. Never changes this node,
            but always returns a new node with the given item changed.
            </summary>
            <param name="index">Index, relative to this node, to change.</param>
            <param name="item">New item to place at the given index.</param>
            <returns>A new node with the given item changed.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.ConcatNode.PrependInPlace(`0)">
            <summary>
            Prepend a item before this node. May change this node, or return 
            a new node. Equivalent to PrependInPlace(new LeafNode(item), true), but
            may be more efficient because a new LeafNode might not be allocated.
            </summary>
            <param name="item">Item to prepend.</param>
            <returns>A node with the given item prepended to this node. May be a new
            node or the current node.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.ConcatNode.AppendInPlace(`0)">
            <summary>
            Append a item after this node. May change this node, or return 
            a new node. Equivalent to AppendInPlace(new LeafNode(item), true), but
            may be more efficient because a new LeafNode might not be allocated.
            </summary>
            <param name="item">Item to append.</param>
            <returns>A node with the given item appended to this node. May be a new
            node or the current node.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.ConcatNode.AppendInPlace(Wintellect.PowerCollections.BigList{`0}.Node,System.Boolean)">
            <summary>
            Append a node after this node. May change this node, or return 
            a new node.
            </summary>
            <param name="node">Node to append.</param>
            <param name="nodeIsUnused">If true, the given node is not used
            in any current list, so it may be change, overwritten, or destroyed
            if convenient. If false, the given node is in use. It should be marked
            as shared if is is used within the return value.</param>
            <returns>A node with the give node appended to this node. May be a new
            node or the current node.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.ConcatNode.InsertInPlace(System.Int32,`0)">
            <summary>
            Inserts an item inside this node. May change this node, or return
            a new node with the given appending done. Equivalent to 
            InsertInPlace(new LeafNode(item), true), but may be more efficient.
            </summary>
            <param name="index">Index, relative to this node, to insert at. Must 
            be in bounds.</param>
            <param name="item">Item to insert.</param>
            <returns>A node with the give item inserted. If done in-place, returns
            "this".</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.ConcatNode.InsertInPlace(System.Int32,Wintellect.PowerCollections.BigList{`0}.Node,System.Boolean)">
            <summary>
            Inserts a node inside this node. May change this node, or return
            a new node with the given appending done.
            </summary>
            <param name="index">Index, relative to this node, to insert at. Must 
            be in bounds.</param>
            <param name="node">Node to insert.</param>
            <param name="nodeIsUnused">If true, the given node is not used
            in any current list, so it may be change, overwritten, or destroyed
            if convenient. If false, the given node is in use. It should be marked
            as shared if is is used within the return value.</param>
            <returns>A node with the given item inserted. If done in-place, returns
            "this".</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.ConcatNode.Insert(System.Int32,Wintellect.PowerCollections.BigList{`0}.Node,System.Boolean)">
            <summary>
            Inserts a node inside this node. Never changes this node, but returns
            a new node with the given appending done.
            </summary>
            <param name="index">Index, relative to this node, to insert at. Must 
            be in bounds.</param>
            <param name="node">Node to insert.</param>
            <param name="nodeIsUnused">If true, the given node is not used
            in any current list, so it may be change, overwritten, or destroyed
            if convenient. If false, the given node is in use. It should be marked
            as shared if is is used within the return value.</param>
            <returns>A new node with the give node inserted.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.ConcatNode.RemoveRangeInPlace(System.Int32,System.Int32)">
            <summary>
            Remove a range of items from this node. May change this node, or returns
            a new node with the given appending done. The
            sub-range may not be empty, but may extend outside the node. 
            In other words, first might be less than zero or last might be greater
            than count. But, last can't be less than zero and first can't be
            greater than count. Also, last must be greater than or equal to last.
            </summary>
            <param name="first">Inclusive index of first item in sub-range, relative
            to this node.</param>
            <param name="last">Inclusize index of last item in sub-range, relative
            to this node.</param>
            <returns>A node with the sub-range removed. If done in-place, returns
            "this".</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.ConcatNode.RemoveRange(System.Int32,System.Int32)">
            <summary>
            Remove a range of items from this node. Never changes this node, but returns
            a new node with the removing done. The
            sub-range may not be empty, but may extend outside the node. 
            In other words, first might be less than zero or last might be greater
            than count. But, last can't be less than zero and first can't be
            greater than count. Also, last must be greater than or equal to last.
            </summary>
            <param name="first">Inclusive index of first item in sub-range, relative
            to this node.</param>
            <param name="last">Inclusize index of last item in sub-range, relative
            to this node.</param>
            <returns>A new node with the sub-range removed.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.ConcatNode.Subrange(System.Int32,System.Int32)">
            <summary>
            Returns a node that has a sub-range of items from this node. The
            sub-range may not be empty, but may extend outside the node. 
            In other words, first might be less than zero or last might be greater
            than count. But, last can't be less than zero and first can't be
            greater than count. Also, last must be greater than or equal to last.
            </summary>
            <param name="first">Inclusive first element, relative to this node.</param>
            <param name="last">Inclusize last element, relative to this node.</param>
            <returns>Node with the given sub-range.</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.BigList`1.ConcatNode.Depth">
            <summary>
            The depth of this node -- the maximum length path to 
            a leaf. If this node has two children that are leaves, the
            depth in 1.
            </summary>
            <value>The depth of this node.</value>
        </member>
        <member name="T:Wintellect.PowerCollections.BigList`1.BigListRange">
            <summary>
            The class that is used to implement IList&lt;T&gt; to view a sub-range
            of a BigList. The object stores a wrapped list, and a start/count indicating
            a sub-range of the list. Insertion/deletions through the sub-range view
            cause the count to change also; insertions and deletions directly on
            the wrapped list do not.
            </summary>
            <remarks>This is different from Algorithms.Range in a very few respects:
            it is specialized to only wrap BigList, and it is a lot more efficient in enumeration.</remarks>
        </member>
        <member name="M:Wintellect.PowerCollections.BigList`1.BigListRange.#ctor(Wintellect.PowerCollections.BigList{`0},System.Int32,System.Int32)">
            <summary>
            Create a sub-range view object on the indicate part 
            of the list. 
            </summary>
            <param name="wrappedList">List to wrap.</param>
            <param name="start">The start index of the view in the wrapped list.</param>
            <param name="count">The number of items in the view.</param>
        </member>
        <member name="T:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2">
            <summary>
            MultiDictionaryBase is a base class that can be used to more easily implement a class
            that associates multiple values to a single key. The class implements the generic
            IDictionary&lt;TKey, ICollection&lt;TValue&gt;&gt; interface. The resulting collection
            is read-only -- items cannot be added or removed.
            </summary>
            <remarks>
            <para>To use ReadOnlyMultiDictionaryBase as a base class, the derived class must override
            Count, Contains(TKey,TValue), EnumerateKeys, and TryEnumerateValuesForKey . </para>
            </remarks>
            <typeparam name="TKey">The key type of the dictionary.</typeparam>
            <typeparam name="TValue">The value type of the dictionary.</typeparam>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.#ctor">
            <summary>
            Creates a new ReadOnlyMultiDictionaryBase. 
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.MethodModifiesCollection">
            <summary>
            Throws an NotSupportedException stating that this collection cannot be modified.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.EnumerateKeys">
            <summary>
            Enumerate all the keys in the dictionary. This method must be overridden by a derived
            class.
            </summary>
            <returns>An IEnumerator&lt;TKey&gt; that enumerates all of the keys in the collection that
            have at least one value associated with them.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.TryEnumerateValuesForKey(`0,System.Collections.Generic.IEnumerator{`1}@)">
            <summary>
            Enumerate all of the values associated with a given key. This method must be overridden
            by the derived class. If the key exists and has values associated with it, an enumerator for those
            values is returned throught <paramref name="values"/>. If the key does not exist, false is returned.
            </summary>
            <param name="key">The key to get values for.</param>
            <param name="values">If true is returned, this parameter receives an enumerators that
            enumerates the values associated with that key.</param>
            <returns>True if the key exists and has values associated with it. False otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.System#Collections#Generic#IDictionary{TKey@System#Collections#Generic#ICollection{TValue}}#Add(`0,System.Collections.Generic.ICollection{`1})">
            <summary>
            Implements IDictionary&lt;TKey, IEnumerable&lt;TValue&gt;&gt;.Add. If the 
            key is already present, and ArgumentException is thrown. Otherwise, a
            new key is added, and new values are associated with that key.
            </summary>
            <param name="key">Key to add.</param>
            <param name="values">Values to associate with that key.</param>
            <exception cref="T:System.ArgumentException">The key is already present in the dictionary.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.System#Collections#Generic#IDictionary{TKey@System#Collections#Generic#ICollection{TValue}}#Remove(`0)">
            <summary>
            Removes a key from the dictionary. This method must be overridden in the derived class.
            </summary>
            <param name="key">Key to remove from the dictionary.</param>
            <returns>True if the key was found, false otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.System#Collections#Generic#IDictionary{TKey@System#Collections#Generic#ICollection{TValue}}#TryGetValue(`0,System.Collections.Generic.ICollection{`1}@)">
            <summary>
            Determines if this dictionary contains a key equal to <paramref name="key"/>. If so, all the values
            associated with that key are returned through the values parameter. This method must be
            overridden by the derived class.
            </summary>
            <param name="key">The key to search for.</param>
            <param name="values">Returns all values associated with key, if true was returned.</param>
            <returns>True if the dictionary contains key. False if the dictionary does not contain key.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.ContainsKey(`0)">
            <summary>
            Determines whether a given key is found in the dictionary.
            </summary>
            <remarks>The default implementation simply calls TryGetValue.
            It may be appropriate to override this method to 
            provide a more efficient implementation.</remarks>
            <param name="key">Key to look for in the dictionary.</param>
            <returns>True if the key is present in the dictionary.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.Contains(`0,`1)">
            <summary>
            Determines if this dictionary contains a key-value pair equal to <paramref name="key"/> and 
            <paramref name="value"/>. The dictionary is not changed. This method must be overridden in the derived class.
            </summary>
            <param name="key">The key to search for.</param>
            <param name="value">The value to search for.</param>
            <returns>True if the dictionary has associated <paramref name="value"/> with <paramref name="key"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.Contains(System.Collections.Generic.KeyValuePair{`0,System.Collections.Generic.ICollection{`1}})">
            <summary>
            Determines if this dictionary contains the given key and all of the values associated with that key..
            </summary>
            <param name="pair">A key and collection of values to search for.</param>
            <returns>True if the dictionary has associated all of the values in <paramref name="pair"/>.Value with <paramref name="pair"/>.Key.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.EqualValues(`1,`1)">
            <summary>
            If the derived class does not use the default comparison for values, this
            methods should be overridden to compare two values for equality. This is
            used for the correct implementation of ICollection.Contains on the Values
            and KeyValuePairs collections.
            </summary>
            <param name="value1">First value to compare.</param>
            <param name="value2">Second value to compare.</param>
            <returns>True if the values are equal.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.CountValues(`0)">
            <summary>
            Gets a count of the number of values associated with a key. The
            default implementation is slow; it enumerators all of the values
            (using TryEnumerateValuesForKey) to count them. A derived class
            may be able to supply a more efficient implementation.
            </summary>
            <param name="key">The key to count values for.</param>
            <returns>The number of values associated with <paramref name="key"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.CountAllValues">
            <summary>
            Gets a total count of values in the collection. This default implementation
            is slow; it enumerates all of the keys in the dictionary and calls CountValues on each.
            A derived class may be able to supply a more efficient implementation.
            </summary>
            <returns>The total number of values associated with all keys in the dictionary.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.ToString">
            <summary>
            Shows the string representation of the dictionary. The string representation contains
            a list of the mappings in the dictionary.
            </summary>
            <returns>The string representation of the dictionary.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.DebuggerDisplayString">
            <summary>
            Display the contents of the dictionary in the debugger. This is intentionally private, it is called
            only from the debugger due to the presence of the DebuggerDisplay attribute. It is similar
            format to ToString(), but is limited to 250-300 characters or so, so as not to overload the debugger.
            </summary>
            <returns>The string representation of the items in the collection, similar in format to ToString().</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.GetEnumerator">
            <summary>
            Enumerate all the keys in the dictionary, and for each key, the collection of values for that key.
            </summary>
            <returns>An enumerator to enumerate all the key, ICollection&lt;value&gt; pairs in the dictionary.</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.Count">
            <summary>
            Gets the number of keys in the dictionary. This property must be overridden
            in the derived class.
            </summary>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.Keys">
            <summary>
            Gets a read-only collection all the keys in this dictionary.
            </summary>
            <value>An readonly ICollection&lt;TKey&gt; of all the keys in this dictionary.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.Values">
            <summary>
            Gets a read-only collection of all the values in the dictionary. 
            </summary>
            <returns>A read-only ICollection&lt;TValue&gt; of all the values in the dictionary.</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.System#Collections#Generic#IDictionary{TKey@System#Collections#Generic#ICollection{TValue}}#Values">
            <summary>
            Gets a read-only collection of all the value collections in the dictionary. 
            </summary>
            <returns>A read-only ICollection&lt;IEnumerable&lt;TValue&gt;&gt; of all the values in the dictionary.</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.KeyValuePairs">
            <summary>
            Gets a read-only collection of all key-value pairs in the dictionary. If a key has multiple
            values associated with it, then a key-value pair is present for each value associated
            with the key.
            </summary>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.Item(`0)">
            <summary>
            Returns a collection of all of the values in the dictionary associated with <paramref name="key"/>.
            If the key is not present in the dictionary, an ICollection with no
            values is returned. The returned ICollection is read-only.
            </summary>
            <param name="key">The key to get the values associated with.</param>
            <value>An ICollection&lt;TValue&gt; with all the values associated with <paramref name="key"/>.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.System#Collections#Generic#IDictionary{TKey@System#Collections#Generic#ICollection{TValue}}#Item(`0)">
            <summary>
            Gets a collection of all the values in the dictionary associated with <paramref name="key"/>.
            If the key is not present in the dictionary, a KeyNotFound exception is thrown.
            </summary>
            <param name="key">The key to get the values associated with.</param>
            <value>An IEnumerable&lt;TValue&gt; that enumerates all the values associated with <paramref name="key"/>.</value>
            <exception cref="T:System.Collections.Generic.KeyNotFoundException">The given key is not present in the dictionary.</exception>
            <exception cref="T:System.NotSupportedException">The set accessor is called.</exception>
        </member>
        <member name="T:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.ValuesForKeyCollection">
            <summary>
            A private class that provides the ICollection&lt;TValue&gt; for a particular key. This is the collection
            that is returned from the indexer. The collections is read-write, live, and can be used to add, remove,
            etc. values from the multi-dictionary.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.ValuesForKeyCollection.#ctor(Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase{`0,`1},`0)">
            <summary>
            Constructor. Initializes this collection.
            </summary>
            <param name="myDictionary">Dictionary we're using.</param>
            <param name="key">The key we're looking at.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.ValuesForKeyCollection.NoValues">
            <summary>
            A simple function that returns an IEnumerator&lt;TValue&gt; that
            doesn't yield any values. A helper.
            </summary>
            <returns>An IEnumerator&lt;TValue&gt; that yields no values.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.ValuesForKeyCollection.GetEnumerator">
            <summary>
            Enumerate all the values associated with key.
            </summary>
            <returns>An IEnumerator&lt;TValue&gt; that enumerates all the values associated with key.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.ValuesForKeyCollection.Contains(`1)">
            <summary>
            Determines if the given values is associated with key.
            </summary>
            <param name="item">Value to check for.</param>
            <returns>True if value is associated with key, false otherwise.</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.ValuesForKeyCollection.Count">
            <summary>
            Get the number of values associated with the key.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.KeysCollection">
            <summary>
            A private class that implements ICollection&lt;TKey&gt; and ICollection for the
            Keys collection. The collection is read-only.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.KeysCollection.#ctor(Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase{`0,`1})">
            <summary>
            Constructor.
            </summary>
            <param name="myDictionary">The dictionary this is associated with.</param>
        </member>
        <member name="T:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.ValuesCollection">
            <summary>
            A private class that implements ICollection&lt;TValue&gt; and ICollection for the
            Values collection. The collection is read-only.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.EnumerableValuesCollection">
            <summary>
            A private class that implements ICollection&lt;IEnumerable&lt;TValue&gt;&gt; and ICollection for the
            Values collection on IDictionary. The collection is read-only.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.ReadOnlyMultiDictionaryBase`2.KeyValuePairsCollection">
            <summary>
            A private class that implements ICollection&lt;KeyValuePair&lt;TKey,TValue&gt;&gt; and ICollection for the
            KeyValuePairs collection. The collection is read-only.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.Set`1">
             <summary>
             Set&lt;T&gt; is a collection that contains items of type T. 
             The item are maintained in a haphazard, unpredictable order, and duplicate items are not allowed.
             </summary>
             <remarks>
             <p>The items are compared in one of two ways. If T implements IComparable&lt;T&gt; 
             then the Equals method of that interface will be used to compare items, otherwise the Equals
             method from Object will be used. Alternatively, an instance of IComparer&lt;T&gt; can be passed
             to the constructor to use to compare items.</p>
             <p>Set is implemented as a hash table. Inserting, deleting, and looking up an
             an element all are done in approximately constant time, regardless of the number of items in the Set.</p>
             <p><see cref="T:Wintellect.PowerCollections.OrderedSet`1"/> is similar, but uses comparison instead of hashing, and does maintains
             the items in sorted order.</p>
            </remarks>
            <seealso cref="T:Wintellect.PowerCollections.OrderedSet`1"/>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.#ctor">
             <summary>
             Creates a new Set. The Equals method and GetHashCode method on T
             will be used to compare items for equality.
             </summary>
            <remarks>
             Items that are null are permitted, and will be sorted before all other items.
            </remarks>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.#ctor(System.Collections.Generic.IEqualityComparer{`0})">
            <summary>
            Creates a new Set. The Equals and GetHashCode method of the passed comparer object
            will be used to compare items in this set.
            </summary>
            <param name="equalityComparer">An instance of IEqualityComparer&lt;T&gt; that will be used to compare items.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.#ctor(System.Collections.Generic.IEnumerable{`0})">
             <summary>
             Creates a new Set. The Equals method and GetHashCode method on T
             will be used to compare items for equality.
             </summary>
            <remarks>
             Items that are null are permitted.
            </remarks>
             <param name="collection">A collection with items to be placed into the Set.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.#ctor(System.Collections.Generic.IEnumerable{`0},System.Collections.Generic.IEqualityComparer{`0})">
            <summary>
            Creates a new Set. The Equals and GetHashCode method of the passed comparer object
            will be used to compare items in this set. The set is
            initialized with all the items in the given collection.
            </summary>
            <param name="collection">A collection with items to be placed into the Set.</param>
            <param name="equalityComparer">An instance of IEqualityComparer&lt;T&gt; that will be used to compare items.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.#ctor(System.Collections.Generic.IEqualityComparer{`0},Wintellect.PowerCollections.Hash{`0})">
            <summary>
            Creates a new Set given a comparer and a tree that contains the data. Used
            internally for Clone.
            </summary>
            <param name="equalityComparer">EqualityComparer for the set.</param>
            <param name="hash">Data for the set.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.System#ICloneable#Clone">
            <summary>
            Makes a shallow clone of this set; i.e., if items of the
            set are reference types, then they are not cloned. If T is a value type,
            then each element is copied as if by simple assignment.
            </summary>
            <remarks>Cloning the set takes time O(N), where N is the number of items in the set.</remarks>
            <returns>The cloned set.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.Clone">
            <summary>
            Makes a shallow clone of this set; i.e., if items of the
            set are reference types, then they are not cloned. If T is a value type,
            then each element is copied as if by simple assignment.
            </summary>
            <remarks>Cloning the set takes time O(N), where N is the number of items in the set.</remarks>
            <returns>The cloned set.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.CloneContents">
            <summary>
            Makes a deep clone of this set. A new set is created with a clone of
            each element of this set, by calling ICloneable.Clone on each element. If T is
            a value type, then each element is copied as if by simple assignment.
            </summary>
            <remarks><para>If T is a reference type, it must implement
            ICloneable. Otherwise, an InvalidOperationException is thrown.</para>
            <para>Cloning the set takes time O(N), where N is the number of items in the set.</para></remarks>
            <returns>The cloned set.</returns>
            <exception cref="T:System.InvalidOperationException">T is a reference type that does not implement ICloneable.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.GetEnumerator">
            <summary>
            Returns an enumerator that enumerates all the items in the set. 
            The items are enumerated in sorted order.
            </summary>
            <remarks>
            <p>Typically, this method is not called directly. Instead the "foreach" statement is used
            to enumerate the items, which uses this method implicitly.</p>
            <p>If an item is added to or deleted from the set while it is being enumerated, then 
            the enumeration will end with an InvalidOperationException.</p>
            <p>Enumerating all the items in the set takes time O(N), where N is the number
            of items in the set.</p>
            </remarks>
            <returns>An enumerator for enumerating all the items in the Set.</returns>		
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.Contains(`0)">
            <summary>
            Determines if this set contains an item equal to <paramref name="item"/>. The set
            is not changed.
            </summary>
            <remarks>Searching the set for an item takes approximately constant time, regardless of the number of items in the set.</remarks>
            <param name="item">The item to search for.</param>
            <returns>True if the set contains <paramref name="item"/>. False if the set does not contain <paramref name="item"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.TryGetItem(`0,`0@)">
            <summary>
            <para>Determines if this set contains an item equal to <paramref name="item"/>, according to the 
            comparison mechanism that was used when the set was created. The set
            is not changed.</para>
            <para>If the set does contain an item equal to <paramref name="item"/>, then the item from the set is returned.</para>
            </summary>
            <remarks>Searching the set for an item takes approximately constant time, regardless of the number of items in the set.</remarks>
            <example>
            In the following example, the set contains strings which are compared in a case-insensitive manner. 
            <code>
            Set&lt;string&gt; set = new Set&lt;string&gt;(StringComparer.CurrentCultureIgnoreCase);
            set.Add("HELLO");
            string s;
            bool b = set.TryGetItem("Hello", out s);   // b receives true, s receives "HELLO".
            </code>
            </example>
            <param name="item">The item to search for.</param>
            <param name="foundItem">Returns the item from the set that was equal to <paramref name="item"/>.</param>
            <returns>True if the set contains <paramref name="item"/>. False if the set does not contain <paramref name="item"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.Add(`0)">
            <summary>
            Adds a new item to the set. If the set already contains an item equal to
            <paramref name="item"/>, that item is replaced with <paramref name="item"/>.
            </summary>
            <remarks>
            <para>Equality between items is determined by the comparison instance or delegate used
            to create the set.</para>
            <para>Adding an item takes approximately constant time, regardless of the number of items in the set.</para></remarks>
            <param name="item">The item to add to the set.</param>
            <returns>True if the set already contained an item equal to <paramref name="item"/> (which was replaced), false 
            otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.System#Collections#Generic#ICollection{T}#Add(`0)">
            <summary>
            Adds a new item to the set. If the set already contains an item equal to
            <paramref name="item"/>, that item is replaced with <paramref name="item"/>.
            </summary>
            <remarks>
            <para>Equality between items is determined by the comparison instance or delegate used
            to create the set.</para>
            <para>Adding an item takes approximately constant time, regardless of the number of items in the set.</para></remarks>
            <param name="item">The item to add to the set.</param>
            <returns>True if the set already contained an item equal to <paramref name="item"/> (which was replaced), false 
            otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.AddMany(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Adds all the items in <paramref name="collection"/> to the set. If the set already contains an item equal to
            one of the items in <paramref name="collection"/>, that item will be replaced.
            </summary>
            <remarks>
            <para>Equality between items is determined by the comparison instance or delegate used
            to create the set.</para>
            <para>Adding the collection takes time O(M), where M is the 
            number of items in <paramref name="collection"/>.</para></remarks>
            <param name="collection">A collection of items to add to the set.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.Remove(`0)">
            <summary>
            Searches the set for an item equal to <paramref name="item"/>, and if found,
            removes it from the set. If not found, the set is unchanged.
            </summary>
            <remarks>
            <para>Equality between items is determined by the comparison instance or delegate used
            to create the set.</para>
            <para>Removing an item from the set takes approximately constant time, regardless of the size of the set.</para></remarks>
            <param name="item">The item to remove.</param>
            <returns>True if <paramref name="item"/> was found and removed. False if <paramref name="item"/> was not in the set.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.RemoveMany(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Removes all the items in <paramref name="collection"/> from the set. 
            </summary>
            <remarks>
            <para>Equality between items is determined by the comparison instance or delegate used
            to create the set.</para>
            <para>Removing the collection takes time O(M), where M is the 
            number of items in <paramref name="collection"/>.</para></remarks>
            <param name="collection">A collection of items to remove from the set.</param>
            <returns>The number of items removed from the set.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="collection"/> is null.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.Clear">
            <summary>
            Removes all items from the set.
            </summary>
            <remarks>Clearing the set takes a constant amount of time, regardless of the number of items in it.</remarks>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.CheckConsistentComparison(Wintellect.PowerCollections.Set{`0})">
            <summary>
            Check that this set and another set were created with the same comparison
            mechanism. Throws exception if not compatible.
            </summary>
            <param name="otherSet">Other set to check comparision mechanism.</param>
            <exception cref="T:System.InvalidOperationException">If otherSet and this set don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.IsSupersetOf(Wintellect.PowerCollections.Set{`0})">
            <summary>
            Determines if this set is a superset of another set. Neither set is modified.
            This set is a superset of <paramref name="otherSet"/> if every element in
            <paramref name="otherSet"/> is also in this set.
            <remarks>IsSupersetOf is computed in time O(M), where M is the size of the 
            <paramref name="otherSet"/>.</remarks>
            </summary>
            <param name="otherSet">Set to compare to.</param>
            <returns>True if this is a superset of <paramref name="otherSet"/>.</returns>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.IsProperSupersetOf(Wintellect.PowerCollections.Set{`0})">
            <summary>
            Determines if this set is a proper superset of another set. Neither set is modified.
            This set is a proper superset of <paramref name="otherSet"/> if every element in
            <paramref name="otherSet"/> is also in this set.
            Additionally, this set must have strictly more items than <paramref name="otherSet"/>.
            </summary>
            <remarks>IsProperSubsetOf is computed in time O(M), where M is the size of
            <paramref name="otherSet"/>.</remarks>
            <param name="otherSet">Set to compare to.</param>
            <returns>True if this is a proper superset of <paramref name="otherSet"/>.</returns>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.IsSubsetOf(Wintellect.PowerCollections.Set{`0})">
            <summary>
            Determines if this set is a subset of another set. Neither set is modified.
            This set is a subset of <paramref name="otherSet"/> if every element in this set
            is also in <paramref name="otherSet"/>.
            </summary>
            <remarks>IsSubsetOf is computed in time O(N), where N is the size of the this set.</remarks>
            <param name="otherSet">Set to compare to.</param>
            <returns>True if this is a subset of <paramref name="otherSet"/>.</returns>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.IsProperSubsetOf(Wintellect.PowerCollections.Set{`0})">
            <summary>
            Determines if this set is a proper subset of another set. Neither set is modified.
            This set is a subset of <paramref name="otherSet"/> if every element in this set
            is also in <paramref name="otherSet"/>. Additionally, this set must have strictly 
            fewer items than <paramref name="otherSet"/>.
            </summary>
            <remarks>IsProperSubsetOf is computed in time O(N), where N is the size of the this set.</remarks>
            <param name="otherSet">Set to compare to.</param>
            <returns>True if this is a proper subset of <paramref name="otherSet"/>.</returns>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.IsEqualTo(Wintellect.PowerCollections.Set{`0})">
            <summary>
            Determines if this set is equal to another set. This set is equal to
            <paramref name="otherSet"/> if they contain the same items.
            </summary>
            <remarks>IsEqualTo is computed in time O(N), where N is the number of items in 
            this set.</remarks>
            <param name="otherSet">Set to compare to</param>
            <returns>True if this set is equal to <paramref name="otherSet"/>, false otherwise.</returns>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.IsDisjointFrom(Wintellect.PowerCollections.Set{`0})">
            <summary>
            Determines if this set is disjoint from another set. Two sets are disjoint
            if no item from one set is equal to any item in the other set.
            </summary>
            <remarks>
            <para>The answer is computed in time O(N), where N is the size of the smaller set.</para>
            </remarks>
            <param name="otherSet">Set to check disjointness with.</param>
            <returns>True if the two sets are disjoint, false otherwise.</returns>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.UnionWith(Wintellect.PowerCollections.Set{`0})">
            <summary>
            Computes the union of this set with another set. The union of two sets
            is all items that appear in either or both of the sets. This set receives
            the union of the two sets, the other set is unchanged.
            </summary>
            <remarks>
            <para>If equal items appear in both sets, the union will include an arbitrary choice of one of the
            two equal items.</para>
            <para>The union of two sets is computed in time O(M + N), where M is the size of the 
            larger set, and N is the size of the smaller set.</para>
            </remarks>
            <param name="otherSet">Set to union with.</param>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.Union(Wintellect.PowerCollections.Set{`0})">
            <summary>
            Computes the union of this set with another set. The union of two sets
            is all items that appear in either or both of the sets. A new set is 
            created with the union of the sets and is returned. This set and the other set 
            are unchanged.
            </summary>
            <remarks>
            <para>If equal items appear in both sets, the union will include an arbitrary choice of one of the
            two equal items.</para>
            <para>The union of two sets is computed in time O(M + N), where M is the size of the 
            one set, and N is the size of the other set.</para>
            </remarks>
            <param name="otherSet">Set to union with.</param>
            <returns>The union of the two sets.</returns>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.IntersectionWith(Wintellect.PowerCollections.Set{`0})">
            <summary>
            Computes the intersection of this set with another set. The intersection of two sets
            is all items that appear in both of the sets. This set receives
            the intersection of the two sets, the other set is unchanged.
            </summary>
            <remarks>
            <para>When equal items appear in both sets, the intersection will include an arbitrary choice of one of the
            two equal items.</para>
            <para>The intersection of two sets is computed in time O(N), where N is the size of the smaller set.</para>
            </remarks>
            <param name="otherSet">Set to intersection with.</param>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.Intersection(Wintellect.PowerCollections.Set{`0})">
            <summary>
            Computes the intersection of this set with another set. The intersection of two sets
            is all items that appear in both of the sets. A new set is 
            created with the intersection of the sets and is returned. This set and the other set 
            are unchanged.
            </summary>
            <remarks>
            <para>When equal items appear in both sets, the intersection will include an arbitrary choice of one of the
            two equal items.</para>
            <para>The intersection of two sets is computed in time O(N), where N is the size of the smaller set.</para>
            </remarks>
            <param name="otherSet">Set to intersection with.</param>
            <returns>The intersection of the two sets.</returns>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.DifferenceWith(Wintellect.PowerCollections.Set{`0})">
            <summary>
            Computes the difference of this set with another set. The difference of these two sets
            is all items that appear in this set, but not in <paramref name="otherSet"/>. This set receives
            the difference of the two sets; the other set is unchanged.
            </summary>
            <remarks>
            <para>The difference of two sets is computed in time O(N), where N is the size of the smaller set.</para>
            </remarks>
            <param name="otherSet">Set to difference with.</param>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.Difference(Wintellect.PowerCollections.Set{`0})">
            <summary>
            Computes the difference of this set with another set. The difference of these two sets
            is all items that appear in this set, but not in <paramref name="otherSet"/>. A new set is 
            created with the difference of the sets and is returned. This set and the other set 
            are unchanged.
            </summary>
            <remarks>
            <para>The difference of two sets is computed in time O(N), where N is the size of the smaller set.</para>
            </remarks>
            <param name="otherSet">Set to difference with.</param>
            <returns>The difference of the two sets.</returns>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.SymmetricDifferenceWith(Wintellect.PowerCollections.Set{`0})">
            <summary>
            Computes the symmetric difference of this set with another set. The symmetric difference of two sets
            is all items that appear in either of the sets, but not both. This set receives
            the symmetric difference of the two sets; the other set is unchanged.
            </summary>
            <remarks>
            <para>The symmetric difference of two sets is computed in time O(N), where N is the size of the smaller set.</para>
            </remarks>
            <param name="otherSet">Set to symmetric difference with.</param>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Set`1.SymmetricDifference(Wintellect.PowerCollections.Set{`0})">
            <summary>
            Computes the symmetric difference of this set with another set. The symmetric difference of two sets
            is all items that appear in either of the sets, but not both. A new set is 
            created with the symmetric difference of the sets and is returned. This set and the other set 
            are unchanged.
            </summary>
            <remarks>
            <para>The symmetric difference of two sets is computed in time O(N), where N is the size of the smaller set.</para>
            </remarks>
            <param name="otherSet">Set to symmetric difference with.</param>
            <returns>The symmetric difference of the two sets.</returns>
            <exception cref="T:System.InvalidOperationException">This set and <paramref name="otherSet"/> don't use the same method for comparing items.</exception>
        </member>
        <member name="P:Wintellect.PowerCollections.Set`1.Comparer">
            <summary>
            Returns the IEqualityComparer&lt;T&gt; used to compare items in this set. 
            </summary>
            <value>If the set was created using a comparer, that comparer is returned. Otherwise
            the default comparer for T (EqualityComparer&lt;T&gt;.Default) is returned.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.Set`1.Count">
            <summary>
            Returns the number of items in the set.
            </summary>
            <remarks>The size of the set is returned in constant time.</remarks>
            <value>The number of items in the set.</value>
        </member>
        <member name="T:Wintellect.PowerCollections.Comparers">
            <summary>
            A collection of methods to create IComparer and IEqualityComparer instances in various ways.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Comparers.ComparerFromComparison``1(System.Comparison{``0})">
            <summary>
            Given an Comparison on a type, returns an IComparer on that type. 
            </summary>
            <typeparam name="T">T to compare.</typeparam>
            <param name="comparison">Comparison delegate on T</param>
            <returns>IComparer that uses the comparison.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Comparers.ComparerKeyValueFromComparerKey``2(System.Collections.Generic.IComparer{``0})">
            <summary>
            Given an IComparer on TKey, returns an IComparer on
            key-value Pairs. 
            </summary>
            <typeparam name="TKey">TKey of the pairs</typeparam>
            <typeparam name="TValue">TValue of the apris</typeparam>
            <param name="keyComparer">IComparer on TKey</param>
            <returns>IComparer for comparing key-value pairs.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Comparers.EqualityComparerKeyValueFromComparerKey``2(System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Given an IEqualityComparer on TKey, returns an IEqualityComparer on
            key-value Pairs. 
            </summary>
            <typeparam name="TKey">TKey of the pairs</typeparam>
            <typeparam name="TValue">TValue of the apris</typeparam>
            <param name="keyEqualityComparer">IComparer on TKey</param>
            <returns>IEqualityComparer for comparing key-value pairs.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Comparers.ComparerPairFromKeyValueComparers``2(System.Collections.Generic.IComparer{``0},System.Collections.Generic.IComparer{``1})">
            <summary>
            Given an IComparer on TKey and TValue, returns an IComparer on
            key-value Pairs of TKey and TValue, comparing first keys, then values. 
            </summary>
            <typeparam name="TKey">TKey of the pairs</typeparam>
            <typeparam name="TValue">TValue of the apris</typeparam>
            <param name="keyComparer">IComparer on TKey</param>
            <param name="valueComparer">IComparer on TValue</param>
            <returns>IComparer for comparing key-value pairs.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Comparers.ComparerKeyValueFromComparisonKey``2(System.Comparison{``0})">
            <summary>
            Given an Comparison on TKey, returns an IComparer on
            key-value Pairs. 
            </summary>
            <typeparam name="TKey">TKey of the pairs</typeparam>
            <typeparam name="TValue">TValue of the apris</typeparam>
            <param name="keyComparison">Comparison delegate on TKey</param>
            <returns>IComparer for comparing key-value pairs.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Comparers.DefaultComparer``1">
            <summary>
            Given an element type, check that it implements IComparable&lt;T&gt; or IComparable, then returns
            a IComparer that can be used to compare elements of that type.
            </summary>
            <returns>The IComparer&lt;T&gt; instance.</returns>
            <exception cref="T:System.InvalidOperationException">T does not implement IComparable&lt;T&gt;.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Comparers.DefaultKeyValueComparer``2">
            <summary>
            Given an key and value type, check that TKey implements IComparable&lt;T&gt; or IComparable, then returns
            a IComparer that can be used to compare KeyValuePairs of those types.
            </summary>
            <returns>The IComparer&lt;KeyValuePair&lt;TKey, TValue&gt;&gt; instance.</returns>
            <exception cref="T:System.InvalidOperationException">TKey does not implement IComparable&lt;T&gt;.</exception>
        </member>
        <member name="T:Wintellect.PowerCollections.Comparers.KeyValueEqualityComparer`2">
            <summary>
            Class to change an IEqualityComparer&lt;TKey&gt; to an IEqualityComparer&lt;KeyValuePair&lt;TKey, TValue&gt;&gt; 
            Only the keys are compared.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.Comparers.KeyValueComparer`2">
            <summary>
            Class to change an IComparer&lt;TKey&gt; to an IComparer&lt;KeyValuePair&lt;TKey, TValue&gt;&gt; 
            Only the keys are compared.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.Comparers.PairComparer`2">
            <summary>
            Class to change an IComparer&lt;TKey&gt; and IComparer&lt;TValue&gt; to an IComparer&lt;KeyValuePair&lt;TKey, TValue&gt;&gt; 
            Keys are compared, followed by values.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.Comparers.ComparisonComparer`1">
            <summary>
            Class to change an Comparison&lt;T&gt; to an IComparer&lt;T&gt;.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.Comparers.ComparisonKeyValueComparer`2">
            <summary>
            Class to change an Comparison&lt;TKey&gt; to an IComparer&lt;KeyValuePair&lt;TKey, TValue&gt;&gt;.
            GetHashCode cannot be used on this class.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.DuplicatePolicy">
            <summary>
            Describes what to do if a key is already in the tree when doing an
            insertion.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.RedBlackTree`1">
             <summary>
             The base implementation for various collections classes that use Red-Black trees
             as part of their implementation. This class should not (and can not) be 
             used directly by end users; it's only for internal use by the collections package.
             </summary>
             <remarks>
             The Red-Black tree manages items of type T, and uses a IComparer&lt;T&gt; that
             compares items to sort the tree. Multiple items can compare equal and be stored
             in the tree. Insert, Delete, and Find operations are provided in their full generality;
             all operations allow dealing with either the first or last of items that compare equal. 
            </remarks>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.GetNodeStack">
            <summary>
            Create an array of Nodes big enough for any path from top 
            to bottom. This is cached, and reused from call-to-call, so only one
            can be around at a time per tree.
            </summary>
            <returns>The node stack.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.StopEnumerations">
            <summary>
            Must be called whenever there is a structural change in the tree. Causes
            changeStamp to be changed, which causes any in-progress enumerations
            to throw exceptions.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.CheckEnumerationStamp(System.Int32)">
            <summary>
            Checks the given stamp against the current change stamp. If different, the
            collection has changed during enumeration and an InvalidOperationException
            must be thrown
            </summary>
            <param name="startStamp">changeStamp at the start of the enumeration.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.#ctor(System.Collections.Generic.IComparer{`0})">
            <summary>
            Initialize a red-black tree, using the given interface instance to compare elements. Only
            Compare is used on the IComparer interface.
            </summary>
            <param name="comparer">The IComparer&lt;T&gt; used to sort keys.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.Clone">
            <summary>
            Clone the tree, returning a new tree containing the same items. Should
            take O(N) take.
            </summary>
            <returns>Clone version of this tree.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.Find(`0,System.Boolean,System.Boolean,`0@)">
            <summary>
            Finds the key in the tree. If multiple items in the tree have
            compare equal to the key, finds the first or last one. Optionally replaces the item
            with the one searched for.
            </summary>
            <param name="key">Key to search for.</param>
            <param name="findFirst">If true, find the first of duplicates, else finds the last of duplicates.</param>
            <param name="replace">If true, replaces the item with key (if function returns true)</param>
            <param name="item">Returns the found item, before replacing (if function returns true).</param>
            <returns>True if the key was found.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.FindIndex(`0,System.Boolean)">
            <summary>
            Finds the index of the key in the tree. If multiple items in the tree have
            compare equal to the key, finds the first or last one. 
            </summary>
            <param name="key">Key to search for.</param>
            <param name="findFirst">If true, find the first of duplicates, else finds the last of duplicates.</param>
            <returns>Index of the item found if the key was found, -1 if not found.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.GetItemByIndex(System.Int32)">
            <summary>
            Find the item at a particular index in the tree.
            </summary>
            <param name="index">The zero-based index of the item. Must be &gt;= 0 and &lt; Count.</param>
            <returns>The item at the particular index.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.Insert(`0,Wintellect.PowerCollections.DuplicatePolicy,`0@)">
            <summary>
            Insert a new node into the tree, maintaining the red-black invariants.
            </summary>
            <remarks>Algorithm from Sedgewick, "Algorithms".</remarks>
            <param name="item">The new item to insert</param>
            <param name="dupPolicy">What to do if equal item is already present.</param>
            <param name="previous">If false, returned, the previous item.</param>
            <returns>false if duplicate exists, otherwise true.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.InsertSplit(Wintellect.PowerCollections.RedBlackTree{`0}.Node,Wintellect.PowerCollections.RedBlackTree{`0}.Node,Wintellect.PowerCollections.RedBlackTree{`0}.Node,Wintellect.PowerCollections.RedBlackTree{`0}.Node,System.Boolean@)">
            <summary>
            Split a node with two red children (a 4-node in the 2-3-4 tree formalism), as
            part of an insert operation.
            </summary>
            <param name="ggparent">great grand-parent of "node", can be null near root</param>
            <param name="gparent">grand-parent of "node", can be null near root</param>
            <param name="parent">parent of "node", can be null near root</param>
            <param name="node">Node to split, can't be null</param>
            <param name="rotated">Indicates that rotation(s) occurred in the tree.</param>
            <returns>Node to continue searching from.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.Rotate(Wintellect.PowerCollections.RedBlackTree{`0}.Node,Wintellect.PowerCollections.RedBlackTree{`0}.Node,Wintellect.PowerCollections.RedBlackTree{`0}.Node)">
            <summary>
            Performs a rotation involving the node, it's child and grandchild. The counts of 
            childs and grand-child are set the correct values from their children; this is important
            if they have been adjusted on the way down the try as part of an insert/delete.
            </summary>
            <param name="node">Top node of the rotation. Can be null if child==root.</param>
            <param name="child">One child of "node". Not null.</param>
            <param name="gchild">One child of "child". Not null.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.Delete(`0,System.Boolean,`0@)">
            <summary>
            Deletes a key from the tree. If multiple elements are equal to key, 
            deletes the first or last. If no element is equal to the key, 
            returns false.
            </summary>
            <remarks>Top-down algorithm from Weiss. Basic plan is to move down in the tree, 
            rotating and recoloring along the way to always keep the current node red, which 
            ensures that the node we delete is red. The details are quite complex, however! </remarks>
            <param name="key">Key to delete.</param>
            <param name="deleteFirst">Which item to delete if multiple are equal to key. True to delete the first, false to delete last.</param>
            <param name="item">Returns the item that was deleted, if true returned.</param>
            <returns>True if an element was deleted, false if no element had 
            specified key.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.GetEnumerator">
            
            <summary>
            Enumerate all the items in-order
            </summary>
            <returns>An enumerator for all the items, in order.</returns>
            <exception cref="T:System.InvalidOperationException">The tree has an item added or deleted during the enumeration.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.System#Collections#IEnumerable#GetEnumerator">
            <summary>
            Enumerate all the items in-order
            </summary>
            <returns>An enumerator for all the items, in order.</returns>
            <exception cref="T:System.InvalidOperationException">The tree has an item added or deleted during the enumeration.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.BoundedRangeTester(System.Boolean,`0,System.Boolean,`0)">
            <summary>
            Gets a range tester that defines a range by first and last items.
            </summary>
            <param name="useFirst">If true, bound the range on the bottom by first.</param>
            <param name="first">If useFirst is true, the inclusive lower bound.</param>
            <param name="useLast">If true, bound the range on the top by last.</param>
            <param name="last">If useLast is true, the exclusive upper bound.</param>
            <returns>A RangeTester delegate that tests for an item in the given range.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.DoubleBoundedRangeTester(`0,System.Boolean,`0,System.Boolean)">
            <summary>
            Gets a range tester that defines a range by first and last items.
            </summary>
            <param name="first">The lower bound.</param>
            <param name="firstInclusive">True if the lower bound is inclusive, false if exclusive.</param>
            <param name="last">The upper bound.</param>
            <param name="lastInclusive">True if the upper bound is inclusive, false if exclusive.</param>
            <returns>A RangeTester delegate that tests for an item in the given range.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.LowerBoundedRangeTester(`0,System.Boolean)">
            <summary>
            Gets a range tester that defines a range by a lower bound.
            </summary>
            <param name="first">The lower bound.</param>
            <param name="inclusive">True if the lower bound is inclusive, false if exclusive.</param>
            <returns>A RangeTester delegate that tests for an item in the given range.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.UpperBoundedRangeTester(`0,System.Boolean)">
            <summary>
            Gets a range tester that defines a range by upper bound.
            </summary>
            <param name="last">The upper bound.</param>
            <param name="inclusive">True if the upper bound is inclusive, false if exclusive.</param>
            <returns>A RangeTester delegate that tests for an item in the given range.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.EqualRangeTester(`0)">
            <summary>
            Gets a range tester that defines a range by all items equal to an item.
            </summary>
            <param name="equalTo">The item that is contained in the range.</param>
            <returns>A RangeTester delegate that tests for an item equal to <paramref name="equalTo"/>.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.EntireRangeTester(`0)">
            <summary>
            A range tester that defines a range that is the entire tree.
            </summary>
            <param name="item">Item to test.</param>
            <returns>Always returns 0.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.EnumerateRange(Wintellect.PowerCollections.RedBlackTree{`0}.RangeTester)">
            <summary>
            Enumerate the items in a custom range in the tree. The range is determined by 
            a RangeTest delegate.
            </summary>
            <param name="rangeTester">Tests an item against the custom range.</param>
            <returns>An IEnumerable&lt;T&gt; that enumerates the custom range in order.</returns>
            <exception cref="T:System.InvalidOperationException">The tree has an item added or deleted during the enumeration.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.EnumerateRangeInOrder(Wintellect.PowerCollections.RedBlackTree{`0}.RangeTester,Wintellect.PowerCollections.RedBlackTree{`0}.Node)">
            <summary>
            Enumerate all the items in a custom range, under and including node, in-order.
            </summary>
            <param name="rangeTester">Tests an item against the custom range.</param>
            <param name="node">Node to begin enumeration. May be null.</param>
            <returns>An enumerable of the items.</returns>
            <exception cref="T:System.InvalidOperationException">The tree has an item added or deleted during the enumeration.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.EnumerateRangeReversed(Wintellect.PowerCollections.RedBlackTree{`0}.RangeTester)">
            <summary>
            Enumerate the items in a custom range in the tree, in reversed order. The range is determined by 
            a RangeTest delegate.
            </summary>
            <param name="rangeTester">Tests an item against the custom range.</param>
            <returns>An IEnumerable&lt;T&gt; that enumerates the custom range in reversed order.</returns>
            <exception cref="T:System.InvalidOperationException">The tree has an item added or deleted during the enumeration.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.EnumerateRangeInReversedOrder(Wintellect.PowerCollections.RedBlackTree{`0}.RangeTester,Wintellect.PowerCollections.RedBlackTree{`0}.Node)">
            <summary>
            Enumerate all the items in a custom range, under and including node, in reversed order.
            </summary>
            <param name="rangeTester">Tests an item against the custom range.</param>
            <param name="node">Node to begin enumeration. May be null.</param>
            <returns>An enumerable of the items, in reversed oreder.</returns>
            <exception cref="T:System.InvalidOperationException">The tree has an item added or deleted during the enumeration.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.DeleteItemFromRange(Wintellect.PowerCollections.RedBlackTree{`0}.RangeTester,System.Boolean,`0@)">
            <summary>
            Deletes either the first or last item from a range, as identified by a RangeTester
            delegate. If the range is empty, returns false.
            </summary>
            <remarks>Top-down algorithm from Weiss. Basic plan is to move down in the tree, 
            rotating and recoloring along the way to always keep the current node red, which 
            ensures that the node we delete is red. The details are quite complex, however! </remarks>
            <param name="rangeTester">Range to delete from.</param>
            <param name="deleteFirst">If true, delete the first item from the range, else the last.</param>
            <param name="item">Returns the item that was deleted, if true returned.</param>
            <returns>True if an element was deleted, false if the range is empty.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.DeleteRange(Wintellect.PowerCollections.RedBlackTree{`0}.RangeTester)">
            <summary>
            Delete all the items in a range, identified by a RangeTester delegate.
            </summary>
            <param name="rangeTester">The delegate that defines the range to delete.</param>
            <returns>The number of items deleted.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.CountRange(Wintellect.PowerCollections.RedBlackTree{`0}.RangeTester)">
            <summary>
            Count the items in a custom range in the tree. The range is determined by 
            a RangeTester delegate.
            </summary>
            <param name="rangeTester">The delegate that defines the range.</param>
            <returns>The number of items in the range.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.CountRangeUnderNode(Wintellect.PowerCollections.RedBlackTree{`0}.RangeTester,Wintellect.PowerCollections.RedBlackTree{`0}.Node,System.Boolean,System.Boolean)">
            <summary>
            Count all the items in a custom range, under and including node.
            </summary>
            <param name="rangeTester">The delegate that defines the range.</param>
            <param name="node">Node to begin enumeration. May be null.</param>
            <param name="belowRangeTop">This node and all under it are either in the range or below it.</param>
            <param name="aboveRangeBottom">This node and all under it are either in the range or above it.</param>
            <returns>The number of items in the range, under and include node.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.FirstItemInRange(Wintellect.PowerCollections.RedBlackTree{`0}.RangeTester,`0@)">
            <summary>
            Find the first item in a custom range in the tree, and it's index. The range is determined
            by a RangeTester delegate.
            </summary>
            <param name="rangeTester">The delegate that defines the range.</param>
            <param name="item">Returns the item found, if true was returned.</param>
            <returns>Index of first item in range if range is non-empty, -1 otherwise.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.LastItemInRange(Wintellect.PowerCollections.RedBlackTree{`0}.RangeTester,`0@)">
            <summary>
            Find the last item in a custom range in the tree, and it's index. The range is determined
            by a RangeTester delegate.
            </summary>
            <param name="rangeTester">The delegate that defines the range.</param>
            <param name="item">Returns the item found, if true was returned.</param>
            <returns>Index of the item if range is non-empty, -1 otherwise.</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.RedBlackTree`1.ElementCount">
            <summary>
            Returns the number of elements in the tree.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.RedBlackTree`1.Node">
            <summary>
            The class that is each node in the red-black tree.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.Node.IncrementCount">
            <summary>
            Add one to the Count.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.Node.DecrementCount">
            <summary>
            Subtract one from the Count. The current
            Count must be non-zero.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.RedBlackTree`1.Node.Clone">
            <summary>
            Clones a node and all its descendants.
            </summary>
            <returns>The cloned node.</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.RedBlackTree`1.Node.IsRed">
            <summary>
            Is this a red node?
            </summary>
        </member>
        <member name="P:Wintellect.PowerCollections.RedBlackTree`1.Node.Count">
            <summary>
            Get or set the Count field -- a 31-bit field
            that holds the number of nodes at or below this
            level.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.RedBlackTree`1.RangeTester">
            <summary>
            A delegate that tests if an item is within a custom range. The range must be a contiguous
            range of items with the ordering of this tree. The range test function must test
            if an item is before, withing, or after the range.
            </summary>
            <param name="item">Item to test against the range.</param>
            <returns>Returns negative if item is before the range, zero if item is withing the range,
            and positive if item is after the range.</returns>
        </member>
        <member name="T:Wintellect.PowerCollections.OrderedDictionary`2">
             <summary>
             OrderedDictionary&lt;TKey, TValue&gt; is a collection that maps keys of type TKey
             to values of type TValue. The keys are maintained in a sorted order, and at most one value
             is permitted for each key.
             </summary>
             <remarks>
             <p>The keys are compared in one of three ways. If TKey implements IComparable&lt;TKey&gt; or IComparable,
             then the CompareTo method of that interface will be used to compare elements. Alternatively, a comparison
             function can be passed in either as a delegate, or as an instance of IComparer&lt;TKey&gt;.</p>
             <p>OrderedDictionary is implemented as a balanced binary tree. Inserting, deleting, and looking up an
             an element all are done in log(N) type, where N is the number of keys in the tree.</p>
             <p><see cref="T:System.Collections.Generic.Dictionary`2"/> is similar, but uses hashing instead of comparison, and does not maintain
             the keys in sorted order.</p>
            </remarks>
            <seealso cref="T:System.Collections.Generic.Dictionary`2"/>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.NewPair(`0,`1)">
            <summary>
            Helper function to create a new KeyValuePair struct.
            </summary>
            <param name="key">The key.</param>
            <param name="value">The value.</param>
            <returns>A new KeyValuePair.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.NewPair(`0)">
            <summary>
            Helper function to create a new KeyValuePair struct with a default value.
            </summary>
            <param name="key">The key.</param>
            <returns>A new KeyValuePair.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.#ctor">
            <summary>
            Creates a new OrderedDictionary. The TKey must implemented IComparable&lt;TKey&gt;
            or IComparable. 
            The CompareTo method of this interface will be used to compare keys in this dictionary.
            </summary>
            <exception cref="T:System.InvalidOperationException">TKey does not implement IComparable&lt;TKey&gt;.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.#ctor(System.Collections.Generic.IComparer{`0})">
            <summary>
            Creates a new OrderedDictionary. The Compare method of the passed comparison object
            will be used to compare keys in this dictionary.
            </summary>
            <remarks>
            The GetHashCode and Equals methods of the provided IComparer&lt;TKey&gt; will never
            be called, and need not be implemented.</remarks>
            <param name="comparer">An instance of IComparer&lt;TKey&gt; that will be used to compare keys.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.#ctor(System.Comparison{`0})">
            <summary>
            Creates a new OrderedDictionary. The passed delegate will be used to compare keys in this dictionary.
            </summary>
            <param name="comparison">A delegate to a method that will be used to compare keys.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.#ctor(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}})">
            <summary>
            <para>Creates a new OrderedDictionary. The TKey must implemented IComparable&lt;TKey&gt;
            or IComparable. 
            The CompareTo method of this interface will be used to compare keys in this dictionary.</para>
            <para>A collection and keys and values (typically another dictionary) is used to initialized the 
            contents of the dictionary.</para>
            </summary>
            <param name="keysAndValues">A collection of keys and values whose contents are used to initialized the dictionary.</param>
            <exception cref="T:System.InvalidOperationException">TKey does not implement IComparable&lt;TKey&gt;.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.#ctor(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}},System.Collections.Generic.IComparer{`0})">
            <summary>
            <para>Creates a new OrderedDictionary. The Compare method of the passed comparison object
            will be used to compare keys in this dictionary.</para>
            <para>A collection and keys and values (typically another dictionary) is used to initialized the 
            contents of the dictionary.</para>
            </summary>
            <remarks>
            The GetHashCode and Equals methods of the provided IComparer&lt;TKey&gt; will never
            be called, and need not be implemented.</remarks>
            <param name="keysAndValues">A collection of keys and values whose contents are used to initialized the dictionary.</param>
            <param name="comparer">An instance of IComparer&lt;TKey&gt; that will be used to compare keys.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.#ctor(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}},System.Comparison{`0})">
            <summary>
            <para>Creates a new OrderedDictionary. The passed delegate will be used to compare keys in this dictionary.</para>
            <para>A collection and keys and values (typically another dictionary) is used to initialized the 
            contents of the dictionary.</para>
            </summary>
            <param name="keysAndValues">A collection of keys and values whose contents are used to initialized the dictionary.</param>
            <param name="comparison">A delegate to a method that will be used to compare keys.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.#ctor(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}},System.Collections.Generic.IComparer{`0},System.Collections.Generic.IComparer{System.Collections.Generic.KeyValuePair{`0,`1}})">
            <summary>
            Creates a new OrderedDictionary. The passed comparer 
            will be used to compare key-value pairs in this dictionary. Used internally  
            from other constructors.
            </summary>
            <param name="keysAndValues">A collection of keys and values whose contents are used to initialized the dictionary.</param>
            <param name="keyComparer">An IComparer that will be used to compare keys.</param>
            <param name="pairComparer">An IComparer that will be used to compare key-value pairs.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.#ctor(System.Collections.Generic.IComparer{`0},System.Collections.Generic.IComparer{System.Collections.Generic.KeyValuePair{`0,`1}},Wintellect.PowerCollections.RedBlackTree{System.Collections.Generic.KeyValuePair{`0,`1}})">
            <summary>
            Creates a new OrderedDictionary. The passed comparison delegate 
            will be used to compare keys in this dictionary, and the given tree is used. Used internally for Clone().
            </summary>
            <param name="keyComparer">An IComparer that will be used to compare keys.</param>
            <param name="pairComparer">A delegate to a method that will be used to compare key-value pairs.</param>
            <param name="tree">RedBlackTree that contains the data for the dictionary.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.Clone">
            <summary>
            Makes a shallow clone of this dictionary; i.e., if keys or values of the
            dictionary are reference types, then they are not cloned. If TKey or TValue is a value type,
            then each element is copied as if by simple assignment.
            </summary>
            <remarks>Cloning the dictionary takes time O(N), where N is the number of keys in the dictionary.</remarks>
            <returns>The cloned dictionary.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.NonCloneableType(System.Type)">
            <summary>
            Throw an InvalidOperationException indicating that this type is not cloneable.
            </summary>
            <param name="t">Type to test.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.CloneContents">
            <summary>
            Makes a deep clone of this dictionary. A new dictionary is created with a clone of
            each entry of this dictionary, by calling ICloneable.Clone on each element. If TKey or TValue is
            a value type, then each element is copied as if by simple assignment.
            </summary>
            <remarks><para>If TKey or TValue is a reference type, it must implement
            ICloneable. Otherwise, an InvalidOperationException is thrown.</para>
            <para>Cloning the dictionary takes time O(N log N), where N is the number of keys in the dictionary.</para></remarks>
            <returns>The cloned dictionary.</returns>
            <exception cref="T:System.InvalidOperationException">TKey or TValue is a reference type that does not implement ICloneable.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.Reversed">
             <summary>
             Returns a View collection that can be used for enumerating the keys and values in the collection in 
             reversed order.
             </summary>
            <remarks>
            <p>Typically, this method is used in conjunction with a foreach statement. For example:
            <code>
             foreach(KeyValuePair&lt;TKey, TValue&gt; pair in dictionary.Reversed()) {
                // process pair
             }
            </code></p>
             <p>If an entry is added to or deleted from the dictionary while the View is being enumerated, then 
             the enumeration will end with an InvalidOperationException.</p>
            <p>Calling Reverse does not copy the data in the dictionary, and the operation takes constant time.</p>
            </remarks>
             <returns>An OrderedDictionary.View of key-value pairs in reverse order.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.Range(`0,System.Boolean,`0,System.Boolean)">
             <summary>
             Returns a collection that can be used for enumerating some of the keys and values in the collection. 
             Only keys that are greater than <paramref name="from"/> and 
             less than <paramref name="to"/> are included. The keys are enumerated in sorted order.
             Keys equal to the end points of the range can be included or excluded depending on the
             <paramref name="fromInclusive"/> and <paramref name="toInclusive"/> parameters.
             </summary>
            <remarks>
            <p>If <paramref name="from"/> is greater than or equal to <paramref name="to"/>, the returned collection is empty. </p>
            <p>The sorted order of the keys is determined by the comparison instance or delegate used
             to create the dictionary.</p>
            <p>Typically, this property is used in conjunction with a foreach statement. For example:</p>
            <code>
             foreach(KeyValuePair&lt;TKey, TValue&gt; pair in dictionary.Range(from, true, to, false)) {
                // process pair
             }
            </code>
            <p>Calling Range does not copy the data in the dictionary, and the operation takes constant time.</p></remarks>
             <param name="from">The lower bound of the range.</param>
             <param name="fromInclusive">If true, the lower bound is inclusive--keys equal to the lower bound will
             be included in the range. If false, the lower bound is exclusive--keys equal to the lower bound will not
             be included in the range.</param>
             <param name="to">The upper bound of the range. </param>
             <param name="toInclusive">If true, the upper bound is inclusive--keys equal to the upper bound will
             be included in the range. If false, the upper bound is exclusive--keys equal to the upper bound will not
             be included in the range.</param>
             <returns>An OrderedDictionary.View of key-value pairs in the given range.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.RangeFrom(`0,System.Boolean)">
             <summary>
             Returns a collection that can be used for enumerating some of the keys and values in the collection. 
             Only keys that are greater than (and optionally, equal to) <paramref name="from"/> are included. 
             The keys are enumerated in sorted order. Keys equal to <paramref name="from"/> can be included
             or excluded depending on the <paramref name="fromInclusive"/> parameter.
             </summary>
            <remarks>
            <p>The sorted order of the keys is determined by the comparison instance or delegate used
             to create the dictionary.</p>
            <p>Typically, this property is used in conjunction with a foreach statement. For example:</p>
            <code>
             foreach(KeyValuePair&lt;TKey, TValue&gt; pair in dictionary.RangeFrom(from, true)) {
                // process pair
             }
            </code>
            <p>Calling RangeFrom does not copy of the data in the dictionary, and the operation takes constant time.</p>
            </remarks>
             <param name="from">The lower bound of the range.</param>
             <param name="fromInclusive">If true, the lower bound is inclusive--keys equal to the lower bound will
             be included in the range. If false, the lower bound is exclusive--keys equal to the lower bound will not
             be included in the range.</param>
             <returns>An OrderedDictionary.View of key-value pairs in the given range.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.RangeTo(`0,System.Boolean)">
             <summary>
             Returns a collection that can be used for enumerating some of the keys and values in the collection. 
             Only items that are less than (and optionally, equal to) <paramref name="to"/> are included. 
             The items are enumerated in sorted order. Items equal to <paramref name="to"/> can be included
             or excluded depending on the <paramref name="toInclusive"/> parameter.
             </summary>
            <remarks>
            <p>The sorted order of the keys is determined by the comparison instance or delegate used
             to create the dictionary.</p>
            <p>Typically, this property is used in conjunction with a foreach statement. For example:</p>
            <code>
             foreach(KeyValuePair&lt;TKey, TValue&gt; pair in dictionary.RangeFrom(from, false)) {
                // process pair
             }
            </code>
            <p>Calling RangeTo does not copy the data in the dictionary, and the operation takes constant time.</p>
            </remarks>
             <param name="to">The upper bound of the range. </param>
             <param name="toInclusive">If true, the upper bound is inclusive--keys equal to the upper bound will
             be included in the range. If false, the upper bound is exclusive--keys equal to the upper bound will not
             be included in the range.</param>
             <returns>An OrderedDictionary.View of key-value pairs in the given range.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.Remove(`0)">
            <summary>
            Removes the key (and associated value) from the collection that is equal to the passed in key. If
            no key in the dictionary is equal to the passed key, false is returned and the 
            dictionary is unchanged.
            </summary>
            <remarks>Equality between keys is determined by the comparison instance or delegate used
            to create the dictionary.</remarks>
            <param name="key">The key to remove.</param>
            <returns>True if the key was found and removed. False if the key was not found.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.Clear">
            <summary>
            Removes all keys and values from the dictionary.
            </summary>
            <remarks>Clearing the dictionary takes a constant amount of time, regardless of the number of keys in it.</remarks>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.GetValueElseAdd(`0,`1@)">
            <summary>
            Finds a key in the dictionary. If the dictionary already contains
            a key equal to the passed key, then the existing value is returned via value. If the dictionary
            doesn't contain that key, then value is associated with that key.
            </summary>
            <remarks><para> between keys is determined by the comparison instance or delegate used
            to create the dictionary.</para>
            <para>This method takes time O(log N), where N is the number of keys in the dictionary. If a value is added, It is more efficient than
            calling TryGetValue followed by Add, because the dictionary is not searched twice.</para></remarks>
            <param name="key">The new key. </param>
            <param name="value">The new value to associated with that key, if the key isn't present. If the key was present, 
            returns the exist value associated with that key.</param>
            <returns>True if key was already present, false if key wasn't present (and a new value was added).</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.Add(`0,`1)">
            <summary>
            Adds a new key and value to the dictionary. If the dictionary already contains
            a key equal to the passed key, then an ArgumentException is thrown
            </summary>
            <remarks>
            <para>Equality between keys is determined by the comparison instance or delegate used
            to create the dictionary.</para>
            <para>Adding an key and value takes time O(log N), where N is the number of keys in the dictionary.</para></remarks>
            <param name="key">The new key. "null" is a valid key value.</param>
            <param name="value">The new value to associated with that key.</param>
            <exception cref="T:System.ArgumentException">key is already present in the dictionary</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.Replace(`0,`1)">
            <summary>
            Changes the value associated with a given key. If the dictionary does not contain
            a key equal to the passed key, then an ArgumentException is thrown.
            </summary>
            <remarks>
            <p>Unlike adding or removing an element, changing the value associated with a key
            can be performed while an enumeration (foreach) on the the dictionary is in progress.</p>
            <p>Equality between keys is determined by the comparison instance or delegate used
            to create the dictionary.</p>
            <p>Replace takes time O(log N), where N is the number of entries in the dictionary.</p></remarks>
            <param name="key">The new key. </param>
            <param name="value">The new value to associated with that key.</param>
            <exception cref="T:System.Collections.Generic.KeyNotFoundException">key is not present in the dictionary</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.AddMany(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{`0,`1}})">
            <summary>
            Adds multiple key-value pairs to a dictionary. If a key exists in both the current instance and dictionaryToAdd,
            then the value is updated with the value from <paramref name="keysAndValues>"/> (no exception is thrown).
            Since IDictionary&lt;TKey,TValue&gt; inherits from IEnumerable&lt;KeyValuePair&lt;TKey,TValue&gt;&gt;, this
            method can be used to merge one dictionary into another.
            </summary>
            <remarks>AddMany takes time O(M log (N+M)), where M is the size of <paramref name="keysAndValues>"/>, and N is the size of
            this dictionary.</remarks>
            <param name="keysAndValues">A collection of keys and values whose contents are added to the current dictionary.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.RemoveMany(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Removes all the keys found in another collection (such as an array or List&lt;TKey&gt;). Each key in keyCollectionToRemove
            is removed from the dictionary. Keys that are not present are ignored.
            </summary>
            <remarks>RemoveMany takes time O(M log N), where M is the size of keyCollectionToRemove, and N is this
            size of this collection.</remarks>
            <returns>The number of keys removed from the dictionary.</returns>
            <param name="keyCollectionToRemove">A collection of keys to remove from the dictionary.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.ContainsKey(`0)">
            <summary>
            Determines if this dictionary contains a key equal to <paramref name="key"/>. The dictionary
            is not changed.
            </summary>
            <remarks>Searching the dictionary for a key takes time O(log N), where N is the number of keys in the dictionary.</remarks>
            <param name="key">The key to search for.</param>
            <returns>True if the dictionary contains key. False if the dictionary does not contain key.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.TryGetValue(`0,`1@)">
            <summary>
            Determines if this dictionary contains a key equal to <paramref name="key"/>. If so, the value
            associated with that key is returned through the value parameter.
            </summary>
            <remarks>TryGetValue takes time O(log N), where N is the number of entries in the dictionary.</remarks>
            <param name="key">The key to search for.</param>
            <param name="value">Returns the value associated with key, if true was returned.</param>
            <returns>True if the dictionary contains key. False if the dictionary does not contain key.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.GetEnumerator">
            <summary>
            Returns an enumerator that enumerates all the entries in the dictionary. Each entry is 
            returned as a KeyValuePair&lt;TKey,TValue&gt;.
            The entries are enumerated in the sorted order of the keys.
            </summary>
            <remarks>
            <p>Typically, this method is not called directly. Instead the "foreach" statement is used
            to enumerate the elements of the dictionary, which uses this method implicitly.</p>
            <p>If an element is added to or deleted from the dictionary while it is being enumerated, then 
            the enumeration will end with an InvalidOperationException.</p>
            <p>Enumeration all the entries in the dictionary takes time O(N log N), where N is the number
            of entries in the dictionary.</p>
            </remarks>
            <returns>An enumerator for enumerating all the elements in the OrderedDictionary.</returns>		
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.System#ICloneable#Clone">
            <summary>
            Implements ICloneable.Clone. Makes a shallow clone of this dictionary; i.e., if keys or values are reference types, then they are not cloned.
            </summary>
            <returns>The cloned dictionary.</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.OrderedDictionary`2.Comparer">
            <summary>
            Returns the IComparer&lt;T&gt; used to compare keys in this dictionary. 
            </summary>
            <value>If the dictionary was created using a comparer, that comparer is returned. If the dictionary was
            created using a comparison delegate, then a comparer equivalent to that delegate
            is returned. Otherwise
            the default comparer for TKey (Comparer&lt;TKey&gt;.Default) is returned.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.OrderedDictionary`2.Item(`0)">
            <summary>
            Gets or sets the value associated with a given key. When getting a value, if this
            key is not found in the collection, then an ArgumentException is thrown. When setting
            a value, the value replaces any existing value in the dictionary.
            </summary>
            <remarks>The indexer takes time O(log N), where N is the number of entries in the dictionary.</remarks>
            <value>The value associated with the key</value>
            <exception cref="T:System.ArgumentException">A value is being retrieved, and the key is not present in the dictionary.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="key"/> is null.</exception>
        </member>
        <member name="P:Wintellect.PowerCollections.OrderedDictionary`2.Count">
            <summary>
            Returns the number of keys in the dictionary.
            </summary>
            <remarks>The size of the dictionary is returned in constant time..</remarks>
            <value>The number of keys in the dictionary.</value>
        </member>
        <member name="T:Wintellect.PowerCollections.OrderedDictionary`2.View">
             <summary>
             The OrderedDictionary&lt;TKey,TValue&gt;.View class is used to look at a subset of the keys and values
             inside an ordered dictionary. It is returned from the Range, RangeTo, RangeFrom, and Reversed methods. 
             </summary>
            <remarks>
             <p>Views are dynamic. If the underlying dictionary changes, the view changes in sync. If a change is made
             to the view, the underlying dictionary changes accordingly.</p>
            <p>Typically, this class is used in conjunction with a foreach statement to enumerate the keys
             and values in a subset of the OrderedDictionary. For example:</p>
            <code>
             foreach(KeyValuePair&lt;TKey, TValue&gt; pair in dictionary.Range(from, to)) {
                // process pair
             }
            </code>
            </remarks>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.View.#ctor(Wintellect.PowerCollections.OrderedDictionary{`0,`1},Wintellect.PowerCollections.RedBlackTree{System.Collections.Generic.KeyValuePair{`0,`1}}.RangeTester,System.Boolean,System.Boolean)">
            <summary>
            Initialize the View.
            </summary>
            <param name="myDictionary">Associated OrderedDictionary to be viewed.</param>
            <param name="rangeTester">Range tester that defines the range being used.</param>
            <param name="entireTree">If true, then rangeTester defines the entire tree.</param>
            <param name="reversed">Is the view enuemerated in reverse order?</param>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.View.KeyInView(`0)">
            <summary>
            Determine if the given key lies within the bounds of this view.
            </summary>
            <param name="key">Key to test.</param>
            <returns>True if the key is within the bounds of this view.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.View.GetEnumerator">
            <summary>
            Enumerate all the keys and values in this view.
            </summary>
            <returns>An IEnumerator of KeyValuePairs with the keys and views in this view.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.View.ContainsKey(`0)">
            <summary>
            Tests if the key is present in the part of the dictionary being viewed.
            </summary>
            <param name="key">Key to check for.</param>
            <returns>True if the key is within this view. </returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.View.TryGetValue(`0,`1@)">
            <summary>
            Determines if this view contains a key equal to <paramref name="key"/>. If so, the value
            associated with that key is returned through the value parameter. 
            </summary>
            <param name="key">The key to search for.</param>
            <param name="value">Returns the value associated with key, if true was returned.</param>
            <returns>True if the key is within this view. </returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.View.Remove(`0)">
            <summary>
            Removes the key (and associated value) from the underlying dictionary of this view. that is equal to the passed in key. If
            no key in the view is equal to the passed key, the dictionary and view are unchanged.
            </summary>
            <param name="key">The key to remove.</param>
            <returns>True if the key was found and removed. False if the key was not found.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.View.Clear">
            <summary>
            Removes all the keys and values within this view from the underlying OrderedDictionary.
            </summary>
            <example>The following removes all the keys that start with "A" from an OrderedDictionary.
            <code>
            dictionary.Range("A", "B").Clear();
            </code>
            </example>
        </member>
        <member name="M:Wintellect.PowerCollections.OrderedDictionary`2.View.Reversed">
            <summary>
            Creates a new View that has the same keys and values as this, in the reversed order.
            </summary>
            <returns>A new View that has the reversed order of this view.</returns>
        </member>
        <member name="P:Wintellect.PowerCollections.OrderedDictionary`2.View.Count">
            <summary>
            Number of keys in this view.
            </summary>
            <value>Number of keys that lie within the bounds the view.</value>
        </member>
        <member name="P:Wintellect.PowerCollections.OrderedDictionary`2.View.Item(`0)">
            <summary>
            Gets or sets the value associated with a given key. When getting a value, if this
            key is not found in the collection, then an ArgumentException is thrown. When setting
            a value, the value replaces any existing value in the dictionary. When setting a value, the 
            key must be within the range of keys being viewed.
            </summary>
            <value>The value associated with the key.</value>
            <exception cref="T:System.ArgumentException">A value is being retrieved, and the key is not present in the dictionary, 
            or a value is being set, and the key is outside the range of keys being viewed by this View.</exception>
        </member>
        <member name="T:Wintellect.PowerCollections.Strings">
            <summary>
            A holder class for localizable strings that are used. Currently, these are not loaded from resources, but 
            just coded into this class. To make this library localizable, simply change this class to load the
            given strings from resources.
            </summary>
        </member>
        <member name="T:Wintellect.PowerCollections.Triple`3">
            <summary>
            Stores a triple of objects within a single struct. This struct is useful to use as the
            T of a collection, or as the TKey or TValue of a dictionary.
            </summary>
        </member>
        <member name="F:Wintellect.PowerCollections.Triple`3.firstComparer">
            <summary>
            Comparers for the first and second type that are used to compare
            values.
            </summary>
        </member>
        <member name="F:Wintellect.PowerCollections.Triple`3.First">
            <summary>
            The first element of the triple.
            </summary>
        </member>
        <member name="F:Wintellect.PowerCollections.Triple`3.Second">
            <summary>
            The second element of the triple.
            </summary>
        </member>
        <member name="F:Wintellect.PowerCollections.Triple`3.Third">
            <summary>
            The thrid element of the triple.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Triple`3.#ctor(`0,`1,`2)">
            <summary>
            Creates a new triple with given elements.
            </summary>
            <param name="first">The first element of the triple.</param>
            <param name="second">The second element of the triple.</param>
            <param name="third">The third element of the triple.</param>
        </member>
        <member name="M:Wintellect.PowerCollections.Triple`3.Equals(System.Object)">
            <summary>
            Determines if this triple is equal to another object. The triple is equal to another object 
            if that object is a Triple, all element types are the same, and the all three elements
            compare equal using object.Equals.
            </summary>
            <param name="obj">Object to compare for equality.</param>
            <returns>True if the objects are equal. False if the objects are not equal.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Triple`3.Equals(Wintellect.PowerCollections.Triple{`0,`1,`2})">
            <summary>
            Determines if this triple is equal to another triple. Two triples are equal if the all three elements
            compare equal using IComparable&lt;T&gt;.Equals or object.Equals.
            </summary>
            <param name="other">Triple to compare with for equality.</param>
            <returns>True if the triples are equal. False if the triples are not equal.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Triple`3.GetHashCode">
            <summary>
            Returns a hash code for the triple, suitable for use in a hash-table or other hashed collection.
            Two triples that compare equal (using Equals) will have the same hash code. The hash code for
            the triple is derived by combining the hash codes for each of the two elements of the triple.
            </summary>
            <returns>The hash code.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Triple`3.CompareTo(Wintellect.PowerCollections.Triple{`0,`1,`2})">
            <summary>
            <para> Compares this triple to another triple of the some type. The triples are compared by using
            the IComparable&lt;T&gt; or IComparable interface on TFirst, TSecond, and TThird. The triples
            are compared by their first elements first, if their first elements are equal, then they
            are compared by their second elements. If their second elements are also equal, then they
            are compared by their third elements.</para>
            <para>If TFirst, TSecond, or TThird does not implement IComparable&lt;T&gt; or IComparable, then
            an NotSupportedException is thrown, because the triples cannot be compared.</para>
            </summary>
            <param name="other">The triple to compare to.</param>
            <returns>An integer indicating how this triple compares to <paramref name="other"/>. Less
            than zero indicates this triple is less than <paramref name="other"/>. Zero indicate this triple is
            equals to <paramref name="other"/>. Greater than zero indicates this triple is greater than
            <paramref name="other"/>.</returns>
            <exception cref="T:System.NotSupportedException">Either FirstSecond, TSecond, or TThird is not comparable
            via the IComparable&lt;T&gt; or IComparable interfaces.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Triple`3.System#IComparable#CompareTo(System.Object)">
            <summary>
            <para> Compares this triple to another triple of the some type. The triples are compared by using
            the IComparable&lt;T&gt; or IComparable interface on TFirst, TSecond, and TThird. The triples
            are compared by their first elements first, if their first elements are equal, then they
            are compared by their second elements. If their second elements are also equal, then they
            are compared by their third elements.</para>
            <para>If TFirst, TSecond, or TThird does not implement IComparable&lt;T&gt; or IComparable, then
            an NotSupportedException is thrown, because the triples cannot be compared.</para>
            </summary>
            <param name="obj">The triple to compare to.</param>
            <returns>An integer indicating how this triple compares to <paramref name="obj"/>. Less
            than zero indicates this triple is less than <paramref name="obj"/>. Zero indicate this triple is
            equals to <paramref name="obj"/>. Greater than zero indicates this triple is greater than
            <paramref name="obj"/>.</returns>
            <exception cref="T:System.ArgumentException"><paramref name="obj"/> is not of the correct type.</exception>
            <exception cref="T:System.NotSupportedException">Either FirstSecond, TSecond, or TThird is not comparable
            via the IComparable&lt;T&gt; or IComparable interfaces.</exception>
        </member>
        <member name="M:Wintellect.PowerCollections.Triple`3.ToString">
            <summary>
            Returns a string representation of the triple. The string representation of the triple is
            of the form:
            <c>First: {0}, Second: {1}, Third: {2}</c>
            where {0} is the result of First.ToString(), {1} is the result of Second.ToString(), and
            {2} is the result of Third.ToString() (or "null" if they are null.)
            </summary>
            <returns> The string representation of the triple.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Triple`3.op_Equality(Wintellect.PowerCollections.Triple{`0,`1,`2},Wintellect.PowerCollections.Triple{`0,`1,`2})">
            <summary>
            Determines if two triples are equal. Two triples are equal if the all three elements
            compare equal using IComparable&lt;T&gt;.Equals or object.Equals.
            </summary>
            <param name="pair1">First triple to compare.</param>
            <param name="pair2">Second triple to compare.</param>
            <returns>True if the triples are equal. False if the triples are not equal.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Triple`3.op_Inequality(Wintellect.PowerCollections.Triple{`0,`1,`2},Wintellect.PowerCollections.Triple{`0,`1,`2})">
            <summary>
            Determines if two triples are not equal. Two triples are equal if the all three elements
            compare equal using IComparable&lt;T&gt;.Equals or object.Equals.
            </summary>
            <param name="pair1">First triple to compare.</param>
            <param name="pair2">Second triple to compare.</param>
            <returns>True if the triples are not equal. False if the triples are equal.</returns>
        </member>
        <member name="T:Wintellect.PowerCollections.Util">
            <summary>
            A holder class for various internal utility functions that need to be shared.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Util.IsCloneableType(System.Type,System.Boolean@)">
            <summary>
            Determine if a type is cloneable: either a value type or implementing
            ICloneable.
            </summary>
            <param name="type">Type to check.</param>
            <param name="isValue">Returns if the type is a value type, and does not implement ICloneable.</param>
            <returns>True if the type is cloneable.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Util.SimpleClassName(System.Type)">
            <summary>
            Returns the simple name of the class, for use in exception messages. 
            </summary>
            <returns>The simple name of this class.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Util.CreateEnumerableWrapper``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Wrap an enumerable so that clients can't get to the underlying
            implementation via a down-case
            </summary>
            <param name="wrapped">Enumerable to wrap.</param>
            <returns>A wrapper around the enumerable.</returns>
        </member>
        <member name="M:Wintellect.PowerCollections.Util.GetHashCode``1(``0,System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Gets the hash code for an object using a comparer. Correctly handles
            null.
            </summary>
            <param name="item">Item to get hash code for. Can be null.</param>
            <param name="equalityComparer">The comparer to use.</param>
            <returns>The hash code for the item.</returns>
        </member>
        <member name="T:Wintellect.PowerCollections.Util.WrapEnumerable`1">
            <summary>
            Wrap an enumerable so that clients can't get to the underlying 
            implementation via a down-cast.
            </summary>
        </member>
        <member name="M:Wintellect.PowerCollections.Util.WrapEnumerable`1.#ctor(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Create the wrapper around an enumerable.
            </summary>
            <param name="wrapped">IEnumerable to wrap.</param>
        </member>
    </members>
</doc>
