lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [08/48] lucenenet git commit: Lucene.Net.Search: Fixed up documentation comments
Date Tue, 06 Jun 2017 00:11:41 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/FieldComparator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/FieldComparator.cs b/src/Lucene.Net/Search/FieldComparator.cs
index dd7b64e..1ff68b3 100644
--- a/src/Lucene.Net/Search/FieldComparator.cs
+++ b/src/Lucene.Net/Search/FieldComparator.cs
@@ -30,66 +30,63 @@ namespace Lucene.Net.Search
     using SortedDocValues = Lucene.Net.Index.SortedDocValues;
 
     /// <summary>
-    /// Expert: a FieldComparer compares hits so as to determine their
-    /// sort order when collecting the top results with {@link
-    /// TopFieldCollector}.  The concrete public FieldComparer
-    /// classes here correspond to the SortField types.
+    /// Expert: a <see cref="FieldComparer"/> compares hits so as to determine their
+    /// sort order when collecting the top results with
+    /// <see cref="TopFieldCollector"/>.  The concrete public <see cref="FieldComparer"/>
+    /// classes here correspond to the <see cref="SortField"/> types.
     ///
-    /// <p>this API is designed to achieve high performance
-    /// sorting, by exposing a tight interaction with {@link
-    /// FieldValueHitQueue} as it visits hits.  Whenever a hit is
+    /// <para>This API is designed to achieve high performance
+    /// sorting, by exposing a tight interaction with 
+    /// <see cref="FieldValueHitQueue"/> as it visits hits.  Whenever a hit is
     /// competitive, it's enrolled into a virtual slot, which is
-    /// an int ranging from 0 to numHits-1.  The {@link
-    /// FieldComparer} is made aware of segment transitions
+    /// an <see cref="int"/> ranging from 0 to numHits-1.  The 
+    /// <see cref="FieldComparer"/> is made aware of segment transitions
     /// during searching in case any internal state it's tracking
-    /// needs to be recomputed during these transitions.</p>
+    /// needs to be recomputed during these transitions.</para>
     ///
-    /// <p>A comparer must define these functions:</p>
+    /// <para>A comparer must define these functions:</para>
     ///
-    /// <ul>
+    /// <list type="bullet">
     ///
-    ///  <li> <seealso cref="#compare"/> Compare a hit at 'slot a'
-    ///       with hit 'slot b'.
+    ///  <item><term><see cref="Compare(int, int)"/></term> <description> Compare a hit at 'slot a'
+    ///       with hit 'slot b'.</description></item>
     ///
-    ///  <li> <seealso cref="#setBottom"/> this method is called by
-    ///       <seealso cref="FieldValueHitQueue"/> to notify the
-    ///       FieldComparer of the current weakest ("bottom")
+    ///  <item><term><see cref="SetBottom(int)"/></term> <description>This method is called by
+    ///       <see cref="FieldValueHitQueue"/> to notify the
+    ///       <see cref="FieldComparer"/> of the current weakest ("bottom")
     ///       slot.  Note that this slot may not hold the weakest
     ///       value according to your comparer, in cases where
     ///       your comparer is not the primary one (ie, is only
-    ///       used to break ties from the comparers before it).
+    ///       used to break ties from the comparers before it).</description></item>
     ///
-    ///  <li> <seealso cref="#compareBottom"/> Compare a new hit (docID)
-    ///       against the "weakest" (bottom) entry in the queue.
+    ///  <item><term><see cref="CompareBottom(int)"/></term> <description>Compare a new hit (docID)
+    ///       against the "weakest" (bottom) entry in the queue.</description></item>
     ///
-    ///  <li> <seealso cref="#setTopValue"/> this method is called by
-    ///       <seealso cref="TopFieldCollector"/> to notify the
-    ///       FieldComparer of the top most value, which is
-    ///       used by future calls to <seealso cref="#compareTop"/>.
+    ///  <item><term><see cref="SetTopValue(object)"/></term> <description>This method is called by
+    ///       <see cref="TopFieldCollector"/> to notify the
+    ///       <see cref="FieldComparer"/> of the top most value, which is
+    ///       used by future calls to <see cref="CompareTop(int)"/>.</description></item>
     ///
-    ///  <li> <seealso cref="#compareBottom"/> Compare a new hit (docID)
-    ///       against the "weakest" (bottom) entry in the queue.
-    ///
-    ///  <li> <seealso cref="#compareTop"/> Compare a new hit (docID)
+    ///  <item><term><see cref="CompareTop(int)"/></term> <description>Compare a new hit (docID)
     ///       against the top value previously set by a call to
-    ///       <seealso cref="#setTopValue"/>.
+    ///       <see cref="SetTopValue(object)"/>.</description></item>
     ///
-    ///  <li> <seealso cref="#copy"/> Installs a new hit into the
-    ///       priority queue.  The <seealso cref="FieldValueHitQueue"/>
-    ///       calls this method when a new hit is competitive.
+    ///  <item><term><see cref="Copy(int, int)"/></term> <description>Installs a new hit into the
+    ///       priority queue.  The <see cref="FieldValueHitQueue"/>
+    ///       calls this method when a new hit is competitive.</description></item>
     ///
-    ///  <li> <seealso cref="#setNextReader(AtomicReaderContext)"/> Invoked
+    ///  <item><term><see cref="SetNextReader(AtomicReaderContext)"/></term> <description>Invoked
     ///       when the search is switching to the next segment.
     ///       You may need to update internal state of the
     ///       comparer, for example retrieving new values from
-    ///       the <seealso cref="IFieldCache"/>.
-    ///
-    ///  <li> <seealso cref="#value"/> Return the sort value stored in
-    ///       the specified slot.  this is only called at the end
-    ///       of the search, in order to populate {@link
-    ///       FieldDoc#fields} when returning the top results.
-    /// </ul>
+    ///       the <see cref="IFieldCache"/>.</description></item>
     ///
+    ///  <item><term><see cref="FieldComparer.this[int]"/></term> <description>Return the sort value stored in
+    ///       the specified slot.  This is only called at the end
+    ///       of the search, in order to populate
+    ///       <see cref="FieldDoc.Fields"/> when returning the top results.</description></item>
+    /// </list>
+    /// <para/>
     /// @lucene.experimental
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -98,93 +95,93 @@ namespace Lucene.Net.Search
     public abstract class FieldComparer<T> : FieldComparer
     {
         /// <summary>
-        /// Compare hit at slot1 with hit at slot2.
+        /// Compare hit at <paramref name="slot1"/> with hit at <paramref name="slot2"/>.
         /// </summary>
         /// <param name="slot1"> first slot to compare </param>
         /// <param name="slot2"> second slot to compare </param>
-        /// <returns> any N < 0 if slot2's value is sorted after
-        /// slot1, any N > 0 if the slot2's value is sorted before
-        /// slot1 and 0 if they are equal </returns>
+        /// <returns> any N &lt; 0 if <paramref name="slot2"/>'s value is sorted after
+        /// <paramref name="slot1"/>, any N &gt; 0 if the <paramref name="slot2"/>'s value is sorted before
+        /// <paramref name="slot1"/> and 0 if they are equal </returns>
         public abstract override int Compare(int slot1, int slot2);
 
         /// <summary>
         /// Set the bottom slot, ie the "weakest" (sorted last)
-        /// entry in the queue.  When <seealso cref="#compareBottom"/> is
-        /// called, you should compare against this slot.  this
-        /// will always be called before <seealso cref="#compareBottom"/>.
+        /// entry in the queue.  When <see cref="CompareBottom(int)"/> is
+        /// called, you should compare against this slot.  This
+        /// will always be called before <see cref="CompareBottom(int)"/>.
         /// </summary>
         /// <param name="slot"> the currently weakest (sorted last) slot in the queue </param>
         public abstract override void SetBottom(int slot);
 
         /// <summary>
-        /// Record the top value, for future calls to {@link
-        /// #compareTop}.  this is only called for searches that
-        /// use searchAfter (deep paging), and is called before any
-        /// calls to <seealso cref="#setNextReader"/>.
+        /// Record the top value, for future calls to 
+        /// <see cref="CompareTop(int)"/>.  This is only called for searches that
+        /// use SearchAfter (deep paging), and is called before any
+        /// calls to <see cref="SetNextReader(AtomicReaderContext)"/>.
         /// </summary>
         public abstract override void SetTopValue(object value);
 
         /// <summary>
-        /// Compare the bottom of the queue with this doc.  this will
-        /// only invoked after setBottom has been called.  this
-        /// should return the same result as {@link
-        /// #compare(int,int)}} as if bottom were slot1 and the new
+        /// Compare the bottom of the queue with this doc.  This will
+        /// only invoked after <see cref="SetBottom(int)"/> has been called.  This
+        /// should return the same result as 
+        /// <see cref="Compare(int, int)"/> as if bottom were slot1 and the new
         /// document were slot 2.
         ///
-        /// <p>For a search that hits many results, this method
+        /// <para>For a search that hits many results, this method
         /// will be the hotspot (invoked by far the most
-        /// frequently).</p>
+        /// frequently).</para>
         /// </summary>
-        /// <param name="doc"> that was hit </param>
-        /// <returns> any N < 0 if the doc's value is sorted after
-        /// the bottom entry (not competitive), any N > 0 if the
+        /// <param name="doc"> Doc that was hit </param>
+        /// <returns> Any N &lt; 0 if the doc's value is sorted after
+        /// the bottom entry (not competitive), any N &gt; 0 if the
         /// doc's value is sorted before the bottom entry and 0 if
         /// they are equal. </returns>
         public abstract override int CompareBottom(int doc);
 
         /// <summary>
-        /// Compare the top value with this doc.  this will
-        /// only invoked after setTopValue has been called.  this
-        /// should return the same result as {@link
-        /// #compare(int,int)}} as if topValue were slot1 and the new
-        /// document were slot 2.  this is only called for searches that
-        /// use searchAfter (deep paging).
+        /// Compare the top value with this doc.  This will
+        /// only invoked after <see cref="SetTopValue(object)"/> has been called.  This
+        /// should return the same result as 
+        /// <see cref="Compare(int, int)"/> as if topValue were slot1 and the new
+        /// document were slot 2.  This is only called for searches that
+        /// use SearchAfter (deep paging).
         /// </summary>
-        /// <param name="doc"> that was hit </param>
-        /// <returns> any N < 0 if the doc's value is sorted after
-        /// the bottom entry (not competitive), any N > 0 if the
+        /// <param name="doc"> Doc that was hit </param>
+        /// <returns> Any N &lt; 0 if the doc's value is sorted after
+        /// the bottom entry (not competitive), any N &gt; 0 if the
         /// doc's value is sorted before the bottom entry and 0 if
         /// they are equal. </returns>
         public abstract override int CompareTop(int doc);
 
         /// <summary>
-        /// this method is called when a new hit is competitive.
+        /// This method is called when a new hit is competitive.
         /// You should copy any state associated with this document
         /// that will be required for future comparisons, into the
         /// specified slot.
         /// </summary>
-        /// <param name="slot"> which slot to copy the hit to </param>
-        /// <param name="doc"> docID relative to current reader </param>
+        /// <param name="slot"> Which slot to copy the hit to </param>
+        /// <param name="doc"> DocID relative to current reader </param>
         public abstract override void Copy(int slot, int doc);
 
         /// <summary>
-        /// Set a new <seealso cref="AtomicReaderContext"/>. All subsequent docIDs are relative to
+        /// Set a new <see cref="AtomicReaderContext"/>. All subsequent docIDs are relative to
         /// the current reader (you must add docBase if you need to
         /// map it to a top-level docID).
         /// </summary>
-        /// <param name="context"> current reader context </param>
-        /// <returns> the comparer to use for this segment; most
+        /// <param name="context"> Current reader context </param>
+        /// <returns> The comparer to use for this segment; most
         ///   comparers can just return "this" to reuse the same
         ///   comparer across segments </returns>
-        /// <exception cref="IOException"> if there is a low-level IO error </exception>
+        /// <exception cref="System.IO.IOException"> If there is a low-level IO error </exception>
         public abstract override FieldComparer SetNextReader(AtomicReaderContext context);
 
         /// <summary>
         /// Returns -1 if first is less than second.  Default
-        ///  impl to assume the type implements Comparable and
-        ///  invoke .compareTo; be sure to override this method if
-        ///  your FieldComparer's type isn't a Comparable or
-        ///  if your values may sometimes be null
+        /// impl to assume the type implements <see cref="IComparable{T}"/> and
+        /// invoke <see cref="IComparable{T}.CompareTo(T)"/>; be sure to override this method if
+        /// your FieldComparer's type isn't a <see cref="IComparable{T}"/> or
+        /// if your values may sometimes be <c>null</c>
         /// </summary>
         public virtual int CompareValues(T first, T second)
         {
@@ -204,6 +201,13 @@ namespace Lucene.Net.Search
             }
         }
 
+        /// <summary>
+        /// Returns -1 if first is less than second.  Default
+        /// impl to assume the type implements <see cref="IComparable{T}"/> and
+        /// invoke <see cref="IComparable{T}.CompareTo(T)"/>; be sure to override this method if
+        /// your FieldComparer's type isn't a <see cref="IComparable{T}"/> or
+        /// if your values may sometimes be <c>null</c>
+        /// </summary>
         public override int CompareValues(object first, object second)
         {
             return CompareValues((T)first, (T)second);
@@ -221,92 +225,92 @@ namespace Lucene.Net.Search
 
         //Set up abstract methods
         /// <summary>
-        /// Compare hit at slot1 with hit at slot2.
+        /// Compare hit at <paramref name="slot1"/> with hit at <paramref name="slot2"/>.
         /// </summary>
         /// <param name="slot1"> first slot to compare </param>
         /// <param name="slot2"> second slot to compare </param>
-        /// <returns> any N < 0 if slot2's value is sorted after
-        /// slot1, any N > 0 if the slot2's value is sorted before
-        /// slot1 and 0 if they are equal </returns>
+        /// <returns> any N &lt; 0 if <paramref name="slot2"/>'s value is sorted after
+        /// <paramref name="slot1"/>, any N &gt; 0 if the <paramref name="slot2"/>'s value is sorted before
+        /// <paramref name="slot1"/> and 0 if they are equal </returns>
         public abstract int Compare(int slot1, int slot2);
 
         /// <summary>
         /// Set the bottom slot, ie the "weakest" (sorted last)
-        /// entry in the queue.  When <seealso cref="#compareBottom"/> is
-        /// called, you should compare against this slot.  this
-        /// will always be called before <seealso cref="#compareBottom"/>.
+        /// entry in the queue.  When <see cref="CompareBottom(int)"/> is
+        /// called, you should compare against this slot.  This
+        /// will always be called before <see cref="CompareBottom(int)"/>.
         /// </summary>
-        /// <param name="slot"> the currently weakest (sorted last) slot in the queue </param>
+        /// <param name="slot"> The currently weakest (sorted last) slot in the queue </param>
         public abstract void SetBottom(int slot);
 
         /// <summary>
-        /// Record the top value, for future calls to {@link
-        /// #compareTop}.  this is only called for searches that
-        /// use searchAfter (deep paging), and is called before any
-        /// calls to <seealso cref="#setNextReader"/>.
+        /// Record the top value, for future calls to 
+        /// <see cref="CompareTop(int)"/>.  This is only called for searches that
+        /// use SearchAfter (deep paging), and is called before any
+        /// calls to <see cref="SetNextReader(AtomicReaderContext)"/>.
         /// </summary>
         public abstract void SetTopValue(object value);
 
         /// <summary>
-        /// Compare the bottom of the queue with this doc.  this will
-        /// only invoked after setBottom has been called.  this
-        /// should return the same result as {@link
-        /// #compare(int,int)}} as if bottom were slot1 and the new
+        /// Compare the bottom of the queue with this doc.  This will
+        /// only invoked after setBottom has been called.  This
+        /// should return the same result as 
+        /// <see cref="Compare(int, int)"/> as if bottom were slot1 and the new
         /// document were slot 2.
         ///
-        /// <p>For a search that hits many results, this method
+        /// <para>For a search that hits many results, this method
         /// will be the hotspot (invoked by far the most
-        /// frequently).</p>
+        /// frequently).</para>
         /// </summary>
-        /// <param name="doc"> that was hit </param>
-        /// <returns> any N < 0 if the doc's value is sorted after
-        /// the bottom entry (not competitive), any N > 0 if the
+        /// <param name="doc"> Doc that was hit </param>
+        /// <returns> Any N &lt; 0 if the doc's value is sorted after
+        /// the bottom entry (not competitive), any N &gt; 0 if the
         /// doc's value is sorted before the bottom entry and 0 if
         /// they are equal. </returns>
         public abstract int CompareBottom(int doc);
 
         /// <summary>
-        /// Compare the top value with this doc.  this will
-        /// only invoked after setTopValue has been called.  this
-        /// should return the same result as {@link
-        /// #compare(int,int)}} as if topValue were slot1 and the new
-        /// document were slot 2.  this is only called for searches that
-        /// use searchAfter (deep paging).
+        /// Compare the top value with this doc.  This will
+        /// only invoked after <see cref="SetTopValue(object)"/> has been called.  This
+        /// should return the same result as 
+        /// <see cref="Compare(int, int)"/> as if topValue were slot1 and the new
+        /// document were slot 2.  This is only called for searches that
+        /// use SearchAfter (deep paging).
         /// </summary>
-        /// <param name="doc"> that was hit </param>
-        /// <returns> any N < 0 if the doc's value is sorted after
-        /// the bottom entry (not competitive), any N > 0 if the
+        /// <param name="doc"> Doc that was hit </param>
+        /// <returns> Any N &lt; 0 if the doc's value is sorted after
+        /// the bottom entry (not competitive), any N &gt; 0 if the
         /// doc's value is sorted before the bottom entry and 0 if
         /// they are equal. </returns>
         public abstract int CompareTop(int doc);
 
         /// <summary>
-        /// this method is called when a new hit is competitive.
+        /// This method is called when a new hit is competitive.
         /// You should copy any state associated with this document
         /// that will be required for future comparisons, into the
         /// specified slot.
         /// </summary>
-        /// <param name="slot"> which slot to copy the hit to </param>
-        /// <param name="doc"> docID relative to current reader </param>
+        /// <param name="slot"> Which slot to copy the hit to </param>
+        /// <param name="doc"> DocID relative to current reader </param>
         public abstract void Copy(int slot, int doc);
 
         /// <summary>
-        /// Set a new <seealso cref="AtomicReaderContext"/>. All subsequent docIDs are relative to
+        /// Set a new <see cref="AtomicReaderContext"/>. All subsequent docIDs are relative to
         /// the current reader (you must add docBase if you need to
         /// map it to a top-level docID).
         /// </summary>
-        /// <param name="context"> current reader context </param>
-        /// <returns> the comparer to use for this segment; most
+        /// <param name="context"> Current reader context </param>
+        /// <returns> The comparer to use for this segment; most
         ///   comparers can just return "this" to reuse the same
         ///   comparer across segments </returns>
-        /// <exception cref="IOException"> if there is a low-level IO error </exception>
+        /// <exception cref="System.IO.IOException"> if there is a low-level IO error </exception>
         public abstract FieldComparer SetNextReader(AtomicReaderContext context);
 
         /// <summary>
-        /// Sets the Scorer to use in case a document's score is
-        ///  needed.
+        /// Sets the <see cref="Scorer"/> to use in case a document's score is
+        /// needed.
         /// </summary>
-        /// <param name="scorer"> Scorer instance that you should use to
+        /// <param name="scorer"> <see cref="Scorer"/> instance that you should use to
         /// obtain the current hit's score, if necessary.  </param>
         public virtual void SetScorer(Scorer scorer)
         {
@@ -318,15 +322,13 @@ namespace Lucene.Net.Search
         /// Return the actual value in the slot.
         /// LUCENENET NOTE: This was value(int) in Lucene.
         /// </summary>
-        /// <param name="slot"> the value </param>
-        /// <returns> value in this slot </returns>
+        /// <param name="slot"> The value </param>
+        /// <returns> Value in this slot </returns>
         public abstract IComparable this[int slot] { get; }
 
 
         internal static readonly IComparer<double> SIGNED_ZERO_COMPARER = new SignedZeroComparer();
 
-
-
         /// <summary>
         /// Base FieldComparer class for numeric types
         /// </summary>
@@ -366,8 +368,8 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Parses field's values as byte (using {@link
-        ///  FieldCache#getBytes} and sorts by ascending value
+        /// Parses field's values as <see cref="byte"/> (using 
+        /// <see cref="IFieldCache.GetBytes(Index.AtomicReader, string, FieldCache.IByteParser, bool)"/> and sorts by ascending value
         /// </summary>
         [Obsolete, CLSCompliant(false)] // LUCENENET NOTE: marking non-CLS compliant because of sbyte - it is obsolete, anyway
 #if FEATURE_SERIALIZABLE
@@ -457,8 +459,8 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Parses field's values as double (using {@link
-        ///  FieldCache#getDoubles} and sorts by ascending value
+        /// Parses field's values as <see cref="double"/> (using 
+        /// <see cref="IFieldCache.GetDoubles(Index.AtomicReader, string, FieldCache.IDoubleParser, bool)"/> and sorts by ascending value
         /// </summary>
 #if FEATURE_SERIALIZABLE
         [Serializable]
@@ -559,8 +561,8 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Parses field's values as float (using {@link
-        ///  FieldCache#getFloats} and sorts by ascending value
+        /// Parses field's values as <see cref="float"/> (using 
+        /// <see cref="IFieldCache.GetSingles(Index.AtomicReader, string, FieldCache.ISingleParser, bool)"/>  and sorts by ascending value
         /// <para/>
         /// NOTE: This was FloatComparator in Lucene
         /// </summary>
@@ -664,8 +666,8 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Parses field's values as short (using {@link
-        /// FieldCache#getShorts} and sorts by ascending value
+        /// Parses field's values as <see cref="short"/> (using 
+        /// <see cref="IFieldCache.GetInt16s(Index.AtomicReader, string, FieldCache.IInt16Parser, bool)"/> and sorts by ascending value
         /// <para/>
         /// NOTE: This was ShortComparator in Lucene
         /// </summary>
@@ -758,8 +760,8 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Parses field's values as int (using {@link
-        /// FieldCache#getInts} and sorts by ascending value
+        /// Parses field's values as <see cref="int"/> (using 
+        /// <see cref="IFieldCache.GetInt32s(Index.AtomicReader, string, FieldCache.IInt32Parser, bool)"/> and sorts by ascending value
         /// <para/>
         /// NOTE: This was IntComparator in Lucene
         /// </summary>
@@ -848,8 +850,8 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Parses field's values as long (using {@link
-        /// FieldCache#getLongs} and sorts by ascending value
+        /// Parses field's values as <see cref="long"/> (using
+        /// <see cref="IFieldCache.GetInt64s(Index.AtomicReader, string, FieldCache.IInt64Parser, bool)"/> and sorts by ascending value
         /// <para/>
         /// NOTE: This was LongComparator in Lucene
         /// </summary>
@@ -944,11 +946,11 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Sorts by descending relevance.  NOTE: if you are
-        ///  sorting only by descending relevance and then
-        ///  secondarily by ascending docID, performance is faster
-        ///  using <seealso cref="TopScoreDocCollector"/> directly (which {@link
-        ///  IndexSearcher#search} uses when no <seealso cref="Sort"/> is
-        ///  specified).
+        /// sorting only by descending relevance and then
+        /// secondarily by ascending docID, performance is faster
+        /// using <see cref="TopScoreDocCollector"/> directly (which all overloads of
+        /// <see cref="IndexSearcher.Search(Query, int)"/> use when no <see cref="Sort"/> is
+        /// specified).
         /// </summary>
 #if FEATURE_SERIALIZABLE
         [Serializable]
@@ -1101,63 +1103,90 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Sorts by field's natural Term sort order, using
-        ///  ordinals.  this is functionally equivalent to {@link
-        ///  Lucene.Net.Search.FieldComparer.TermValComparer}, but it first resolves the string
-        ///  to their relative ordinal positions (using the index
-        ///  returned by <seealso cref="IFieldCache#getTermsIndex"/>), and
-        ///  does most comparisons using the ordinals.  For medium
-        ///  to large results, this comparer will be much faster
-        ///  than <seealso cref="Lucene.Net.Search.FieldComparer.TermValComparer"/>.  For very small
-        ///  result sets it may be slower.
+        /// Sorts by field's natural <see cref="Index.Term"/> sort order, using
+        /// ordinals.  This is functionally equivalent to 
+        /// <see cref="Lucene.Net.Search.FieldComparer.TermValComparer"/>, but it first resolves the string
+        /// to their relative ordinal positions (using the index
+        /// returned by <see cref="IFieldCache.GetTermsIndex(Index.AtomicReader, string, float)"/>), and
+        /// does most comparisons using the ordinals.  For medium
+        /// to large results, this comparer will be much faster
+        /// than <see cref="Lucene.Net.Search.FieldComparer.TermValComparer"/>.  For very small
+        /// result sets it may be slower.
         /// </summary>
 #if FEATURE_SERIALIZABLE
         [Serializable]
 #endif
         public class TermOrdValComparer : FieldComparer<BytesRef>
         {
-            /* Ords for each slot.
-	            @lucene.internal */
+            /// <summary>
+            /// Ords for each slot.
+            /// <para/>
+            /// @lucene.internal
+            /// </summary>
             internal readonly int[] ords;
 
-            /* Values for each slot.
-	            @lucene.internal */
+            /// <summary>
+            /// Values for each slot.
+            /// <para/>
+            /// @lucene.internal
+            /// </summary>
             internal readonly BytesRef[] values;
 
-            /* Which reader last copied a value into the slot. When
-	            we compare two slots, we just compare-by-ord if the
-	            readerGen is the same; else we must compare the
-	            values (slower).
-	            @lucene.internal */
+            /// <summary>
+            /// Which reader last copied a value into the slot. When
+            /// we compare two slots, we just compare-by-ord if the
+            /// readerGen is the same; else we must compare the
+            /// values(slower).
+            /// <para/>
+            /// @lucene.internal
+            /// </summary>
             internal readonly int[] readerGen;
 
-            /* Gen of current reader we are on.
-	            @lucene.internal */
+            /// <summary>
+            /// Gen of current reader we are on.
+            /// <para/>
+            /// @lucene.internal
+            /// </summary>
             internal int currentReaderGen = -1;
 
-            /* Current reader's doc ord/values.
-	            @lucene.internal */
+            /// <summary>
+            /// Current reader's doc ord/values.
+            /// <para/>
+            /// @lucene.internal
+            /// </summary>
             internal SortedDocValues termsIndex;
 
             internal readonly string field;
 
-            /* Bottom slot, or -1 if queue isn't full yet
-	            @lucene.internal */
+            /// <summary>
+            /// Bottom slot, or -1 if queue isn't full yet
+            /// <para/>
+            /// @lucene.internal
+            /// </summary>
             internal int bottomSlot = -1;
 
-            /* Bottom ord (same as ords[bottomSlot] once bottomSlot
-	            is set).  Cached for faster compares.
-	            @lucene.internal */
+            /// <summary>
+            /// Bottom ord (same as ords[bottomSlot] once bottomSlot
+            /// is set).  Cached for faster compares.
+            /// <para/>
+            /// @lucene.internal
+            /// </summary>
             internal int bottomOrd;
 
-            /* True if current bottom slot matches the current
-	            reader.
-	            @lucene.internal */
+            /// <summary>
+            /// True if current bottom slot matches the current
+            /// reader.
+            /// <para/>
+            /// @lucene.internal
+            /// </summary>
             internal bool bottomSameReader;
 
-            /* Bottom value (same as values[bottomSlot] once
-	            bottomSlot is set).  Cached for faster compares.
-	            @lucene.internal */
+            /// <summary>
+            /// Bottom value (same as values[bottomSlot] once
+            /// bottomSlot is set).  Cached for faster compares.
+            /// <para/>
+            /// @lucene.internal
+            /// </summary>
             internal BytesRef bottomValue;
 
             /// <summary>
@@ -1188,8 +1217,8 @@ namespace Lucene.Net.Search
 
             /// <summary>
             /// Creates this, with control over how missing values
-            ///  are sorted.  Pass sortMissingLast=true to put
-            ///  missing values at the end.
+            /// are sorted.  Pass true for <paramref name="sortMissingLast"/> to put
+            /// missing values at the end.
             /// </summary>
             public TermOrdValComparer(int numHits, string field, bool sortMissingLast)
             {
@@ -1281,7 +1310,7 @@ namespace Lucene.Net.Search
             }
 
             /// <summary>
-            /// Retrieves the SortedDocValues for the field in this segment </summary>
+            /// Retrieves the <see cref="SortedDocValues"/> for the field in this segment </summary>
             protected virtual SortedDocValues GetSortedDocValues(AtomicReaderContext context, string field)
             {
                 return FieldCache.DEFAULT.GetTermsIndex((context.AtomicReader), field);
@@ -1422,10 +1451,10 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Sorts by field's natural Term sort order.  All
-        ///  comparisons are done using BytesRef.compareTo, which is
-        ///  slow for medium to large result sets but possibly
-        ///  very fast for very small results sets.
+        /// Sorts by field's natural <see cref="Index.Term"/> sort order.  All
+        /// comparisons are done using <see cref="BytesRef.CompareTo(BytesRef)"/>, which is
+        /// slow for medium to large result sets but possibly
+        /// very fast for very small results sets.
         /// </summary>
         // TODO: should we remove this?  who really uses it?
 #if FEATURE_SERIALIZABLE

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/FieldComparatorSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/FieldComparatorSource.cs b/src/Lucene.Net/Search/FieldComparatorSource.cs
index a4b864b..2fb448b 100644
--- a/src/Lucene.Net/Search/FieldComparatorSource.cs
+++ b/src/Lucene.Net/Search/FieldComparatorSource.cs
@@ -20,10 +20,9 @@ namespace Lucene.Net.Search
      */
 
     /// <summary>
-    /// Provides a <seealso cref="FieldComparer"/> for custom field sorting.
-    ///
+    /// Provides a <see cref="FieldComparer"/> for custom field sorting.
+    /// <para/>
     /// @lucene.experimental
-    ///
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]
@@ -35,8 +34,8 @@ namespace Lucene.Net.Search
         /// </summary>
         /// <param name="fieldname">
         ///          Name of the field to create comparer for. </param>
-        /// <returns> FieldComparer. </returns>
-        /// <exception cref="IOException">
+        /// <returns> <see cref="FieldComparer"/>. </returns>
+        /// <exception cref="System.IO.IOException">
         ///           If an error occurs reading the index. </exception>
         public abstract FieldComparer NewComparer(string fieldname, int numHits, int sortPos, bool reversed);
     }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/FieldDoc.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/FieldDoc.cs b/src/Lucene.Net/Search/FieldDoc.cs
index d4c3f55..9b6b7e3 100644
--- a/src/Lucene.Net/Search/FieldDoc.cs
+++ b/src/Lucene.Net/Search/FieldDoc.cs
@@ -23,23 +23,23 @@ namespace Lucene.Net.Search
      */
 
     /// <summary>
-    /// Expert: A ScoreDoc which also contains information about
+    /// Expert: A <see cref="ScoreDoc"/> which also contains information about
     /// how to sort the referenced document.  In addition to the
     /// document number and score, this object contains an array
     /// of values for the document from the field(s) used to sort.
     /// For example, if the sort criteria was to sort by fields
-    /// "a", "b" then "c", the <code>fields</code> object array
+    /// "a", "b" then "c", the <c>fields</c> object array
     /// will have three elements, corresponding respectively to
     /// the term values for the document in fields "a", "b" and "c".
     /// The class of each element in the array will be either
-    /// Integer, Float or String depending on the type of values
+    /// <see cref="int"/>, <see cref="float"/> or <see cref="string"/> depending on the type of values
     /// in the terms of each field.
     ///
-    /// <p>Created: Feb 11, 2004 1:23:38 PM
-    ///
+    /// <para/>Created: Feb 11, 2004 1:23:38 PM
+    /// <para/>
     /// @since   lucene 1.4 </summary>
-    /// <seealso cref= ScoreDoc </seealso>
-    /// <seealso cref= TopFieldDocs </seealso>
+    /// <seealso cref="ScoreDoc"/>
+    /// <seealso cref="TopFieldDocs"/>
 #if FEATURE_SERIALIZABLE
     [Serializable]
 #endif
@@ -48,11 +48,11 @@ namespace Lucene.Net.Search
         /// <summary>
         /// Expert: The values which are used to sort the referenced document.
         /// The order of these will match the original sort criteria given by a
-        /// Sort object.  Each Object will have been returned from
-        /// the <code>value</code> method corresponding
+        /// <see cref="Sort"/> object.  Each Object will have been returned from
+        /// the <see cref="FieldComparer.this[int]"/> method corresponding
         /// FieldComparer used to sort this field. </summary>
-        /// <seealso cref= Sort </seealso>
-        /// <seealso cref= IndexSearcher#search(Query,Filter,int,Sort) </seealso>
+        /// <seealso cref="Sort"/>
+        /// <seealso cref="IndexSearcher.Search(Query,Filter,int,Sort)"/>
         [WritableArray]
         [SuppressMessage("Microsoft.Performance", "CA1819", Justification = "Lucene's design requires some writable array properties")]
         public object[] Fields
@@ -85,7 +85,9 @@ namespace Lucene.Net.Search
             this.fields = fields;
         }
 
-        // A convenience method for debugging.
+        /// <summary>
+        /// A convenience method for debugging.
+        /// </summary>
         public override string ToString()
         {
             // super.toString returns the doc and score information, so just add the

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/FieldValueFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/FieldValueFilter.cs b/src/Lucene.Net/Search/FieldValueFilter.cs
index 906720a..90abf55 100644
--- a/src/Lucene.Net/Search/FieldValueFilter.cs
+++ b/src/Lucene.Net/Search/FieldValueFilter.cs
@@ -26,9 +26,9 @@ namespace Lucene.Net.Search
     using MatchNoBits = Lucene.Net.Util.Bits.MatchNoBits;
 
     /// <summary>
-    /// A <seealso cref="Filter"/> that accepts all documents that have one or more values in a
-    /// given field. this <seealso cref="Filter"/> request <seealso cref="IBits"/> from the
-    /// <seealso cref="IFieldCache"/> and build the bits if not present.
+    /// A <see cref="Filter"/> that accepts all documents that have one or more values in a
+    /// given field. this <see cref="Filter"/> request <see cref="IBits"/> from the
+    /// <see cref="IFieldCache"/> and build the bits if not present.
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]
@@ -39,22 +39,22 @@ namespace Lucene.Net.Search
         private readonly bool negate;
 
         /// <summary>
-        /// Creates a new <seealso cref="FieldValueFilter"/>
+        /// Creates a new <see cref="FieldValueFilter"/>
         /// </summary>
         /// <param name="field">
-        ///          the field to filter </param>
+        ///          The field to filter </param>
         public FieldValueFilter(string field)
             : this(field, false)
         {
         }
 
         /// <summary>
-        /// Creates a new <seealso cref="FieldValueFilter"/>
+        /// Creates a new <see cref="FieldValueFilter"/>
         /// </summary>
         /// <param name="field">
-        ///          the field to filter </param>
+        ///          The field to filter </param>
         /// <param name="negate">
-        ///          iff <code>true</code> all documents with no value in the given
+        ///          If <c>true</c> all documents with no value in the given
         ///          field are accepted.
         ///  </param>
         public FieldValueFilter(string field, bool negate)
@@ -65,15 +65,15 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Returns the field this filter is applied on. </summary>
-        /// <returns> the field this filter is applied on. </returns>
+        /// <returns> The field this filter is applied on. </returns>
         public virtual string Field
         {
             get { return field; }
         }
 
         /// <summary>
-        /// Returns <code>true</code> iff this filter is negated, otherwise <code>false</code> </summary>
-        /// <returns> <code>true</code> iff this filter is negated, otherwise <code>false</code> </returns>
+        /// Returns <c>true</c> if this filter is negated, otherwise <c>false</c> </summary>
+        /// <returns> <c>true</c> if this filter is negated, otherwise <c>false</c> </returns>
         public virtual bool Negate
         {
             get { return negate; }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/FieldValueHitQueue.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/FieldValueHitQueue.cs b/src/Lucene.Net/Search/FieldValueHitQueue.cs
index 439a755..b0d29ac 100644
--- a/src/Lucene.Net/Search/FieldValueHitQueue.cs
+++ b/src/Lucene.Net/Search/FieldValueHitQueue.cs
@@ -135,17 +135,15 @@ namespace Lucene.Net.Search
         }
 
         /// <summary> Creates a hit queue sorted by the given list of fields.
-        ///
-        /// <p/><b>NOTE</b>: The instances returned by this method
+        /// <para/><b>NOTE</b>: The instances returned by this method
         /// pre-allocate a full array of length <c>numHits</c>.
-        ///
         /// </summary>
-        /// <param name="fields">SortField array we are sorting by in priority order (highest
+        /// <param name="fields"><see cref="SortField"/> array we are sorting by in priority order (highest
         /// priority first); cannot be <c>null</c> or empty
         /// </param>
         /// <param name="size">The number of hits to retain. Must be greater than zero.
         /// </param>
-        /// <throws>  IOException </throws>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
         public static FieldValueHitQueue<T> Create<T>(SortField[] fields, int size)
             where T : FieldValueHitQueue.Entry
         {
@@ -167,13 +165,13 @@ namespace Lucene.Net.Search
 
     /// <summary>
     /// Expert: A hit queue for sorting by hits by terms in more than one field.
-    /// Uses <code>FieldCache.DEFAULT</code> for maintaining
+    /// Uses <c>FieldCache.DEFAULT</c> for maintaining
     /// internal term lookup tables.
-    ///
+    /// <para/>
     /// @lucene.experimental
     /// @since 2.9 </summary>
-    /// <seealso cref= IndexSearcher#search(Query,Filter,int,Sort) </seealso>
-    /// <seealso cref= FieldCache </seealso>
+    /// <seealso cref="IndexSearcher.Search(Query,Filter,int,Sort)"/>
+    /// <seealso cref="FieldCache"/>
 #if FEATURE_SERIALIZABLE
     [Serializable]
 #endif
@@ -237,15 +235,15 @@ namespace Lucene.Net.Search
         //public abstract bool LessThan(FieldValueHitQueue.Entry a, FieldValueHitQueue.Entry b);
 
         /// <summary>
-        /// Given a queue Entry, creates a corresponding FieldDoc
+        /// Given a queue <see cref="FieldValueHitQueue.Entry"/>, creates a corresponding <see cref="FieldDoc"/>
         /// that contains the values used to sort the given document.
         /// These values are not the raw values out of the index, but the internal
-        /// representation of them. this is so the given search hit can be collated by
+        /// representation of them. This is so the given search hit can be collated by
         /// a MultiSearcher with other search hits.
         /// </summary>
-        /// <param name="entry"> The Entry used to create a FieldDoc </param>
-        /// <returns> The newly created FieldDoc </returns>
-        /// <seealso cref= IndexSearcher#search(Query,Filter,int,Sort) </seealso>
+        /// <param name="entry"> The <see cref="FieldValueHitQueue.Entry"/> used to create a <see cref="FieldDoc"/> </param>
+        /// <returns> The newly created <see cref="FieldDoc"/> </returns>
+        /// <seealso cref="IndexSearcher.Search(Query,Filter,int,Sort)"/>
         internal virtual FieldDoc FillFields(FieldValueHitQueue.Entry entry)
         {
             int n = m_comparers.Length;
@@ -259,7 +257,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Returns the SortFields being used by this hit queue. </summary>
+        /// Returns the <see cref="SortField"/>s being used by this hit queue. </summary>
         [WritableArray]
         [SuppressMessage("Microsoft.Performance", "CA1819", Justification = "Lucene's design requires some writable array properties")]
         internal virtual SortField[] Fields

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/Filter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/Filter.cs b/src/Lucene.Net/Search/Filter.cs
index b2d7aa6..ad0d726 100644
--- a/src/Lucene.Net/Search/Filter.cs
+++ b/src/Lucene.Net/Search/Filter.cs
@@ -24,40 +24,40 @@ namespace Lucene.Net.Search
     using IBits = Lucene.Net.Util.IBits;
 
     /// <summary>
-    ///  Abstract base class for restricting which documents may
-    ///  be returned during searching.
+    /// Abstract base class for restricting which documents may
+    /// be returned during searching.
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]
 #endif
-    public abstract class Filter
+    public abstract class Filter // LUCENENET TODO: API - Make static NewAnonymous() factory method with delegate method for GetDocIdSet()
     {
         /// <summary>
-        /// Creates a <seealso cref="DocIdSet"/> enumerating the documents that should be
-        /// permitted in search results. <b>NOTE:</b> null can be
-        /// returned if no documents are accepted by this Filter.
-        /// <p>
+        /// Creates a <see cref="DocIdSet"/> enumerating the documents that should be
+        /// permitted in search results. <b>NOTE:</b> <c>null</c> can be
+        /// returned if no documents are accepted by this <see cref="Filter"/>.
+        /// <para/>
         /// Note: this method will be called once per segment in
-        /// the index during searching.  The returned <seealso cref="DocIdSet"/>
+        /// the index during searching.  The returned <see cref="DocIdSet"/>
         /// must refer to document IDs for that segment, not for
         /// the top-level reader.
         /// </summary>
-        /// <param name="context"> a <seealso cref="AtomicReaderContext"/> instance opened on the index currently
+        /// <param name="context"> a <see cref="AtomicReaderContext"/> instance opened on the index currently
         ///         searched on. Note, it is likely that the provided reader info does not
         ///         represent the whole underlying index i.e. if the index has more than
         ///         one segment the given reader only represents a single segment.
         ///         The provided context is always an atomic context, so you can call
-        ///         <seealso cref="AtomicReader#fields()"/>
+        ///         <see cref="AtomicReader.Fields"/>
         ///         on the context's reader, for example.
         /// </param>
         /// <param name="acceptDocs">
-        ///          Bits that represent the allowable docs to match (typically deleted docs
+        ///          <see cref="IBits"/> that represent the allowable docs to match (typically deleted docs
         ///          but possibly filtering other documents)
         /// </param>
-        /// <returns> a DocIdSet that provides the documents which should be permitted or
-        ///         prohibited in search results. <b>NOTE:</b> <code>null</code> should be returned if
+        /// <returns> A <see cref="DocIdSet"/> that provides the documents which should be permitted or
+        ///         prohibited in search results. <b>NOTE:</b> <c>null</c> should be returned if
         ///         the filter doesn't accept any documents otherwise internal optimization might not apply
-        ///         in the case an <i>empty</i> <seealso cref="DocIdSet"/> is returned. </returns>
+        ///         in the case an <i>empty</i> <see cref="DocIdSet"/> is returned. </returns>
         public abstract DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs);
     }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/FilteredDocIdSet.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/FilteredDocIdSet.cs b/src/Lucene.Net/Search/FilteredDocIdSet.cs
index a528232..53e1a98 100644
--- a/src/Lucene.Net/Search/FilteredDocIdSet.cs
+++ b/src/Lucene.Net/Search/FilteredDocIdSet.cs
@@ -22,22 +22,22 @@ namespace Lucene.Net.Search
     using IBits = Lucene.Net.Util.IBits;
 
     /// <summary>
-    /// Abstract decorator class for a DocIdSet implementation
+    /// Abstract decorator class for a <see cref="DocIdSet"/> implementation
     /// that provides on-demand filtering/validation
-    /// mechanism on a given DocIdSet.
+    /// mechanism on a given <see cref="DocIdSet"/>.
     ///
-    /// <p/>
+    /// <para/>
     ///
     /// Technically, this same functionality could be achieved
     /// with ChainedFilter (under queries/), however the
     /// benefit of this class is it never materializes the full
-    /// bitset for the filter.  Instead, the <seealso cref="#match"/>
+    /// bitset for the filter.  Instead, the <see cref="Match(int)"/>
     /// method is invoked on-demand, per docID visited during
     /// searching.  If you know few docIDs will be visited, and
-    /// the logic behind <seealso cref="#match"/> is relatively costly,
+    /// the logic behind <see cref="Match(int)"/> is relatively costly,
     /// this may be a better way to filter than ChainedFilter.
     /// </summary>
-    /// <seealso cref= DocIdSet </seealso>
+    /// <seealso cref="DocIdSet"/>
 #if FEATURE_SERIALIZABLE
     [Serializable]
 #endif
@@ -47,14 +47,14 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Constructor. </summary>
-        /// <param name="innerSet"> Underlying DocIdSet </param>
+        /// <param name="innerSet"> Underlying <see cref="DocIdSet"/> </param>
         public FilteredDocIdSet(DocIdSet innerSet)
         {
             this.innerSet = innerSet;
         }
 
         /// <summary>
-        /// this DocIdSet implementation is cacheable if the inner set is cacheable. </summary>
+        /// This <see cref="DocIdSet"/> implementation is cacheable if the inner set is cacheable. </summary>
         public override bool IsCacheable
         {
             get
@@ -101,13 +101,13 @@ namespace Lucene.Net.Search
         /// <summary>
         /// Validation method to determine whether a docid should be in the result set. </summary>
         /// <param name="docid"> docid to be tested </param>
-        /// <returns> true if input docid should be in the result set, false otherwise. </returns>
+        /// <returns> <c>true</c> if input docid should be in the result set, false otherwise. </returns>
         protected abstract bool Match(int docid);
 
         /// <summary>
-        /// Implementation of the contract to build a DocIdSetIterator. </summary>
-        /// <seealso cref= DocIdSetIterator </seealso>
-        /// <seealso cref= FilteredDocIdSetIterator </seealso>
+        /// Implementation of the contract to build a <see cref="DocIdSetIterator"/>. </summary>
+        /// <seealso cref="DocIdSetIterator"/>
+        /// <seealso cref="FilteredDocIdSetIterator"/>
         public override DocIdSetIterator GetIterator()
         {
             DocIdSetIterator iterator = innerSet.GetIterator();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/FilteredDocIdSetIterator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/FilteredDocIdSetIterator.cs b/src/Lucene.Net/Search/FilteredDocIdSetIterator.cs
index 8f4881b..eb2f2bf 100644
--- a/src/Lucene.Net/Search/FilteredDocIdSetIterator.cs
+++ b/src/Lucene.Net/Search/FilteredDocIdSetIterator.cs
@@ -20,10 +20,10 @@ namespace Lucene.Net.Search
      */
 
     /// <summary>
-    /// Abstract decorator class of a DocIdSetIterator
+    /// Abstract decorator class of a <see cref="DocIdSetIterator"/>
     /// implementation that provides on-demand filter/validation
-    /// mechanism on an underlying DocIdSetIterator.  See {@link
-    /// FilteredDocIdSet}.
+    /// mechanism on an underlying <see cref="DocIdSetIterator"/>.  See 
+    /// <see cref="DocIdSetIterator"/>.
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]
@@ -35,7 +35,7 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Constructor. </summary>
-        /// <param name="innerIter"> Underlying DocIdSetIterator. </param>
+        /// <param name="innerIter"> Underlying <see cref="DocIdSetIterator"/>. </param>
         public FilteredDocIdSetIterator(DocIdSetIterator innerIter)
         {
             if (innerIter == null)
@@ -49,8 +49,8 @@ namespace Lucene.Net.Search
         /// <summary>
         /// Validation method to determine whether a docid should be in the result set. </summary>
         /// <param name="doc"> docid to be tested </param>
-        /// <returns> true if input docid should be in the result set, false otherwise. </returns>
-        /// <seealso cref= #FilteredDocIdSetIterator(DocIdSetIterator) </seealso>
+        /// <returns> <c>true</c> if input docid should be in the result set, <c>false</c> otherwise. </returns>
+        /// <seealso cref="FilteredDocIdSetIterator(DocIdSetIterator)"/>
         protected abstract bool Match(int doc);
 
         public override int DocID

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/FilteredQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/FilteredQuery.cs b/src/Lucene.Net/Search/FilteredQuery.cs
index 654cc72..ebae4de 100644
--- a/src/Lucene.Net/Search/FilteredQuery.cs
+++ b/src/Lucene.Net/Search/FilteredQuery.cs
@@ -31,11 +31,12 @@ namespace Lucene.Net.Search
     /// <summary>
     /// A query that applies a filter to the results of another query.
     ///
-    /// <p>Note: the bits are retrieved from the filter each time this
-    /// query is used in a search - use a CachingWrapperFilter to avoid
+    /// <para/>Note: the bits are retrieved from the filter each time this
+    /// query is used in a search - use a <see cref="CachingWrapperFilter"/> to avoid
     /// regenerating the bits every time.
+    /// <para/>
     /// @since   1.4 </summary>
-    /// <seealso cref=     CachingWrapperFilter </seealso>
+    /// <seealso cref="CachingWrapperFilter"/>
 #if FEATURE_SERIALIZABLE
     [Serializable]
 #endif
@@ -47,9 +48,9 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Constructs a new query which applies a filter to the results of the original query.
-        /// <seealso cref="Filter#getDocIdSet"/> will be called every time this query is used in a search. </summary>
-        /// <param name="query">  Query to be filtered, cannot be <code>null</code>. </param>
-        /// <param name="filter"> Filter to apply to query results, cannot be <code>null</code>. </param>
+        /// <see cref="Filter.GetDocIdSet(AtomicReaderContext, IBits)"/> will be called every time this query is used in a search. </summary>
+        /// <param name="query">  Query to be filtered, cannot be <c>null</c>. </param>
+        /// <param name="filter"> Filter to apply to query results, cannot be <c>null</c>. </param>
         public FilteredQuery(Query query, Filter filter)
             : this(query, filter, RANDOM_ACCESS_FILTER_STRATEGY)
         {
@@ -57,12 +58,12 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Expert: Constructs a new query which applies a filter to the results of the original query.
-        /// <seealso cref="Filter#getDocIdSet"/> will be called every time this query is used in a search. </summary>
-        /// <param name="query">  Query to be filtered, cannot be <code>null</code>. </param>
-        /// <param name="filter"> Filter to apply to query results, cannot be <code>null</code>. </param>
-        /// <param name="strategy"> a filter strategy used to create a filtered scorer.
+        /// <see cref="Filter.GetDocIdSet(AtomicReaderContext, IBits)"/> will be called every time this query is used in a search. </summary>
+        /// <param name="query">  Query to be filtered, cannot be <c>null</c>. </param>
+        /// <param name="filter"> Filter to apply to query results, cannot be <c>null</c>. </param>
+        /// <param name="strategy"> A filter strategy used to create a filtered scorer.
         /// </param>
-        /// <seealso cref= FilterStrategy </seealso>
+        /// <seealso cref="FilterStrategy"/>
         public FilteredQuery(Query query, Filter filter, FilterStrategy strategy)
         {
             if (query == null || filter == null)
@@ -79,8 +80,8 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Returns a Weight that applies the filter to the enclosed query's Weight.
-        /// this is accomplished by overriding the Scorer returned by the Weight.
+        /// Returns a <see cref="Weight"/> that applies the filter to the enclosed query's <see cref="Weight"/>.
+        /// this is accomplished by overriding the <see cref="Scorer"/> returned by the <see cref="Weight"/>.
         /// </summary>
         public override Weight CreateWeight(IndexSearcher searcher)
         {
@@ -181,8 +182,8 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// A scorer that consults the filter iff a document was matched by the
-        /// delegate scorer. this is useful if the filter computation is more expensive
+        /// A scorer that consults the filter if a document was matched by the
+        /// delegate scorer. This is useful if the filter computation is more expensive
         /// than document scoring or if the filter has a linear running time to compute
         /// the next matching doc like exact geo distances.
         /// </summary>
@@ -299,7 +300,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// A Scorer that uses a "leap-frog" approach (also called "zig-zag join"). The scorer and the filter
+        /// A <see cref="Scorer"/> that uses a "leap-frog" approach (also called "zig-zag join"). The scorer and the filter
         /// take turns trying to advance to each other's next matching document, often
         /// jumping past the target document. When both land on the same document, it's
         /// collected.
@@ -418,8 +419,8 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Rewrites the query. If the wrapped is an instance of
-        /// <seealso cref="MatchAllDocsQuery"/> it returns a <seealso cref="ConstantScoreQuery"/>. Otherwise
-        /// it returns a new {@code FilteredQuery} wrapping the rewritten query.
+        /// <see cref="MatchAllDocsQuery"/> it returns a <see cref="ConstantScoreQuery"/>. Otherwise
+        /// it returns a new <see cref="FilteredQuery"/> wrapping the rewritten query.
         /// </summary>
         public override Query Rewrite(IndexReader reader)
         {
@@ -440,7 +441,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Returns this FilteredQuery's (unfiltered) Query </summary>
+        /// Returns this <see cref="FilteredQuery"/>'s (unfiltered) <see cref="Query"/> </summary>
         public Query Query
         {
             get
@@ -450,7 +451,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Returns this FilteredQuery's filter </summary>
+        /// Returns this <see cref="FilteredQuery"/>'s filter </summary>
         public Filter Filter
         {
             get
@@ -460,7 +461,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Returns this FilteredQuery's <seealso cref="FilterStrategy"/> </summary>
+        /// Returns this <see cref="FilteredQuery"/>'s <seealso cref="FilterStrategy"/> </summary>
         public virtual FilterStrategy Strategy
         {
             get
@@ -469,7 +470,11 @@ namespace Lucene.Net.Search
             }
         }
 
-        // inherit javadoc
+        /// <summary>
+        /// Expert: adds all terms occurring in this query to the terms set. Only
+        /// works if this query is in its rewritten (<see cref="Rewrite(IndexReader)"/>) form.
+        /// </summary>
+        /// <exception cref="InvalidOperationException"> If this query is not yet rewritten </exception>
         public override void ExtractTerms(ISet<Term> terms)
         {
             Query.ExtractTerms(terms);
@@ -489,7 +494,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Returns true iff <code>o</code> is equal to this. </summary>
+        /// Returns true if <paramref name="o"/> is equal to this. </summary>
         public override bool Equals(object o)
         {
             if (o == this)
@@ -517,16 +522,16 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// A <seealso cref="FilterStrategy"/> that conditionally uses a random access filter if
-        /// the given <seealso cref="DocIdSet"/> supports random access (returns a non-null value
-        /// from <seealso cref="DocIdSet#bits()"/>) and
-        /// <seealso cref="RandomAccessFilterStrategy#useRandomAccess(Bits, int)"/> returns
-        /// <code>true</code>. Otherwise this strategy falls back to a "zig-zag join" (
-        /// <seealso cref="FilteredQuery#LEAP_FROG_FILTER_FIRST_STRATEGY"/>) strategy.
+        /// A <see cref="FilterStrategy"/> that conditionally uses a random access filter if
+        /// the given <see cref="DocIdSet"/> supports random access (returns a non-null value
+        /// from <see cref="DocIdSet.Bits"/>) and
+        /// <see cref="RandomAccessFilterStrategy.UseRandomAccess(IBits, int)"/> returns
+        /// <c>true</c>. Otherwise this strategy falls back to a "zig-zag join" (
+        /// <see cref="FilteredQuery.LEAP_FROG_FILTER_FIRST_STRATEGY"/>) strategy.
         ///
-        /// <p>
-        /// Note: this strategy is the default strategy in <seealso cref="FilteredQuery"/>
-        /// </p>
+        /// <para>
+        /// Note: this strategy is the default strategy in <see cref="FilteredQuery"/>
+        /// </para>
         /// </summary>
         public static readonly FilterStrategy RANDOM_ACCESS_FILTER_STRATEGY = new RandomAccessFilterStrategy();
 
@@ -536,9 +541,9 @@ namespace Lucene.Net.Search
         /// take turns trying to advance to each other's next matching document, often
         /// jumping past the target document. When both land on the same document, it's
         /// collected.
-        /// <p>
+        /// <para>
         /// Note: this strategy uses the filter to lead the iteration.
-        /// </p>
+        /// </para>
         /// </summary>
         public static readonly FilterStrategy LEAP_FROG_FILTER_FIRST_STRATEGY = new LeapFrogFilterStrategy(false);
 
@@ -548,55 +553,56 @@ namespace Lucene.Net.Search
         /// take turns trying to advance to each other's next matching document, often
         /// jumping past the target document. When both land on the same document, it's
         /// collected.
-        /// <p>
+        /// <para>
         /// Note: this strategy uses the query to lead the iteration.
-        /// </p>
+        /// </para>
         /// </summary>
         public static readonly FilterStrategy LEAP_FROG_QUERY_FIRST_STRATEGY = new LeapFrogFilterStrategy(true);
 
         /// <summary>
-        /// A filter strategy that advances the Query or rather its <seealso cref="Scorer"/> first and consults the
-        /// filter <seealso cref="DocIdSet"/> for each matched document.
-        /// <p>
-        /// Note: this strategy requires a <seealso cref="DocIdSet#bits()"/> to return a non-null value. Otherwise
-        /// this strategy falls back to <seealso cref="FilteredQuery#LEAP_FROG_QUERY_FIRST_STRATEGY"/>
-        /// </p>
-        /// <p>
+        /// A filter strategy that advances the <see cref="Search.Query"/> or rather its <see cref="Scorer"/> first and consults the
+        /// filter <see cref="DocIdSet"/> for each matched document.
+        /// <para>
+        /// Note: this strategy requires a <see cref="DocIdSet.Bits"/> to return a non-null value. Otherwise
+        /// this strategy falls back to <see cref="FilteredQuery.LEAP_FROG_QUERY_FIRST_STRATEGY"/>
+        /// </para>
+        /// <para>
         /// Use this strategy if the filter computation is more expensive than document
         /// scoring or if the filter has a linear running time to compute the next
         /// matching doc like exact geo distances.
-        /// </p>
+        /// </para>
         /// </summary>
         public static readonly FilterStrategy QUERY_FIRST_FILTER_STRATEGY = new QueryFirstFilterStrategy();
 
         /// <summary>
-        /// Abstract class that defines how the filter (<seealso cref="DocIdSet"/>) applied during document collection. </summary>
+        /// Abstract class that defines how the filter (<see cref="DocIdSet"/>) applied during document collection. </summary>
 #if FEATURE_SERIALIZABLE
         [Serializable]
 #endif
         public abstract class FilterStrategy
         {
             /// <summary>
-            /// Returns a filtered <seealso cref="Scorer"/> based on this strategy.
+            /// Returns a filtered <see cref="Scorer"/> based on this strategy.
             /// </summary>
             /// <param name="context">
-            ///          the <seealso cref="AtomicReaderContext"/> for which to return the <seealso cref="Scorer"/>. </param>
-            /// <param name="weight"> the <seealso cref="FilteredQuery"/> <seealso cref="Weight"/> to create the filtered scorer. </param>
-            /// <param name="docIdSet"> the filter <seealso cref="DocIdSet"/> to apply </param>
+            ///          the <see cref="AtomicReaderContext"/> for which to return the <see cref="Scorer"/>. </param>
+            /// <param name="weight"> the <see cref="FilteredQuery"/> <see cref="Weight"/> to create the filtered scorer. </param>
+            /// <param name="docIdSet"> the filter <see cref="DocIdSet"/> to apply </param>
             /// <returns> a filtered scorer
             /// </returns>
-            /// <exception cref="IOException"> if an <seealso cref="IOException"/> occurs </exception>
+            /// <exception cref="System.IO.IOException"> if an <see cref="System.IO.IOException"/> occurs </exception>
             public abstract Scorer FilteredScorer(AtomicReaderContext context, Weight weight, DocIdSet docIdSet);
 
             /// <summary>
-            /// Returns a filtered <seealso cref="BulkScorer"/> based on this
+            /// Returns a filtered <see cref="BulkScorer"/> based on this
             /// strategy.  this is an optional method: the default
-            /// implementation just calls <seealso cref="#filteredScorer"/> and
-            /// wraps that into a BulkScorer.
+            /// implementation just calls <see cref="FilteredScorer(AtomicReaderContext, Weight, DocIdSet)"/> and
+            /// wraps that into a <see cref="BulkScorer"/>.
             /// </summary>
             /// <param name="context">
             ///          the <seealso cref="AtomicReaderContext"/> for which to return the <seealso cref="Scorer"/>. </param>
             /// <param name="weight"> the <seealso cref="FilteredQuery"/> <seealso cref="Weight"/> to create the filtered scorer. </param>
+            /// <param name="scoreDocsInOrder"> <c>true</c> to score docs in order </param>
             /// <param name="docIdSet"> the filter <seealso cref="DocIdSet"/> to apply </param>
             /// <returns> a filtered top scorer </returns>
             public virtual BulkScorer FilteredBulkScorer(AtomicReaderContext context, Weight weight, bool scoreDocsInOrder, DocIdSet docIdSet)
@@ -613,12 +619,12 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// A <seealso cref="FilterStrategy"/> that conditionally uses a random access filter if
-        /// the given <seealso cref="DocIdSet"/> supports random access (returns a non-null value
-        /// from <seealso cref="DocIdSet#bits()"/>) and
-        /// <seealso cref="RandomAccessFilterStrategy#useRandomAccess(Bits, int)"/> returns
+        /// A <see cref="FilterStrategy"/> that conditionally uses a random access filter if
+        /// the given <see cref="DocIdSet"/> supports random access (returns a non-null value
+        /// from <see cref="DocIdSet.Bits"/>) and
+        /// <see cref="RandomAccessFilterStrategy.UseRandomAccess(IBits, int)"/> returns
         /// <code>true</code>. Otherwise this strategy falls back to a "zig-zag join" (
-        /// <seealso cref="FilteredQuery#LEAP_FROG_FILTER_FIRST_STRATEGY"/>) strategy .
+        /// <see cref="FilteredQuery.LEAP_FROG_FILTER_FIRST_STRATEGY"/>) strategy .
         /// </summary>
 #if FEATURE_SERIALIZABLE
         [Serializable]
@@ -661,14 +667,14 @@ namespace Lucene.Net.Search
 
             /// <summary>
             /// Expert: decides if a filter should be executed as "random-access" or not.
-            /// random-access means the filter "filters" in a similar way as deleted docs are filtered
-            /// in Lucene. this is faster when the filter accepts many documents.
+            /// Random-access means the filter "filters" in a similar way as deleted docs are filtered
+            /// in Lucene. This is faster when the filter accepts many documents.
             /// However, when the filter is very sparse, it can be faster to execute the query+filter
             /// as a conjunction in some cases.
-            ///
-            /// The default implementation returns <code>true</code> if the first document accepted by the
-            /// filter is < 100.
-            ///
+            /// <para/>
+            /// The default implementation returns <c>true</c> if the first document accepted by the
+            /// filter is &lt; 100.
+            /// <para/>
             /// @lucene.internal
             /// </summary>
             protected virtual bool UseRandomAccess(IBits bits, int firstFilterDoc)
@@ -717,17 +723,17 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// A filter strategy that advances the <seealso cref="Scorer"/> first and consults the
-        /// <seealso cref="DocIdSet"/> for each matched document.
-        /// <p>
-        /// Note: this strategy requires a <seealso cref="DocIdSet#bits()"/> to return a non-null value. Otherwise
-        /// this strategy falls back to <seealso cref="FilteredQuery#LEAP_FROG_QUERY_FIRST_STRATEGY"/>
-        /// </p>
-        /// <p>
+        /// A filter strategy that advances the <see cref="Scorer"/> first and consults the
+        /// <see cref="DocIdSet"/> for each matched document.
+        /// <para>
+        /// Note: this strategy requires a <see cref="DocIdSet.Bits"/> to return a non-null value. Otherwise
+        /// this strategy falls back to <see cref="FilteredQuery.LEAP_FROG_QUERY_FIRST_STRATEGY"/>
+        /// </para>
+        /// <para>
         /// Use this strategy if the filter computation is more expensive than document
         /// scoring or if the filter has a linear running time to compute the next
         /// matching doc like exact geo distances.
-        /// </p>
+        /// </para>
         /// </summary>
 #if FEATURE_SERIALIZABLE
         [Serializable]

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/FuzzyQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/FuzzyQuery.cs b/src/Lucene.Net/Search/FuzzyQuery.cs
index 9da7082..fa11a18 100644
--- a/src/Lucene.Net/Search/FuzzyQuery.cs
+++ b/src/Lucene.Net/Search/FuzzyQuery.cs
@@ -31,26 +31,26 @@ namespace Lucene.Net.Search
     /// <summary>
     /// Implements the fuzzy search query. The similarity measurement
     /// is based on the Damerau-Levenshtein (optimal string alignment) algorithm,
-    /// though you can explicitly choose classic Levenshtein by passing <code>false</code>
-    /// to the <code>transpositions</code> parameter.
+    /// though you can explicitly choose classic Levenshtein by passing <c>false</c>
+    /// to the <c>transpositions</c> parameter.
     ///
-    /// <p>this query uses <seealso cref="MultiTermQuery.TopTermsScoringBooleanQueryRewrite"/>
+    /// <para/>this query uses <see cref="MultiTermQuery.TopTermsScoringBooleanQueryRewrite"/>
     /// as default. So terms will be collected and scored according to their
-    /// edit distance. Only the top terms are used for building the <seealso cref="BooleanQuery"/>.
+    /// edit distance. Only the top terms are used for building the <see cref="BooleanQuery"/>.
     /// It is not recommended to change the rewrite mode for fuzzy queries.
     ///
-    /// <p>At most, this query will match terms up to
-    /// {@value Lucene.Net.Util.Automaton.LevenshteinAutomata#MAXIMUM_SUPPORTED_DISTANCE} edits.
+    /// <para/>At most, this query will match terms up to
+    /// <see cref="Lucene.Net.Util.Automaton.LevenshteinAutomata.MAXIMUM_SUPPORTED_DISTANCE"/> edits.
     /// Higher distances (especially with transpositions enabled), are generally not useful and
     /// will match a significant amount of the term dictionary. If you really want this, consider
     /// using an n-gram indexing technique (such as the SpellChecker in the
     /// <a href="{@docRoot}/../suggest/overview-summary.html">suggest module</a>) instead.
     ///
-    /// <p>NOTE: terms of length 1 or 2 will sometimes not match because of how the scaled
+    /// <para/>NOTE: terms of length 1 or 2 will sometimes not match because of how the scaled
     /// distance between two terms is computed.  For a term to match, the edit distance between
     /// the terms must be less than the minimum length term (either the input term, or
-    /// the candidate term).  For example, FuzzyQuery on term "abcd" with maxEdits=2 will
-    /// not match an indexed term "ab", and FuzzyQuery on term "a" with maxEdits=2 will not
+    /// the candidate term).  For example, <see cref="FuzzyQuery"/> on term "abcd" with maxEdits=2 will
+    /// not match an indexed term "ab", and <see cref="FuzzyQuery"/> on term "a" with maxEdits=2 will not
     /// match an indexed term "abc".
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -70,19 +70,19 @@ namespace Lucene.Net.Search
         private readonly Term term;
 
         /// <summary>
-        /// Create a new FuzzyQuery that will match terms with an edit distance
-        /// of at most <code>maxEdits</code> to <code>term</code>.
-        /// If a <code>prefixLength</code> &gt; 0 is specified, a common prefix
+        /// Create a new <see cref="FuzzyQuery"/> that will match terms with an edit distance
+        /// of at most <paramref name="maxEdits"/> to <paramref name="term"/>.
+        /// If a <paramref name="prefixLength"/> &gt; 0 is specified, a common prefix
         /// of that length is also required.
         /// </summary>
-        /// <param name="term"> the term to search for </param>
-        /// <param name="maxEdits"> must be >= 0 and <= <seealso cref="LevenshteinAutomata#MAXIMUM_SUPPORTED_DISTANCE"/>. </param>
-        /// <param name="prefixLength"> length of common (non-fuzzy) prefix </param>
-        /// <param name="maxExpansions"> the maximum number of terms to match. If this number is
-        ///  greater than <seealso cref="BooleanQuery#getMaxClauseCount"/> when the query is rewritten,
-        ///  then the maxClauseCount will be used instead. </param>
-        /// <param name="transpositions"> true if transpositions should be treated as a primitive
-        ///        edit operation. If this is false, comparisons will implement the classic
+        /// <param name="term"> The term to search for </param>
+        /// <param name="maxEdits"> Must be &gt;= 0 and &lt;= <see cref="LevenshteinAutomata.MAXIMUM_SUPPORTED_DISTANCE"/>. </param>
+        /// <param name="prefixLength"> Length of common (non-fuzzy) prefix </param>
+        /// <param name="maxExpansions"> The maximum number of terms to match. If this number is
+        /// greater than <see cref="BooleanQuery.MaxClauseCount"/> when the query is rewritten,
+        /// then the maxClauseCount will be used instead. </param>
+        /// <param name="transpositions"> <c>true</c> if transpositions should be treated as a primitive
+        ///        edit operation. If this is <c>false</c>, comparisons will implement the classic
         ///        Levenshtein algorithm. </param>
         public FuzzyQuery(Term term, int maxEdits, int prefixLength, int maxExpansions, bool transpositions)
             : base(term.Field)
@@ -109,8 +109,8 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Calls {@link #FuzzyQuery(Term, int, int, int, boolean)
-        /// FuzzyQuery(term, maxEdits, prefixLength, defaultMaxExpansions, defaultTranspositions)}.
+        /// Calls <see cref="FuzzyQuery.FuzzyQuery(Term, int, int, int, bool)">
+        /// FuzzyQuery(term, maxEdits, prefixLength, defaultMaxExpansions, defaultTranspositions)</see>.
         /// </summary>
         public FuzzyQuery(Term term, int maxEdits, int prefixLength)
             : this(term, maxEdits, prefixLength, DefaultMaxExpansions, DefaultTranspositions)
@@ -118,7 +118,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Calls <seealso cref="#FuzzyQuery(Term, int, int) FuzzyQuery(term, maxEdits, defaultPrefixLength)"/>.
+        /// Calls <see cref="FuzzyQuery(Term, int, int)">FuzzyQuery(term, maxEdits, defaultPrefixLength)</see>.
         /// </summary>
         public FuzzyQuery(Term term, int maxEdits)
             : this(term, maxEdits, DefaultPrefixLength)
@@ -126,14 +126,14 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Calls <seealso cref="#FuzzyQuery(Term, int) FuzzyQuery(term, defaultMaxEdits)"/>.
+        /// Calls <see cref="FuzzyQuery(Term, int)">FuzzyQuery(term, defaultMaxEdits)</see>.
         /// </summary>
         public FuzzyQuery(Term term)
             : this(term, DefaultMaxEdits)
         {
         }
 
-        /// <returns> the maximum number of edit distances allowed for this query to match. </returns>
+        /// <returns> The maximum number of edit distances allowed for this query to match. </returns>
         public virtual int MaxEdits
         {
             get
@@ -143,7 +143,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Returns the non-fuzzy prefix length. this is the number of characters at the start
+        /// Returns the non-fuzzy prefix length. This is the number of characters at the start
         /// of a term that must be identical (not fuzzy) to the query term if the query
         /// is to match that term.
         /// </summary>
@@ -156,8 +156,8 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Returns true if transpositions should be treated as a primitive edit operation.
-        /// If this is false, comparisons will implement the classic Levenshtein algorithm.
+        /// Returns <c>true</c> if transpositions should be treated as a primitive edit operation.
+        /// If this is <c>false</c>, comparisons will implement the classic Levenshtein algorithm.
         /// </summary>
         public virtual bool Transpositions
         {
@@ -269,10 +269,9 @@ namespace Lucene.Net.Search
         /// <para/>
         /// NOTE: this was floatToEdits() in Lucene
         /// </summary>
-        /// <param name="minimumSimilarity"> scaled similarity </param>
-        /// <param name="termLen"> length (in unicode codepoints) of the term. </param>
-        /// <returns> equivalent number of maxEdits </returns>
-        /// @deprecated pass integer edit distances instead.
+        /// <param name="minimumSimilarity"> Scaled similarity </param>
+        /// <param name="termLen"> Length (in unicode codepoints) of the term. </param>
+        /// <returns> Equivalent number of maxEdits </returns>
         [Obsolete("pass integer edit distances instead.")]
         public static int SingleToEdits(float minimumSimilarity, int termLen)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/FuzzyTermsEnum.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/FuzzyTermsEnum.cs b/src/Lucene.Net/Search/FuzzyTermsEnum.cs
index f4bbd5d..e29aa59 100644
--- a/src/Lucene.Net/Search/FuzzyTermsEnum.cs
+++ b/src/Lucene.Net/Search/FuzzyTermsEnum.cs
@@ -45,12 +45,12 @@ namespace Lucene.Net.Search
     using UnicodeUtil = Lucene.Net.Util.UnicodeUtil;
 
     /// <summary>
-    /// Subclass of TermsEnum for enumerating all terms that are similar
+    /// Subclass of <see cref="TermsEnum"/> for enumerating all terms that are similar
     /// to the specified filter term.
     ///
-    /// <p>Term enumerations are always ordered by
-    /// <seealso cref="#getComparer"/>.  Each term in the enumeration is
-    /// greater than all that precede it.</p>
+    /// <para>Term enumerations are always ordered by
+    /// <see cref="Comparer"/>.  Each term in the enumeration is
+    /// greater than all that precede it.</para>
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]
@@ -92,22 +92,23 @@ namespace Lucene.Net.Search
         private readonly bool transpositions;
 
         /// <summary>
-        /// Constructor for enumeration of all terms from specified <code>reader</code> which share a prefix of
-        /// length <code>prefixLength</code> with <code>term</code> and which have a fuzzy similarity &gt;
-        /// <code>minSimilarity</code>.
-        /// <p>
+        /// Constructor for enumeration of all terms from specified <c>reader</c> which share a prefix of
+        /// length <paramref name="prefixLength"/> with <paramref name="term"/> and which have a fuzzy similarity &gt;
+        /// <paramref name="minSimilarity"/>.
+        /// <para/>
         /// After calling the constructor the enumeration is already pointing to the first
         /// valid term if such a term exists.
         /// </summary>
         /// <param name="terms"> Delivers terms. </param>
-        /// <param name="atts"> <seealso cref="AttributeSource"/> created by the rewrite method of <seealso cref="MultiTermQuery"/>
+        /// <param name="atts"> <see cref="AttributeSource"/> created by the rewrite method of <see cref="MultiTermQuery"/>
         /// thats contains information about competitive boosts during rewrite. It is also used
         /// to cache DFAs between segment transitions. </param>
         /// <param name="term"> Pattern term. </param>
         /// <param name="minSimilarity"> Minimum required similarity for terms from the reader. Pass an integer value
         ///        representing edit distance. Passing a fraction is deprecated. </param>
         /// <param name="prefixLength"> Length of required common prefix. Default value is 0. </param>
-        /// <exception cref="IOException"> if there is a low-level IO error </exception>
+        /// <param name="transpositions"> Transpositions </param>
+        /// <exception cref="System.IO.IOException"> if there is a low-level IO error </exception>
         public FuzzyTermsEnum(Terms terms, AttributeSource atts, Term term, float minSimilarity, int prefixLength, bool transpositions)
         {
             InitializeInstanceFields();
@@ -167,8 +168,8 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// return an automata-based enum for matching up to editDistance from
-        /// lastTerm, if possible
+        /// Return an automata-based enum for matching up to <paramref name="editDistance"/> from
+        /// <paramref name="lastTerm"/>, if possible
         /// </summary>
         protected virtual TermsEnum GetAutomatonEnum(int editDistance, BytesRef lastTerm)
         {
@@ -186,7 +187,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// initialize levenshtein DFAs up to maxDistance, if possible </summary>
+        /// Initialize levenshtein DFAs up to maxDistance, if possible </summary>
         private IList<CompiledAutomaton> InitAutomata(int maxDistance)
         {
             IList<CompiledAutomaton> runAutomata = dfaAtt.Automata;
@@ -212,7 +213,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// swap in a new actual enum to proxy to </summary>
+        /// Swap in a new actual enum to proxy to </summary>
         protected virtual void SetEnum(TermsEnum actualEnum)
         {
             this.actualEnum = actualEnum;
@@ -220,7 +221,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// fired when the max non-competitive boost has changed. this is the hook to
+        /// Fired when the max non-competitive boost has changed. This is the hook to
         /// swap in a smarter actualEnum
         /// </summary>
         private void BottomChanged(BytesRef lastTerm, bool init)
@@ -361,9 +362,9 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Implement fuzzy enumeration with Terms.intersect.
-        /// <p>
-        /// this is the fastest method as opposed to LinearFuzzyTermsEnum:
+        /// Implement fuzzy enumeration with <see cref="Terms.Intersect(CompiledAutomaton, BytesRef)"/>.
+        /// <para/>
+        /// This is the fastest method as opposed to LinearFuzzyTermsEnum:
         /// as enumeration is logarithmic to the number of terms (instead of linear)
         /// and comparison is linear to length of the term (rather than quadratic)
         /// </summary>
@@ -400,7 +401,7 @@ namespace Lucene.Net.Search
             }
 
             /// <summary>
-            /// finds the smallest Lev(n) DFA that accepts the term. </summary>
+            /// Finds the smallest Lev(n) DFA that accepts the term. </summary>
             protected override AcceptStatus Accept(BytesRef term)
             {
                 //System.out.println("AFTE.accept term=" + term);
@@ -447,7 +448,7 @@ namespace Lucene.Net.Search
             }
 
             /// <summary>
-            /// returns true if term is within k edits of the query term </summary>
+            /// Returns <c>true</c> if <paramref name="term"/> is within <paramref name="k"/> edits of the query term </summary>
             internal bool Matches(BytesRef term, int k)
             {
                 return k == 0 ? term.Equals(termRef) : matchers[k].Run(term.Bytes, term.Offset, term.Length);
@@ -475,8 +476,9 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// reuses compiled automata across different segments,
+        /// Reuses compiled automata across different segments,
         /// because they are independent of the index
+        /// <para/>
         /// @lucene.internal
         /// </summary>
         public interface ILevenshteinAutomataAttribute : IAttribute
@@ -486,6 +488,7 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Stores compiled automata as a list (indexed by edit distance)
+        /// <para/>
         /// @lucene.internal
         /// </summary>
 #if FEATURE_SERIALIZABLE


Mime
View raw message