You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@struts.apache.org by hu...@apache.org on 2005/09/10 21:05:02 UTC
svn commit: r280025 [4/5] - in /struts/sandbox/trunk/overdrive/Nexus: Core/
Core/Helpers/ Extras/ Extras/Spring/ Test/ Test/Resources/Command/
Test/bin/Debug/ Web/
Added: struts/sandbox/trunk/overdrive/Nexus/Test/bin/Debug/Spring.Core.xml
URL: http://svn.apache.org/viewcvs/struts/sandbox/trunk/overdrive/Nexus/Test/bin/Debug/Spring.Core.xml?rev=280025&view=auto
==============================================================================
--- struts/sandbox/trunk/overdrive/Nexus/Test/bin/Debug/Spring.Core.xml (added)
+++ struts/sandbox/trunk/overdrive/Nexus/Test/bin/Debug/Spring.Core.xml Sat Sep 10 12:04:14 2005
@@ -0,0 +1,21981 @@
+<?xml version="1.0"?>
+<doc>
+ <assembly>
+ <name>Spring.Core</name>
+ </assembly>
+ <members>
+ <member name="T:Spring.Collections.DictionarySet">
+ <summary>
+ <see cref="T:Spring.Collections.DictionarySet"/> is an <see langword="abstract"/> class
+ that supports the creation of new
+ <see cref="T:Spring.Collections.ISet"/> types where the underlying data
+ store is an <see cref="T:System.Collections.IDictionary"/> instance.
+ </summary>
+ <remarks>
+ <p>You can use any object that implements the <see cref="T:System.Collections.IDictionary"/>
+ interface to hold set data. You can define your own, or you can use one of the objects
+ provided in the framework. The type of <see cref="T:System.Collections.IDictionary"/> you
+ choose will affect both the performance and the behavior of the
+ <see cref="T:Spring.Collections.ISet"/> using it.</p>
+
+ <p>This object overrides the <see cref="M:System.Object.Equals(System.Object)"/> method, but not the
+ <see cref="M:System.Object.GetHashCode"/> method, because the
+ <see cref="T:Spring.Collections.DictionarySet"/> class is mutable. Therefore, it is not
+ safe to use as a key value in a hash table.</p>
+
+ <p>To make a <see cref="T:Spring.Collections.ISet"/> typed based on your own
+ <see cref="T:System.Collections.IDictionary"/>, simply derive a new class with a
+ constructor that takes no parameters. Some <see cref="T:Spring.Collections.ISet"/>
+ implmentations cannot be defined with a default constructor. If this is the case for
+ your class, you will need to override <b>clone</b> as well.</p>
+
+ <p>It is also standard practice that at least one of your constructors takes an
+ <see cref="T:System.Collections.ICollection"/> or an <see cref="T:Spring.Collections.ISet"/>
+ as an argument.</p>
+ </remarks>
+ </member>
+ <member name="T:Spring.Collections.Set">
+ <summary>
+ A collection that contains no duplicate elements.
+ </summary>
+ <remarks>
+ <p>
+ This interface models the mathematical
+ <see cref="T:Spring.Collections.ISet"/> abstraction.
+ The order of elements in a set is dependant on (a)the data-structure implementation, and
+ (b)the implementation of the various <see cref="T:Spring.Collections.ISet"/> methods, and thus is not guaranteed.</p>
+
+ <p><see cref="T:Spring.Collections.ISet"/> overrides the <see cref="M:System.Object.Equals(System.Object)"/> method to test for "equivalency": whether the
+ two sets contain the same elements. The "==" and "!=" operators are not overridden by
+ design, since it is often desirable to compare object references for equality.</p>
+
+ <p>Also, the <see cref="M:System.Object.GetHashCode"/> method is not implemented on any of the set implementations, since none
+ of them are truely immutable. This is by design, and it is the way almost all collections in
+ the .NET framework function. So as a general rule, don't store collection objects inside <see cref="T:Spring.Collections.ISet"/>
+ instances. You would typically want to use a keyed <see cref="T:System.Collections.IDictionary"/> instead.</p>
+
+ <p>None of the <see cref="T:Spring.Collections.ISet"/> implementations in this library are guranteed to be thread-safe
+ in any way unless wrapped in a <see cref="T:Spring.Collections.SynchronizedSet"/>.</p>
+
+ <p>The following table summarizes the binary operators that are supported by the <see cref="T:Spring.Collections.ISet"/> class.</p>
+ <list type="table">
+ <listheader>
+ <term>Operation</term>
+ <term>Description</term>
+ <term>Method</term>
+ </listheader>
+ <item>
+ <term>Union (OR)</term>
+ <term>Element included in result if it exists in either <c>A</c> OR <c>B</c>.</term>
+ <term><c>Union()</c></term>
+ </item>
+ <item>
+ <term>Intersection (AND)</term>
+ <term>Element included in result if it exists in both <c>A</c> AND <c>B</c>.</term>
+ <term><c>InterSect()</c></term>
+ </item>
+ <item>
+ <term>Exclusive Or (XOR)</term>
+ <term>Element included in result if it exists in one, but not both, of <c>A</c> and <c>B</c>.</term>
+ <term><c>ExclusiveOr()</c></term>
+ </item>
+ <item>
+ <term>Minus (n/a)</term>
+ <term>Take all the elements in <c>A</c>. Now, if any of them exist in <c>B</c>, remove
+ them. Note that unlike the other operators, <c>A - B</c> is not the same as <c>B - A</c>.</term>
+ <term><c>Minus()</c></term>
+ </item>
+ </list>
+ </remarks>
+ </member>
+ <member name="T:Spring.Collections.ISet">
+ <summary>
+ A collection that contains no duplicate elements.
+ </summary>
+ <remarks>
+ <p>
+ This interface models the mathematical
+ <see cref="T:Spring.Collections.ISet"/> abstraction.
+ The order of elements in a set is dependant on (a)the data-structure implementation, and
+ (b)the implementation of the various <see cref="T:Spring.Collections.ISet"/> methods, and thus is not guaranteed.</p>
+
+ <p><see cref="T:Spring.Collections.ISet"/> overrides the <see cref="M:System.Object.Equals(System.Object)"/> method to test for "equivalency": whether the
+ two sets contain the same elements. The "==" and "!=" operators are not overridden by
+ design, since it is often desirable to compare object references for equality.</p>
+
+ <p>Also, the <see cref="M:System.Object.GetHashCode"/> method is not implemented on any of the set implementations, since none
+ of them are truely immutable. This is by design, and it is the way almost all collections in
+ the .NET framework function. So as a general rule, don't store collection objects inside <see cref="T:Spring.Collections.ISet"/>
+ instances. You would typically want to use a keyed <see cref="T:System.Collections.IDictionary"/> instead.</p>
+
+ <p>None of the <see cref="T:Spring.Collections.ISet"/> implementations in this library are guranteed to be thread-safe
+ in any way unless wrapped in a <see cref="T:Spring.Collections.SynchronizedSet"/>.</p>
+
+ <p>The following table summarizes the binary operators that are supported by the <see cref="T:Spring.Collections.ISet"/> class.</p>
+ <list type="table">
+ <listheader>
+ <term>Operation</term>
+ <term>Description</term>
+ <term>Method</term>
+ </listheader>
+ <item>
+ <term>Union (OR)</term>
+ <term>Element included in result if it exists in either <c>A</c> OR <c>B</c>.</term>
+ <term><c>Union()</c></term>
+ </item>
+ <item>
+ <term>Intersection (AND)</term>
+ <term>Element included in result if it exists in both <c>A</c> AND <c>B</c>.</term>
+ <term><c>InterSect()</c></term>
+ </item>
+ <item>
+ <term>Exclusive Or (XOR)</term>
+ <term>Element included in result if it exists in one, but not both, of <c>A</c> and <c>B</c>.</term>
+ <term><c>ExclusiveOr()</c></term>
+ </item>
+ <item>
+ <term>Minus (n/a)</term>
+ <term>Take all the elements in <c>A</c>. Now, if any of them exist in <c>B</c>, remove
+ them. Note that unlike the other operators, <c>A - B</c> is not the same as <c>B - A</c>.</term>
+ <term><c>Minus()</c></term>
+ </item>
+ </list>
+ </remarks>
+ </member>
+ <member name="M:Spring.Collections.ISet.Union(Spring.Collections.ISet)">
+ <summary>
+ Performs a "union" of the two sets, where all the elements
+ in both sets are present. That is, the element is included if it is in either <c>a</c> or <c>b</c>.
+ Neither this set nor the input set are modified during the operation. The return value
+ is a <b>clone</b> of this set with the extra elements added in.
+ </summary>
+ <param name="a">A collection of elements.</param>
+ <returns>A new <see cref="T:Spring.Collections.ISet"/> containing the union of this <see cref="T:Spring.Collections.ISet"/> with the specified collection.
+ Neither of the input objects is modified by the union.</returns>
+ </member>
+ <member name="M:Spring.Collections.ISet.Intersect(Spring.Collections.ISet)">
+ <summary>
+ Performs an "intersection" of the two sets, where only the elements
+ that are present in both sets remain. That is, the element is included if it exists in
+ both sets. The <c>Intersect()</c> operation does not modify the input sets. It returns
+ a <b>clone</b> of this set with the appropriate elements removed.
+ </summary>
+ <param name="a">A set of elements.</param>
+ <returns>The intersection of this set with <c>a</c>.</returns>
+ </member>
+ <member name="M:Spring.Collections.ISet.Minus(Spring.Collections.ISet)">
+ <summary>
+ Performs a "minus" of set <c>b</c> from set <c>a</c>. This returns a set of all
+ the elements in set <c>a</c>, removing the elements that are also in set <c>b</c>.
+ The original sets are not modified during this operation. The result set is a <b>clone</b>
+ of this <see cref="T:Spring.Collections.ISet"/> containing the elements from the operation.
+ </summary>
+ <param name="a">A set of elements.</param>
+ <returns>A set containing the elements from this set with the elements in <c>a</c> removed.</returns>
+ </member>
+ <member name="M:Spring.Collections.ISet.ExclusiveOr(Spring.Collections.ISet)">
+ <summary>
+ Performs an "exclusive-or" of the two sets, keeping only the elements that
+ are in one of the sets, but not in both. The original sets are not modified
+ during this operation. The result set is a <b>clone</b> of this set containing
+ the elements from the exclusive-or operation.
+ </summary>
+ <param name="a">A set of elements.</param>
+ <returns>A set containing the result of <c>a ^ b</c>.</returns>
+ </member>
+ <member name="M:Spring.Collections.ISet.Contains(System.Object)">
+ <summary>
+ Returns <c>true</c> if this set contains the specified element.
+ </summary>
+ <param name="o">The element to look for.</param>
+ <returns><c>true</c> if this set contains the specified element, <c>false</c> otherwise.</returns>
+ </member>
+ <member name="M:Spring.Collections.ISet.ContainsAll(System.Collections.ICollection)">
+ <summary>
+ Returns <c>true</c> if the set contains all the elements in the specified collection.
+ </summary>
+ <param name="c">A collection of objects.</param>
+ <returns><c>true</c> if the set contains all the elements in the specified collection, <c>false</c> otherwise.</returns>
+ </member>
+ <member name="M:Spring.Collections.ISet.Add(System.Object)">
+ <summary>
+ Adds the specified element to this set if it is not already present.
+ </summary>
+ <param name="o">The object to add to the set.</param>
+ <returns><c>true</c> is the object was added, <c>false</c> if it was already present.</returns>
+ </member>
+ <member name="M:Spring.Collections.ISet.AddAll(System.Collections.ICollection)">
+ <summary>
+ Adds all the elements in the specified collection to the set if they are not already present.
+ </summary>
+ <param name="c">A collection of objects to add to the set.</param>
+ <returns><c>true</c> is the set changed as a result of this operation, <c>false</c> if not.</returns>
+ </member>
+ <member name="M:Spring.Collections.ISet.Remove(System.Object)">
+ <summary>
+ Removes the specified element from the set.
+ </summary>
+ <param name="o">The element to be removed.</param>
+ <returns><c>true</c> if the set contained the specified element, <c>false</c> otherwise.</returns>
+ </member>
+ <member name="M:Spring.Collections.ISet.RemoveAll(System.Collections.ICollection)">
+ <summary>
+ Remove all the specified elements from this set, if they exist in this set.
+ </summary>
+ <param name="c">A collection of elements to remove.</param>
+ <returns><c>true</c> if the set was modified as a result of this operation.</returns>
+ </member>
+ <member name="M:Spring.Collections.ISet.RetainAll(System.Collections.ICollection)">
+ <summary>
+ Retains only the elements in this set that are contained in the specified collection.
+ </summary>
+ <param name="c">Collection that defines the set of elements to be retained.</param>
+ <returns><c>true</c> if this set changed as a result of this operation.</returns>
+ </member>
+ <member name="M:Spring.Collections.ISet.Clear">
+ <summary>
+ Removes all objects from the set.
+ </summary>
+ </member>
+ <member name="P:Spring.Collections.ISet.IsEmpty">
+ <summary>
+ Returns <c>true</c> if this set contains no elements.
+ </summary>
+ </member>
+ <member name="M:Spring.Collections.Set.Union(Spring.Collections.ISet)">
+ <summary>
+ Performs a "union" of the two sets, where all the elements
+ in both sets are present. That is, the element is included if it is in either <c>a</c> or <c>b</c>.
+ Neither this set nor the input set are modified during the operation. The return value
+ is a <b>clone</b> of this set with the extra elements added in.
+ </summary>
+ <param name="a">A collection of elements.</param>
+ <returns>A new <see cref="T:Spring.Collections.ISet"/> containing the union of this <see cref="T:Spring.Collections.ISet"/> with the specified collection.
+ Neither of the input objects is modified by the union.</returns>
+ </member>
+ <member name="M:Spring.Collections.Set.Union(Spring.Collections.ISet,Spring.Collections.ISet)">
+ <summary>
+ Performs a "union" of two sets, where all the elements
+ in both are present. That is, the element is included if it is in either <c>a</c> or <c>b</c>.
+ The return value is a <b>clone</b> of one of the sets (<c>a</c> if it is not <c>null</c>) with elements of the other set
+ added in. Neither of the input sets is modified by the operation.
+ </summary>
+ <param name="a">A set of elements.</param>
+ <param name="b">A set of elements.</param>
+ <returns>A set containing the union of the input sets. <c>null</c> if both sets are <c>null</c>.</returns>
+ </member>
+ <member name="M:Spring.Collections.Set.op_BitwiseOr(Spring.Collections.Set,Spring.Collections.Set)">
+ <summary>
+ Performs a "union" of two sets, where all the elements
+ in both are present. That is, the element is included if it is in either <c>a</c> or <c>b</c>.
+ The return value is a <b>clone</b> of one of the sets (<c>a</c> if it is not <c>null</c>) with elements of the other set
+ added in. Neither of the input sets is modified by the operation.
+ </summary>
+ <param name="a">A set of elements.</param>
+ <param name="b">A set of elements.</param>
+ <returns>A set containing the union of the input sets. <c>null</c> if both sets are <c>null</c>.</returns>
+ </member>
+ <member name="M:Spring.Collections.Set.Intersect(Spring.Collections.ISet)">
+ <summary>
+ Performs an "intersection" of the two sets, where only the elements
+ that are present in both sets remain. That is, the element is included if it exists in
+ both sets. The <c>Intersect()</c> operation does not modify the input sets. It returns
+ a <b>clone</b> of this set with the appropriate elements removed.
+ </summary>
+ <param name="a">A set of elements.</param>
+ <returns>The intersection of this set with <c>a</c>.</returns>
+ </member>
+ <member name="M:Spring.Collections.Set.Intersect(Spring.Collections.ISet,Spring.Collections.ISet)">
+ <summary>
+ Performs an "intersection" of the two sets, where only the elements
+ that are present in both sets remain. That is, the element is included only if it exists in
+ both <c>a</c> and <c>b</c>. Neither input object is modified by the operation.
+ The result object is a <b>clone</b> of one of the input objects (<c>a</c> if it is not <c>null</c>) containing the
+ elements from the intersect operation.
+ </summary>
+ <param name="a">A set of elements.</param>
+ <param name="b">A set of elements.</param>
+ <returns>The intersection of the two input sets. <c>null</c> if both sets are <c>null</c>.</returns>
+ </member>
+ <member name="M:Spring.Collections.Set.op_BitwiseAnd(Spring.Collections.Set,Spring.Collections.Set)">
+ <summary>
+ Performs an "intersection" of the two sets, where only the elements
+ that are present in both sets remain. That is, the element is included only if it exists in
+ both <c>a</c> and <c>b</c>. Neither input object is modified by the operation.
+ The result object is a <b>clone</b> of one of the input objects (<c>a</c> if it is not <c>null</c>) containing the
+ elements from the intersect operation.
+ </summary>
+ <param name="a">A set of elements.</param>
+ <param name="b">A set of elements.</param>
+ <returns>The intersection of the two input sets. <c>null</c> if both sets are <c>null</c>.</returns>
+ </member>
+ <member name="M:Spring.Collections.Set.Minus(Spring.Collections.ISet)">
+ <summary>
+ Performs a "minus" of set <c>b</c> from set <c>a</c>. This returns a set of all
+ the elements in set <c>a</c>, removing the elements that are also in set <c>b</c>.
+ The original sets are not modified during this operation. The result set is a <b>clone</b>
+ of this <see cref="T:Spring.Collections.ISet"/> containing the elements from the operation.
+ </summary>
+ <param name="a">A set of elements.</param>
+ <returns>A set containing the elements from this set with the elements in <c>a</c> removed.</returns>
+ </member>
+ <member name="M:Spring.Collections.Set.Minus(Spring.Collections.ISet,Spring.Collections.ISet)">
+ <summary>
+ Performs a "minus" of set <c>b</c> from set <c>a</c>. This returns a set of all
+ the elements in set <c>a</c>, removing the elements that are also in set <c>b</c>.
+ The original sets are not modified during this operation. The result set is a <b>clone</b>
+ of set <c>a</c> containing the elements from the operation.
+ </summary>
+ <param name="a">A set of elements.</param>
+ <param name="b">A set of elements.</param>
+ <returns>A set containing <c>A - B</c> elements. <c>null</c> if <c>a</c> is <c>null</c>.</returns>
+ </member>
+ <member name="M:Spring.Collections.Set.op_Subtraction(Spring.Collections.Set,Spring.Collections.Set)">
+ <summary>
+ Performs a "minus" of set <c>b</c> from set <c>a</c>. This returns a set of all
+ the elements in set <c>a</c>, removing the elements that are also in set <c>b</c>.
+ The original sets are not modified during this operation. The result set is a <b>clone</b>
+ of set <c>a</c> containing the elements from the operation.
+ </summary>
+ <param name="a">A set of elements.</param>
+ <param name="b">A set of elements.</param>
+ <returns>A set containing <c>A - B</c> elements. <c>null</c> if <c>a</c> is <c>null</c>.</returns>
+ </member>
+ <member name="M:Spring.Collections.Set.ExclusiveOr(Spring.Collections.ISet)">
+ <summary>
+ Performs an "exclusive-or" of the two sets, keeping only the elements that
+ are in one of the sets, but not in both. The original sets are not modified
+ during this operation. The result set is a <b>clone</b> of this set containing
+ the elements from the exclusive-or operation.
+ </summary>
+ <param name="a">A set of elements.</param>
+ <returns>A set containing the result of <c>a ^ b</c>.</returns>
+ </member>
+ <member name="M:Spring.Collections.Set.ExclusiveOr(Spring.Collections.ISet,Spring.Collections.ISet)">
+ <summary>
+ Performs an "exclusive-or" of the two sets, keeping only the elements that
+ are in one of the sets, but not in both. The original sets are not modified
+ during this operation. The result set is a <b>clone</b> of one of the sets
+ (<c>a</c> if it is not <c>null</c>) containing
+ the elements from the exclusive-or operation.
+ </summary>
+ <param name="a">A set of elements.</param>
+ <param name="b">A set of elements.</param>
+ <returns>A set containing the result of <c>a ^ b</c>. <c>null</c> if both sets are <c>null</c>.</returns>
+ </member>
+ <member name="M:Spring.Collections.Set.op_ExclusiveOr(Spring.Collections.Set,Spring.Collections.Set)">
+ <summary>
+ Performs an "exclusive-or" of the two sets, keeping only the elements that
+ are in one of the sets, but not in both. The original sets are not modified
+ during this operation. The result set is a <b>clone</b> of one of the sets
+ (<c>a</c> if it is not <c>null</c>) containing
+ the elements from the exclusive-or operation.
+ </summary>
+ <param name="a">A set of elements.</param>
+ <param name="b">A set of elements.</param>
+ <returns>A set containing the result of <c>a ^ b</c>. <c>null</c> if both sets are <c>null</c>.</returns>
+ </member>
+ <member name="M:Spring.Collections.Set.Add(System.Object)">
+ <summary>
+ Adds the specified element to this set if it is not already present.
+ </summary>
+ <param name="o">The object to add to the set.</param>
+ <returns><c>true</c> is the object was added, <c>false</c> if it was already present.</returns>
+ </member>
+ <member name="M:Spring.Collections.Set.AddAll(System.Collections.ICollection)">
+ <summary>
+ Adds all the elements in the specified collection to the set if they are not already present.
+ </summary>
+ <param name="c">A collection of objects to add to the set.</param>
+ <returns><c>true</c> is the set changed as a result of this operation, <c>false</c> if not.</returns>
+ </member>
+ <member name="M:Spring.Collections.Set.Clear">
+ <summary>
+ Removes all objects from the set.
+ </summary>
+ </member>
+ <member name="M:Spring.Collections.Set.Contains(System.Object)">
+ <summary>
+ Returns <c>true</c> if this set contains the specified element.
+ </summary>
+ <param name="o">The element to look for.</param>
+ <returns><c>true</c> if this set contains the specified element, <c>false</c> otherwise.</returns>
+ </member>
+ <member name="M:Spring.Collections.Set.ContainsAll(System.Collections.ICollection)">
+ <summary>
+ Returns <c>true</c> if the set contains all the elements in the specified collection.
+ </summary>
+ <param name="c">A collection of objects.</param>
+ <returns><c>true</c> if the set contains all the elements in the specified collection, <c>false</c> otherwise.</returns>
+ </member>
+ <member name="M:Spring.Collections.Set.Remove(System.Object)">
+ <summary>
+ Removes the specified element from the set.
+ </summary>
+ <param name="o">The element to be removed.</param>
+ <returns><c>true</c> if the set contained the specified element, <c>false</c> otherwise.</returns>
+ </member>
+ <member name="M:Spring.Collections.Set.RemoveAll(System.Collections.ICollection)">
+ <summary>
+ Remove all the specified elements from this set, if they exist in this set.
+ </summary>
+ <param name="c">A collection of elements to remove.</param>
+ <returns><c>true</c> if the set was modified as a result of this operation.</returns>
+ </member>
+ <member name="M:Spring.Collections.Set.RetainAll(System.Collections.ICollection)">
+ <summary>
+ Retains only the elements in this set that are contained in the specified collection.
+ </summary>
+ <param name="c">Collection that defines the set of elements to be retained.</param>
+ <returns><c>true</c> if this set changed as a result of this operation.</returns>
+ </member>
+ <member name="M:Spring.Collections.Set.Clone">
+ <summary>
+ Returns a clone of the <see cref="T:Spring.Collections.ISet"/> instance. This will work for derived <see cref="T:Spring.Collections.ISet"/>
+ classes if the derived class implements a constructor that takes no arguments.
+ </summary>
+ <returns>A clone of this object.</returns>
+ </member>
+ <member name="M:Spring.Collections.Set.CopyTo(System.Array,System.Int32)">
+ <summary>
+ Copies the elements in the <see cref="T:Spring.Collections.ISet"/> to an array. The type of array needs
+ to be compatible with the objects in the <see cref="T:Spring.Collections.ISet"/>, obviously.
+ </summary>
+ <param name="array">An array that will be the target of the copy operation.</param>
+ <param name="index">The zero-based index where copying will start.</param>
+ </member>
+ <member name="M:Spring.Collections.Set.GetEnumerator">
+ <summary>
+ Gets an enumerator for the elements in the <see cref="T:Spring.Collections.ISet"/>.
+ </summary>
+ <returns>An <c>IEnumerator</c> over the elements in the <see cref="T:Spring.Collections.ISet"/>.</returns>
+ </member>
+ <member name="M:Spring.Collections.Set.Equals(System.Object)">
+ <summary>
+ This method will test the <see cref="T:Spring.Collections.ISet"/> against another <see cref="T:Spring.Collections.ISet"/> for "equality".
+ In this case, "equality" means that the two sets contain the same elements.
+ The "==" and "!=" operators are not overridden by design. If you wish to check
+ for "equivalent" <see cref="T:Spring.Collections.ISet"/> instances, use <c>Equals()</c>. If you wish to check
+ to see if two references are actually the same object, use "==" and "!=".
+ </summary>
+ <param name="o">A <see cref="T:Spring.Collections.ISet"/> object to compare to.</param>
+ <returns></returns>
+ </member>
+ <member name="M:Spring.Collections.Set.GetHashCode">
+ <summary>
+ Gets the hashcode for the object. Not implemented.
+ </summary>
+ <returns>An exception.</returns>
+ <exception cref="T:System.NotImplementedException">This feature is not implemented.</exception>
+ </member>
+ <member name="P:Spring.Collections.Set.IsEmpty">
+ <summary>
+ Returns <c>true</c> if this set contains no elements.
+ </summary>
+ </member>
+ <member name="P:Spring.Collections.Set.Count">
+ <summary>
+ The number of elements currently contained in this collection.
+ </summary>
+ </member>
+ <member name="P:Spring.Collections.Set.IsSynchronized">
+ <summary>
+ Returns <c>true</c> if the <see cref="T:Spring.Collections.ISet"/> is synchronized across threads. Note that
+ enumeration is inherently not thread-safe. Use the <c>SyncRoot</c> to lock the
+ object during enumeration.
+ </summary>
+ </member>
+ <member name="P:Spring.Collections.Set.SyncRoot">
+ <summary>
+ An object that can be used to synchronize this collection to make it thread-safe.
+ When implementing this, if your object uses a base object, like an <see cref="T:System.Collections.IDictionary"/>,
+ or anything that has a <c>SyncRoot</c>, return that object instead of "<c>this</c>".
+ </summary>
+ </member>
+ <member name="F:Spring.Collections.DictionarySet.InternalDictionary">
+ <summary>
+ Provides the storage for elements in the <see cref="T:Spring.Collections.ISet"/>, stored as the key-set
+ of the <see cref="T:System.Collections.IDictionary"/> object. Set this object in the constructor
+ if you create your own <see cref="T:Spring.Collections.ISet"/> class.
+ </summary>
+ </member>
+ <member name="M:Spring.Collections.DictionarySet.Add(System.Object)">
+ <summary>
+ Adds the specified element to this set if it is not already present.
+ </summary>
+ <param name="o">The object to add to the set.</param>
+ <returns><c>true</c> is the object was added, <c>false</c> if it was already present.</returns>
+ </member>
+ <member name="M:Spring.Collections.DictionarySet.AddAll(System.Collections.ICollection)">
+ <summary>
+ Adds all the elements in the specified collection to the set if they are not already present.
+ </summary>
+ <param name="c">A collection of objects to add to the set.</param>
+ <returns><c>true</c> is the set changed as a result of this operation, <c>false</c> if not.</returns>
+ </member>
+ <member name="M:Spring.Collections.DictionarySet.Clear">
+ <summary>
+ Removes all objects from the set.
+ </summary>
+ </member>
+ <member name="M:Spring.Collections.DictionarySet.Contains(System.Object)">
+ <summary>
+ Returns <c>true</c> if this set contains the specified element.
+ </summary>
+ <param name="o">The element to look for.</param>
+ <returns><c>true</c> if this set contains the specified element, <c>false</c> otherwise.</returns>
+ </member>
+ <member name="M:Spring.Collections.DictionarySet.ContainsAll(System.Collections.ICollection)">
+ <summary>
+ Returns <c>true</c> if the set contains all the elements in the specified collection.
+ </summary>
+ <param name="c">A collection of objects.</param>
+ <returns><c>true</c> if the set contains all the elements in the specified collection, <c>false</c> otherwise.</returns>
+ </member>
+ <member name="M:Spring.Collections.DictionarySet.Remove(System.Object)">
+ <summary>
+ Removes the specified element from the set.
+ </summary>
+ <param name="o">The element to be removed.</param>
+ <returns><c>true</c> if the set contained the specified element, <c>false</c> otherwise.</returns>
+ </member>
+ <member name="M:Spring.Collections.DictionarySet.RemoveAll(System.Collections.ICollection)">
+ <summary>
+ Remove all the specified elements from this set, if they exist in this set.
+ </summary>
+ <param name="c">A collection of elements to remove.</param>
+ <returns><c>true</c> if the set was modified as a result of this operation.</returns>
+ </member>
+ <member name="M:Spring.Collections.DictionarySet.RetainAll(System.Collections.ICollection)">
+ <summary>
+ Retains only the elements in this set that are contained in the specified collection.
+ </summary>
+ <param name="c">Collection that defines the set of elements to be retained.</param>
+ <returns><c>true</c> if this set changed as a result of this operation.</returns>
+ </member>
+ <member name="M:Spring.Collections.DictionarySet.CopyTo(System.Array,System.Int32)">
+ <summary>
+ Copies the elements in the <see cref="T:Spring.Collections.ISet"/> to an array. The type of array needs
+ to be compatible with the objects in the <see cref="T:Spring.Collections.ISet"/>, obviously.
+ </summary>
+ <param name="array">An array that will be the target of the copy operation.</param>
+ <param name="index">The zero-based index where copying will start.</param>
+ </member>
+ <member name="M:Spring.Collections.DictionarySet.GetEnumerator">
+ <summary>
+ Gets an enumerator for the elements in the <see cref="T:Spring.Collections.ISet"/>.
+ </summary>
+ <returns>An <c>IEnumerator</c> over the elements in the <see cref="T:Spring.Collections.ISet"/>.</returns>
+ </member>
+ <member name="P:Spring.Collections.DictionarySet.Placeholder">
+ <summary>
+ The placeholder object used as the value for the <see cref="T:System.Collections.IDictionary"/> instance.
+ </summary>
+ <remarks>
+ There is a single instance of this object globally, used for all <c>Sets</c>.
+ </remarks>
+ </member>
+ <member name="P:Spring.Collections.DictionarySet.IsEmpty">
+ <summary>
+ Returns <c>true</c> if this set contains no elements.
+ </summary>
+ </member>
+ <member name="P:Spring.Collections.DictionarySet.Count">
+ <summary>
+ The number of elements contained in this collection.
+ </summary>
+ </member>
+ <member name="P:Spring.Collections.DictionarySet.IsSynchronized">
+ <summary>
+ None of the objects based on <see cref="T:Spring.Collections.DictionarySet"/> are synchronized. Use the
+ <c>SyncRoot</c> property instead.
+ </summary>
+ </member>
+ <member name="P:Spring.Collections.DictionarySet.SyncRoot">
+ <summary>
+ Returns an object that can be used to synchronize the <see cref="T:Spring.Collections.ISet"/> between threads.
+ </summary>
+ </member>
+ <member name="T:Spring.Collections.HashedSet">
+ <summary>
+ Implements a <see cref="T:Spring.Collections.ISet"/> based on a hash table.
+ </summary>
+ <remarks>
+ <p>
+ This will give the best lookup, add, and remove performance for very large data-sets,
+ but iteration will occur in no particular order.
+ </p>
+ </remarks>
+ </member>
+ <member name="M:Spring.Collections.HashedSet.#ctor">
+ <summary>
+ Creates a new set instance based on a hash table.
+ </summary>
+ </member>
+ <member name="M:Spring.Collections.HashedSet.#ctor(System.Collections.ICollection)">
+ <summary>
+ Creates a new set instance based on a hash table and initializes it based on a
+ collection of elements.
+ </summary>
+ <param name="initialValues">
+ A collection of elements that defines the initial set contents.
+ </param>
+ </member>
+ <member name="T:Spring.Collections.HybridSet">
+ <summary>
+ Implements a <see cref="T:Spring.Collections.ISet"/> that automatically changes from a
+ list based implementation to a hashtable based implementation when the size reaches a
+ certain threshold.
+ </summary>
+ <remarks>
+ <p>
+ This is good if you are unsure about whether you data-set will be tiny or huge.
+ Because this uses a dual implementation, iteration order is not guaranteed!
+ </p>
+ </remarks>
+ </member>
+ <member name="M:Spring.Collections.HybridSet.#ctor">
+ <summary>
+ Creates a new set instance based on either a list or a hash table, depending on which
+ will be more efficient based on the data-set size.
+ </summary>
+ </member>
+ <member name="M:Spring.Collections.HybridSet.#ctor(System.Collections.ICollection)">
+ <summary>
+ Creates a new set instance based on either a list or a hash table, depending on which
+ will be more efficient based on the data-set size, and
+ initializes it based on a collection of elements.
+ </summary>
+ <param name="initialValues">A collection of elements that defines the initial set contents.</param>
+ </member>
+ <member name="T:Spring.Collections.ImmutableSet">
+ <summary>
+ Implements an immutable (read-only) <see cref="T:Spring.Collections.ISet"/> wrapper.
+ </summary>
+ <remarks>
+ <p>Although this is advertised as immutable, it really isn't. Anyone with access to the
+ <c>basisSet</c> can still change the data-set. So <see cref="M:System.Object.GetHashCode"/> is not implemented
+ for this <see cref="T:Spring.Collections.ISet"/>, as is the case for all
+ <see cref="T:Spring.Collections.ISet"/> implementations in this library.
+ This design decision was based on the efficiency of not having to <b>clone</b> the
+ <c>basisSet</c> every time you wrap a mutable <see cref="T:Spring.Collections.ISet"/>.</p>
+ </remarks>
+ </member>
+ <member name="M:Spring.Collections.ImmutableSet.#ctor(Spring.Collections.ISet)">
+ <summary>
+ Constructs an immutable (read-only) <see cref="T:Spring.Collections.ISet"/> wrapper.
+ </summary>
+ <param name="basisSet">The <see cref="T:Spring.Collections.ISet"/> that is wrapped.</param>
+ </member>
+ <member name="M:Spring.Collections.ImmutableSet.Add(System.Object)">
+ <summary>
+ Adds the specified element to this set if it is not already present.
+ </summary>
+ <param name="o">The object to add to the set.</param>
+ <returns><c>true</c> is the object was added, <c>false</c> if it was already present.</returns>
+ </member>
+ <member name="M:Spring.Collections.ImmutableSet.AddAll(System.Collections.ICollection)">
+ <summary>
+ Adds all the elements in the specified collection to the set if they are not already present.
+ </summary>
+ <param name="c">A collection of objects to add to the set.</param>
+ <returns><c>true</c> is the set changed as a result of this operation, <c>false</c> if not.</returns>
+ </member>
+ <member name="M:Spring.Collections.ImmutableSet.Clear">
+ <summary>
+ Removes all objects from the set.
+ </summary>
+ </member>
+ <member name="M:Spring.Collections.ImmutableSet.Contains(System.Object)">
+ <summary>
+ Returns <c>true</c> if this set contains the specified element.
+ </summary>
+ <param name="o">The element to look for.</param>
+ <returns><c>true</c> if this set contains the specified element, <c>false</c> otherwise.</returns>
+ </member>
+ <member name="M:Spring.Collections.ImmutableSet.ContainsAll(System.Collections.ICollection)">
+ <summary>
+ Returns <c>true</c> if the set contains all the elements in the specified collection.
+ </summary>
+ <param name="c">A collection of objects.</param>
+ <returns><c>true</c> if the set contains all the elements in the specified collection, <c>false</c> otherwise.</returns>
+ </member>
+ <member name="M:Spring.Collections.ImmutableSet.Remove(System.Object)">
+ <summary>
+ Removes the specified element from the set.
+ </summary>
+ <param name="o">The element to be removed.</param>
+ <returns><c>true</c> if the set contained the specified element, <c>false</c> otherwise.</returns>
+ </member>
+ <member name="M:Spring.Collections.ImmutableSet.RemoveAll(System.Collections.ICollection)">
+ <summary>
+ Remove all the specified elements from this set, if they exist in this set.
+ </summary>
+ <param name="c">A collection of elements to remove.</param>
+ <returns><c>true</c> if the set was modified as a result of this operation.</returns>
+ </member>
+ <member name="M:Spring.Collections.ImmutableSet.RetainAll(System.Collections.ICollection)">
+ <summary>
+ Retains only the elements in this set that are contained in the specified collection.
+ </summary>
+ <param name="c">Collection that defines the set of elements to be retained.</param>
+ <returns><c>true</c> if this set changed as a result of this operation.</returns>
+ </member>
+ <member name="M:Spring.Collections.ImmutableSet.CopyTo(System.Array,System.Int32)">
+ <summary>
+ Copies the elements in the <see cref="T:Spring.Collections.ISet"/> to an array. The type of array needs
+ to be compatible with the objects in the <see cref="T:Spring.Collections.ISet"/>, obviously.
+ </summary>
+ <param name="array">An array that will be the target of the copy operation.</param>
+ <param name="index">The zero-based index where copying will start.</param>
+ </member>
+ <member name="M:Spring.Collections.ImmutableSet.GetEnumerator">
+ <summary>
+ Gets an enumerator for the elements in the <see cref="T:Spring.Collections.ISet"/>.
+ </summary>
+ <returns>An <c>IEnumerator</c> over the elements in the <see cref="T:Spring.Collections.ISet"/>.</returns>
+ </member>
+ <member name="M:Spring.Collections.ImmutableSet.Clone">
+ <summary>
+ Returns a clone of the <see cref="T:Spring.Collections.ISet"/> instance.
+ </summary>
+ <returns>A clone of this object.</returns>
+ </member>
+ <member name="M:Spring.Collections.ImmutableSet.Union(Spring.Collections.ISet)">
+ <summary>
+ Performs a "union" of the two sets, where all the elements
+ in both sets are present. That is, the element is included if it is in either <c>a</c> or <c>b</c>.
+ Neither this set nor the input set are modified during the operation. The return value
+ is a <b>clone</b> of this set with the extra elements added in.
+ </summary>
+ <param name="a">A collection of elements.</param>
+ <returns>A new <see cref="T:Spring.Collections.ISet"/> containing the union of this <see cref="T:Spring.Collections.ISet"/> with the specified collection.
+ Neither of the input objects is modified by the union.</returns>
+ </member>
+ <member name="M:Spring.Collections.ImmutableSet.Intersect(Spring.Collections.ISet)">
+ <summary>
+ Performs an "intersection" of the two sets, where only the elements
+ that are present in both sets remain. That is, the element is included if it exists in
+ both sets. The <c>Intersect()</c> operation does not modify the input sets. It returns
+ a <b>clone</b> of this set with the appropriate elements removed.
+ </summary>
+ <param name="a">A set of elements.</param>
+ <returns>The intersection of this set with <c>a</c>.</returns>
+ </member>
+ <member name="M:Spring.Collections.ImmutableSet.Minus(Spring.Collections.ISet)">
+ <summary>
+ Performs a "minus" of set <c>b</c> from set <c>a</c>. This returns a set of all
+ the elements in set <c>a</c>, removing the elements that are also in set <c>b</c>.
+ The original sets are not modified during this operation. The result set is a <b>clone</b>
+ of this <see cref="T:Spring.Collections.ISet"/> containing the elements from the operation.
+ </summary>
+ <param name="a">A set of elements.</param>
+ <returns>A set containing the elements from this set with the elements in <c>a</c> removed.</returns>
+ </member>
+ <member name="M:Spring.Collections.ImmutableSet.ExclusiveOr(Spring.Collections.ISet)">
+ <summary>
+ Performs an "exclusive-or" of the two sets, keeping only the elements that
+ are in one of the sets, but not in both. The original sets are not modified
+ during this operation. The result set is a <b>clone</b> of this set containing
+ the elements from the exclusive-or operation.
+ </summary>
+ <param name="a">A set of elements.</param>
+ <returns>A set containing the result of <c>a ^ b</c>.</returns>
+ </member>
+ <member name="P:Spring.Collections.ImmutableSet.IsEmpty">
+ <summary>
+ Returns <c>true</c> if this set contains no elements.
+ </summary>
+ </member>
+ <member name="P:Spring.Collections.ImmutableSet.Count">
+ <summary>
+ The number of elements contained in this collection.
+ </summary>
+ </member>
+ <member name="P:Spring.Collections.ImmutableSet.IsSynchronized">
+ <summary>
+ Returns an object that can be used to synchronize use of the <see cref="T:Spring.Collections.ISet"/> across threads.
+ </summary>
+ </member>
+ <member name="P:Spring.Collections.ImmutableSet.SyncRoot">
+ <summary>
+ Returns an object that can be used to synchronize the <see cref="T:Spring.Collections.ISet"/> between threads.
+ </summary>
+ </member>
+ <member name="T:Spring.Collections.LinkedList">
+ <summary>
+ Simple linked list implementation.
+ </summary>
+ <author>Simon White</author>
+ </member>
+ <member name="M:Spring.Collections.LinkedList.#ctor">
+ <summary>
+ Constructs a new <code>LinkedList</code>.
+ </summary>
+ </member>
+ <member name="M:Spring.Collections.LinkedList.#ctor(System.Collections.IList)">
+ <summary>
+ Constructs a new <code>LinkedList</code> that contains all elements
+ of the specified list.
+ </summary>
+ <param name="list"></param>
+ </member>
+ <member name="M:Spring.Collections.LinkedList.RemoveAt(System.Int32)">
+ <summary>
+ Removes the object at the specified index.
+ </summary>
+ <param name="index">the index</param>
+ <exception cref="T:System.ArgumentOutOfRangeException">if the specified index is greater than
+ the number of objects within the list</exception>
+ </member>
+ <member name="M:Spring.Collections.LinkedList.Insert(System.Int32,System.Object)">
+ <summary>
+ Inserts an object at the specified index.
+ </summary>
+ <param name="index">the index</param>
+ <param name="value">the object to be inserted</param>
+ <exception cref="T:System.ArgumentOutOfRangeException">if the specified index is greater than
+ the number of objects within the list</exception>
+ </member>
+ <member name="M:Spring.Collections.LinkedList.Remove(System.Object)">
+ <summary>
+ Removes the first instance of the specified object found.
+ </summary>
+ <param name="value">the object to remove</param>
+ </member>
+ <member name="M:Spring.Collections.LinkedList.Contains(System.Object)">
+ <summary>
+ Tests whether at least one instance of the specified object is
+ contained within the list.
+ </summary>
+ <param name="value">the object to search for</param>
+ <returns>true if an instance was found, otherwise false</returns>
+ </member>
+ <member name="M:Spring.Collections.LinkedList.Clear">
+ <summary>
+ Removes all objects from the list.
+ </summary>
+ </member>
+ <member name="M:Spring.Collections.LinkedList.IndexOf(System.Object)">
+ <summary>
+ Returns the index of the first instance of the specified object found.
+ </summary>
+ <param name="value">the object to search for</param>
+ <returns>the index of the first instance found, or -1</returns>
+ <exception cref="T:System.ArgumentOutOfRangeException">if the specified index is greater than
+ the number of objects within the list</exception>
+ </member>
+ <member name="M:Spring.Collections.LinkedList.Add(System.Object)">
+ <summary>
+ Adds the specified object to the end of the list.
+ </summary>
+ <param name="value">the object to add</param>
+ <returns>the index the object was added at</returns>
+ <exception cref="T:System.ArgumentOutOfRangeException">if the specified index is greater than
+ the number of objects within the list</exception>
+ </member>
+ <member name="M:Spring.Collections.LinkedList.AddAll(System.Collections.IList)">
+ <summary>
+ Adds all objects to the end of the list.
+ </summary>
+ <param name="list">the list of objects to add</param>
+ <exception cref="T:System.ArgumentOutOfRangeException">if the specified index is greater than
+ the number of objects within the list</exception>
+ </member>
+ <member name="M:Spring.Collections.LinkedList.CheckUpdateState">
+ <summary>
+ Checks whether the list can be modified.
+ </summary>
+ <exception cref="T:System.NotSupportedException">if the list
+ cannot be modified</exception>
+ </member>
+ <member name="M:Spring.Collections.LinkedList.ValidateIndex(System.Int32)">
+ <summary>
+ Validates the specified index.
+ </summary>
+ <param name="index">the index</param>
+ <exception cref="T:System.ArgumentOutOfRangeException">if the index
+ is invalid</exception>
+ </member>
+ <member name="M:Spring.Collections.LinkedList.GetNode(System.Int32)">
+ <summary>
+ Returns the node at the specified index.
+ </summary>
+ <param name="index">the index</param>
+ <returns>the node</returns>
+ </member>
+ <member name="M:Spring.Collections.LinkedList.GetNode(System.Object)">
+ <summary>
+ Returns the node (and index) and the first node that contains
+ the specified value.
+ </summary>
+ <param name="value">the value to search for</param>
+ <returns>the node, or null</returns>
+ </member>
+ <member name="M:Spring.Collections.LinkedList.RemoveNode(Spring.Collections.LinkedList.Node)">
+ <summary>
+ Removes the specified node.
+ </summary>
+ <param name="node">the node</param>
+ </member>
+ <member name="M:Spring.Collections.LinkedList.CopyTo(System.Array,System.Int32)">
+ <summary>
+ Copies this list to the specified array starting from the specified index.
+ </summary>
+ <param name="array">The array to be copied to.</param>
+ <param name="index">The start index.</param>
+ </member>
+ <member name="M:Spring.Collections.LinkedList.GetEnumerator">
+ <summary>
+ Returns an enumerator for this list. Note enumerators are fail fast.
+ </summary>
+ <returns>the enumerator</returns>
+ </member>
+ <member name="P:Spring.Collections.LinkedList.IsReadOnly">
+ <summary>
+ Is list read only?
+ </summary>
+ </member>
+ <member name="P:Spring.Collections.LinkedList.Item(System.Int32)">
+ <summary>
+ Indexerer.
+ </summary>
+ </member>
+ <member name="P:Spring.Collections.LinkedList.IsFixedSize">
+ <summary>
+ Is the list a fixed size?
+ </summary>
+ </member>
+ <member name="P:Spring.Collections.LinkedList.IsSynchronized">
+ <summary>
+ Is the list synchronized?
+ </summary>
+ </member>
+ <member name="P:Spring.Collections.LinkedList.Count">
+ <summary>
+ The number of objects within the list.
+ </summary>
+ </member>
+ <member name="P:Spring.Collections.LinkedList.SyncRoot">
+ <summary>
+ Gets an object that can be used to synchronize access to the
+ <see cref="T:Spring.Collections.LinkedList"/>.
+ </summary>
+ </member>
+ <member name="T:Spring.Collections.ListSet">
+ <summary>
+ Implements a <see cref="T:Spring.Collections.ISet"/> based on a list.
+ </summary>
+ <remarks>
+ <p>
+ Performance is much better for very small lists than either
+ <see cref="T:Spring.Collections.HashedSet"/> or <see cref="T:Spring.Collections.SortedSet"/>.
+ However, performance degrades rapidly as the data-set gets bigger. Use a
+ <see cref="T:Spring.Collections.HybridSet"/> instead if you are not sure your data-set
+ will always remain very small. Iteration produces elements in the order they were added.
+ However, element order is not guaranteed to be maintained by the various
+ <see cref="T:Spring.Collections.ISet"/> mathematical operators.
+ </p>
+ </remarks>
+ </member>
+ <member name="M:Spring.Collections.ListSet.#ctor">
+ <summary>
+ Creates a new set instance based on a list.
+ </summary>
+ </member>
+ <member name="M:Spring.Collections.ListSet.#ctor(System.Collections.ICollection)">
+ <summary>
+ Creates a new set instance based on a list and initializes it based on a
+ collection of elements.
+ </summary>
+ <param name="initialValues">
+ A collection of elements that defines the initial set contents.
+ </param>
+ </member>
+ <member name="T:Spring.Collections.SortedSet">
+ <summary>
+ Implements an <see cref="T:Spring.Collections.ISet"/> based on a sorted tree.
+ </summary>
+ <remarks>
+ <p>
+ This gives good performance for operations on very large data-sets, though not as good
+ - asymptotically - as a <see cref="T:Spring.Collections.HashedSet"/>. However, iteration
+ occurs in order.
+ </p>
+ <p>
+ Elements that you put into this type of collection must implement
+ <see cref="T:System.IComparable"/>, and they must actually be comparable. You can't mix
+ <see cref="T:System.String"/> and <see cref="T:System.Int32">int</see> values, for example.
+ </p>
+ <p>
+ This <see cref="T:Spring.Collections.ISet"/> implementation does <b>not</b> support
+ the null value.
+ </p>
+ </remarks>
+ </member>
+ <member name="M:Spring.Collections.SortedSet.#ctor">
+ <summary>
+ Creates a new set instance based on a sorted tree.
+ </summary>
+ </member>
+ <member name="M:Spring.Collections.SortedSet.#ctor(System.Collections.ICollection)">
+ <summary>
+ Creates a new set instance based on a sorted tree and initializes it based on a
+ collection of elements.
+ </summary>
+ <param name="initialValues">
+ A collection of elements that defines the initial set contents.
+ </param>
+ </member>
+ <member name="T:Spring.Collections.SynchronizedSet">
+ <summary>
+ Implements a thread-safe <see cref="T:Spring.Collections.ISet"/> wrapper.
+ </summary>
+ <remarks>
+ <p>
+ The implementation is extremely conservative,
+ serializing critical sections to prevent possible deadlocks, and locking on everything.
+ The one exception is for enumeration, which is inherently not thread-safe. For this, you
+ have to <c>lock</c> the <c>SyncRoot</c> object for the duration of the enumeration.
+ </p>
+ </remarks>
+ </member>
+ <member name="M:Spring.Collections.SynchronizedSet.#ctor(Spring.Collections.ISet)">
+ <summary>
+ Constructs a thread-safe <see cref="T:Spring.Collections.ISet"/> wrapper.
+ </summary>
+ <param name="basisSet">
+ The <see cref="T:Spring.Collections.ISet"/> object that this object will wrap.
+ </param>
+ </member>
+ <member name="M:Spring.Collections.SynchronizedSet.Add(System.Object)">
+ <summary>
+ Adds the specified element to this set if it is not already present.
+ </summary>
+ <param name="o">The object to add to the set.</param>
+ <returns>
+ <c>true</c> is the object was added, <c>false</c> if it was already present.
+ </returns>
+ </member>
+ <member name="M:Spring.Collections.SynchronizedSet.AddAll(System.Collections.ICollection)">
+ <summary>
+ Adds all the elements in the specified collection to the set if they are not already present.
+ </summary>
+ <param name="c">A collection of objects to add to the set.</param>
+ <returns><c>true</c> is the set changed as a result of this operation, <c>false</c> if not.</returns>
+ </member>
+ <member name="M:Spring.Collections.SynchronizedSet.Clear">
+ <summary>
+ Removes all objects from the set.
+ </summary>
+ </member>
+ <member name="M:Spring.Collections.SynchronizedSet.Contains(System.Object)">
+ <summary>
+ Returns <c>true</c> if this set contains the specified element.
+ </summary>
+ <param name="o">The element to look for.</param>
+ <returns><c>true</c> if this set contains the specified element, <c>false</c> otherwise.</returns>
+ </member>
+ <member name="M:Spring.Collections.SynchronizedSet.ContainsAll(System.Collections.ICollection)">
+ <summary>
+ Returns <c>true</c> if the set contains all the elements in the specified collection.
+ </summary>
+ <param name="c">A collection of objects.</param>
+ <returns><c>true</c> if the set contains all the elements in the specified collection, <c>false</c> otherwise.</returns>
+ </member>
+ <member name="M:Spring.Collections.SynchronizedSet.Remove(System.Object)">
+ <summary>
+ Removes the specified element from the set.
+ </summary>
+ <param name="o">The element to be removed.</param>
+ <returns><c>true</c> if the set contained the specified element, <c>false</c> otherwise.</returns>
+ </member>
+ <member name="M:Spring.Collections.SynchronizedSet.RemoveAll(System.Collections.ICollection)">
+ <summary>
+ Remove all the specified elements from this set, if they exist in this set.
+ </summary>
+ <param name="c">A collection of elements to remove.</param>
+ <returns><c>true</c> if the set was modified as a result of this operation.</returns>
+ </member>
+ <member name="M:Spring.Collections.SynchronizedSet.RetainAll(System.Collections.ICollection)">
+ <summary>
+ Retains only the elements in this set that are contained in the specified collection.
+ </summary>
+ <param name="c">Collection that defines the set of elements to be retained.</param>
+ <returns><c>true</c> if this set changed as a result of this operation.</returns>
+ </member>
+ <member name="M:Spring.Collections.SynchronizedSet.CopyTo(System.Array,System.Int32)">
+ <summary>
+ Copies the elements in the <see cref="T:Spring.Collections.ISet"/> to an array. The type of array needs
+ to be compatible with the objects in the <see cref="T:Spring.Collections.ISet"/>, obviously.
+ </summary>
+ <param name="array">An array that will be the target of the copy operation.</param>
+ <param name="index">The zero-based index where copying will start.</param>
+ </member>
+ <member name="M:Spring.Collections.SynchronizedSet.GetEnumerator">
+ <summary>
+ Enumeration is, by definition, not thread-safe. Use a <c>lock</c> on the <c>SyncRoot</c>
+ to synchronize the entire enumeration process.
+ </summary>
+ <returns></returns>
+ </member>
+ <member name="M:Spring.Collections.SynchronizedSet.Clone">
+ <summary>
+ Returns a clone of the <see cref="T:Spring.Collections.ISet"/> instance.
+ </summary>
+ <returns>A clone of this object.</returns>
+ </member>
+ <member name="P:Spring.Collections.SynchronizedSet.IsEmpty">
+ <summary>
+ Returns <c>true</c> if this set contains no elements.
+ </summary>
+ </member>
+ <member name="P:Spring.Collections.SynchronizedSet.Count">
+ <summary>
+ The number of elements contained in this collection.
+ </summary>
+ </member>
+ <member name="P:Spring.Collections.SynchronizedSet.IsSynchronized">
+ <summary>
+ Returns <c>true</c>, indicating that this object is thread-safe. The exception to this
+ is enumeration, which is inherently not thread-safe. Use the <c>SyncRoot</c> object to
+ lock this object for the entire duration of the enumeration.
+ </summary>
+ </member>
+ <member name="P:Spring.Collections.SynchronizedSet.SyncRoot">
+ <summary>
+ Returns an object that can be used to synchronize the <see cref="T:Spring.Collections.ISet"/> between threads.
+ </summary>
+ </member>
+ <member name="T:Spring.Context.Events.ApplicationEventMulticaster">
+ <summary>
+ Provides central place to handle registration / unregistration of application events.
+ </summary>
+ <author>Rod Johnson</author>
+ <author>Griffin Caprio (.NET)</author>
+ <version>$Id: ApplicationEventMulticaster.cs,v 1.3 2005/02/17 23:02:11 springboy Exp $</version>
+ </member>
+ <member name="T:Spring.Context.Events.IApplicationEventMulticaster">
+ <summary>
+ Subinterface of <see cref="T:Spring.Context.Events.IApplicationEventMulticaster"/>
+ to be implemented by listeners that can broadcast events to other listeners.
+ </summary>
+ <author>Rod Johnson</author>
+ <author>Griffin Caprio ( .NET )</author>
+ <version>$Id: IApplicationEventMulticaster.cs,v 1.3 2005/02/17 23:02:12 springboy Exp $</version>
+ </member>
+ <member name="T:Spring.Context.IApplicationListener">
+ <summary>
+ Interface to be implemented by listeners that want to be notified
+ of application events.
+ </summary>
+ <author>Rod Johnson</author>
+ <author>Griffin Caprio (.NET)</author>
+ <version>$Id: IApplicationListener.cs,v 1.3 2005/02/17 23:02:11 springboy Exp $</version>
+ </member>
+ <member name="M:Spring.Context.IApplicationListener.OnApplicationEvent(System.Object,Spring.Context.ApplicationEventArgs)">
+ <summary>
+ Handle an application event.
+ </summary>
+ <param name="source">The source of the event.</param>
+ <param name="applicationEventArgs">The event to respond to.</param>
+ </member>
+ <member name="M:Spring.Context.Events.IApplicationEventMulticaster.AddApplicationListener(Spring.Context.IApplicationListener)">
+ <summary>
+ Add a listener to be notified of all events.
+ </summary>
+ <param name="listener">The listener to add.</param>
+ </member>
+ <member name="M:Spring.Context.Events.IApplicationEventMulticaster.RemoveApplicationListener(Spring.Context.IApplicationListener)">
+ <summary>
+ Remove a listener in the notification list.
+ </summary>
+ <param name="listener">The listener to remove.</param>
+ </member>
+ <member name="M:Spring.Context.Events.IApplicationEventMulticaster.RemoveAllListeners">
+ <summary>
+ Remove all listeners registered with this multicaster.
+ </summary>
+ <remarks>
+ <p>
+ It will perform no action on event notification until
+ more listeners are registered.
+ </p>
+ </remarks>
+ </member>
+ <member name="M:Spring.Context.Events.ApplicationEventMulticaster.#ctor">
+ <summary>
+ Creates a new instance of the
+ <see cref="T:Spring.Context.Events.ApplicationEventMulticaster"/> class.
+ </summary>
+ </member>
+ <member name="M:Spring.Context.Events.ApplicationEventMulticaster.AddApplicationListener(Spring.Context.IApplicationListener)">
+ <summary>
+ Add a listener to be notified of all events.
+ </summary>
+ <param name="listener">The listener to add.</param>
+ </member>
+ <member name="M:Spring.Context.Events.ApplicationEventMulticaster.RemoveApplicationListener(Spring.Context.IApplicationListener)">
+ <summary>
+ Remove a listener in the notification list.
+ </summary>
+ <param name="listener">The listener to remove.</param>
+ </member>
+ <member name="M:Spring.Context.Events.ApplicationEventMulticaster.RemoveAllListeners">
+ <summary>
+ Remove all listeners registered with this multicaster.
+ </summary>
+ <remarks>
+ <p>
+ It will perform no action on event notification until
+ more listeners are registered.
+ </p>
+ </remarks>
+ </member>
+ <member name="M:Spring.Context.Events.ApplicationEventMulticaster.OnApplicationEvent(System.Object,Spring.Context.ApplicationEventArgs)">
+ <summary>
+ Handle an application event.
+ </summary>
+ <param name="source">The source of the event.</param>
+ <param name="applicationEventArgs">The event to respond to.</param>
+ </member>
+ <member name="E:Spring.Context.Events.ApplicationEventMulticaster.NotifyListeners">
+ <summary>
+ Event to notify all listeners for this
+ <see cref="T:Spring.Context.Events.IApplicationEventMulticaster"/>.
+ </summary>
+ </member>
+ <member name="T:Spring.Context.Events.ConsoleListener">
+ <summary>
+ Simple listener for debug use only that logs messages to the console.
+ </summary>
+ <author>Rod Johnson</author>
+ <author>Griffin Caprio (.NET)</author>
+ <version>$Id: ConsoleListener.cs,v 1.3 2005/03/30 16:59:38 markpollack Exp $</version>
+ </member>
+ <member name="M:Spring.Context.Events.ConsoleListener.#ctor">
+ <summary>
+ Event to notify all listeners for this
+ <see cref="T:Spring.Context.Events.ConsoleListener"/>.
+ </summary>
+ </member>
+ <member name="M:Spring.Context.Events.ConsoleListener.OnApplicationEvent(System.Object,Spring.Context.ApplicationEventArgs)">
+ <summary>
+ Handle an application event.
+ </summary>
+ <param name="source">The source of the event.</param>
+ <param name="applicationEventArgs">The event to respond to.</param>
+ </member>
+ <member name="T:Spring.Context.Events.ContextEventArgs">
+ <summary>
+ Application event object sent to listeners registered with a
+ <see cref="T:Spring.Context.IApplicationContext"/> to inform
+ them of context lifecycle events.
+ </summary>
+ <author>Griffin Caprio (.NET)</author>
+ <version>$Id: ContextEventArgs.cs,v 1.4 2005/02/17 23:02:12 springboy Exp $</version>
+ </member>
+ <member name="T:Spring.Context.ApplicationEventArgs">
+ <summary>
+ Instances of this class are to be passed as the second argument to all
+ application event handlers.
+ </summary>
+ <remarks>
+ Abstract as it doesn't make sense for generic events to be published directly.
+ </remarks>
+ <author>Rod Johnson</author>
+ <author>Mark Pollack (.NET)</author>
+ <author>Griffin Caprio (.NET)</author>
+ <version>$Id: ApplicationEventArgs.cs,v 1.2 2005/02/17 23:02:09 springboy Exp $</version>
+ </member>
+ <member name="F:Spring.Context.ApplicationEventArgs._timestamp">
+ <summary>System time when the event happened </summary>
+ </member>
+ <member name="M:Spring.Context.ApplicationEventArgs.#ctor">
+ <summary>
+ Creates a new instance of the
+ <see cref="T:Spring.Context.ApplicationEventArgs"/> class.
+ </summary>
+ </member>
+ <member name="P:Spring.Context.ApplicationEventArgs.TimeStamp">
+ <summary> Returns the the date and time when the event occured.</summary>
+ </member>
+ <member name="P:Spring.Context.ApplicationEventArgs.EventTimeMilliseconds">
+ <summary>The system time in milliseconds when the event happened.</summary>
+ <returns>
+ The system time in milliseconds when the event happened.
+ </returns>
+ </member>
+ <member name="M:Spring.Context.Events.ContextEventArgs.#ctor(Spring.Context.Events.ContextEventArgs.ContextEvent)">
+ <summary>
+ Creates a new instance of the ContextEventArgs class to represent the
+ supplied context event.
+ </summary>
+ <param name="e">The type of context event.</param>
+ </member>
+ <member name="P:Spring.Context.Events.ContextEventArgs.Event">
+ <summary>
+ The event type.
+ </summary>
+ </member>
+ <member name="T:Spring.Context.Events.ContextEventArgs.ContextEvent">
+ <summary>
+ The various context event types.
+ </summary>
+ </member>
+ <member name="F:Spring.Context.Events.ContextEventArgs.ContextEvent.Refreshed">
+ <summary>
+ The event type when the context is refreshed or created.
+ </summary>
+ </member>
+ <member name="F:Spring.Context.Events.ContextEventArgs.ContextEvent.Closed">
+ <summary>
+ The event type when the context is closed.
+ </summary>
+ </member>
+ <member name="T:Spring.Context.Support.AbstractApplicationContext">
+ <summary>
+ Partial implementation of the <see cref="T:Spring.Context.IApplicationContext"/>
+ interface.
+ </summary>
+ <remarks>
+ <p>
+ Doesn't mandate the type of storage used for configuration, but implements common
+ functionality.
+ </p>
+ <p>
+ Uses the Template Method design pattern, requiring concrete subclasses
+ to implement abstract methods.
+ </p>
+ <p>
+ In contrast to a plain object factory, an
+ <see cref="T:Spring.Context.IApplicationContext"/> is supposed
+ to detect special objects defined in its object factory: therefore, this class
+ automatically registers
+ <see cref="T:Spring.Objects.Factory.Config.IObjectFactoryPostProcessor"/>s,
+ <see cref="T:Spring.Objects.Factory.Config.IObjectPostProcessor"/>s
+ and <see cref="T:Spring.Context.IApplicationListener"/>s that are defined as objects
+ in the context.
+ </p>
+ <p>
+ An <see cref="T:Spring.Context.IMessageSource"/> may be also supplied as a object in
+ the context, with the name "messageSource". Else, message resolution is delegated to the
+ parent context.
+ </p>
+ </remarks>
+ <author>Rod Johnson</author>
+ <author>Juergan Hoeller</author>
+ <author>Griffin Caprio (.NET)</author>
+ <version>$Id: AbstractApplicationContext.cs,v 1.24 2005/03/30 16:59:38 markpollack Exp $</version>
+ </member>
+ <member name="T:Spring.Core.IO.ConfigurableResourceLoader">
+ <summary>
+ Configurable implementation of the <see cref="T:Spring.Core.IO.IResourceLoader"/> interface.
+ </summary>
+ <remarks>
+ <p>
+ This <see cref="T:Spring.Core.IO.IResourceLoader"/> implementation supports configuration
+ of resource access protocols and corresponding .NET types that know how to handle them.
+ </p>
+ <p>
+ Basic protocol-to-resource type mappings are also defined by this class, while others can be added
+ either internally, by application contexts extending this class, or externally,
+ by the end user configuring the context.
+ </p>
+ <p>
+ Only one resource type can be defined for each protocol, but multiple protocols can map to the
+ same resource type (for example, "http" and "ftp" protocols both map to <see cref="T:Spring.Core.IO.UrlResource"/> type.
+ </p>
+ </remarks>
+ <author>Aleksandar Seovic</author>
+ <version>$Id: ConfigurableResourceLoader.cs,v 1.10 2005/02/17 23:02:32 springboy Exp $</version>
+ </member>
+ <member name="T:Spring.Core.IO.IResourceLoader">
+ <summary>
+ Interface to be implemented by objects that can load resources.
+ </summary>
+ <remarks>
+ <p>
+ An <c>IApplicationContext</c> implementation is generally required to provide this
+ functionality.
+ </p>
+ <p>
+ <see cref="T:Spring.Core.IO.ConfigurableResourceLoader"/> is a standalone implementation that
+ is usable outside an <c>IApplicationContext</c>, also used by
+ <see cref="T:Spring.Core.IO.ResourceConverter"/>.
+ </p>
+ </remarks>
+ <author>Juergen Hoeller</author>
+ <author>Mark Pollack (.NET)</author>
+ </member>
+ <member name="M:Spring.Core.IO.IResourceLoader.GetResource(System.String)">
+ <summary>
+ Return an <see cref="T:Spring.Core.IO.IResource"/> handle for the specified resource.
+ </summary>
+ <remarks>
+ <p>
+ The handle should always be a reusable resource descriptor, allowing for multiple
+ <see cref="P:Spring.Core.IO.IInputStreamSource.InputStream"/> calls.
+ </p>
+ <p>
+ <ul>
+ <li>Must support fully qualified URLs, e.g. "file:C:/test.dat".</li>
+ <li>Should support relative file paths, e.g. "test.dat" (this will be
+ implementation-specific, typically provided by an <c>IApplicationContext</c>
+ implementation).</li>
+ </ul>
+ </p>
+ <p>Note that an <see cref="T:Spring.Core.IO.IResource"/> handle does not imply an
+ existing resource; you need to invoke an <see cref="T:Spring.Core.IO.IResource"/>'s
+ <see cref="P:Spring.Core.IO.IResource.Exists"/> property to check for existence.
+ </p>
+ </remarks>
+ <param name="location">The resource location.</param>
+ <returns> An appropriate <see cref="T:Spring.Core.IO.IResource"/> handle.</returns>
+ </member>
+ <member name="F:Spring.Core.IO.ConfigurableResourceLoader.PROTOCOL_SEPARATOR">
+ <summary>
+ String that separates protocol name from the resource name
+ </summary>
+ </member>
+ <member name="M:Spring.Core.IO.ConfigurableResourceLoader.#ctor">
+ <summary>
+ Creates a new instance of the <see cref="T:Spring.Core.IO.ConfigurableResourceLoader"/> class.
+ </summary>
+ </member>
+ <member name="M:Spring.Core.IO.ConfigurableResourceLoader.AddProtocolMapping(System.String,System.Type)">
+ <summary>
+ Adds new protocol mapping if it doesn't already exist or overrides
+ existing one for the specified protocol name
+ </summary>
+ <param name="protocolName">protocol to define or override mapping for</param>
+ <param name="resourceType">
+ implementation of <see cref="T:Spring.Core.IO.IResource"/> that should handle specified protocol
+ </param>
+ </member>
+ <member name="M:Spring.Core.IO.ConfigurableResourceLoader.GetResource(System.String)">
+ <summary>
+ Returns a <see cref="T:Spring.Core.IO.IResource"/> given the name of the resource.
+ </summary>
+ <param name="resourceName">Name of the resource</param>
+ <returns>The <see cref="T:Spring.Core.IO.IResource"/> for the specified name.</returns>
+ </member>
+ <member name="M:Spring.Core.IO.ConfigurableResourceLoader.HasProtocol(System.String)">
+ <summary>
+ Checks that a resource name starts with one of the protocol names
+ known by this <see cref="T:Spring.Core.IO.ConfigurableResourceLoader"/>
+ </summary>
+ <param name="resourceName">Name of the resource</param>
+ <returns><c>true</c> if the name of the resource starts with one of the known protocol</returns>
+ </member>
+ <member name="M:Spring.Core.IO.ConfigurableResourceLoader.GetProtocol(System.String)">
+ <summary>
+ Extracts protocol name from resource name.
+ </summary>
+ <param name="resourceName">Name of the resource</param>
+ <returns>extracted protocol name or null if resource is unqualified</returns>
</member>
+ <member name="P:Spring.Core.IO.ConfigurableResourceLoader.DefaultResourceProtocol">
+ <summary>
+ Defines default protocol to use for unqualified resources
+ </summary>
+ </member>
+ <member name="T:Spring.Context.IConfigurableApplicationContext">
+ <summary>
+ Provides means to configure an application context in addition to the
+ application context client methods in the
+ <see cref="T:Spring.Context.IApplicationContext"/> interface.
+ </summary>
+ <remarks>
+ <p>
+ This interface is to be implemented by most (if not all)
+ <see cref="T:Spring.Context.IApplicationContext"/> implementations.
+ </p>
+ <p>
+ Configuration and lifecycle methods are encapsulated here to avoid
+ making them obvious to <see cref="T:Spring.Context.IApplicationContext"/> client code.
+ </p>
+ <p>
+ Calling <see cref="M:System.IDisposable.Dispose"/> will close this
+ application context, releasing all resources and locks that the implementation
+ might hold. This includes disposing all cached singleton objects.
+ </p>
+ <note type="caution">
+ <see cref="M:System.IDisposable.Dispose"/> does <i>not</i> invoke the
+ attendant <see cref="M:System.IDisposable.Dispose"/> on any parent context.
+ </note>
+ </remarks>
+ <author>Juergen Hoeller</author>
+ <author>Mark Pollack (.NET)</author>
+ <version>$Id: IConfigurableApplicationContext.cs,v 1.4 2005/03/30 16:59:36 markpollack Exp $</version>
+ </member>
+ <member name="T:Spring.Context.IApplicationContext">
+ <summary>
+ Central interface to provide configuration for an application.
+ </summary>
+ <remarks>
+ <p>IApplicationContext implementations provide:
+ <ul>
+ <li>Object factory functionality inherited from
+ <see cref="T:Spring.Objects.Factory.IListableObjectFactory"/>
+ and <see cref="T:Spring.Objects.Factory.IHierarchicalObjectFactory"/>
+ </li>
+ <li>The ability to resolve messages, supporting internationalization.
+ Inherited from the <see cref="T:Spring.Context.IMessageSource"/> interface.
+ </li>
+ <li>The ability to load file resources in a generic fashion.
+ Inherited from the <see cref="T:Spring.Core.IO.IResourceLoader"/> interface.
+ </li>
+ <li>Acts an an event registry for supporting loosely coupled
+ eventing between objecs. Inherited from the
+ <see cref="T:Spring.Objects.Events.IEventRegistry"/> interface.
+ </li>
+ <li>The ability to publish events related to context lifecycle.
+ </li>
+ <li>Inheritance from a parent context. Definitions in a descendant context
+ will always take priority.
+ </li>
+ </ul>
+ </p>
+ <p>
+ In addition to standard object factory lifecycle capabilities,
+ IApplicationContext implementations need to detect
+ <see cref="T:Spring.Context.IApplicationContextAware"/>
+ objects and set their
+ <see cref="P:Spring.Context.IApplicationContextAware.ApplicationContext"/>
+ property accordingly.
+ </p>
+ <p>
+ This is read-only while the application is running, but may be
+ reloaded if the implementation supports this.
+ </p>
+ </remarks>
+ <author>Rod Johnson</author>
+ <author>Juergen Hoeller</author>
+ <author>Mark Pollack (.NET)</author>
+ <version>$Id: IApplicationContext.cs,v 1.6 2005/03/30 16:59:36 markpollack Exp $</version>
+ </member>
+ <member name="T:Spring.Objects.Factory.IListableObjectFactory">
+ <summary>
+ Extension of the <see cref="T:Spring.Objects.Factory.IObjectFactory"/> interface
+ to be implemented by object factories that can enumerate all their object instances,
+ rather than attempting object lookup by name one by one as requested by clients.
+ </summary>
+ <remarks>
+ <p>
+ <see cref="T:Spring.Objects.Factory.IObjectFactory"/> implementations that preload
+ all their objects (for example, DOM-based XML factories) may implement this
+ interface. This interface is discussed in
+ "Expert One-on-One J2EE Design and Development", by Rod Johnson.
+ </p>
+ <p>
+ If this is an <see cref="T:Spring.Objects.Factory.IHierarchicalObjectFactory"/>,
+ the return values will not take any
+ <see cref="T:Spring.Objects.Factory.IObjectFactory"/> hierarchy into account, but
+ will relate only to the objects defined in the current factory.
+ Use the <see cref="T:Spring.Objects.Factory.ObjectFactoryUtils"/> helper class to
+ get all objects.
+ </p>
+ <p>
+ With the exception of
+ <see cref="P:Spring.Objects.Factory.IListableObjectFactory.ObjectDefinitionCount"/>,
+ the methods and properties in this interface are not designed for frequent
+ invocation. Implementations may be slow.
+ </p>
+ </remarks>
+ <author>Rod Johnson</author>
+ <author>Rick Evans (.NET)</author>
[... 20396 lines stripped ...]
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@struts.apache.org
For additional commands, e-mail: dev-help@struts.apache.org