lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [29/48] lucenenet git commit: Lucene.Net.Support: Fixed XML documentation comment warnings (except types that are not yet documented).
Date Tue, 06 Jun 2017 00:12:02 GMT
Lucene.Net.Support: Fixed XML documentation comment warnings (except types that are not yet
documented).


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

Branch: refs/heads/master
Commit: 7303348a1d4b915e91ee02a1d28ec63100c61e72
Parents: 268e78d
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Sun Jun 4 23:40:19 2017 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Mon Jun 5 06:16:25 2017 +0700

----------------------------------------------------------------------
 CONTRIBUTING.md                                 |  7 +++---
 src/Lucene.Net/Support/Arrays.cs                |  2 +-
 src/Lucene.Net/Support/BitArrayExtensions.cs    |  2 +-
 src/Lucene.Net/Support/Character.cs             |  6 ++---
 src/Lucene.Net/Support/EquatableList.cs         | 13 +++++-----
 src/Lucene.Net/Support/EquatableSet.cs          | 15 +++++------
 src/Lucene.Net/Support/IO/ByteBuffer.cs         | 26 ++++++++++----------
 src/Lucene.Net/Support/IO/DataInputStream.cs    |  2 +-
 src/Lucene.Net/Support/IO/DataOutputStream.cs   |  2 +-
 src/Lucene.Net/Support/IO/FileSupport.cs        |  2 +-
 .../Support/IndexWriterConfigExtensions.cs      |  2 +-
 src/Lucene.Net/Support/ListExtensions.cs        |  3 ++-
 src/Lucene.Net/Support/PriorityQueue.cs         | 10 +++-----
 src/Lucene.Net/Support/StringExtensions.cs      |  2 +-
 14 files changed, 47 insertions(+), 47 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/7303348a/CONTRIBUTING.md
----------------------------------------------------------------------
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 9fb8f3c..0f04d03 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -52,10 +52,9 @@ helpers to help with that, see for examples see our [Java style methods
to avoid
 
 1. Lucene.Net.Core (project)
    1. Codecs (namespace)
-   2. Support (namespace)
-   3. Util.Automaton (namespace)
-   4. Util.Mutable (namespace)
-   5. Util.Packed (namespace)
+   2. Util.Automaton (namespace)
+   3. Util.Mutable (namespace)
+   4. Util.Packed (namespace)
 2. Lucene.Net.Codecs (project)
 
 See [Documenting Lucene.Net](https://cwiki.apache.org/confluence/display/LUCENENET/Documenting+Lucene.Net)
for instructions. 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/7303348a/src/Lucene.Net/Support/Arrays.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Support/Arrays.cs b/src/Lucene.Net/Support/Arrays.cs
index 01f179a..1d7a6c7 100644
--- a/src/Lucene.Net/Support/Arrays.cs
+++ b/src/Lucene.Net/Support/Arrays.cs
@@ -107,7 +107,7 @@ namespace Lucene.Net.Support
         /// the same order. Also, two array references are considered equal if
         /// both are null.
         /// <para/>
-        /// Note that if the type of <paramref name="T"/> is a <see cref="IDictionary{TKey,
TValue}"/>,
+        /// Note that if the type of <typeparam name="T"/> is a <see cref="IDictionary{TKey,
TValue}"/>,
         /// <see cref="IList{T}"/>, or <see cref="ISet{T}"/>, its values and
any nested collection values
         /// will be compared for equality as well.
         /// </returns>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/7303348a/src/Lucene.Net/Support/BitArrayExtensions.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Support/BitArrayExtensions.cs b/src/Lucene.Net/Support/BitArrayExtensions.cs
index 70bde6b..21e322d 100644
--- a/src/Lucene.Net/Support/BitArrayExtensions.cs
+++ b/src/Lucene.Net/Support/BitArrayExtensions.cs
@@ -169,7 +169,7 @@ namespace Lucene.Net.Support
         }
 
         /// <summary>
-        /// Sets the bit at the given <paramref name="index"/> to true.
+        /// Sets the bit at the given index range to true.
         /// </summary>
         /// <param name="bits">The BitArray object.</param>
         /// <param name="fromIndex">The start of the range to set(inclusive)</param>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/7303348a/src/Lucene.Net/Support/Character.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Support/Character.cs b/src/Lucene.Net/Support/Character.cs
index 03192f4..81fdffb 100644
--- a/src/Lucene.Net/Support/Character.cs
+++ b/src/Lucene.Net/Support/Character.cs
@@ -378,7 +378,7 @@ namespace Lucene.Net.Support
         }
 
         /// <summary>
-        /// LUCENENET safe way to get unicode category. The .NET <seealso cref="char.ConvertFromUtf32(int)"/>
+        /// LUCENENET safe way to get unicode category. The .NET <see cref="char.ConvertFromUtf32(int)"/>
         /// method should be used first to be safe for surrogate pairs. However, if the value
falls between
         /// 0x00d800 and 0x00dfff, that method throws an exception. So this is a wrapper
that converts the
         /// codepoint to a char in those cases.
@@ -386,8 +386,8 @@ namespace Lucene.Net.Support
         /// This mimics the behavior of the Java Character.GetType class, but returns the
.NET UnicodeCategory
         /// enumeration for easy consumption.
         /// </summary>
-        /// <param name="c"></param>
-        /// <returns></returns>
+        /// <param name="codePoint"></param>
+        /// <returns> A <see cref="UnicodeCategory"/> representing the <paramref
name="codePoint"/>. </returns>
         public static UnicodeCategory GetType(int codePoint)
         {
             if ((codePoint >= 0x00d800) && (codePoint <= 0x00dfff))

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/7303348a/src/Lucene.Net/Support/EquatableList.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Support/EquatableList.cs b/src/Lucene.Net/Support/EquatableList.cs
index 422b61a..7dcc15d 100644
--- a/src/Lucene.Net/Support/EquatableList.cs
+++ b/src/Lucene.Net/Support/EquatableList.cs
@@ -58,7 +58,7 @@ namespace Lucene.Net.Support
         /// <see cref="EquatableList{T}.EquatableList(IEnumerable{T})"/> overload).

         /// <para/>
         /// The internal <paramref name="collection"/> is used for
-        /// all operations except for <see cref="Equals()"/>, <see cref="GetHashCode()"/>,
+        /// all operations except for <see cref="Equals(object)"/>, <see cref="GetHashCode()"/>,
         /// and <see cref="ToString()"/>, which are all based on deep analysis
         /// of this collection and any nested collections.
         /// </summary>
@@ -85,7 +85,8 @@ namespace Lucene.Net.Support
         /// Initializes a new 
         /// instance of the <see cref="EquatableList{T}"/>
         /// class that contains elements copied from the specified collection and has
-        /// sufficient capacity to accommodate the number of elements copied. 
+        /// sufficient capacity to accommodate the number of elements copied.
+        /// </summary>
         /// <param name="collection">The collection whose elements are copied to the
new list.</param>
         public EquatableList(IEnumerable<T> collection)
         {
@@ -338,17 +339,17 @@ namespace Lucene.Net.Support
         /// Therefore, <see cref="EquatableList{T}"/> can equal any <see cref="IList{T}"/>
         /// with the exact same values in the same order.
         /// </summary>
-        /// <param name="obj">The other object
+        /// <param name="other">The other object
         /// to compare against.</param>
         /// <returns><c>true</c> if the sequence in <paramref name="other"/>
         /// is the same as this one.</returns>
-        public override bool Equals(object obj)
+        public override bool Equals(object other)
         {
-            if (!(obj is IList<T>))
+            if (!(other is IList<T>))
             {
                 return false;
             }
-            return this.Equals(obj as IList<T>);
+            return this.Equals(other as IList<T>);
         }
 
         /// <summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/7303348a/src/Lucene.Net/Support/EquatableSet.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Support/EquatableSet.cs b/src/Lucene.Net/Support/EquatableSet.cs
index a209fdd..d5efcb8 100644
--- a/src/Lucene.Net/Support/EquatableSet.cs
+++ b/src/Lucene.Net/Support/EquatableSet.cs
@@ -58,7 +58,7 @@ namespace Lucene.Net.Support
         /// <see cref="EquatableSet{T}.EquatableSet(ICollection{T})"/> overload). 
         /// <para/>
         /// The internal <paramref name="collection"/> is used for
-        /// all operations except for <see cref="Equals()"/>, <see cref="GetHashCode()"/>,
+        /// all operations except for <see cref="Equals(object)"/>, <see cref="GetHashCode()"/>,
         /// and <see cref="ToString()"/>, which are all based on deep analysis
         /// of this collection and any nested collections.
         /// </summary>
@@ -85,7 +85,8 @@ namespace Lucene.Net.Support
         /// Initializes a new 
         /// instance of the <see cref="EquatableSet{T}"/>
         /// class that contains elements copied from the specified collection and has
-        /// sufficient capacity to accommodate the number of elements copied. 
+        /// sufficient capacity to accommodate the number of elements copied.
+        /// </summary>
         /// <param name="collection">The collection whose elements are copied to the
new set.</param>
         public EquatableSet(ICollection<T> collection)
         {
@@ -380,7 +381,7 @@ namespace Lucene.Net.Support
         /// Therefore, <see cref="EquatableSet{T}"/> can equal any <see cref="ISet{T}"/>
         /// with the exact same values (in any order).
         /// </summary>
-        /// <param name="obj">The other object
+        /// <param name="other">The other object
         /// to compare against.</param>
         /// <returns><c>true</c> if the sequence in <paramref name="other"/>
         /// is the same as this one.</returns>
@@ -417,17 +418,17 @@ namespace Lucene.Net.Support
         /// Therefore, <see cref="EquatableSet{T}"/> can equal any <see cref="ISet{T}"/>
         /// with the exact same values (in any order).
         /// </summary>
-        /// <param name="obj">The other object
+        /// <param name="other">The other object
         /// to compare against.</param>
         /// <returns><c>true</c> if the sequence in <paramref name="other"/>
         /// is the same as this one.</returns>
-        public override bool Equals(object obj)
+        public override bool Equals(object other)
         {
-            if (!(obj is ISet<T>))
+            if (!(other is ISet<T>))
             {
                 return false;
             }
-            return Equals(obj as ISet<T>);
+            return Equals(other as ISet<T>);
         }
 
         /// <summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/7303348a/src/Lucene.Net/Support/IO/ByteBuffer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Support/IO/ByteBuffer.cs b/src/Lucene.Net/Support/IO/ByteBuffer.cs
index 709d1aa..f2056f2 100644
--- a/src/Lucene.Net/Support/IO/ByteBuffer.cs
+++ b/src/Lucene.Net/Support/IO/ByteBuffer.cs
@@ -194,7 +194,7 @@ namespace Lucene.Net.Support.IO
         /// <para/>
         /// The remaining bytes will be moved to the head of the
         /// buffer, starting from position zero. Then the position is set to
-        /// <see cref="Remaining"/>; the limit is set to capacity; the mark is
+        /// <see cref="Buffer.Remaining"/>; the limit is set to capacity; the mark
is
         /// cleared.
         /// </summary>
         /// <returns>this buffer.</returns>
@@ -303,7 +303,7 @@ namespace Lucene.Net.Support.IO
         /// </summary>
         /// <param name="dest">the destination byte array.</param>
         /// <returns>this buffer.</returns>
-        /// <exception cref="BufferUnderflowException">if <c>dest.Length</c>
is greater than <see cref="Remaining"/>.</exception>
+        /// <exception cref="BufferUnderflowException">if <c>dest.Length</c>
is greater than <see cref="Buffer.Remaining"/>.</exception>
         public virtual ByteBuffer Get(byte[] dest)
         {
             return Get(dest, 0, dest.Length);
@@ -324,7 +324,7 @@ namespace Lucene.Net.Support.IO
         /// </param>
         /// <returns>this buffer.</returns>
         /// <exception cref="IndexOutOfRangeException">if either <paramref name="off"/>
or <paramref name="len"/> is invalid.</exception>
-        /// <exception cref="BufferUnderflowException">if <paramref name="len"/>
is greater than <see cref="Remaining"/>.</exception>
+        /// <exception cref="BufferUnderflowException">if <paramref name="len"/>
is greater than <see cref="Buffer.Remaining"/>.</exception>
         public virtual ByteBuffer Get(byte[] dest, int off, int len)
         {
             int length = dest.Length;
@@ -602,7 +602,7 @@ namespace Lucene.Net.Support.IO
         /// </summary>
         /// <param name="src">the source byte array.</param>
         /// <returns>this buffer.</returns>
-        /// <exception cref="BufferOverflowException">if <see cref="Remaining"/>
is less than <c>src.Length</c>.</exception>
+        /// <exception cref="BufferOverflowException">if <see cref="Buffer.Remaining"/>
is less than <c>src.Length</c>.</exception>
         /// <exception cref="ReadOnlyBufferException">if no changes may be made to
the contents of this buffer.</exception>
         public ByteBuffer Put(byte[] src)
         {
@@ -624,7 +624,7 @@ namespace Lucene.Net.Support.IO
         /// greater than <c>src.Length - off</c>.
         /// </param>
         /// <returns>this buffer.</returns>
-        /// <exception cref="BufferOverflowException">if <see cref="Remaining"/>
is less than <paramref name="len"/>.</exception>
+        /// <exception cref="BufferOverflowException">if <see cref="Buffer.Remaining"/>
is less than <paramref name="len"/>.</exception>
         /// <exception cref="IndexOutOfRangeException">if either <paramref name="off"/>
or <paramref name="len"/> is invalid.</exception>
         /// <exception cref="ReadOnlyBufferException">if no changes may be made to
the contents of this buffer.</exception>
         public virtual ByteBuffer Put(byte[] src, int off, int len)
@@ -653,7 +653,7 @@ namespace Lucene.Net.Support.IO
         /// </summary>
         /// <param name="src">the source byte buffer.</param>
         /// <returns>this buffer.</returns>
-        /// <exception cref="BufferOverflowException">if <c>src.Remaining</c>
is greater than this buffer's <see cref="Remaining"/>.</exception>
+        /// <exception cref="BufferOverflowException">if <c>src.Remaining</c>
is greater than this buffer's <see cref="Buffer.Remaining"/>.</exception>
         /// <exception cref="ArgumentException">if <paramref name="src"/> is
this buffer.</exception>
         /// <exception cref="ReadOnlyBufferException">if no changes may be made to
the contents of this buffer.</exception>
         public virtual ByteBuffer Put(ByteBuffer src)
@@ -704,7 +704,7 @@ namespace Lucene.Net.Support.IO
         /// <param name="index">the index, must not be negative and equal or less than
<c>limit - 2</c>.</param>
         /// <param name="value">the <see cref="char"/> to write.</param>
         /// <returns>this buffer.</returns>
-        /// <exception cref="IndexOutOfRangeException">if <paramref name=""index/>
is invalid.</exception>
+        /// <exception cref="IndexOutOfRangeException">if <paramref name="index"/>
is invalid.</exception>
         /// <exception cref="ReadOnlyBufferException">if no changes may be made to
the contents of this buffer.</exception>
         public abstract ByteBuffer PutChar(int index, char value);
 
@@ -729,7 +729,7 @@ namespace Lucene.Net.Support.IO
         /// <param name="index">the index, must not be negative and equal or less than
<c>limit - 8</c>.</param>
         /// <param name="value">the <see cref="double"/> to write.</param>
         /// <returns></returns>
-        /// <exception cref="IndexOutOfRangeException">if <paramref name=""index/>
is invalid.</exception>
+        /// <exception cref="IndexOutOfRangeException">if <paramref name="index"/>
is invalid.</exception>
         /// <exception cref="ReadOnlyBufferException">if no changes may be made to
the contents of this buffer.</exception>
         public abstract ByteBuffer PutDouble(int index, double value);
 
@@ -758,7 +758,7 @@ namespace Lucene.Net.Support.IO
         /// <param name="index">the index, must not be negative and equal or less than
<c>limit - 4</c>.</param>
         /// <param name="value">the <see cref="float"/> to write.</param>
         /// <returns></returns>
-        /// <exception cref="IndexOutOfRangeException">if <paramref name=""index/>
is invalid.</exception>
+        /// <exception cref="IndexOutOfRangeException">if <paramref name="index"/>
is invalid.</exception>
         /// <exception cref="ReadOnlyBufferException">if no changes may be made to
the contents of this buffer.</exception>
         public abstract ByteBuffer PutSingle(int index, float value);
 
@@ -787,7 +787,7 @@ namespace Lucene.Net.Support.IO
         /// <param name="index">the index, must not be negative and equal or less than
<c>limit - 4</c>.</param>
         /// <param name="value">the <see cref="int"/> to write.</param>
         /// <returns>this buffer.</returns>
-        /// <exception cref="IndexOutOfRangeException">if <paramref name=""index/>
is invalid.</exception>
+        /// <exception cref="IndexOutOfRangeException">if <paramref name="index"/>
is invalid.</exception>
         /// <exception cref="ReadOnlyBufferException">if no changes may be made to
the contents of this buffer.</exception>
         public abstract ByteBuffer PutInt32(int index, int value);
 
@@ -816,7 +816,7 @@ namespace Lucene.Net.Support.IO
         /// <param name="index">the index, must not be negative and equal or less than
<c>limit - 8</c>.</param>
         /// <param name="value">the <see cref="long"/> to write.</param>
         /// <returns>this buffer.</returns>
-        /// <exception cref="IndexOutOfRangeException">if <paramref name=""index/>
is invalid.</exception>
+        /// <exception cref="IndexOutOfRangeException">if <paramref name="index"/>
is invalid.</exception>
         /// <exception cref="ReadOnlyBufferException">if no changes may be made to
the contents of this buffer.</exception>
         public abstract ByteBuffer PutInt64(int index, long value);
 
@@ -845,7 +845,7 @@ namespace Lucene.Net.Support.IO
         /// <param name="index">the index, must not be negative and equal or less than
<c>limit - 2</c>.</param>
         /// <param name="value">the <see cref="short"/> to write.</param>
         /// <returns>this buffer.</returns>
-        /// <exception cref="IndexOutOfRangeException">if <paramref name=""index/>
is invalid.</exception>
+        /// <exception cref="IndexOutOfRangeException">if <paramref name="index"/>
is invalid.</exception>
         /// <exception cref="ReadOnlyBufferException">if no changes may be made to
the contents of this buffer.</exception>
         public abstract ByteBuffer PutInt16(int index, short value);
 
@@ -853,7 +853,7 @@ namespace Lucene.Net.Support.IO
         /// Returns a sliced buffer that shares its content with this buffer.
         /// <para/>
         /// The sliced buffer's capacity will be this buffer's
-        /// <see cref="Remaining"/>, and it's zero position will correspond to
+        /// <see cref="Buffer.Remaining"/>, and it's zero position will correspond
to
         /// this buffer's current position. The new buffer's position will be 0,
         /// limit will be its capacity, and its mark is cleared. The new buffer's
         /// read-only property and byte order are the same as this buffer's.

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/7303348a/src/Lucene.Net/Support/IO/DataInputStream.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Support/IO/DataInputStream.cs b/src/Lucene.Net/Support/IO/DataInputStream.cs
index 8054746..3a7dbdf 100644
--- a/src/Lucene.Net/Support/IO/DataInputStream.cs
+++ b/src/Lucene.Net/Support/IO/DataInputStream.cs
@@ -29,7 +29,7 @@ namespace Lucene.Net.Support.IO
     /// This is a port of DataInputStream that is fully compatible with Java's DataOutputStream.
     /// <para>
     /// Usage Note: Always favor BinaryReader over DataInputStream unless you specifically
need
-    /// the modified UTF-8 format and/or the <see cref="ReadUTF(IDataInput)"/> method.
+    /// the modified UTF-8 format and/or the <see cref="ReadUTF()"/> or <see cref="DecodeUTF(int)"/>
method.
     /// </para>
     /// </summary>
     public class DataInputStream : IDataInput, IDisposable

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/7303348a/src/Lucene.Net/Support/IO/DataOutputStream.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Support/IO/DataOutputStream.cs b/src/Lucene.Net/Support/IO/DataOutputStream.cs
index 13515da..3680347 100644
--- a/src/Lucene.Net/Support/IO/DataOutputStream.cs
+++ b/src/Lucene.Net/Support/IO/DataOutputStream.cs
@@ -29,7 +29,7 @@ namespace Lucene.Net.Support.IO
     /// This is a port of DataOutputStream that is fully compatible with Java's DataInputStream.
     /// <para>
     /// Usage Note: Always favor BinaryWriter over DataOutputStream unless you specifically
need
-    /// the modified UTF-8 format and/or the <see cref="WriteUTF(IDataOutput)"/> method.
+    /// the modified UTF-8 format and/or the <see cref="WriteUTF(string)"/> method.
     /// </para>
     /// </summary>
     public class DataOutputStream : IDataOutput, IDisposable

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/7303348a/src/Lucene.Net/Support/IO/FileSupport.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Support/IO/FileSupport.cs b/src/Lucene.Net/Support/IO/FileSupport.cs
index 90f470a..4724b26 100644
--- a/src/Lucene.Net/Support/IO/FileSupport.cs
+++ b/src/Lucene.Net/Support/IO/FileSupport.cs
@@ -208,7 +208,7 @@ namespace Lucene.Net.Support.IO
 
         /// <summary>
         /// Generates a new random file name with the provided <paramref name="directory"/>,

-        /// <paramref name="prefix"/> and optional <see cref="suffix"/>.
+        /// <paramref name="prefix"/> and optional <paramref name="suffix"/>.
         /// </summary>
         /// <param name="prefix">The prefix string to be used in generating the file's
name</param>
         /// <param name="suffix">The suffix string to be used in generating the file's
name; may be null, in which case a random suffix will be generated</param>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/7303348a/src/Lucene.Net/Support/IndexWriterConfigExtensions.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Support/IndexWriterConfigExtensions.cs b/src/Lucene.Net/Support/IndexWriterConfigExtensions.cs
index 0311eef..522cd8c 100644
--- a/src/Lucene.Net/Support/IndexWriterConfigExtensions.cs
+++ b/src/Lucene.Net/Support/IndexWriterConfigExtensions.cs
@@ -91,7 +91,7 @@ namespace Lucene.Net.Support
         }
 
         /// <summary>
-        /// Builder method for <see cref="LiveLiveIndexWriterConfig.ReaderTermsIndexDivisor"/>.
+        /// Builder method for <see cref="LiveIndexWriterConfig.ReaderTermsIndexDivisor"/>.
         /// </summary>
         /// <param name="config">this <see cref="LiveIndexWriterConfig"/> instance</param>
         /// <param name="divisor"></param>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/7303348a/src/Lucene.Net/Support/ListExtensions.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Support/ListExtensions.cs b/src/Lucene.Net/Support/ListExtensions.cs
index 647f386..86fdddf 100644
--- a/src/Lucene.Net/Support/ListExtensions.cs
+++ b/src/Lucene.Net/Support/ListExtensions.cs
@@ -59,7 +59,7 @@ namespace Lucene.Net.Support
 
         /// <summary>
         /// If the underlying type is <see cref="List{T}"/>,
-        /// calls <see cref="List{T}.Sort"/>. If not, 
+        /// calls <see cref="List{T}.Sort()"/>. If not, 
         /// uses <see cref="Util.CollectionUtil.TimSort{T}(IList{T})"/>
         /// </summary>
         /// <typeparam name="T"></typeparam>
@@ -135,6 +135,7 @@ namespace Lucene.Net.Support
             Util.CollectionUtil.TimSort(list, comparer);
         }
 
+        /// <summary>
         /// Sorts the given <see cref="IList{T}"/> using the <see cref="IComparer{T}"/>.
         /// This method uses the intro sort
         /// algorithm, but falls back to insertion sort for small lists. 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/7303348a/src/Lucene.Net/Support/PriorityQueue.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Support/PriorityQueue.cs b/src/Lucene.Net/Support/PriorityQueue.cs
index 89d56e6..86b97bc 100644
--- a/src/Lucene.Net/Support/PriorityQueue.cs
+++ b/src/Lucene.Net/Support/PriorityQueue.cs
@@ -187,9 +187,8 @@ namespace Lucene.Net.Support
         /// cannot be compared to one another according to <paramref name="collection"/>'s
         /// ordering
         /// </exception>
-        /// <see cref="ArgumentNullException">if the specified collection or any
-        /// of its elements are null</see>
-        /// </summary>
+        /// <exception cref="ArgumentNullException">if the specified collection or
any
+        /// of its elements are null</exception>
         public PriorityQueue(SortedSet<T> collection)
         {
             if (collection == null)
@@ -215,9 +214,8 @@ namespace Lucene.Net.Support
         /// cannot be compared to one another according to <paramref name="collection"/>'s
         /// ordering
         /// </exception>
-        /// <see cref="ArgumentNullException">if the specified collection or any
-        /// of its elements are null</see>
-        /// </summary>
+        /// <exception cref="ArgumentNullException">if the specified collection or
any
+        /// of its elements are null</exception>
         public PriorityQueue(TreeSet<T> collection)
         {
             if (collection == null)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/7303348a/src/Lucene.Net/Support/StringExtensions.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Support/StringExtensions.cs b/src/Lucene.Net/Support/StringExtensions.cs
index e8513f9..3828a72 100644
--- a/src/Lucene.Net/Support/StringExtensions.cs
+++ b/src/Lucene.Net/Support/StringExtensions.cs
@@ -41,7 +41,7 @@ namespace Lucene.Net.Support
         /// </list>
         /// This method is a convenience to replace the .NET CompareTo method 
         /// on all strings, provided the logic does not expect specific values
-        /// but is simply comparing them with <code>></code> or <code><</code>.
+        /// but is simply comparing them with <c>&gt;</c> or <c>&lt;</c>.
         /// </summary>
         /// <param name="str"></param>
         /// <param name="value">The string to compare with.</param>


Mime
View raw message