lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [11/48] lucenenet git commit: Lucene.Net.Search: Fixed up documentation comments
Date Tue, 06 Jun 2017 00:11:44 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/DisjunctionMaxQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/DisjunctionMaxQuery.cs b/src/Lucene.Net/Search/DisjunctionMaxQuery.cs
index ccc2731..dab4dea 100644
--- a/src/Lucene.Net/Search/DisjunctionMaxQuery.cs
+++ b/src/Lucene.Net/Search/DisjunctionMaxQuery.cs
@@ -34,11 +34,13 @@ namespace Lucene.Net.Search
     /// score for that document as produced by any subquery, plus a tie breaking increment
for any additional matching subqueries.
     /// this is useful when searching for a word in multiple fields with different boost
factors (so that the fields cannot be
     /// combined equivalently into a single search field).  We want the primary score to
be the one associated with the highest boost,
-    /// not the sum of the field scores (as BooleanQuery would give).
+    /// not the sum of the field scores (as <see cref="BooleanQuery"/> would give).
+    /// <para/>
     /// If the query is "albino elephant" this ensures that "albino" matching one field and
"elephant" matching
     /// another gets a higher score than "albino" matching both fields.
-    /// To get this result, use both BooleanQuery and DisjunctionMaxQuery:  for each term
a DisjunctionMaxQuery searches for it in
-    /// each field, while the set of these DisjunctionMaxQuery's is combined into a BooleanQuery.
+    /// <para/>
+    /// To get this result, use both <see cref="BooleanQuery"/> and <see cref="DisjunctionMaxQuery"/>:
 for each term a <see cref="DisjunctionMaxQuery"/> searches for it in
+    /// each field, while the set of these <see cref="DisjunctionMaxQuery"/>'s is combined
into a <see cref="BooleanQuery"/>.
     /// The tie breaker capability allows results that include the same term in multiple
fields to be judged better than results that
     /// include this term in only the best of those multiple fields, without confusing this
with the better case of two different terms
     /// in the multiple fields.
@@ -48,27 +50,31 @@ namespace Lucene.Net.Search
 #endif
     public class DisjunctionMaxQuery : Query, IEnumerable<Query>
     {
-        /* The subqueries */
+        /// <summary>
+        /// The subqueries
+        /// </summary>
         private EquatableList<Query> disjuncts = new EquatableList<Query>();
 
-        /* Multiple of the non-max disjunct scores added into our final score.  Non-zero
values support tie-breaking. */
+        /// <summary>
+        /// Multiple of the non-max disjunct scores added into our final score.  Non-zero
values support tie-breaking.
+        /// </summary>
         private float tieBreakerMultiplier = 0.0f;
 
         /// <summary>
-        /// Creates a new empty DisjunctionMaxQuery.  Use add() to add the subqueries. </summary>
-        /// <param name="tieBreakerMultiplier"> the score of each non-maximum disjunct
for a document is multiplied by this weight
+        /// Creates a new empty <see cref="DisjunctionMaxQuery"/>.  Use <see cref="Add(Query)"/>
to add the subqueries. </summary>
+        /// <param name="tieBreakerMultiplier"> The score of each non-maximum disjunct
for a document is multiplied by this weight
         ///        and added into the final score.  If non-zero, the value should be small,
on the order of 0.1, which says that
         ///        10 occurrences of word in a lower-scored field that is also in a higher
scored field is just as good as a unique
-        ///        word in the lower scored field (i.e., one that is not in any higher scored
field. </param>
+        ///        word in the lower scored field (i.e., one that is not in any higher scored
field). </param>
         public DisjunctionMaxQuery(float tieBreakerMultiplier)
         {
             this.tieBreakerMultiplier = tieBreakerMultiplier;
         }
 
         /// <summary>
-        /// Creates a new DisjunctionMaxQuery </summary>
-        /// <param name="disjuncts"> a {@code Collection<Query>} of all the disjuncts
to add </param>
-        /// <param name="tieBreakerMultiplier">   the weight to give to each matching
non-maximum disjunct </param>
+        /// Creates a new <see cref="DisjunctionMaxQuery"/> </summary>
+        /// <param name="disjuncts"> A <see cref="T:ICollection{Query}"/> of
all the disjuncts to add </param>
+        /// <param name="tieBreakerMultiplier"> The weight to give to each matching
non-maximum disjunct </param>
         public DisjunctionMaxQuery(ICollection<Query> disjuncts, float tieBreakerMultiplier)
         {
             this.tieBreakerMultiplier = tieBreakerMultiplier;
@@ -77,7 +83,7 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Add a subquery to this disjunction </summary>
-        /// <param name="query"> the disjunct added </param>
+        /// <param name="query"> The disjunct added </param>
         public virtual void Add(Query query)
         {
             disjuncts.Add(query);
@@ -85,14 +91,14 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Add a collection of disjuncts to this disjunction
-        /// via {@code Iterable<Query>} </summary>
-        /// <param name="disjuncts"> a collection of queries to add as disjuncts. </param>
-        public virtual void Add(ICollection<Query> disjuncts)
+        /// via <see cref="T:ICollection{Query}"/> </summary>
+        /// <param name="disjuncts"> A collection of queries to add as disjuncts. </param>
+        public virtual void Add(ICollection<Query> disjuncts) // LUCENENET TODO: API:
change back to IEnumerable<Query>. Rename AddRange?
         {
             this.disjuncts.AddRange(disjuncts);
         }
 
-        /// <returns> An {@code Iterator<Query>} over the disjuncts </returns>
+        /// <returns> An <see cref="T:IEnumerator{Query}"/> over the disjuncts
</returns>
         public virtual IEnumerator<Query> GetEnumerator()
         {
             return disjuncts.GetEnumerator();
@@ -103,7 +109,7 @@ namespace Lucene.Net.Search
             return GetEnumerator();
         }
 
-        /// <returns> the disjuncts. </returns>
+        /// <returns> The disjuncts. </returns>
         public virtual IList<Query> Disjuncts
         {
             get
@@ -112,7 +118,7 @@ namespace Lucene.Net.Search
             }
         }
 
-        /// <returns> tie breaker value for multiple matches. </returns>
+        /// <returns> Tie breaker value for multiple matches. </returns>
         public virtual float TieBreakerMultiplier
         {
             get
@@ -125,8 +131,8 @@ namespace Lucene.Net.Search
         /// Expert: the Weight for DisjunctionMaxQuery, used to
         /// normalize, score and explain these queries.
         ///
-        /// <p>NOTE: this API and implementation is subject to
-        /// change suddenly in the next release.</p>
+        /// <para>NOTE: this API and implementation is subject to
+        /// change suddenly in the next release.</para>
         /// </summary>
 #if FEATURE_SERIALIZABLE
         [Serializable]
@@ -136,11 +142,11 @@ namespace Lucene.Net.Search
             private readonly DisjunctionMaxQuery outerInstance;
 
             /// <summary>
-            /// The Weights for our subqueries, in 1-1 correspondence with disjuncts </summary>
+            /// The <see cref="Weight"/>s for our subqueries, in 1-1 correspondence
with disjuncts </summary>
             protected List<Weight> m_weights = new List<Weight>(); // The Weight's
for our subqueries, in 1-1 correspondence with disjuncts
 
             /// <summary>
-            /// Construct the Weight for this Query searched by searcher.  Recursively construct
subquery weights. </summary>
+            /// Construct the <see cref="Weight"/> for this <see cref="Search.Query"/>
searched by <paramref name="searcher"/>.  Recursively construct subquery weights. </summary>
             public DisjunctionMaxWeight(DisjunctionMaxQuery outerInstance, IndexSearcher
searcher)
             {
                 this.outerInstance = outerInstance;
@@ -151,17 +157,17 @@ namespace Lucene.Net.Search
             }
 
             /// <summary>
-            /// Return our associated DisjunctionMaxQuery </summary>
+            /// Return our associated <see cref="DisjunctionMaxQuery"/> </summary>
             public override Query Query
             {
                 get
-                /// <summary>
-                /// Compute the sub of squared weights of us applied to our subqueries. 
Used for normalization. </summary>
                 {
                     return outerInstance;
                 }
             }
 
+            /// <summary>
+            /// Compute the sub of squared weights of us applied to our subqueries.  Used
for normalization. </summary>
             public override float GetValueForNormalization()
             {
                 float max = 0.0f, sum = 0.0f;
@@ -187,7 +193,7 @@ namespace Lucene.Net.Search
             }
 
             /// <summary>
-            /// Create the scorer used to score our associated DisjunctionMaxQuery </summary>
+            /// Create the scorer used to score our associated <see cref="DisjunctionMaxQuery"/>
</summary>
             public override Scorer GetScorer(AtomicReaderContext context, IBits acceptDocs)
             {
                 IList<Scorer> scorers = new List<Scorer>();
@@ -237,7 +243,7 @@ namespace Lucene.Net.Search
         } // end of DisjunctionMaxWeight inner class
 
         /// <summary>
-        /// Create the Weight used to score us </summary>
+        /// Create the <see cref="Weight"/> used to score us </summary>
         public override Weight CreateWeight(IndexSearcher searcher)
         {
             return new DisjunctionMaxWeight(this, searcher);
@@ -245,8 +251,8 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Optimize our representation and our subqueries representations </summary>
-        /// <param name="reader"> the IndexReader we query </param>
-        /// <returns> an optimized copy of us (which may not be a copy if there is
nothing to optimize)  </returns>
+        /// <param name="reader"> The <see cref="IndexReader"/> we query </param>
+        /// <returns> An optimized copy of us (which may not be a copy if there is
nothing to optimize)  </returns>
         public override Query Rewrite(IndexReader reader)
         {
             int numDisjunctions = disjuncts.Count;
@@ -290,7 +296,7 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Create a shallow copy of us -- used in rewriting if necessary </summary>
-        /// <returns> a copy of us (but reuse, don't copy, our subqueries)  </returns>
+        /// <returns> A copy of us (but reuse, don't copy, our subqueries)  </returns>
         public override object Clone()
         {
             DisjunctionMaxQuery clone = (DisjunctionMaxQuery)base.Clone();
@@ -298,7 +304,11 @@ namespace Lucene.Net.Search
             return clone;
         }
 
-        // 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)
         {
             foreach (Query query in disjuncts)
@@ -309,8 +319,8 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Prettyprint us. </summary>
-        /// <param name="field"> the field to which we are applied </param>
-        /// <returns> a string that shows what we do, of the form "(disjunct1 | disjunct2
| ... | disjunctn)^boost" </returns>
+        /// <param name="field"> The field to which we are applied </param>
+        /// <returns> A string that shows what we do, of the form "(disjunct1 | disjunct2
| ... | disjunctn)^boost" </returns>
         public override string ToString(string field)
         {
             StringBuilder buffer = new StringBuilder();
@@ -349,9 +359,9 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Return true iff we represent the same query as o </summary>
-        /// <param name="o"> another object </param>
-        /// <returns> true iff o is a DisjunctionMaxQuery with the same boost and the
same subqueries, in the same order, as us </returns>
+        /// Return <c>true</c> if we represent the same query as <paramref
name="o"/> </summary>
+        /// <param name="o"> Another object </param>
+        /// <returns> <c>true</c> if <paramref name="o"/> is a <see
cref="DisjunctionMaxQuery"/> with the same boost and the same subqueries, in the same order,
as us </returns>
         public override bool Equals(object o)
         {
             if (!(o is DisjunctionMaxQuery))

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/DisjunctionMaxScorer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/DisjunctionMaxScorer.cs b/src/Lucene.Net/Search/DisjunctionMaxScorer.cs
index d915790..45bddea 100644
--- a/src/Lucene.Net/Search/DisjunctionMaxScorer.cs
+++ b/src/Lucene.Net/Search/DisjunctionMaxScorer.cs
@@ -20,9 +20,9 @@ namespace Lucene.Net.Search
      */
 
     /// <summary>
-    /// The Scorer for DisjunctionMaxQuery.  The union of all documents generated by the
the subquery scorers
+    /// The <see cref="Scorer"/> for <see cref="DisjunctionMaxQuery"/>.  The
union of all documents generated by the the subquery scorers
     /// is generated in document number order.  The score for each document is the maximum
of the scores computed
-    /// by the subquery scorers that generate that document, plus tieBreakerMultiplier times
the sum of the scores
+    /// by the subquery scorers that generate that document, plus <see cref="tieBreakerMultiplier"/>
times the sum of the scores
     /// for the other subqueries that generate the document.
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -30,24 +30,24 @@ namespace Lucene.Net.Search
 #endif
     internal class DisjunctionMaxScorer : DisjunctionScorer
     {
-        /* Multiplier applied to non-maximum-scoring subqueries for a document as they are
summed into the result. */
+        /// <summary>Multiplier applied to non-maximum-scoring subqueries for a document
as they are summed into the result.</summary>
         private readonly float tieBreakerMultiplier;
         private int freq = -1;
 
-        /* Used when scoring currently matching doc. */
+        /// <summary>Used when scoring currently matching doc.</summary>
         private float scoreSum;
         private float scoreMax;
 
         /// <summary>
-        /// Creates a new instance of DisjunctionMaxScorer
+        /// Creates a new instance of <see cref="DisjunctionMaxScorer"/>
         /// </summary>
         /// <param name="weight">
-        ///          The Weight to be used. </param>
+        ///          The <see cref="Weight"/> to be used. </param>
         /// <param name="tieBreakerMultiplier">
         ///          Multiplier applied to non-maximum-scoring subqueries for a
         ///          document as they are summed into the result. </param>
         /// <param name="subScorers">
-        ///          The sub scorers this Scorer should iterate on </param>
+        ///          The sub scorers this <see cref="Scorer"/> should iterate on </param>
         public DisjunctionMaxScorer(Weight weight, float tieBreakerMultiplier, Scorer[] subScorers)
             : base(weight, subScorers)
         {
@@ -55,8 +55,8 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Determine the current document score.  Initially invalid, until <seealso cref="#nextDoc()"/>
is called the first time. </summary>
-        /// <returns> the score of the current generated document </returns>
+        /// Determine the current document score.  Initially invalid, until <see cref="DocIdSetIterator.NextDoc()"/>
is called the first time. </summary>
+        /// <returns> The score of the current generated document </returns>
         public override float GetScore()
         {
             return scoreMax + (scoreSum - scoreMax) * tieBreakerMultiplier;
@@ -74,7 +74,9 @@ namespace Lucene.Net.Search
             }
         }
 
-        // Recursively iterate all subScorers that generated last doc computing sum and max
+        /// <summary>
+        /// Recursively iterate all subScorers that generated last doc computing sum and
max
+        /// </summary>
         private void ScoreAll(int root)
         {
             if (root < m_numScorers && m_subScorers[root].DocID == m_doc)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/DisjunctionScorer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/DisjunctionScorer.cs b/src/Lucene.Net/Search/DisjunctionScorer.cs
index 528c977..d35e073 100644
--- a/src/Lucene.Net/Search/DisjunctionScorer.cs
+++ b/src/Lucene.Net/Search/DisjunctionScorer.cs
@@ -22,7 +22,7 @@ namespace Lucene.Net.Search
      */
 
     /// <summary>
-    /// Base class for Scorers that score disjunctions.
+    /// Base class for <see cref="Scorer"/>s that score disjunctions.
     /// Currently this just provides helper methods to manage the heap.
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -107,7 +107,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Remove the root Scorer from subScorers and re-establish it as a heap
+        /// Remove the root <see cref="Scorer"/> from subScorers and re-establish it
as a heap
         /// </summary>
         protected void HeapRemoveRoot()
         {
@@ -201,13 +201,13 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Called after next() or advance() land on a new document.
-        /// <p>
-        /// {@code subScorers[0]} will be positioned to the new docid,
-        /// which could be {@code NO_MORE_DOCS} (subclass must handle this).
-        /// <p>
-        /// implementations should assign {@code doc} appropriately, and do any
-        /// other work necessary to implement {@code score()} and {@code freq()}
+        /// Called after <see cref="NextDoc()"/> or <see cref="Advance(int)"/>
land on a new document.
+        /// <para/>
+        /// <c>subScorers[0]</c> will be positioned to the new docid,
+        /// which could be <c>NO_MORE_DOCS</c> (subclass must handle this).
+        /// <para/>
+        /// Implementations should assign <c>doc</c> appropriately, and do any
+        /// other work necessary to implement <see cref="Scorer.GetScore()"/> and <see
cref="Index.DocsEnum.Freq"/>
         /// </summary>
         // TODO: make this less horrible
         protected abstract void AfterNext();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/DisjunctionSumScorer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/DisjunctionSumScorer.cs b/src/Lucene.Net/Search/DisjunctionSumScorer.cs
index 372ae9c..e7ece8e 100644
--- a/src/Lucene.Net/Search/DisjunctionSumScorer.cs
+++ b/src/Lucene.Net/Search/DisjunctionSumScorer.cs
@@ -20,8 +20,8 @@ namespace Lucene.Net.Search
      */
 
     /// <summary>
-    /// A Scorer for OR like queries, counterpart of <code>ConjunctionScorer</code>.
-    /// this Scorer implements <seealso cref="Scorer#advance(int)"/> and uses advance()
on the given Scorers.
+    /// A <see cref="Scorer"/> for OR like queries, counterpart of <see cref="ConjunctionScorer"/>.
+    /// This <see cref="Scorer"/> implements <see cref="DocIdSetIterator.Advance(int)"/>
and uses Advance() on the given <see cref="Scorer"/>s.
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]
@@ -36,7 +36,7 @@ namespace Lucene.Net.Search
         private readonly float[] coord;
 
         /// <summary>
-        /// Construct a <code>DisjunctionScorer</code>. </summary>
+        /// Construct a <see cref="DisjunctionScorer"/>. </summary>
         /// <param name="weight"> The weight to be used. </param>
         /// <param name="subScorers"> Array of at least two subscorers. </param>
         /// <param name="coord"> Table of coordination factors </param>
@@ -80,7 +80,7 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Returns the score of the current document matching the query.
-        /// Initially invalid, until <seealso cref="#nextDoc()"/> is called the first
time.
+        /// Initially invalid, until <see cref="DisjunctionScorer.NextDoc()"/> is called
the first time.
         /// </summary>
         public override float GetScore()
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/DocIdSet.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/DocIdSet.cs b/src/Lucene.Net/Search/DocIdSet.cs
index 154ab0a..7528f20 100644
--- a/src/Lucene.Net/Search/DocIdSet.cs
+++ b/src/Lucene.Net/Search/DocIdSet.cs
@@ -22,8 +22,8 @@ namespace Lucene.Net.Search
     using IBits = Lucene.Net.Util.IBits;
 
     /// <summary>
-    /// A DocIdSet contains a set of doc ids. Implementing classes must
-    /// only implement <seealso cref="#iterator"/> to provide access to the set.
+    /// A <see cref="DocIdSet"/> contains a set of doc ids. Implementing classes must
+    /// only implement <see cref="GetIterator()"/> to provide access to the set.
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]
@@ -31,8 +31,8 @@ namespace Lucene.Net.Search
     public abstract class DocIdSet
     {
         /// <summary>
-        /// Provides a <seealso cref="DocIdSetIterator"/> to access the set.
-        /// this implementation can return <code>null</code> if there
+        /// Provides a <see cref="DocIdSetIterator"/> to access the set.
+        /// This implementation can return <c>null</c> if there
         /// are no docs that match.
         /// </summary>
         public abstract DocIdSetIterator GetIterator();
@@ -45,29 +45,29 @@ namespace Lucene.Net.Search
         // (down-low filtering using e.g. FixedBitSet)
 
         /// <summary>
-        /// Optionally provides a <seealso cref="GetBits"/> interface for random access
+        /// Optionally provides a <see cref="IBits"/> interface for random access
         /// to matching documents. </summary>
-        /// <returns> {@code null}, if this {@code DocIdSet} does not support random
access.
-        /// In contrast to <see cref="GetIterator()"/>, a return value of {@code null}
+        /// <returns> <c>null</c>, if this <see cref="DocIdSet"/>
does not support random access.
+        /// In contrast to <see cref="GetIterator()"/>, a return value of <c>null</c>
         /// <b>does not</b> imply that no documents match the filter!
         /// The default implementation does not provide random access, so you
-        /// only need to implement this method if your DocIdSet can
+        /// only need to implement this method if your <see cref="DocIdSet"/> can
         /// guarantee random access to every docid in O(1) time without
-        /// external disk access (as <seealso cref="GetBits"/> interface cannot throw
-        /// <seealso cref="IOException"/>). this is generally true for bit sets
-        /// like <seealso cref="Lucene.Net.Util.FixedBitSet"/>, which return
-        /// itself if they are used as {@code DocIdSet}. </returns>
+        /// external disk access (as <see cref="IBits"/> interface cannot throw
+        /// <see cref="System.IO.IOException"/>). This is generally true for bit sets
+        /// like <see cref="Lucene.Net.Util.FixedBitSet"/>, which return
+        /// itself if they are used as <see cref="DocIdSet"/>. </returns>
         public virtual IBits Bits // LUCENENET NOTE: This isn't a great candidate for a property,
but it makes more sense to call this Bits than Bits(). GetBits() was already taken in the
same context.
         {
             get { return null; }
         }
 
         /// <summary>
-        /// this method is a hint for <seealso cref="CachingWrapperFilter"/>, if this
<code>DocIdSet</code>
+        /// This method is a hint for <see cref="CachingWrapperFilter"/>, if this <see
cref="DocIdSet"/>
         /// should be cached without copying it. The default is to return
-        /// <code>false</code>. If you have an own <code>DocIdSet</code>
implementation
+        /// <c>false</c>. If you have an own <see cref="DocIdSet"/> implementation
         /// that does its iteration very effective and fast without doing disk I/O,
-        /// override this method and return <code>true</code>.
+        /// override this property and return <c>true</c>.
         /// </summary>
         public virtual bool IsCacheable
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/DocIdSetIterator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/DocIdSetIterator.cs b/src/Lucene.Net/Search/DocIdSetIterator.cs
index cca215c..ca91594 100644
--- a/src/Lucene.Net/Search/DocIdSetIterator.cs
+++ b/src/Lucene.Net/Search/DocIdSetIterator.cs
@@ -21,9 +21,9 @@ namespace Lucene.Net.Search
      */
 
     /// <summary>
-    /// this abstract class defines methods to iterate over a set of non-decreasing
+    /// This abstract class defines methods to iterate over a set of non-decreasing
     /// doc ids. Note that this class assumes it iterates on doc Ids, and therefore
-    /// <seealso cref="#NO_MORE_DOCS"/> is set to {@value #NO_MORE_DOCS} in order to
be used as
+    /// <see cref="NO_MORE_DOCS"/> is set to <see cref="int.MaxValue"/> in order
to be used as
     /// a sentinel object. Implementations of this class are expected to consider
     /// <see cref="int.MaxValue"/> as an invalid value.
     /// </summary>
@@ -33,7 +33,7 @@ namespace Lucene.Net.Search
     public abstract class DocIdSetIterator
     {
         /// <summary>
-        /// An empty {@code DocIdSetIterator} instance </summary>
+        /// An empty <see cref="DocIdSetIterator"/> instance </summary>
         public static DocIdSetIterator GetEmpty()
         {
             return new DocIdSetIteratorAnonymousInnerClassHelper();
@@ -74,20 +74,20 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// When returned by <seealso cref="#nextDoc()"/>, <seealso cref="#advance(int)"/>
and
-        /// <seealso cref="#docID()"/> it means there are no more docs in the iterator.
+        /// When returned by <see cref="NextDoc()"/>, <see cref="Advance(int)"/>
and
+        /// <see cref="DocID()"/> it means there are no more docs in the iterator.
         /// </summary>
         public const int NO_MORE_DOCS = int.MaxValue;
 
         /// <summary>
         /// Returns the following:
-        /// <ul>
-        /// <li>-1 or <seealso cref="#NO_MORE_DOCS"/> if <seealso cref="#nextDoc()"/>
or
-        /// <seealso cref="#advance(int)"/> were not called yet.
-        /// <li><seealso cref="#NO_MORE_DOCS"/> if the iterator has exhausted.
-        /// <li>Otherwise it should return the doc ID it is currently on.
-        /// </ul>
-        /// <p>
+        /// <list type="bullet">
+        /// <item><description>-1 or <see cref="NO_MORE_DOCS"/> if <see
cref="NextDoc()"/> or
+        /// <seealso cref="Advance(int)"/> were not called yet.</description></item>
+        /// <item><description><see cref="NO_MORE_DOCS"/> if the iterator
has exhausted.</description></item>
+        /// <item><description>Otherwise it should return the doc ID it is currently
on.</description></item>
+        /// </list>
+        /// <para/>
         ///
         /// @since 2.9
         /// </summary>
@@ -95,12 +95,12 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Advances to the next document in the set and returns the doc it is
-        /// currently on, or <seealso cref="#NO_MORE_DOCS"/> if there are no more docs
in the
-        /// set.<br>
+        /// currently on, or <see cref="NO_MORE_DOCS"/> if there are no more docs in
the
+        /// set.
         ///
-        /// <b>NOTE:</b> after the iterator has exhausted you should not call
this
+        /// <para/><b>NOTE:</b> after the iterator has exhausted you should
not call this
         /// method, as it may result in unpredicted behavior.
-        ///
+        /// <para/>
         /// @since 2.9
         /// </summary>
         public abstract int NextDoc();
@@ -108,39 +108,41 @@ namespace Lucene.Net.Search
         /// <summary>
         /// Advances to the first beyond the current whose document number is greater
         /// than or equal to <i>target</i>, and returns the document number itself.
-        /// Exhausts the iterator and returns <seealso cref="#NO_MORE_DOCS"/> if <i>target</i>
+        /// Exhausts the iterator and returns <see cref="NO_MORE_DOCS"/> if <i>target</i>
         /// is greater than the highest document number in the set.
-        /// <p>
+        /// <para/>
         /// The behavior of this method is <b>undefined</b> when called with
-        /// <code> target &lt;= current</code>, or after the iterator has
exhausted.
+        /// <c> target &lt;= current</c>, or after the iterator has exhausted.
         /// Both cases may result in unpredicted behavior.
-        /// <p>
-        /// When <code> target &gt; current</code> it behaves as if written:
+        /// <para/>
+        /// When <c> target &gt; current</c> it behaves as if written:
         ///
-        /// <pre class="prettyprint">
-        /// int advance(int target) {
-        ///   int doc;
-        ///   while ((doc = nextDoc()) &lt; target) {
-        ///   }
-        ///   return doc;
+        /// <code>
+        /// int Advance(int target) 
+        /// {
+        ///     int doc;
+        ///     while ((doc = NextDoc()) &lt; target) 
+        ///     {
+        ///     }
+        ///     return doc;
         /// }
-        /// </pre>
+        /// </code>
         ///
         /// Some implementations are considerably more efficient than that.
-        /// <p>
-        /// <b>NOTE:</b> this method may be called with <seealso cref="#NO_MORE_DOCS"/>
for
-        /// efficiency by some Scorers. If your implementation cannot efficiently
+        /// <para/>
+        /// <b>NOTE:</b> this method may be called with <see cref="NO_MORE_DOCS"/>
for
+        /// efficiency by some <see cref="Scorer"/>s. If your implementation cannot
efficiently
         /// determine that it should exhaust, it is recommended that you check for that
         /// value in each call to this method.
-        /// <p>
+        /// <para/>
         ///
         /// @since 2.9
         /// </summary>
         public abstract int Advance(int target);
 
         /// <summary>
-        /// Slow (linear) implementation of <seealso cref="#advance"/> relying on
-        ///  <seealso cref="#nextDoc()"/> to advance beyond the target position.
+        /// Slow (linear) implementation of <see cref="Advance(int)"/> relying on
+        /// <see cref="NextDoc()"/> to advance beyond the target position.
         /// </summary>
         protected internal int SlowAdvance(int target)
         {
@@ -154,9 +156,9 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Returns the estimated cost of this <seealso cref="DocIdSetIterator"/>.
-        /// <p>
-        /// this is generally an upper bound of the number of documents this iterator
+        /// Returns the estimated cost of this <see cref="DocIdSetIterator"/>.
+        /// <para/>
+        /// This is generally an upper bound of the number of documents this iterator
         /// might match, but may be a rough heuristic, hardcoded value, or otherwise
         /// completely inaccurate.
         /// </summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/DocTermOrdsRangeFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/DocTermOrdsRangeFilter.cs b/src/Lucene.Net/Search/DocTermOrdsRangeFilter.cs
index 5d59a29..b2830d3 100644
--- a/src/Lucene.Net/Search/DocTermOrdsRangeFilter.cs
+++ b/src/Lucene.Net/Search/DocTermOrdsRangeFilter.cs
@@ -27,11 +27,11 @@ namespace Lucene.Net.Search
     using SortedSetDocValues = Lucene.Net.Index.SortedSetDocValues;
 
     /// <summary>
-    /// A range filter built on top of a cached multi-valued term field (in <seealso cref="IFieldCache"/>).
+    /// A range filter built on top of a cached multi-valued term field (in <see cref="IFieldCache"/>).
     ///
-    /// <p>Like <seealso cref="FieldCacheRangeFilter"/>, this is just a specialized
range query versus
-    ///    using a TermRangeQuery with <seealso cref="DocTermOrdsRewriteMethod"/>:
it will only do
-    ///    two ordinal to term lookups.</p>
+    /// <para>Like <see cref="FieldCacheRangeFilter"/>, this is just a specialized
range query versus
+    ///    using a <see cref="TermRangeQuery"/> with <see cref="DocTermOrdsRewriteMethod"/>:
it will only do
+    ///    two ordinal to term lookups.</para>
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]
@@ -54,13 +54,13 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// this method is implemented for each data type </summary>
+        /// This method is implemented for each data type </summary>
         public override abstract DocIdSet GetDocIdSet(AtomicReaderContext context, IBits
acceptDocs);
 
         /// <summary>
-        /// Creates a BytesRef range filter using <seealso cref="IFieldCache#getTermsIndex"/>.
this works with all
+        /// Creates a BytesRef range filter using <see cref="IFieldCache.GetTermsIndex(Index.AtomicReader,
string, float)"/>. This works with all
         /// fields containing zero or one term in the field. The range can be half-open by
setting one
-        /// of the values to <code>null</code>.
+        /// of the values to <c>null</c>.
         /// </summary>
         public static DocTermOrdsRangeFilter NewBytesRefRange(string field, BytesRef lowerVal,
BytesRef upperVal, bool includeLower, bool includeUpper)
         {
@@ -232,14 +232,14 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Returns <code>true</code> if the lower endpoint is inclusive </summary>
+        /// Returns <c>true</c> if the lower endpoint is inclusive </summary>
         public virtual bool IncludesLower
         {
             get { return includeLower; }
         }
 
         /// <summary>
-        /// Returns <code>true</code> if the upper endpoint is inclusive </summary>
+        /// Returns <c>true</c> if the upper endpoint is inclusive </summary>
         public virtual bool IncludesUpper
         {
             get { return includeUpper; }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/DocTermOrdsRewriteMethod.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/DocTermOrdsRewriteMethod.cs b/src/Lucene.Net/Search/DocTermOrdsRewriteMethod.cs
index 28f2326..77ddffa 100644
--- a/src/Lucene.Net/Search/DocTermOrdsRewriteMethod.cs
+++ b/src/Lucene.Net/Search/DocTermOrdsRewriteMethod.cs
@@ -31,9 +31,10 @@ namespace Lucene.Net.Search
     using TermsEnum = Lucene.Net.Index.TermsEnum;
 
     /// <summary>
-    /// Rewrites MultiTermQueries into a filter, using DocTermOrds for term enumeration.
-    /// <p>
-    /// this can be used to perform these queries against an unindexed docvalues field.
+    /// Rewrites <see cref="MultiTermQuery"/>s into a filter, using DocTermOrds for
term enumeration.
+    /// <para>
+    /// This can be used to perform these queries against an unindexed docvalues field.
+    /// </para>
     /// @lucene.experimental
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -56,7 +57,7 @@ namespace Lucene.Net.Search
             protected readonly MultiTermQuery m_query;
 
             /// <summary>
-            /// Wrap a <seealso cref="MultiTermQuery"/> as a Filter.
+            /// Wrap a <see cref="MultiTermQuery"/> as a <see cref="Filter"/>.
             /// </summary>
             protected internal MultiTermQueryDocTermOrdsWrapperFilter(MultiTermQuery query)
             {
@@ -102,7 +103,7 @@ namespace Lucene.Net.Search
             }
 
             /// <summary>
-            /// Returns a DocIdSet with documents that should be permitted in search
+            /// Returns a <see cref="DocIdSet"/> with documents that should be permitted
in search
             /// results.
             /// </summary>
             public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/Explanation.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/Explanation.cs b/src/Lucene.Net/Search/Explanation.cs
index 09e146a..f2c2de1 100644
--- a/src/Lucene.Net/Search/Explanation.cs
+++ b/src/Lucene.Net/Search/Explanation.cs
@@ -43,12 +43,12 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Indicates whether or not this Explanation models a good match.
+        /// Indicates whether or not this <see cref="Explanation"/> models a good match.
         ///
-        /// <p>
+        /// <para>
         /// By default, an Explanation represents a "match" if the value is positive.
-        /// </p> </summary>
-        /// <seealso cref= #getValue </seealso>
+        /// </para> </summary>
+        /// <seealso cref="Value"/>
         public virtual bool IsMatch
         {
             get
@@ -58,7 +58,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// The value assigned to this explanation node. </summary>
+        /// Gets or Sets the value assigned to this explanation node. </summary>
         public virtual float Value
         {
             get
@@ -72,7 +72,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// A description of this explanation node. </summary>
+        /// Gets or Sets the description of this explanation node. </summary>
         public virtual string Description
         {
             get
@@ -87,7 +87,7 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// A short one line summary which should contain all high level
-        /// information about this Explanation, without the "Details"
+        /// information about this <see cref="Explanation"/>, without the "Details"
         /// </summary>
         protected virtual string GetSummary()
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/FakeScorer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/FakeScorer.cs b/src/Lucene.Net/Search/FakeScorer.cs
index 33f454b..c2e87aa 100644
--- a/src/Lucene.Net/Search/FakeScorer.cs
+++ b/src/Lucene.Net/Search/FakeScorer.cs
@@ -21,8 +21,8 @@ namespace Lucene.Net.Search
      */
 
     /// <summary>
-    /// Used by <seealso cref="BulkScorer"/>s that need to pass a {@link
-    ///  Scorer} to <seealso cref="ICollector#setScorer"/>.
+    /// Used by <see cref="BulkScorer"/>s that need to pass a
+    /// <see cref="Scorer"/> to <see cref="ICollector.SetScorer(Scorer)"/>.
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]


Mime
View raw message