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]
