You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by ni...@apache.org on 2017/06/06 00:11:44 UTC
[11/48] lucenenet git commit: Lucene.Net.Search: Fixed up
documentation comments
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 <= current</code>, or after the iterator has exhausted.
+ /// <c> target <= current</c>, or after the iterator has exhausted.
/// Both cases may result in unpredicted behavior.
- /// <p>
- /// When <code> target > current</code> it behaves as if written:
+ /// <para/>
+ /// When <c> target > current</c> it behaves as if written:
///
- /// <pre class="prettyprint">
- /// int advance(int target) {
- /// int doc;
- /// while ((doc = nextDoc()) < target) {
- /// }
- /// return doc;
+ /// <code>
+ /// int Advance(int target)
+ /// {
+ /// int doc;
+ /// while ((doc = NextDoc()) < 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]