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 <[email protected]> Authored: Sat Feb 4 18:30:43 2017 +0700 Committer: Shad Storhaug <[email protected]> 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)]
