lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [13/39] lucenenet git commit: Lucene.Net.Analysis.Util (CharArrayIterator + CharArrayMap + CharArraySet) refactor: member accessibility and documentation comments
Date Sat, 04 Feb 2017 20:32:32 GMT
Lucene.Net.Analysis.Util (CharArrayIterator + CharArrayMap + CharArraySet) refactor: member accessibility and documentation comments


Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/b19aee50
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/b19aee50
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/b19aee50

Branch: refs/heads/api-work
Commit: b19aee50367acf30f8e678e2430875c2a0467cb7
Parents: 47155b3
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Sat Feb 4 18:30:43 2017 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Sat Feb 4 23:08:18 2017 +0700

----------------------------------------------------------------------
 .../Analysis/Util/CharArrayIterator.cs          |  13 +-
 .../Analysis/Util/CharArrayMap.cs               | 322 +++++++++++--------
 .../Analysis/Util/CharArraySet.cs               |  83 ++---
 3 files changed, 232 insertions(+), 186 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b19aee50/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayIterator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayIterator.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayIterator.cs
index e50e87e..b5a3456 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayIterator.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayIterator.cs
@@ -1,7 +1,6 @@
 ´╗┐using Lucene.Net.Support;
 ´╗┐using System;
 using System.Diagnostics.CodeAnalysis;
-using Icu;
 
 namespace Lucene.Net.Analysis.Util
 {
@@ -26,7 +25,7 @@ namespace Lucene.Net.Analysis.Util
     /// A CharacterIterator used internally for use with <see cref="BreakIterator"/>
     /// @lucene.internal
     /// </summary>
-    public abstract class CharArrayIterator : CharacterIterator
+    public abstract class CharArrayIterator : CharacterIterator // LUCENENET TODO: Since the only purpose of this class is to work around Java bugs, is this class really needed?
     {
         private char[] array;
         private int start;
@@ -83,7 +82,7 @@ namespace Lucene.Net.Analysis.Util
             }
         }
 
-        protected internal abstract char JreBugWorkaround(char ch);
+        protected abstract char JreBugWorkaround(char ch);
  
 
         public override char First()
@@ -170,7 +169,7 @@ namespace Lucene.Net.Analysis.Util
 
         /// <summary>
         /// Create a new CharArrayIterator that works around JRE bugs
-        /// in a manner suitable for <see cref="BreakIterator#getSentenceInstance()"/>
+        /// in a manner suitable for <c>BreakIterator#getSentenceInstance()</c>
         /// </summary>
         public static CharArrayIterator NewSentenceInstance()
         {
@@ -180,7 +179,7 @@ namespace Lucene.Net.Analysis.Util
         private class CharArrayIteratorAnonymousInnerClassHelper2 : CharArrayIterator
         {
             // no bugs
-            protected internal override char JreBugWorkaround(char ch)
+            protected override char JreBugWorkaround(char ch)
             {
                 return ch;
             }
@@ -188,7 +187,7 @@ namespace Lucene.Net.Analysis.Util
 
         /// <summary>
         /// Create a new CharArrayIterator that works around JRE bugs
-        /// in a manner suitable for <see cref="BreakIterator#getWordInstance()"/>
+        /// in a manner suitable for <c>BreakIterator#getWordInstance()</c>
         /// </summary>
         public static CharArrayIterator NewWordInstance()
         {
@@ -198,7 +197,7 @@ namespace Lucene.Net.Analysis.Util
         private class CharArrayIteratorAnonymousInnerClassHelper4 : CharArrayIterator
         {
             // no bugs
-            protected internal override char JreBugWorkaround(char ch)
+            protected override char JreBugWorkaround(char ch)
             {
                 return ch;
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b19aee50/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs
index b6e2e36..f8a8ad2 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs
@@ -72,13 +72,13 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// LUCENENET SPECIFIC type used to act as a placeholder. Since <c>null</c>
         /// means that our value is not populated, we need an instance of something
-        /// to indicate it is. Using an instance of <see cref="V"/> would only work if
+        /// to indicate it is. Using an instance of <typeparamref name="TValue"/> would only work if
         /// we could constrain it with the new() constraint, which isn't possible because
         /// some types such as <see cref="string"/> don't have a default constructor.
         /// So, this is a workaround that allows any type regardless of the type of constructor.
         /// 
         /// <para>
-        /// Note also that we gain the ability to use value types for <see cref="V"/>, but
+        /// Note also that we gain the ability to use value types for <typeparamref name="TValue"/>, but
         /// also create a difference in behavior from Java Lucene where the actual values 
         /// returned could be <c>null</c>.
         /// </para>
@@ -102,11 +102,10 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// Create map with enough capacity to hold startSize terms
+        /// Create map with enough capacity to hold <paramref name="startSize"/> terms
         /// </summary>
         /// <param name="matchVersion">
-        ///          compatibility match version see <a href="#version">Version
-        ///          note</a> above for details. </param>
+        ///          lucene compatibility version - see <see cref="CharArrayMap{TValue}"/> for details. </param>
         /// <param name="startSize">
         ///          the initial capacity </param>
         /// <param name="ignoreCase">
@@ -133,7 +132,7 @@ namespace Lucene.Net.Analysis.Util
         ///          compatibility match version see <a href="#version">Version
         ///          note</a> above for details. </param>
         /// <param name="c">
-        ///          a map (<see cref="IDictionary{string, V}"/>) whose mappings to be copied </param>
+        ///          a map (<see cref="T:IDictionary{string, V}"/>) whose mappings to be copied </param>
         /// <param name="ignoreCase">
         ///          <c>false</c> if and only if the set should be case sensitive;
         ///          otherwise <c>true</c>. </param>
@@ -160,11 +159,11 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// Adds the <see cref="KeyValuePair{string, V}.Value"/> for the passed in <see cref="KeyValuePair{string, V}.Key"/>.
-        /// Note that the <see cref="KeyValuePair{string, V}"/> instance is not added to the dictionary.
+        /// Adds the <see cref="T:KeyValuePair{string, V}.Value"/> for the passed in <see cref="T:KeyValuePair{string, V}.Key"/>.
+        /// Note that the <see cref="T:KeyValuePair{string, V}"/> instance is not added to the dictionary.
         /// </summary>
-        /// <param name="item">A <see cref="KeyValuePair{string, V}"/> whose <see cref="KeyValuePair{string, V}.Value"/> 
-        /// will be added for the corresponding <see cref="KeyValuePair{string, V}.Key"/>. </param>
+        /// <param name="item">A <see cref="T:KeyValuePair{string, V}"/> whose <see cref="T:KeyValuePair{string, V}.Value"/> 
+        /// will be added for the corresponding <see cref="T:KeyValuePair{string, V}.Key"/>. </param>
         public virtual void Add(KeyValuePair<string, TValue> item)
         {
             Add(item.Key, item.Value);
@@ -209,12 +208,12 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// Copies all items in the current dictionary the <paramref name="array"/> starting at the <see cref="arrayIndex"/>.
+        /// Copies all items in the current dictionary the <paramref name="array"/> starting at the <paramref name="arrayIndex"/>.
         /// The array is assumed to already be dimensioned to fit the elements in this dictionary; otherwise a <see cref="ArgumentOutOfRangeException"/>
         /// will be thrown.
         /// </summary>
         /// <param name="array">The array to copy the items into.</param>
-        /// <param name="arrayIndex">A 32-bit integer that represents the index in <see cref="array"/> at which copying begins.</param>
+        /// <param name="arrayIndex">A 32-bit integer that represents the index in <paramref name="array"/> at which copying begins.</param>
         public virtual void CopyTo(KeyValuePair<string, TValue>[] array, int arrayIndex)
         {
             var iter = (EntryIterator)EntrySet().GetEnumerator();
@@ -240,7 +239,7 @@ namespace Lucene.Net.Analysis.Util
 
         /// <summary>
         /// <c>true</c> if the <paramref name="length"/> chars of <paramref name="text"/> starting at <paramref name="offset"/>
-        /// are in the <see cref="KeySet"/> 
+        /// are in the <see cref="Keys"/> 
         /// </summary>
         public virtual bool ContainsKey(char[] text, int offset, int length)
         {
@@ -248,7 +247,7 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// <c>true</c> if the entire <see cref="KeySet"/> is the same as the 
+        /// <c>true</c> if the entire <see cref="Keys"/> is the same as the 
         /// <paramref name="text"/> <see cref="T:char[]"/> being passed in; 
         /// otherwise <c>false</c>.
         /// </summary>
@@ -258,7 +257,7 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// <c>true</c> if the <paramref name="text"/> <see cref="string"/> is in the <see cref="KeySet"/>; 
+        /// <c>true</c> if the <paramref name="text"/> <see cref="string"/> is in the <see cref="Keys"/>; 
         /// otherwise <c>false</c>
         /// </summary>
         public virtual bool ContainsKey(string text)
@@ -267,17 +266,17 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// <c>true</c> if the <paramref name="text"/> <see cref="ICharSequence"/> is in the <see cref="KeySet"/>; 
+        /// <c>true</c> if the <paramref name="text"/> <see cref="ICharSequence"/> is in the <see cref="Keys"/>; 
         /// otherwise <c>false</c>
         /// </summary>
-        public virtual bool ContainsKey(ICharSequence cs)
+        public virtual bool ContainsKey(ICharSequence text)
         {
-            return keys[GetSlot(cs)] != null;
+            return keys[GetSlot(text)] != null;
         }
 
 
         /// <summary>
-        /// <c>true</c> if the <paramref name="o"/> <see cref="object.ToString()"/> is in the <see cref="KeySet"/>; 
+        /// <c>true</c> if the <paramref name="o"/> <see cref="object.ToString()"/> is in the <see cref="Keys"/>; 
         /// otherwise <c>false</c>
         /// </summary>
         public virtual bool ContainsKey(object o)
@@ -318,18 +317,18 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// returns the value of the mapping of the chars inside this <see cref="ICharSequence"/>
         /// </summary>
-        public virtual TValue Get(ICharSequence cs)
+        public virtual TValue Get(ICharSequence text)
         {
-            var value = values[GetSlot(cs)];
+            var value = values[GetSlot(text)];
             return (value != null) ? value.Value : default(TValue);
         }
 
         /// <summary>
         /// returns the value of the mapping of the chars inside this <see cref="string"/>
         /// </summary>
-        public virtual TValue Get(string cs)
+        public virtual TValue Get(string text)
         {
-            var value = values[GetSlot(cs)];
+            var value = values[GetSlot(text)];
             return (value != null) ? value.Value : default(TValue);
         }
 
@@ -490,10 +489,10 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// LUCENENET specific. Centralizes the logic between <see cref="Put"/>
+        /// LUCENENET specific. Centralizes the logic between Put()
         /// implementations that accept a value and those that don't. This value is
         /// so we know whether or not the value was set, since we can't reliably do
-        /// a check for <c>null</c> on the <see cref="V"/> type.
+        /// a check for <c>null</c> on the <typeparamref name="TValue"/> type.
         /// </summary>
         private MapValue PutImpl(char[] text, MapValue value)
         {
@@ -523,7 +522,7 @@ namespace Lucene.Net.Analysis.Util
         #region PutAll
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IDictionary{char[],TValue}"/>'s
+        /// This implementation enumerates over the specified <see cref="T:IDictionary{char[],TValue}"/>'s
         /// entries, and calls this map's <see cref="Put(char[], TValue)"/> operation once for each entry.
         /// </summary>
         /// <param name="collection">A dictionary of values to add/update in the current map.</param>
@@ -536,7 +535,7 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IDictionary{string,TValue}"/>'s
+        /// This implementation enumerates over the specified <see cref="T:IDictionary{string,TValue}"/>'s
         /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
         /// </summary>
         /// <param name="collection">A dictionary of values to add/update in the current map.</param>
@@ -549,7 +548,7 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IDictionary{ICharSequence,TValue}"/>'s
+        /// This implementation enumerates over the specified <see cref="T:IDictionary{ICharSequence,TValue}"/>'s
         /// entries, and calls this map's <see cref="Put(ICharSequence, TValue)"/> operation once for each entry.
         /// </summary>
         /// <param name="collection">A dictionary of values to add/update in the current map.</param>
@@ -562,7 +561,7 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IDictionary{object,TValue}"/>'s
+        /// This implementation enumerates over the specified <see cref="T:IDictionary{object,TValue}"/>'s
         /// entries, and calls this map's <see cref="Put(object, TValue)"/> operation once for each entry.
         /// </summary>
         /// <param name="collection">A dictionary of values to add/update in the current map.</param>
@@ -575,7 +574,7 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IEnumerable{KeyValuePair{char[],TValue}}"/>'s
+        /// This implementation enumerates over the specified <see cref="T:IEnumerable{KeyValuePair{char[],TValue}}"/>'s
         /// entries, and calls this map's <see cref="Put(char[], TValue)"/> operation once for each entry.
         /// </summary>
         /// <param name="collection">The values to add/update in the current map.</param>
@@ -588,7 +587,7 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IEnumerable{KeyValuePair{string,TValue}}"/>'s
+        /// This implementation enumerates over the specified <see cref="T:IEnumerable{KeyValuePair{string,TValue}}"/>'s
         /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
         /// </summary>
         /// <param name="collection">The values to add/update in the current map.</param>
@@ -601,7 +600,7 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IEnumerable{KeyValuePair{ICharSequence,TValue}}"/>'s
+        /// This implementation enumerates over the specified <see cref="T:IEnumerable{KeyValuePair{ICharSequence,TValue}}"/>'s
         /// entries, and calls this map's <see cref="Put(ICharSequence, TValue)"/> operation once for each entry.
         /// </summary>
         /// <param name="collection">The values to add/update in the current map.</param>
@@ -614,7 +613,7 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IEnumerable{KeyValuePair{object,TValue}}"/>'s
+        /// This implementation enumerates over the specified <see cref="T:IEnumerable{KeyValuePair{object,TValue}}"/>'s
         /// entries, and calls this map's <see cref="Put(object, TValue)"/> operation once for each entry.
         /// </summary>
         /// <param name="collection">The values to add/update in the current map.</param>
@@ -750,7 +749,7 @@ namespace Lucene.Net.Analysis.Util
         /// LUCENENET Specific - test for value equality similar to how it is done in Java
         /// </summary>
         /// <param name="obj">Another dictionary to test the values of</param>
-        /// <returns><c>true</c> if the given object is an <see cref="IDictionary{object, V}"/> that contains
+        /// <returns><c>true</c> if the given object is an <see cref="T:IDictionary{object, V}"/> that contains
         /// the same key value pairs as the current map</returns>
         public override bool Equals(object obj)
         {
@@ -1456,7 +1455,7 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// helper for CharArraySet to not produce endless recursion
+        /// helper for <see cref="CharArraySet"/> to not produce endless recursion
         /// </summary>
 #if !NETSTANDARD
         [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
@@ -1640,7 +1639,7 @@ namespace Lucene.Net.Analysis.Util
         /// public EntrySet_ class so efficient methods are exposed to users
         /// 
         /// NOTE: In .NET this was renamed to EntrySet_ because it conflicted with the
-        /// method EntrySet(). Since there is also an extension method named <see cref="IDictionary{K,V}.EntrySet()"/> 
+        /// method EntrySet(). Since there is also an extension method named <see cref="T:IDictionary{K,V}.EntrySet()"/> 
         /// that this class needs to override, changing the name of the method was not
         /// possible because the extension method would produce incorrect results if it were
         /// inadvertently called, leading to hard-to-diagnose bugs.
@@ -1767,7 +1766,7 @@ namespace Lucene.Net.Analysis.Util
             return EMPTY_MAP;
         }
 
-        // LUCENENET: Moved UnmodifyableCharArraymap to CharArrayMap class
+        // LUCENENET: Moved UnmodifiableCharArraymap to CharArrayMap class
 
         // LUCENENET: Moved EmptyCharArrayMap to CharArrayMap class
     }
@@ -1783,8 +1782,8 @@ namespace Lucene.Net.Analysis.Util
         bool ContainsKey(char[] text, int offset, int length);
         bool ContainsKey(char[] text);
         bool ContainsKey(object o);
-        bool ContainsKey(string cs);
-        bool ContainsKey(ICharSequence cs);
+        bool ContainsKey(string text);
+        bool ContainsKey(ICharSequence text);
         int Count { get; }
         LuceneVersion MatchVersion { get; }
         ICollection<string> OriginalKeySet { get; }
@@ -1807,8 +1806,8 @@ namespace Lucene.Net.Analysis.Util
         /// <b>Note:</b> If you intend to create a copy of another <see cref="CharArrayMap{TValue}"/> where
         /// the <see cref="LuceneVersion"/> of the source map differs from its copy
         /// <see cref="CharArrayMap{TValue}.CharArrayMap(LuceneVersion, IDictionary{string, TValue}, bool)"/> should be used instead.
-        /// The <see cref="Copy(LuceneVersion, IDictionary{string, TValue})"/> will preserve the <see cref="LuceneVersion"/> of the
-        /// source map it is an instance of <see cref="CharArrayMap{TValue}"/>.
+        /// The <see cref="Copy{TValue}(LuceneVersion, IDictionary{string, TValue})"/> will preserve the <see cref="LuceneVersion"/> of the
+        /// source map if it is an instance of <see cref="CharArrayMap{TValue}"/>.
         /// </para>
         /// </summary>
         /// <param name="matchVersion">
@@ -1879,7 +1878,7 @@ namespace Lucene.Net.Analysis.Util
 
         /// <summary>
         /// Used by <see cref="CharArraySet"/> to create an <see cref="UnmodifiableCharArrayMap{TValue}"/> instance
-        /// without knowing the type of <see cref="TValue"/>.
+        /// without knowing the type of <typeparamref name="TValue"/>.
         /// </summary>
         internal static ICharArrayMap UnmodifiableMap<TValue>(ICharArrayMap map)
         {
@@ -2017,8 +2016,8 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// Empty <see cref="CharArrayMap{V}.UnmodifiableCharArrayMap"/> optimized for speed.
-        /// Contains checks will always return <code>false</code> or throw
+        /// Empty <see cref="UnmodifiableCharArrayMap{V}"/> optimized for speed.
+        /// Contains checks will always return <c>false</c> or throw
         /// NPE if necessary.
         /// </summary>
         internal class EmptyCharArrayMap<V> : UnmodifiableCharArrayMap<V>
@@ -2048,11 +2047,11 @@ namespace Lucene.Net.Analysis.Util
                 return false;
             }
 
-            public override bool ContainsKey(ICharSequence cs)
+            public override bool ContainsKey(ICharSequence text)
             {
-                if (cs == null)
+                if (text == null)
                 {
-                    throw new ArgumentNullException("cs");
+                    throw new ArgumentNullException("text");
                 }
                 return false;
             }
@@ -2084,11 +2083,11 @@ namespace Lucene.Net.Analysis.Util
                 return default(V);
             }
 
-            public override V Get(ICharSequence cs)
+            public override V Get(ICharSequence text)
             {
-                if (cs == null)
+                if (text == null)
                 {
-                    throw new ArgumentNullException("cs");
+                    throw new ArgumentNullException("text");
                 }
                 return default(V);
             }
@@ -2461,183 +2460,197 @@ namespace Lucene.Net.Analysis.Util
         #region PutAll
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IDictionary{bool,TValue}"/>'s
-        /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        /// This implementation enumerates over the specified <paramref name="dictionary"/>'s
+        /// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         /// </summary>
-        /// <param name="collection">A dictionary of values to add/update in the current map.</param>
-        public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<bool, TValue> collection)
+        /// <param name="map">this map</param>
+        /// <param name="dictionary">A dictionary of values to add/update in the current map.</param>
+        public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<bool, TValue> dictionary)
         {
-            foreach (var kvp in collection)
+            foreach (var kvp in dictionary)
             {
                 map.Put(kvp.Key.ToString(), kvp.Value);
             }
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IDictionary{byte,TValue}"/>'s
-        /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        /// This implementation enumerates over the specified <paramref name="dictionary"/>'s
+        /// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         /// </summary>
-        /// <param name="collection">A dictionary of values to add/update in the current map.</param>
-        public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<byte, TValue> collection)
+        /// <param name="map">this map</param>
+        /// <param name="dictionary">A dictionary of values to add/update in the current map.</param>
+        public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<byte, TValue> dictionary)
         {
-            foreach (var kvp in collection)
+            foreach (var kvp in dictionary)
             {
                 map.Put(kvp.Key.ToString(CultureInfo.InvariantCulture), kvp.Value);
             }
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IDictionary{char,TValue}"/>'s
-        /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        /// This implementation enumerates over the specified <paramref name="dictionary"/>'s
+        /// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         /// </summary>
-        /// <param name="collection">A dictionary of values to add/update in the current map.</param>
-        public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<char, TValue> collection)
+        /// <param name="map">this map</param>
+        /// <param name="dictionary">A dictionary of values to add/update in the current map.</param>
+        public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<char, TValue> dictionary)
         {
-            foreach (var kvp in collection)
+            foreach (var kvp in dictionary)
             {
                 map.Put("" + kvp.Key, kvp.Value);
             }
         }
 
         ///// <summary>
-        ///// This implementation enumerates over the specified <see cref="IDictionary{Decimal,TValue}"/>'s
-        ///// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        ///// This implementation enumerates over the specified <paramref name="dictionary"/>'s
+        ///// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         ///// </summary>
-        ///// <param name="collection">A dictionary of values to add/update in the current map.</param>
-        //public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<decimal, TValue> collection)
+        ///// <param name="map">this map</param>
+        ///// <param name="dictionary">A dictionary of values to add/update in the current map.</param>
+        //public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<decimal, TValue> dictionary)
         //{
-        //    foreach (var kvp in collection)
+        //    foreach (var kvp in dictionary)
         //    {
         //        map.Put(kvp.Key.ToString(CultureInfo.InvariantCulture), kvp.Value);
         //    }
         //}
 
         ///// <summary>
-        ///// This implementation enumerates over the specified <see cref="IDictionary{double,TValue}"/>'s
-        ///// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        ///// This implementation enumerates over the specified <paramref name="dictionary"/>'s
+        ///// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         ///// </summary>
-        ///// <param name="collection">A dictionary of values to add/update in the current map.</param>
-        //public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<double, TValue> collection)
+        ///// <param name="map">this map</param>
+        ///// <param name="dictionary">A dictionary of values to add/update in the current map.</param>
+        //public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<double, TValue> dictionary)
         //{
-        //    foreach (var kvp in collection)
+        //    foreach (var kvp in dictionary)
         //    {
         //        map.Put(kvp.Key.ToString(CultureInfo.InvariantCulture), kvp.Value);
         //    }
         //}
 
         ///// <summary>
-        ///// This implementation enumerates over the specified <see cref="IDictionary{float,TValue}"/>'s
-        ///// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        ///// This implementation enumerates over the specified <paramref name="dictionary"/>'s
+        ///// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         ///// </summary>
-        ///// <param name="collection">A dictionary of values to add/update in the current map.</param>
-        //public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<float, TValue> collection)
+        ///// <param name="map">this map</param>
+        ///// <param name="dictionary">A dictionary of values to add/update in the current map.</param>
+        //public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<float, TValue> dictionary)
         //{
-        //    foreach (var kvp in collection)
+        //    foreach (var kvp in dictionary)
         //    {
         //        map.Put(kvp.Key.ToString(CultureInfo.InvariantCulture), kvp.Value);
         //    }
         //}
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IDictionary{int,TValue}"/>'s
-        /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        /// This implementation enumerates over the specified <paramref name="dictionary"/>'s
+        /// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         /// </summary>
-        /// <param name="collection">A dictionary of values to add/update in the current map.</param>
-        public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<int, TValue> collection)
+        /// <param name="map">this map</param>
+        /// <param name="dictionary">A dictionary of values to add/update in the current map.</param>
+        public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<int, TValue> dictionary)
         {
-            foreach (var kvp in collection)
+            foreach (var kvp in dictionary)
             {
                 map.Put(kvp.Key.ToString(CultureInfo.InvariantCulture), kvp.Value);
             }
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IDictionary{long,TValue}"/>'s
-        /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        /// This implementation enumerates over the specified <paramref name="dictionary"/>'s
+        /// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         /// </summary>
-        /// <param name="collection">A dictionary of values to add/update in the current map.</param>
-        public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<long, TValue> collection)
+        /// <param name="map">this map</param>
+        /// <param name="dictionary">A dictionary of values to add/update in the current map.</param>
+        public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<long, TValue> dictionary)
         {
-            foreach (var kvp in collection)
+            foreach (var kvp in dictionary)
             {
                 map.Put(kvp.Key.ToString(CultureInfo.InvariantCulture), kvp.Value);
             }
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IDictionary{sbyte,TValue}"/>'s
-        /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        /// This implementation enumerates over the specified <paramref name="dictionary"/>'s
+        /// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         /// </summary>
-        /// <param name="collection">A dictionary of values to add/update in the current map.</param>
+        /// <param name="map">this map</param>
+        /// <param name="dictionary">A dictionary of values to add/update in the current map.</param>
         [CLSCompliant(false)]
-        public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<sbyte, TValue> collection)
+        public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<sbyte, TValue> dictionary)
         {
-            foreach (var kvp in collection)
+            foreach (var kvp in dictionary)
             {
                 map.Put(kvp.Key.ToString(CultureInfo.InvariantCulture), kvp.Value);
             }
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IDictionary{short,TValue}"/>'s
-        /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        /// This implementation enumerates over the specified <paramref name="dictionary"/>'s
+        /// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         /// </summary>
-        /// <param name="collection">A dictionary of values to add/update in the current map.</param>
-        public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<short, TValue> collection)
+        /// <param name="map">this map</param>
+        /// <param name="dictionary">A dictionary of values to add/update in the current map.</param>
+        public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<short, TValue> dictionary)
         {
-            foreach (var kvp in collection)
+            foreach (var kvp in dictionary)
             {
                 map.Put(kvp.Key.ToString(CultureInfo.InvariantCulture), kvp.Value);
             }
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IDictionary{uint,TValue}"/>'s
-        /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        /// This implementation enumerates over the specified <paramref name="dictionary"/>'s
+        /// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         /// </summary>
-        /// <param name="collection">A dictionary of values to add/update in the current map.</param>
+        /// <param name="map">this map</param>
+        /// <param name="dictionary">A dictionary of values to add/update in the current map.</param>
         [CLSCompliant(false)]
-        public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<uint, TValue> collection)
+        public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<uint, TValue> dictionary)
         {
-            foreach (var kvp in collection)
+            foreach (var kvp in dictionary)
             {
                 map.Put(kvp.Key.ToString(CultureInfo.InvariantCulture), kvp.Value);
             }
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IDictionary{ulong,TValue}"/>'s
-        /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        /// This implementation enumerates over the specified <paramref name="dictionary"/>'s
+        /// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         /// </summary>
-        /// <param name="collection">A dictionary of values to add/update in the current map.</param>
+        /// <param name="map">this map</param>
+        /// <param name="dictionary">A dictionary of values to add/update in the current map.</param>
         [CLSCompliant(false)]
-        public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<ulong, TValue> collection)
+        public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<ulong, TValue> dictionary)
         {
-            foreach (var kvp in collection)
+            foreach (var kvp in dictionary)
             {
                 map.Put(kvp.Key.ToString(CultureInfo.InvariantCulture), kvp.Value);
             }
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IDictionary{ushort,TValue}"/>'s
-        /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        /// This implementation enumerates over the specified <paramref name="dictionary"/>'s
+        /// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         /// </summary>
-        /// <param name="collection">A dictionary of values to add/update in the current map.</param>
+        /// <param name="map">this map</param>
+        /// <param name="dictionary">A dictionary of values to add/update in the current map.</param>
         [CLSCompliant(false)]
-        public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<ushort, TValue> collection)
+        public static void PutAll<TValue>(this CharArrayMap<TValue> map, IDictionary<ushort, TValue> dictionary)
         {
-            foreach (var kvp in collection)
+            foreach (var kvp in dictionary)
             {
                 map.Put(kvp.Key.ToString(CultureInfo.InvariantCulture), kvp.Value);
             }
         }
 
-  
+
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IEnumerable{KeyValuePair{bool,TValue}}"/>'s
-        /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        /// This implementation enumerates over the specified <paramref name="collection"/>'s
+        /// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         /// </summary>
+        /// <param name="map">this map</param>
         /// <param name="collection">The values to add/update in the current map.</param>
         public static void PutAll<TValue>(this CharArrayMap<TValue> map, IEnumerable<KeyValuePair<bool, TValue>> collection)
         {
@@ -2648,9 +2661,10 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IEnumerable{KeyValuePair{byte,TValue}}"/>'s
-        /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        /// This implementation enumerates over the specified <paramref name="collection"/>'s
+        /// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         /// </summary>
+        /// <param name="map">this map</param>
         /// <param name="collection">The values to add/update in the current map.</param>
         public static void PutAll<TValue>(this CharArrayMap<TValue> map, IEnumerable<KeyValuePair<byte, TValue>> collection)
         {
@@ -2661,9 +2675,10 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IEnumerable{KeyValuePair{char,TValue}}"/>'s
-        /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        /// This implementation enumerates over the specified <paramref name="collection"/>'s
+        /// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         /// </summary>
+        /// <param name="map">this map</param>
         /// <param name="collection">The values to add/update in the current map.</param>
         public static void PutAll<TValue>(this CharArrayMap<TValue> map, IEnumerable<KeyValuePair<char, TValue>> collection)
         {
@@ -2674,9 +2689,10 @@ namespace Lucene.Net.Analysis.Util
         }
 
         ///// <summary>
-        ///// This implementation enumerates over the specified <see cref="IEnumerable{KeyValuePair{Decimal,TValue}}"/>'s
-        ///// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        ///// This implementation enumerates over the specified <paramref name="collection"/>'s
+        ///// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         ///// </summary>
+        ///// <param name="map">this map</param>
         ///// <param name="collection">The values to add/update in the current map.</param>
         //public static void PutAll<TValue>(this CharArrayMap<TValue> map, IEnumerable<KeyValuePair<decimal, TValue>> collection)
         //{
@@ -2687,9 +2703,10 @@ namespace Lucene.Net.Analysis.Util
         //}
 
         ///// <summary>
-        ///// This implementation enumerates over the specified <see cref="IEnumerable{KeyValuePair{double,TValue}}"/>'s
-        ///// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        ///// This implementation enumerates over the specified <paramref name="collection"/>'s
+        ///// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         ///// </summary>
+        ///// <param name="map">this map</param>
         ///// <param name="collection">The values to add/update in the current map.</param>
         //public static void PutAll<TValue>(this CharArrayMap<TValue> map, IEnumerable<KeyValuePair<double, TValue>> collection)
         //{
@@ -2700,9 +2717,10 @@ namespace Lucene.Net.Analysis.Util
         //}
 
         ///// <summary>
-        ///// This implementation enumerates over the specified <see cref="IEnumerable{KeyValuePair{float,TValue}}"/>'s
-        ///// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        ///// This implementation enumerates over the specified <paramref name="collection"/>'s
+        ///// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         ///// </summary>
+        ///// <param name="map">this map</param>
         ///// <param name="collection">The values to add/update in the current map.</param>
         //public static void PutAll<TValue>(this CharArrayMap<TValue> map, IEnumerable<KeyValuePair<float, TValue>> collection)
         //{
@@ -2713,9 +2731,10 @@ namespace Lucene.Net.Analysis.Util
         //}
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IEnumerable{KeyValuePair{int,TValue}}"/>'s
-        /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        /// This implementation enumerates over the specified <paramref name="collection"/>'s
+        /// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         /// </summary>
+        /// <param name="map">this map</param>
         /// <param name="collection">The values to add/update in the current map.</param>
         public static void PutAll<TValue>(this CharArrayMap<TValue> map, IEnumerable<KeyValuePair<int, TValue>> collection)
         {
@@ -2726,9 +2745,10 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IEnumerable{KeyValuePair{long,TValue}}"/>'s
-        /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        /// This implementation enumerates over the specified <paramref name="collection"/>'s
+        /// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         /// </summary>
+        /// <param name="map">this map</param>
         /// <param name="collection">The values to add/update in the current map.</param>
         public static void PutAll<TValue>(this CharArrayMap<TValue> map, IEnumerable<KeyValuePair<long, TValue>> collection)
         {
@@ -2739,9 +2759,10 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IEnumerable{KeyValuePair{sbyte,TValue}}"/>'s
-        /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        /// This implementation enumerates over the specified <paramref name="collection"/>'s
+        /// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         /// </summary>
+        /// <param name="map">this map</param>
         /// <param name="collection">The values to add/update in the current map.</param>
         [CLSCompliant(false)]
         public static void PutAll<TValue>(this CharArrayMap<TValue> map, IEnumerable<KeyValuePair<sbyte, TValue>> collection)
@@ -2753,9 +2774,10 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IEnumerable{KeyValuePair{short,TValue}}"/>'s
-        /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        /// This implementation enumerates over the specified <paramref name="collection"/>'s
+        /// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         /// </summary>
+        /// <param name="map">this map</param>
         /// <param name="collection">The values to add/update in the current map.</param>
         public static void PutAll<TValue>(this CharArrayMap<TValue> map, IEnumerable<KeyValuePair<short, TValue>> collection)
         {
@@ -2766,9 +2788,10 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IEnumerable{KeyValuePair{uint,TValue}}"/>'s
-        /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        /// This implementation enumerates over the specified <paramref name="collection"/>'s
+        /// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         /// </summary>
+        /// <param name="map">this map</param>
         /// <param name="collection">The values to add/update in the current map.</param>
         [CLSCompliant(false)]
         public static void PutAll<TValue>(this CharArrayMap<TValue> map, IEnumerable<KeyValuePair<uint, TValue>> collection)
@@ -2780,9 +2803,10 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IEnumerable{KeyValuePair{ulong,TValue}}"/>'s
-        /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        /// This implementation enumerates over the specified <paramref name="collection"/>'s
+        /// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         /// </summary>
+        /// <param name="map">this map</param>
         /// <param name="collection">The values to add/update in the current map.</param>
         [CLSCompliant(false)]
         public static void PutAll<TValue>(this CharArrayMap<TValue> map, IEnumerable<KeyValuePair<ulong, TValue>> collection)
@@ -2794,9 +2818,10 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// This implementation enumerates over the specified <see cref="IEnumerable{KeyValuePair{ushort,TValue}}"/>'s
-        /// entries, and calls this map's <see cref="Put(string, TValue)"/> operation once for each entry.
+        /// This implementation enumerates over the specified <paramref name="collection"/>'s
+        /// entries, and calls this map's <see cref="CharArrayMap{TValue}.Put(string, TValue)"/> operation once for each entry.
         /// </summary>
+        /// <param name="map">this map</param>
         /// <param name="collection">The values to add/update in the current map.</param>
         [CLSCompliant(false)]
         public static void PutAll<TValue>(this CharArrayMap<TValue> map, IEnumerable<KeyValuePair<ushort, TValue>> collection)
@@ -2814,6 +2839,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Gets the value associated with the specified key.
         /// </summary>
+        /// <param name="map">this map</param>
         /// <param name="key">The key of the value to get.</param>
         /// <param name="value">When this method returns, contains the value associated with the specified key, 
         /// if the key is found; otherwise, the default value for the type of the value parameter. 
@@ -2827,6 +2853,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Gets the value associated with the specified key.
         /// </summary>
+        /// <param name="map">this map</param>
         /// <param name="key">The key of the value to get.</param>
         /// <param name="value">When this method returns, contains the value associated with the specified key, 
         /// if the key is found; otherwise, the default value for the type of the value parameter. 
@@ -2840,6 +2867,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Gets the value associated with the specified key.
         /// </summary>
+        /// <param name="map">this map</param>
         /// <param name="key">The key of the value to get.</param>
         /// <param name="value">When this method returns, contains the value associated with the specified key, 
         /// if the key is found; otherwise, the default value for the type of the value parameter. 
@@ -2853,6 +2881,7 @@ namespace Lucene.Net.Analysis.Util
         ///// <summary>
         ///// Gets the value associated with the specified key.
         ///// </summary>
+        ///// <param name="map">this map</param>
         ///// <param name="key">The key of the value to get.</param>
         ///// <param name="value">When this method returns, contains the value associated with the specified key, 
         ///// if the key is found; otherwise, the default value for the type of the value parameter. 
@@ -2866,6 +2895,7 @@ namespace Lucene.Net.Analysis.Util
         ///// <summary>
         ///// Gets the value associated with the specified key.
         ///// </summary>
+        ///// <param name="map">this map</param>
         ///// <param name="key">The key of the value to get.</param>
         ///// <param name="value">When this method returns, contains the value associated with the specified key, 
         ///// if the key is found; otherwise, the default value for the type of the value parameter. 
@@ -2879,6 +2909,7 @@ namespace Lucene.Net.Analysis.Util
         ///// <summary>
         ///// Gets the value associated with the specified key.
         ///// </summary>
+        ///// <param name="map">this map</param>
         ///// <param name="key">The key of the value to get.</param>
         ///// <param name="value">When this method returns, contains the value associated with the specified key, 
         ///// if the key is found; otherwise, the default value for the type of the value parameter. 
@@ -2892,6 +2923,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Gets the value associated with the specified key.
         /// </summary>
+        /// <param name="map">this map</param>
         /// <param name="key">The key of the value to get.</param>
         /// <param name="value">When this method returns, contains the value associated with the specified key, 
         /// if the key is found; otherwise, the default value for the type of the value parameter. 
@@ -2905,6 +2937,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Gets the value associated with the specified key.
         /// </summary>
+        /// <param name="map">this map</param>
         /// <param name="key">The key of the value to get.</param>
         /// <param name="value">When this method returns, contains the value associated with the specified key, 
         /// if the key is found; otherwise, the default value for the type of the value parameter. 
@@ -2918,6 +2951,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Gets the value associated with the specified key.
         /// </summary>
+        /// <param name="map">this map</param>
         /// <param name="key">The key of the value to get.</param>
         /// <param name="value">When this method returns, contains the value associated with the specified key, 
         /// if the key is found; otherwise, the default value for the type of the value parameter. 
@@ -2932,6 +2966,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Gets the value associated with the specified key.
         /// </summary>
+        /// <param name="map">this map</param>
         /// <param name="key">The key of the value to get.</param>
         /// <param name="value">When this method returns, contains the value associated with the specified key, 
         /// if the key is found; otherwise, the default value for the type of the value parameter. 
@@ -2945,6 +2980,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Gets the value associated with the specified key.
         /// </summary>
+        /// <param name="map">this map</param>
         /// <param name="key">The key of the value to get.</param>
         /// <param name="value">When this method returns, contains the value associated with the specified key, 
         /// if the key is found; otherwise, the default value for the type of the value parameter. 
@@ -2959,6 +2995,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Gets the value associated with the specified key.
         /// </summary>
+        /// <param name="map">this map</param>
         /// <param name="key">The key of the value to get.</param>
         /// <param name="value">When this method returns, contains the value associated with the specified key, 
         /// if the key is found; otherwise, the default value for the type of the value parameter. 
@@ -2973,6 +3010,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Gets the value associated with the specified key.
         /// </summary>
+        /// <param name="map">this map</param>
         /// <param name="key">The key of the value to get.</param>
         /// <param name="value">When this method returns, contains the value associated with the specified key, 
         /// if the key is found; otherwise, the default value for the type of the value parameter. 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b19aee50/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArraySet.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArraySet.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArraySet.cs
index 9ac42ba..97bab79 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArraySet.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArraySet.cs
@@ -70,8 +70,7 @@ namespace Lucene.Net.Analysis.Util
         /// Create set with enough capacity to hold <paramref name="startSize"/> terms
         /// </summary>
         /// <param name="matchVersion">
-        ///          compatibility match version see <a href="#version">Version
-        ///          note</a> above for details. </param>
+        ///          compatibility match version see <see cref="CharArraySet"/> for details. </param>
         /// <param name="startSize">
         ///          the initial capacity </param>
         /// <param name="ignoreCase">
@@ -86,8 +85,7 @@ namespace Lucene.Net.Analysis.Util
         /// Creates a set from a collection of objects. 
         /// </summary>
         /// <param name="matchVersion">
-        ///          compatibility match version see <a href="#version">Version
-        ///          note</a> above for details. </param>
+        ///          compatibility match version see <see cref="CharArraySet"/> for details. </param>
         /// <param name="c">
         ///          a collection whose elements to be placed into the set </param>
         /// <param name="ignoreCase">
@@ -108,7 +106,7 @@ namespace Lucene.Net.Analysis.Util
         }
 
         /// <summary>
-        /// Clears all entries in this set. This method is supported for reusing, but not <see cref="ICollection{Object}.Remove(string)"/>.
+        /// Clears all entries in this set. This method is supported for reusing, but not <see cref="M:ICollection{string}.Remove(string)"/>.
         /// </summary>
         public virtual void Clear()
         {
@@ -173,7 +171,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Add this <see cref="ICharSequence"/> into the set
         /// </summary>
-        /// <returns><c>true</c> if <paramref name="o"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
+        /// <returns><c>true</c> if <paramref name="text"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
         public virtual bool Add(ICharSequence text)
         {
             return map.Put(text);
@@ -182,7 +180,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Add this <see cref="string"/> into the set
         /// </summary>
-        /// <returns><c>true</c> if <paramref name="o"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
+        /// <returns><c>true</c> if <paramref name="text"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
         public virtual bool Add(string text)
         {
             return map.Put(text);
@@ -193,7 +191,7 @@ namespace Lucene.Net.Analysis.Util
         /// If <c>ignoreCase</c> is true for this <see cref="CharArraySet"/>, the text array will be directly modified.
         /// The user should never modify this text array after calling this method.
         /// </summary>
-        /// <returns><c>true</c> if <paramref name="o"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
+        /// <returns><c>true</c> if <paramref name="text"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
         public virtual bool Add(char[] text)
         {
             return map.Put(text);
@@ -252,14 +250,13 @@ namespace Lucene.Net.Analysis.Util
         /// <para>
         /// <b>Note:</b> If you intend to create a copy of another <see cref="CharArraySet"/> where
         /// the <see cref="LuceneVersion"/> of the source set differs from its copy
-        /// <see cref="CharArraySet(LuceneVersion, IEnumerable{string}, bool)"/> should be used instead.
-        /// The <see cref="Copy{T}(LuceneVersion, IEnumerable{T})"/> will preserve the <see cref="LuceneVersion"/> of the
+        /// <see cref="CharArraySet.CharArraySet(LuceneVersion, ICollection{string}, bool)"/> should be used instead.
+        /// The <see cref="Copy{T}(LuceneVersion, ICollection{T})"/> will preserve the <see cref="LuceneVersion"/> of the
         /// source set it is an instance of <see cref="CharArraySet"/>.
         /// </para>
         /// </summary>
         /// <param name="matchVersion">
-        ///          compatibility match version see <a href="#version">Version
-        ///          note</a> above for details. This argument will be ignored if the
+        ///          compatibility match version. This argument will be ignored if the
         ///          given set is a <see cref="CharArraySet"/>. </param>
         /// <param name="set">
         ///          a set to copy </param>
@@ -529,7 +526,7 @@ namespace Lucene.Net.Analysis.Util
         /// Determines whether a <see cref="CharArraySet"/> object is a subset of the specified collection.
         /// </summary>
         /// <param name="other">The collection to compare to the current <see cref="CharArraySet"/> object.</param>
-        /// <returns><c>true</c> if the <see cref="CharArraySet"/> object is a subset of <paramref name="other"/>; otherwise, <c>false</c>.</returns>
+        /// <returns><c>true</c> if this <see cref="CharArraySet"/> object is a subset of <paramref name="other"/>; otherwise, <c>false</c>.</returns>
         public virtual bool IsSubsetOf(IEnumerable<string> other)
         {
             if (other == null)
@@ -561,7 +558,7 @@ namespace Lucene.Net.Analysis.Util
         /// Determines whether a <see cref="CharArraySet"/> object is a subset of the specified collection.
         /// </summary>
         /// <param name="other">The collection to compare to the current <see cref="CharArraySet"/> object.</param>
-        /// <returns><c>true</c> if the <see cref="CharArraySet"/> object is a subset of <paramref name="other"/>; otherwise, <c>false</c>.</returns>
+        /// <returns><c>true</c> if this <see cref="CharArraySet"/> object is a subset of <paramref name="other"/>; otherwise, <c>false</c>.</returns>
         public virtual bool IsSubsetOf<T>(IEnumerable<T> other)
         {
             if (other == null)
@@ -584,7 +581,7 @@ namespace Lucene.Net.Analysis.Util
         /// Determines whether a <see cref="CharArraySet"/> object is a superset of the specified collection.
         /// </summary>
         /// <param name="other">The collection to compare to the current <see cref="CharArraySet"/> object.</param>
-        /// <returns><c>true</c> if the HashSet<T> object is a superset of <paramref name="other"/>; otherwise, <c>false</c>.</returns>
+        /// <returns><c>true</c> if this <see cref="CharArraySet"/> object is a superset of <paramref name="other"/>; otherwise, <c>false</c>.</returns>
         public virtual bool IsSupersetOf(IEnumerable<string> other)
         {
             if (other == null)
@@ -611,7 +608,7 @@ namespace Lucene.Net.Analysis.Util
         /// Determines whether a <see cref="CharArraySet"/> object is a superset of the specified collection.
         /// </summary>
         /// <param name="other">The collection to compare to the current <see cref="CharArraySet"/> object.</param>
-        /// <returns><c>true</c> if the HashSet<T> object is a superset of <paramref name="other"/>; otherwise, <c>false</c>.</returns>
+        /// <returns><c>true</c> if this <see cref="CharArraySet"/> object is a superset of <paramref name="other"/>; otherwise, <c>false</c>.</returns>
         public virtual bool IsSupersetOf<T>(IEnumerable<T> other)
         {
             if (other == null)
@@ -630,7 +627,7 @@ namespace Lucene.Net.Analysis.Util
         /// Determines whether a <see cref="CharArraySet"/> object is a proper subset of the specified collection.
         /// </summary>
         /// <param name="other">The collection to compare to the current <see cref="CharArraySet"/> object.</param>
-        /// <returns><c>true</c> if the <see cref="CharArraySet"/> object is a proper subset of <paramref name="other"/>; otherwise, <c>false</c>.</returns>
+        /// <returns><c>true</c> if this <see cref="CharArraySet"/> object is a proper subset of <paramref name="other"/>; otherwise, <c>false</c>.</returns>
         public virtual bool IsProperSubsetOf(IEnumerable<string> other)
         {
             if (other == null)
@@ -666,7 +663,7 @@ namespace Lucene.Net.Analysis.Util
         /// Determines whether a <see cref="CharArraySet"/> object is a proper subset of the specified collection.
         /// </summary>
         /// <param name="other">The collection to compare to the current <see cref="CharArraySet"/> object.</param>
-        /// <returns><c>true</c> if the <see cref="CharArraySet"/> object is a proper subset of <paramref name="other"/>; otherwise, <c>false</c>.</returns>
+        /// <returns><c>true</c> if this <see cref="CharArraySet"/> object is a proper subset of <paramref name="other"/>; otherwise, <c>false</c>.</returns>
         public virtual bool IsProperSubsetOf<T>(IEnumerable<T> other)
         {
             if (other == null)
@@ -690,7 +687,7 @@ namespace Lucene.Net.Analysis.Util
         /// Determines whether a <see cref="CharArraySet"/> object is a proper superset of the specified collection.
         /// </summary>
         /// <param name="other">The collection to compare to the current <see cref="CharArraySet"/> object.</param>
-        /// <returns><c>true</c> if the HashSet<T> object is a proper superset of <paramref name="other"/>; otherwise, <c>false</c>.</returns>
+        /// <returns><c>true</c> if this <see cref="CharArraySet"/> object is a proper superset of <paramref name="other"/>; otherwise, <c>false</c>.</returns>
         public virtual bool IsProperSupersetOf(IEnumerable<string> other)
         {
             if (other == null)
@@ -727,7 +724,7 @@ namespace Lucene.Net.Analysis.Util
         /// Determines whether a <see cref="CharArraySet"/> object is a proper superset of the specified collection.
         /// </summary>
         /// <param name="other">The collection to compare to the current <see cref="CharArraySet"/> object.</param>
-        /// <returns><c>true</c> if the HashSet<T> object is a proper superset of <paramref name="other"/>; otherwise, <c>false</c>.</returns>
+        /// <returns><c>true</c> if this <see cref="CharArraySet"/> object is a proper superset of <paramref name="other"/>; otherwise, <c>false</c>.</returns>
         public virtual bool IsProperSupersetOf<T>(IEnumerable<T> other)
         {
             if (other == null)
@@ -752,7 +749,7 @@ namespace Lucene.Net.Analysis.Util
         /// Determines whether the current <see cref="CharArraySet"/> object and a specified collection share common elements.
         /// </summary>
         /// <param name="other">The collection to compare to the current <see cref="CharArraySet"/> object.</param>
-        /// <returns><c>true</c> if the HashSet<T> object and <paramref name="other"/> share at least one common element; otherwise, <c>false</c>.</returns>
+        /// <returns><c>true</c> if the <see cref="CharArraySet"/> object and <paramref name="other"/> share at least one common element; otherwise, <c>false</c>.</returns>
         public virtual bool Overlaps(IEnumerable<string> other)
         {
             if (other == null)
@@ -776,7 +773,7 @@ namespace Lucene.Net.Analysis.Util
         /// Determines whether the current <see cref="CharArraySet"/> object and a specified collection share common elements.
         /// </summary>
         /// <param name="other">The collection to compare to the current <see cref="CharArraySet"/> object.</param>
-        /// <returns><c>true</c> if the HashSet<T> object and <paramref name="other"/> share at least one common element; otherwise, <c>false</c>.</returns>
+        /// <returns><c>true</c> if this <see cref="CharArraySet"/> object and <paramref name="other"/> share at least one common element; otherwise, <c>false</c>.</returns>
         public virtual bool Overlaps<T>(IEnumerable<T> other)
         {
             if (other == null)
@@ -801,7 +798,7 @@ namespace Lucene.Net.Analysis.Util
         /// in the specified collection.
         /// </summary>
         /// <param name="other">collection to be checked for containment in this collection</param>
-        /// <returns><c>true</c> if this collection contains all of the elements in the specified collection; otherwise, <c>false</c>.</returns>
+        /// <returns><c>true</c> if this <see cref="CharArraySet"/> contains all of the elements in the specified collection; otherwise, <c>false</c>.</returns>
         public virtual bool ContainsAll(IEnumerable<string> other)
         {
             foreach (var local in other)
@@ -819,7 +816,7 @@ namespace Lucene.Net.Analysis.Util
         /// in the specified collection.
         /// </summary>
         /// <param name="other">collection to be checked for containment in this collection</param>
-        /// <returns><c>true</c> if this collection contains all of the elements in the specified collection; otherwise, <c>false</c>.</returns>
+        /// <returns><c>true</c> if this <see cref="CharArraySet"/> contains all of the elements in the specified collection; otherwise, <c>false</c>.</returns>
         public virtual bool ContainsAll<T>(IEnumerable<T> other)
         {
             foreach (var local in other)
@@ -874,7 +871,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Add this <see cref="bool"/> into the set
         /// </summary>
-        /// <returns><c>true</c> if <paramref name="o"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
+        /// <returns><c>true</c> if <paramref name="text"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
         public static bool Add(this CharArraySet set, bool text)
         {
             return set.map.Put(text.ToString());
@@ -883,7 +880,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Add this <see cref="byte"/> into the set
         /// </summary>
-        /// <returns><c>true</c> if <paramref name="o"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
+        /// <returns><c>true</c> if <paramref name="text"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
         public static bool Add(this CharArraySet set, byte text)
         {
             return set.map.Put(text.ToString(CultureInfo.InvariantCulture));
@@ -892,7 +889,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Add this <see cref="char"/> into the set
         /// </summary>
-        /// <returns><c>true</c> if <paramref name="o"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
+        /// <returns><c>true</c> if <paramref name="text"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
         public static bool Add(this CharArraySet set, char text)
         {
             return set.map.Put("" + text);
@@ -901,7 +898,7 @@ namespace Lucene.Net.Analysis.Util
         ///// <summary>
         ///// Add this <see cref="decimal"/> into the set
         ///// </summary>
-        ///// <returns><c>true</c> if <paramref name="o"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
+        ///// <returns><c>true</c> if <paramref name="text"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
         //public static bool Add(this CharArraySet set, decimal text)
         //{
         //    return set.map.Put(text.ToString(CultureInfo.InvariantCulture));
@@ -910,7 +907,7 @@ namespace Lucene.Net.Analysis.Util
         ///// <summary>
         ///// Add this <see cref="double"/> into the set
         ///// </summary>
-        ///// <returns><c>true</c> if <paramref name="o"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
+        ///// <returns><c>true</c> if <paramref name="text"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
         //public static bool Add(this CharArraySet set, double text)
         //{
         //    return set.map.Put(text.ToString(CultureInfo.InvariantCulture));
@@ -919,7 +916,7 @@ namespace Lucene.Net.Analysis.Util
         ///// <summary>
         ///// Add this <see cref="float"/> into the set
         ///// </summary>
-        ///// <returns><c>true</c> if <paramref name="o"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
+        ///// <returns><c>true</c> if <paramref name="text"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
         //public static bool Add(this CharArraySet set, float text)
         //{
         //    return set.map.Put(text.ToString(CultureInfo.InvariantCulture));
@@ -928,7 +925,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Add this <see cref="int"/> into the set
         /// </summary>
-        /// <returns><c>true</c> if <paramref name="o"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
+        /// <returns><c>true</c> if <paramref name="text"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
         public static bool Add(this CharArraySet set, int text)
         {
             return set.map.Put(text.ToString(CultureInfo.InvariantCulture));
@@ -937,7 +934,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Add this <see cref="long"/> into the set
         /// </summary>
-        /// <returns><c>true</c> if <paramref name="o"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
+        /// <returns><c>true</c> if <paramref name="text"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
         public static bool Add(this CharArraySet set, long text)
         {
             return set.map.Put(text.ToString(CultureInfo.InvariantCulture));
@@ -946,7 +943,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Add this <see cref="sbyte"/> into the set
         /// </summary>
-        /// <returns><c>true</c> if <paramref name="o"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
+        /// <returns><c>true</c> if <paramref name="text"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
         [CLSCompliant(false)]
         public static bool Add(this CharArraySet set, sbyte text)
         {
@@ -956,7 +953,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Add this <see cref="short"/> into the set
         /// </summary>
-        /// <returns><c>true</c> if <paramref name="o"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
+        /// <returns><c>true</c> if <paramref name="text"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
         public static bool Add(this CharArraySet set, short text)
         {
             return set.map.Put(text.ToString(CultureInfo.InvariantCulture));
@@ -965,7 +962,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Add this <see cref="uint"/> into the set
         /// </summary>
-        /// <returns><c>true</c> if <paramref name="o"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
+        /// <returns><c>true</c> if <paramref name="text"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
         [CLSCompliant(false)]
         public static bool Add(this CharArraySet set, uint text)
         {
@@ -975,7 +972,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Add this <see cref="ulong"/> into the set
         /// </summary>
-        /// <returns><c>true</c> if <paramref name="o"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
+        /// <returns><c>true</c> if <paramref name="text"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
         [CLSCompliant(false)]
         public static bool Add(this CharArraySet set, ulong text)
         {
@@ -985,7 +982,7 @@ namespace Lucene.Net.Analysis.Util
         /// <summary>
         /// Add this <see cref="ushort"/> into the set
         /// </summary>
-        /// <returns><c>true</c> if <paramref name="o"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
+        /// <returns><c>true</c> if <paramref name="text"/> was added to the set; <c>false</c> if it already existed prior to this call</returns>
         [CLSCompliant(false)]
         public static bool Add(this CharArraySet set, ushort text)
         {
@@ -1112,6 +1109,7 @@ namespace Lucene.Net.Analysis.Util
         /// Modifies the current <see cref="CharArraySet"/> to contain all elements that are present 
         /// in itself, the specified collection, or both.
         /// </summary>
+        /// <param name="set">this <see cref="CharArraySet"/></param>
         /// <param name="other">The collection whose elements should be merged into the <see cref="CharArraySet"/>.</param>
         /// <returns><c>true</c> if this <see cref="CharArraySet"/> changed as a result of the call</returns>
         public static bool UnionWith(this CharArraySet set, IEnumerable<byte> other)
@@ -1139,6 +1137,7 @@ namespace Lucene.Net.Analysis.Util
         /// Modifies the current <see cref="CharArraySet"/> to contain all elements that are present 
         /// in itself, the specified collection, or both.
         /// </summary>
+        /// <param name="set">this <see cref="CharArraySet"/></param>
         /// <param name="other">The collection whose elements should be merged into the <see cref="CharArraySet"/>.</param>
         /// <returns><c>true</c> if this <see cref="CharArraySet"/> changed as a result of the call</returns>
         public static bool UnionWith(this CharArraySet set, IEnumerable<char> other)
@@ -1166,6 +1165,7 @@ namespace Lucene.Net.Analysis.Util
         ///// Modifies the current <see cref="CharArraySet"/> to contain all elements that are present 
         ///// in itself, the specified collection, or both.
         ///// </summary>
+        ///// <param name="set">this <see cref="CharArraySet"/></param>
         ///// <param name="other">The collection whose elements should be merged into the <see cref="CharArraySet"/>.</param>
         ///// <returns><c>true</c> if this <see cref="CharArraySet"/> changed as a result of the call</returns>
         //public static bool UnionWith(this CharArraySet set, IEnumerable<decimal> other)
@@ -1193,6 +1193,7 @@ namespace Lucene.Net.Analysis.Util
         ///// Modifies the current <see cref="CharArraySet"/> to contain all elements that are present 
         ///// in itself, the specified collection, or both.
         ///// </summary>
+        ///// <param name="set">this <see cref="CharArraySet"/></param>
         ///// <param name="other">The collection whose elements should be merged into the <see cref="CharArraySet"/>.</param>
         ///// <returns><c>true</c> if this <see cref="CharArraySet"/> changed as a result of the call</returns>
         //public static bool UnionWith(this CharArraySet set, IEnumerable<double> other)
@@ -1220,6 +1221,7 @@ namespace Lucene.Net.Analysis.Util
         ///// Modifies the current <see cref="CharArraySet"/> to contain all elements that are present 
         ///// in itself, the specified collection, or both.
         ///// </summary>
+        ///// <param name="set">this <see cref="CharArraySet"/></param>
         ///// <param name="other">The collection whose elements should be merged into the <see cref="CharArraySet"/>.</param>
         ///// <returns><c>true</c> if this <see cref="CharArraySet"/> changed as a result of the call</returns>
         //public static bool UnionWith(this CharArraySet set, IEnumerable<float> other)
@@ -1247,6 +1249,7 @@ namespace Lucene.Net.Analysis.Util
         /// Modifies the current <see cref="CharArraySet"/> to contain all elements that are present 
         /// in itself, the specified collection, or both.
         /// </summary>
+        /// <param name="set">this <see cref="CharArraySet"/></param>
         /// <param name="other">The collection whose elements should be merged into the <see cref="CharArraySet"/>.</param>
         /// <returns><c>true</c> if this <see cref="CharArraySet"/> changed as a result of the call</returns>
         public static bool UnionWith(this CharArraySet set, IEnumerable<int> other)
@@ -1274,6 +1277,7 @@ namespace Lucene.Net.Analysis.Util
         /// Modifies the current <see cref="CharArraySet"/> to contain all elements that are present 
         /// in itself, the specified collection, or both.
         /// </summary>
+        /// <param name="set">this <see cref="CharArraySet"/></param>
         /// <param name="other">The collection whose elements should be merged into the <see cref="CharArraySet"/>.</param>
         /// <returns><c>true</c> if this <see cref="CharArraySet"/> changed as a result of the call</returns>
         public static bool UnionWith(this CharArraySet set, IEnumerable<long> other)
@@ -1301,6 +1305,7 @@ namespace Lucene.Net.Analysis.Util
         /// Modifies the current <see cref="CharArraySet"/> to contain all elements that are present 
         /// in itself, the specified collection, or both.
         /// </summary>
+        /// <param name="set">this <see cref="CharArraySet"/></param>
         /// <param name="other">The collection whose elements should be merged into the <see cref="CharArraySet"/>.</param>
         /// <returns><c>true</c> if this <see cref="CharArraySet"/> changed as a result of the call</returns>
         [CLSCompliant(false)]
@@ -1329,6 +1334,7 @@ namespace Lucene.Net.Analysis.Util
         /// Modifies the current <see cref="CharArraySet"/> to contain all elements that are present 
         /// in itself, the specified collection, or both.
         /// </summary>
+        /// <param name="set">this <see cref="CharArraySet"/></param>
         /// <param name="other">The collection whose elements should be merged into the <see cref="CharArraySet"/>.</param>
         /// <returns><c>true</c> if this <see cref="CharArraySet"/> changed as a result of the call</returns>
         public static bool UnionWith(this CharArraySet set, IEnumerable<short> other)
@@ -1356,6 +1362,7 @@ namespace Lucene.Net.Analysis.Util
         /// Modifies the current <see cref="CharArraySet"/> to contain all elements that are present 
         /// in itself, the specified collection, or both.
         /// </summary>
+        /// <param name="set">this <see cref="CharArraySet"/></param>
         /// <param name="other">The collection whose elements should be merged into the <see cref="CharArraySet"/>.</param>
         /// <returns><c>true</c> if this <see cref="CharArraySet"/> changed as a result of the call</returns>
         [CLSCompliant(false)]
@@ -1384,6 +1391,7 @@ namespace Lucene.Net.Analysis.Util
         /// Modifies the current <see cref="CharArraySet"/> to contain all elements that are present 
         /// in itself, the specified collection, or both.
         /// </summary>
+        /// <param name="set">this <see cref="CharArraySet"/></param>
         /// <param name="other">The collection whose elements should be merged into the <see cref="CharArraySet"/>.</param>
         /// <returns><c>true</c> if this <see cref="CharArraySet"/> changed as a result of the call</returns>
         [CLSCompliant(false)]
@@ -1412,6 +1420,7 @@ namespace Lucene.Net.Analysis.Util
         /// Modifies the current <see cref="CharArraySet"/> to contain all elements that are present 
         /// in itself, the specified collection, or both.
         /// </summary>
+        /// <param name="set">this <see cref="CharArraySet"/></param>
         /// <param name="other">The collection whose elements should be merged into the <see cref="CharArraySet"/>.</param>
         /// <returns><c>true</c> if this <see cref="CharArraySet"/> changed as a result of the call</returns>
         [CLSCompliant(false)]


Mime
View raw message