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:40 UTC
[07/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/HitQueue.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/HitQueue.cs b/src/Lucene.Net/Search/HitQueue.cs
index dd67264..23c67bf 100644
--- a/src/Lucene.Net/Search/HitQueue.cs
+++ b/src/Lucene.Net/Search/HitQueue.cs
@@ -27,43 +27,45 @@ namespace Lucene.Net.Search
internal sealed class HitQueue : PriorityQueue<ScoreDoc>
{
/// <summary>
- /// Creates a new instance with <code>size</code> elements. If
- /// <code>prePopulate</code> is set to true, the queue will pre-populate itself
- /// with sentinel objects and set its <seealso cref="#size()"/> to <code>size</code>. In
- /// that case, you should not rely on <seealso cref="#size()"/> to get the number of
- /// actual elements that were added to the queue, but keep track yourself.<br>
- /// <b>NOTE:</b> in case <code>prePopulate</code> is true, you should pop
+ /// Creates a new instance with <paramref name="size"/> elements. If
+ /// <paramref name="prePopulate"/> is set to <c>true</c>, the queue will pre-populate itself
+ /// with sentinel objects and set its <see cref="PriorityQueue{T}.Count"/> to <paramref name="size"/>. In
+ /// that case, you should not rely on <see cref="PriorityQueue{T}.Count"/> to get the number of
+ /// actual elements that were added to the queue, but keep track yourself.
+ /// <para/>
+ /// <b>NOTE:</b> in case <paramref name="prePopulate"/> is <c>true</c>, you should pop
/// elements from the queue using the following code example:
///
- /// <pre class="prettyprint">
+ /// <code>
/// PriorityQueue<ScoreDoc> pq = new HitQueue(10, true); // pre-populate.
- /// ScoreDoc top = pq.top();
+ /// ScoreDoc top = pq.Top;
///
/// // Add/Update one element.
- /// top.score = 1.0f;
- /// top.doc = 0;
- /// top = (ScoreDoc) pq.updateTop();
+ /// top.Score = 1.0f;
+ /// top.Soc = 0;
+ /// top = (ScoreDoc) pq.UpdateTop();
/// int totalHits = 1;
///
/// // Now pop only the elements that were *truly* inserted.
- /// // First, pop all the sentinel elements (there are pq.size() - totalHits).
- /// for (int i = pq.size() - totalHits; i > 0; i--) pq.pop();
+ /// // First, pop all the sentinel elements (there are pq.Count - totalHits).
+ /// for (int i = pq.Count - totalHits; i > 0; i--) pq.Pop();
///
/// // Now pop the truly added elements.
/// ScoreDoc[] results = new ScoreDoc[totalHits];
- /// for (int i = totalHits - 1; i >= 0; i--) {
- /// results[i] = (ScoreDoc) pq.pop();
+ /// for (int i = totalHits - 1; i >= 0; i--)
+ /// {
+ /// results[i] = (ScoreDoc)pq.Pop();
/// }
- /// </pre>
+ /// </code>
///
- /// <p><b>NOTE</b>: this class pre-allocate a full array of
- /// length <code>size</code>.
+ /// <para/><b>NOTE</b>: this class pre-allocate a full array of
+ /// length <paramref name="size"/>.
/// </summary>
/// <param name="size">
- /// the requested size of this queue. </param>
+ /// The requested size of this queue. </param>
/// <param name="prePopulate">
- /// specifies whether to pre-populate the queue with sentinel values. </param>
- /// <seealso cref= #getSentinelObject() </seealso>
+ /// Specifies whether to pre-populate the queue with sentinel values. </param>
+ /// <seealso cref="GetSentinelObject()"/>
internal HitQueue(int size, bool prePopulate)
: base(size, prePopulate)
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/IMaxNonCompetitiveBoostAttribute.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/IMaxNonCompetitiveBoostAttribute.cs b/src/Lucene.Net/Search/IMaxNonCompetitiveBoostAttribute.cs
deleted file mode 100644
index 4b2a2d0..0000000
--- a/src/Lucene.Net/Search/IMaxNonCompetitiveBoostAttribute.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-using Lucene.Net.Util;
-using BytesRef = Lucene.Net.Util.BytesRef;
-
-namespace Lucene.Net.Search
-{
- /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
- /// <summary>
- /// Add this <seealso cref="Attribute"/> to a fresh <seealso cref="AttributeSource"/> before calling
- /// <seealso cref="MultiTermQuery#getTermsEnum(Terms,AttributeSource)"/>.
- /// <seealso cref="FuzzyQuery"/> is using this to control its internal behaviour
- /// to only return competitive terms.
- /// <p><b>Please note:</b> this attribute is intended to be added by the <seealso cref="MultiTermQuery.RewriteMethod"/>
- /// to an empty <seealso cref="AttributeSource"/> that is shared for all segments
- /// during query rewrite. this attribute source is passed to all segment enums
- /// on <seealso cref="MultiTermQuery#getTermsEnum(Terms,AttributeSource)"/>.
- /// <seealso cref="TopTermsRewrite"/> uses this attribute to
- /// inform all enums about the current boost, that is not competitive.
- /// @lucene.internal
- /// </summary>
- public interface IMaxNonCompetitiveBoostAttribute : IAttribute
- {
- /// <summary>
- /// this is the maximum boost that would not be competitive. </summary>
- float MaxNonCompetitiveBoost { set; get; }
-
- /// <summary>
- /// this is the term or <code>null</code> of the term that triggered the boost change. </summary>
- BytesRef CompetitiveTerm { set; get; }
- }
-}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/ITopTermsRewrite.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/ITopTermsRewrite.cs b/src/Lucene.Net/Search/ITopTermsRewrite.cs
deleted file mode 100644
index 747fc00..0000000
--- a/src/Lucene.Net/Search/ITopTermsRewrite.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-namespace Lucene.Net.Search
-{
- /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
- internal interface ITopTermsRewrite
- {
- int Count { get; } // LUCENENET NOTE: This was size() in Lucene.
- }
-}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/IndexSearcher.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/IndexSearcher.cs b/src/Lucene.Net/Search/IndexSearcher.cs
index 89bf357..e7acb6e 100644
--- a/src/Lucene.Net/Search/IndexSearcher.cs
+++ b/src/Lucene.Net/Search/IndexSearcher.cs
@@ -40,30 +40,30 @@ namespace Lucene.Net.Search
using Terms = Lucene.Net.Index.Terms;
/// <summary>
- /// Implements search over a single IndexReader.
+ /// Implements search over a single <see cref="Index.IndexReader"/>.
///
- /// <p>Applications usually need only call the inherited
- /// <seealso cref="#search(Query,int)"/>
- /// or <seealso cref="#search(Query,Filter,int)"/> methods. For
+ /// <para/>Applications usually need only call the inherited
+ /// <see cref="Search(Query,int)"/>
+ /// or <see cref="Search(Query,Filter,int)"/> methods. For
/// performance reasons, if your index is unchanging, you
- /// should share a single IndexSearcher instance across
+ /// should share a single <see cref="IndexSearcher"/> instance across
/// multiple searches instead of creating a new one
/// per-search. If your index has changed and you wish to
/// see the changes reflected in searching, you should
- /// use <seealso cref="DirectoryReader#openIfChanged(DirectoryReader)"/>
+ /// use <see cref="Index.DirectoryReader.OpenIfChanged(Index.DirectoryReader)"/>
/// to obtain a new reader and
- /// then create a new IndexSearcher from that. Also, for
+ /// then create a new <see cref="IndexSearcher"/> from that. Also, for
/// low-latency turnaround it's best to use a near-real-time
- /// reader (<seealso cref="DirectoryReader#open(IndexWriter,boolean)"/>).
- /// Once you have a new <seealso cref="IndexReader"/>, it's relatively
- /// cheap to create a new IndexSearcher from it.
+ /// reader (<see cref="Index.DirectoryReader.Open(Index.IndexWriter,bool)"/>).
+ /// Once you have a new <see cref="Index.IndexReader"/>, it's relatively
+ /// cheap to create a new <see cref="IndexSearcher"/> from it.
///
- /// <a name="thread-safety"></a><p><b>NOTE</b>: <code>{@link
- /// IndexSearcher}</code> instances are completely
+ /// <para/><a name="thread-safety"></a><p><b>NOTE</b>:
+ /// <see cref="IndexSearcher"/> instances are completely
/// thread safe, meaning multiple threads can call any of its
/// methods, concurrently. If your application requires
/// external synchronization, you should <b>not</b>
- /// synchronize on the <code>IndexSearcher</code> instance;
+ /// synchronize on the <see cref="IndexSearcher"/> instance;
/// use your own (non-Lucene) objects instead.</p>
/// </summary>
#if FEATURE_SERIALIZABLE
@@ -80,7 +80,7 @@ namespace Lucene.Net.Search
protected internal readonly IList<AtomicReaderContext> m_leafContexts;
/// <summary>
- /// used with executor - each slice holds a set of leafs executed within one thread </summary>
+ /// Used with executor - each slice holds a set of leafs executed within one thread </summary>
protected readonly LeafSlice[] m_leafSlices;
// These are only used for multi-threaded search
@@ -90,10 +90,11 @@ namespace Lucene.Net.Search
private static readonly Similarity defaultSimilarity = new DefaultSimilarity();
/// <summary>
- /// Expert: returns a default Similarity instance.
+ /// Expert: returns a default <see cref="Similarities.Similarity"/> instance.
/// In general, this method is only called to initialize searchers and writers.
/// User code and query implementations should respect
- /// <seealso cref="IndexSearcher#getSimilarity()"/>.
+ /// <see cref="IndexSearcher.Similarity"/>.
+ /// <para/>
/// @lucene.internal
/// </summary>
public static Similarity DefaultSimilarity
@@ -105,7 +106,7 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// The Similarity implementation used by this searcher. </summary>
+ /// The <see cref="Similarities.Similarity"/> implementation used by this searcher. </summary>
private Similarity similarity = defaultSimilarity;
/// <summary>
@@ -117,15 +118,10 @@ namespace Lucene.Net.Search
/// <summary>
/// Runs searches for each segment separately, using the
- /// provided ExecutorService. IndexSearcher will not
- /// shutdown/awaitTermination this ExecutorService on
- /// close; you must do so, eventually, on your own. NOTE:
- /// if you are using <seealso cref="NIOFSDirectory"/>, do not use
- /// the shutdownNow method of ExecutorService as this uses
- /// Thread.interrupt under-the-hood which can silently
- /// close file descriptors (see <a
- /// href="https://issues.apache.org/jira/browse/LUCENE-2239">LUCENE-2239</a>).
- ///
+ /// provided <see cref="TaskScheduler"/>. <see cref="IndexSearcher"/> will not
+ /// shutdown/awaitTermination this <see cref="TaskScheduler"/> on
+ /// dispose; you must do so, eventually, on your own.
+ /// <para/>
/// @lucene.experimental
/// </summary>
public IndexSearcher(IndexReader r, TaskScheduler executor)
@@ -134,20 +130,17 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// Creates a searcher searching the provided top-level <seealso cref="IndexReaderContext"/>.
- /// <p>
- /// Given a non-<code>null</code> <seealso cref="ExecutorService"/> this method runs
- /// searches for each segment separately, using the provided ExecutorService.
- /// IndexSearcher will not shutdown/awaitTermination this ExecutorService on
- /// close; you must do so, eventually, on your own. NOTE: if you are using
- /// <seealso cref="NIOFSDirectory"/>, do not use the shutdownNow method of
- /// ExecutorService as this uses Thread.interrupt under-the-hood which can
- /// silently close file descriptors (see <a
- /// href="https://issues.apache.org/jira/browse/LUCENE-2239">LUCENE-2239</a>).
+ /// Creates a searcher searching the provided top-level <see cref="IndexReaderContext"/>.
+ /// <para/>
+ /// Given a non-<c>null</c> <see cref="TaskScheduler"/> this method runs
+ /// searches for each segment separately, using the provided <see cref="TaskScheduler"/>.
+ /// <see cref="IndexSearcher"/> will not shutdown/awaitTermination this <see cref="TaskScheduler"/> on
+ /// close; you must do so, eventually, on your own.
+ /// <para/>
+ /// @lucene.experimental
/// </summary>
- /// <seealso cref= IndexReaderContext </seealso>
- /// <seealso cref= IndexReader#getContext()
- /// @lucene.experimental </seealso>
+ /// <seealso cref="IndexReaderContext"/>
+ /// <seealso cref="IndexReader.Context"/>
public IndexSearcher(IndexReaderContext context, TaskScheduler executor)
{
Debug.Assert(context.IsTopLevel, "IndexSearcher's ReaderContext must be topLevel for reader" + context.Reader);
@@ -159,11 +152,12 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// Creates a searcher searching the provided top-level <seealso cref="IndexReaderContext"/>.
+ /// Creates a searcher searching the provided top-level <see cref="IndexReaderContext"/>.
+ /// <para/>
+ /// @lucene.experimental
/// </summary>
- /// <seealso cref= IndexReaderContext </seealso>
- /// <seealso cref= IndexReader#getContext()
- /// @lucene.experimental </seealso>
+ /// <seealso cref="IndexReaderContext"/>
+ /// <seealso cref="IndexReader.Context"/>
public IndexSearcher(IndexReaderContext context)
: this(context, null)
{
@@ -171,8 +165,8 @@ namespace Lucene.Net.Search
/// <summary>
/// Expert: Creates an array of leaf slices each holding a subset of the given leaves.
- /// Each <seealso cref="LeafSlice"/> is executed in a single thread. By default there
- /// will be one <seealso cref="LeafSlice"/> per leaf (<seealso cref="AtomicReaderContext"/>).
+ /// Each <see cref="LeafSlice"/> is executed in a single thread. By default there
+ /// will be one <see cref="LeafSlice"/> per leaf (<see cref="AtomicReaderContext"/>).
/// </summary>
protected virtual LeafSlice[] Slices(IList<AtomicReaderContext> leaves)
{
@@ -185,7 +179,7 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// Return the <seealso cref="IndexReader"/> this searches. </summary>
+ /// Return the <see cref="Index.IndexReader"/> this searches. </summary>
public virtual IndexReader IndexReader
{
get
@@ -195,30 +189,30 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// Sugar for <code>.getIndexReader().document(docID)</code> </summary>
- /// <seealso cref= IndexReader#document(int) </seealso>
+ /// Sugar for <code>.IndexReader.Document(docID)</code> </summary>
+ /// <seealso cref="IndexReader.Document(int)"/>
public virtual Document Doc(int docID)
{
return reader.Document(docID);
}
/// <summary>
- /// Sugar for <code>.getIndexReader().document(docID, fieldVisitor)</code> </summary>
- /// <seealso cref= IndexReader#document(int, StoredFieldVisitor) </seealso>
+ /// Sugar for <code>.IndexReader.Document(docID, fieldVisitor)</code> </summary>
+ /// <seealso cref="IndexReader.Document(int, StoredFieldVisitor)"/>
public virtual void Doc(int docID, StoredFieldVisitor fieldVisitor)
{
reader.Document(docID, fieldVisitor);
}
/// <summary>
- /// Sugar for <code>.getIndexReader().document(docID, fieldsToLoad)</code> </summary>
- /// <seealso cref= IndexReader#document(int, Set) </seealso>
+ /// Sugar for <code>.IndexReader.Document(docID, fieldsToLoad)</code> </summary>
+ /// <seealso cref="IndexReader.Document(int, ISet{string})"/>
public virtual Document Doc(int docID, ISet<string> fieldsToLoad)
{
return reader.Document(docID, fieldsToLoad);
}
- /// @deprecated Use <seealso cref="#doc(int, Set)"/> instead.
+ /// @deprecated Use <see cref="Doc(int, ISet{string})"/> instead.
[Obsolete("Use <seealso cref=#doc(int, java.util.Set)/> instead.")]
public Document Document(int docID, ISet<string> fieldsToLoad)
{
@@ -226,8 +220,7 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// Expert: Set the Similarity implementation used by this IndexSearcher.
- ///
+ /// Expert: Set the <see cref="Similarities.Similarity"/> implementation used by this IndexSearcher.
/// </summary>
public virtual Similarity Similarity
{
@@ -249,54 +242,54 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// Finds the top <code>n</code>
- /// hits for <code>query</code> where all results are after a previous
- /// result (<code>after</code>).
- /// <p>
- /// By passing the bottom result from a previous page as <code>after</code>,
+ /// Finds the top <paramref name="n"/>
+ /// hits for top <paramref name="query"/> where all results are after a previous
+ /// result (top <paramref name="after"/>).
+ /// <para/>
+ /// By passing the bottom result from a previous page as <paramref name="after"/>,
/// this method can be used for efficient 'deep-paging' across potentially
/// large result sets.
/// </summary>
/// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
- /// <seealso cref="BooleanQuery#getMaxClauseCount()"/> clauses. </exception>
+ /// <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
public virtual TopDocs SearchAfter(ScoreDoc after, Query query, int n)
{
return Search(CreateNormalizedWeight(query), after, n);
}
/// <summary>
- /// Finds the top <code>n</code>
- /// hits for <code>query</code>, applying <code>filter</code> if non-null,
- /// where all results are after a previous result (<code>after</code>).
- /// <p>
- /// By passing the bottom result from a previous page as <code>after</code>,
+ /// Finds the top <paramref name="n"/>
+ /// hits for <paramref name="query"/>, applying <paramref name="filter"/> if non-null,
+ /// where all results are after a previous result (<paramref name="after"/>).
+ /// <para/>
+ /// By passing the bottom result from a previous page as <paramref name="after"/>,
/// this method can be used for efficient 'deep-paging' across potentially
/// large result sets.
/// </summary>
/// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
- /// <seealso cref="BooleanQuery#getMaxClauseCount()"/> clauses. </exception>
+ /// <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
public virtual TopDocs SearchAfter(ScoreDoc after, Query query, Filter filter, int n)
{
return Search(CreateNormalizedWeight(WrapFilter(query, filter)), after, n);
}
/// <summary>
- /// Finds the top <code>n</code>
- /// hits for <code>query</code>.
+ /// Finds the top <paramref name="n"/>
+ /// hits for <paramref name="query"/>.
/// </summary>
/// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
- /// <seealso cref="BooleanQuery#getMaxClauseCount()"/> clauses. </exception>
+ /// <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
public virtual TopDocs Search(Query query, int n)
{
return Search(query, null, n);
}
/// <summary>
- /// Finds the top <code>n</code>
- /// hits for <code>query</code>, applying <code>filter</code> if non-null.
+ /// Finds the top <paramref name="n"/>
+ /// hits for <paramref name="query"/>, applying <paramref name="filter"/> if non-null.
/// </summary>
/// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
- /// <seealso cref="BooleanQuery#getMaxClauseCount()"/> clauses. </exception>
+ /// <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
public virtual TopDocs Search(Query query, Filter filter, int n)
{
return Search(CreateNormalizedWeight(WrapFilter(query, filter)), null, n);
@@ -305,14 +298,14 @@ namespace Lucene.Net.Search
/// <summary>
/// Lower-level search API.
///
- /// <p><seealso cref="ICollector#collect(int)"/> is called for every matching
+ /// <para/><see cref="ICollector.Collect(int)"/> is called for every matching
/// document.
/// </summary>
- /// <param name="query"> to match documents </param>
- /// <param name="filter"> if non-null, used to permit documents to be collected. </param>
- /// <param name="results"> to receive hits </param>
+ /// <param name="query"> To match documents </param>
+ /// <param name="filter"> Ef non-null, used to permit documents to be collected. </param>
+ /// <param name="results"> To receive hits </param>
/// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
- /// <seealso cref="BooleanQuery#getMaxClauseCount()"/> clauses. </exception>
+ /// <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
public virtual void Search(Query query, Filter filter, ICollector results)
{
Search(m_leafContexts, CreateNormalizedWeight(WrapFilter(query, filter)), results);
@@ -321,10 +314,10 @@ namespace Lucene.Net.Search
/// <summary>
/// Lower-level search API.
///
- /// <p><seealso cref="ICollector#collect(int)"/> is called for every matching document.
+ /// <para/><seealso cref="ICollector.Collect(int)"/> is called for every matching document.
/// </summary>
/// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
- /// <seealso cref="BooleanQuery#getMaxClauseCount()"/> clauses. </exception>
+ /// <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
public virtual void Search(Query query, ICollector results)
{
Search(m_leafContexts, CreateNormalizedWeight(query), results);
@@ -332,16 +325,16 @@ namespace Lucene.Net.Search
/// <summary>
/// Search implementation with arbitrary sorting. Finds
- /// the top <code>n</code> hits for <code>query</code>, applying
- /// <code>filter</code> if non-null, and sorting the hits by the criteria in
- /// <code>sort</code>.
+ /// the top <paramref name="n"/> hits for <paramref name="query"/>, applying
+ /// <paramref name="filter"/> if non-null, and sorting the hits by the criteria in
+ /// <paramref name="sort"/>.
///
- /// <p>NOTE: this does not compute scores by default; use
- /// <seealso cref="IndexSearcher#search(Query,Filter,int,Sort,boolean,boolean)"/> to
+ /// <para/>NOTE: this does not compute scores by default; use
+ /// <see cref="IndexSearcher.Search(Query,Filter,int,Sort,bool,bool)"/> to
/// control scoring.
/// </summary>
/// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
- /// <seealso cref="BooleanQuery#getMaxClauseCount()"/> clauses. </exception>
+ /// <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
public virtual TopFieldDocs Search(Query query, Filter filter, int n, Sort sort)
{
return Search(CreateNormalizedWeight(WrapFilter(query, filter)), n, sort, false, false);
@@ -351,32 +344,32 @@ namespace Lucene.Net.Search
/// Search implementation with arbitrary sorting, plus
/// control over whether hit scores and max score
/// should be computed. Finds
- /// the top <code>n</code> hits for <code>query</code>, applying
- /// <code>filter</code> if non-null, and sorting the hits by the criteria in
- /// <code>sort</code>. If <code>doDocScores</code> is <code>true</code>
+ /// the top <paramref name="n"/> hits for <paramref name="query"/>, applying
+ /// <paramref name="filter"/> if non-null, and sorting the hits by the criteria in
+ /// <paramref name="sort"/>. If <paramref name="doDocScores"/> is <c>true</c>
/// then the score of each hit will be computed and
- /// returned. If <code>doMaxScore</code> is
- /// <code>true</code> then the maximum score over all
+ /// returned. If <paramref name="doMaxScore"/> is
+ /// <c>true</c> then the maximum score over all
/// collected hits will be computed.
/// </summary>
/// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
- /// <seealso cref="BooleanQuery#getMaxClauseCount()"/> clauses. </exception>
+ /// <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
public virtual TopFieldDocs Search(Query query, Filter filter, int n, Sort sort, bool doDocScores, bool doMaxScore)
{
return Search(CreateNormalizedWeight(WrapFilter(query, filter)), n, sort, doDocScores, doMaxScore);
}
/// <summary>
- /// Finds the top <code>n</code>
- /// hits for <code>query</code>, applying <code>filter</code> if non-null,
- /// where all results are after a previous result (<code>after</code>).
- /// <p>
- /// By passing the bottom result from a previous page as <code>after</code>,
+ /// Finds the top <paramref name="n"/>
+ /// hits for <paramref name="query"/>, applying <paramref name="filter"/> if non-null,
+ /// where all results are after a previous result (<paramref name="after"/>).
+ /// <para/>
+ /// By passing the bottom result from a previous page as <paramref name="after"/>,
/// this method can be used for efficient 'deep-paging' across potentially
/// large result sets.
/// </summary>
/// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
- /// <seealso cref="BooleanQuery#getMaxClauseCount()"/> clauses. </exception>
+ /// <seealso cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
public virtual TopDocs SearchAfter(ScoreDoc after, Query query, Filter filter, int n, Sort sort)
{
if (after != null && !(after is FieldDoc))
@@ -392,25 +385,25 @@ namespace Lucene.Net.Search
/// Search implementation with arbitrary sorting and no filter. </summary>
/// <param name="query"> The query to search for </param>
/// <param name="n"> Return only the top n results </param>
- /// <param name="sort"> The <seealso cref="Lucene.Net.Search.Sort"/> object </param>
- /// <returns> The top docs, sorted according to the supplied <seealso cref="Lucene.Net.Search.Sort"/> instance </returns>
- /// <exception cref="IOException"> if there is a low-level I/O error </exception>
+ /// <param name="sort"> The <see cref="Lucene.Net.Search.Sort"/> object </param>
+ /// <returns> The top docs, sorted according to the supplied <see cref="Lucene.Net.Search.Sort"/> instance </returns>
+ /// <exception cref="System.IO.IOException"> if there is a low-level I/O error </exception>
public virtual TopFieldDocs Search(Query query, int n, Sort sort)
{
return Search(CreateNormalizedWeight(query), n, sort, false, false);
}
/// <summary>
- /// Finds the top <code>n</code>
- /// hits for <code>query</code> where all results are after a previous
- /// result (<code>after</code>).
- /// <p>
- /// By passing the bottom result from a previous page as <code>after</code>,
+ /// Finds the top <paramref name="n"/>
+ /// hits for <paramref name="query"/> where all results are after a previous
+ /// result (<paramref name="after"/>).
+ /// <para/>
+ /// By passing the bottom result from a previous page as <paramref name="after"/>,
/// this method can be used for efficient 'deep-paging' across potentially
/// large result sets.
/// </summary>
/// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
- /// <seealso cref="BooleanQuery#getMaxClauseCount()"/> clauses. </exception>
+ /// <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
public virtual TopDocs SearchAfter(ScoreDoc after, Query query, int n, Sort sort)
{
if (after != null && !(after is FieldDoc))
@@ -423,21 +416,21 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// Finds the top <code>n</code>
- /// hits for <code>query</code> where all results are after a previous
- /// result (<code>after</code>), allowing control over
+ /// Finds the top <paramref name="n"/>
+ /// hits for <paramref name="query"/> where all results are after a previous
+ /// result (<paramref name="after"/>), allowing control over
/// whether hit scores and max score should be computed.
- /// <p>
- /// By passing the bottom result from a previous page as <code>after</code>,
+ /// <para/>
+ /// By passing the bottom result from a previous page as <paramref name="after"/>,
/// this method can be used for efficient 'deep-paging' across potentially
- /// large result sets. If <code>doDocScores</code> is <code>true</code>
+ /// large result sets. If <paramref name="doDocScores"/> is <c>true</c>
/// then the score of each hit will be computed and
- /// returned. If <code>doMaxScore</code> is
- /// <code>true</code> then the maximum score over all
+ /// returned. If <paramref name="doMaxScore"/> is
+ /// <c>true</c> then the maximum score over all
/// collected hits will be computed.
/// </summary>
/// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
- /// <seealso cref="BooleanQuery#getMaxClauseCount()"/> clauses. </exception>
+ /// <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
public virtual TopDocs SearchAfter(ScoreDoc after, Query query, Filter filter, int n, Sort sort, bool doDocScores, bool doMaxScore)
{
if (after != null && !(after is FieldDoc))
@@ -450,13 +443,13 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// Expert: Low-level search implementation. Finds the top <code>n</code>
- /// hits for <code>query</code>, applying <code>filter</code> if non-null.
+ /// Expert: Low-level search implementation. Finds the top <paramref name="nDocs"/>
+ /// hits for <c>query</c>, applying <c>filter</c> if non-null.
///
- /// <p>Applications should usually call <seealso cref="IndexSearcher#search(Query,int)"/> or
- /// <seealso cref="IndexSearcher#search(Query,Filter,int)"/> instead. </summary>
+ /// <para/>Applications should usually call <see cref="IndexSearcher.Search(Query,int)"/> or
+ /// <see cref="IndexSearcher.Search(Query,Filter,int)"/> instead. </summary>
/// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
- /// <seealso cref="BooleanQuery#getMaxClauseCount()"/> clauses. </exception>
+ /// <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
protected virtual TopDocs Search(Weight weight, ScoreDoc after, int nDocs)
{
int limit = reader.MaxDoc;
@@ -508,12 +501,12 @@ namespace Lucene.Net.Search
/// <summary>
/// Expert: Low-level search implementation. Finds the top <code>n</code>
- /// hits for <code>query</code>.
+ /// hits for <c>query</c>.
///
- /// <p>Applications should usually call <seealso cref="IndexSearcher#search(Query,int)"/> or
- /// <seealso cref="IndexSearcher#search(Query,Filter,int)"/> instead. </summary>
+ /// <para/>Applications should usually call <see cref="IndexSearcher.Search(Query,int)"/> or
+ /// <see cref="IndexSearcher.Search(Query,Filter,int)"/> instead. </summary>
/// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
- /// <seealso cref="BooleanQuery#getMaxClauseCount()"/> clauses. </exception>
+ /// <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
protected virtual TopDocs Search(IList<AtomicReaderContext> leaves, Weight weight, ScoreDoc after, int nDocs)
{
// single thread
@@ -532,23 +525,23 @@ namespace Lucene.Net.Search
/// Expert: Low-level search implementation with arbitrary
/// sorting and control over whether hit scores and max
/// score should be computed. Finds
- /// the top <code>n</code> hits for <code>query</code> and sorting the hits
- /// by the criteria in <code>sort</code>.
+ /// the top <paramref name="nDocs"/> hits for <c>query</c> and sorting the hits
+ /// by the criteria in <paramref name="sort"/>.
///
- /// <p>Applications should usually call {@link
- /// IndexSearcher#search(Query,Filter,int,Sort)} instead.
+ /// <para/>Applications should usually call
+ /// <see cref="IndexSearcher.Search(Query,Filter,int,Sort)"/> instead.
/// </summary>
/// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
- /// <seealso cref="BooleanQuery#getMaxClauseCount()"/> clauses. </exception>
+ /// <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
protected virtual TopFieldDocs Search(Weight weight, int nDocs, Sort sort, bool doDocScores, bool doMaxScore)
{
return Search(weight, null, nDocs, sort, true, doDocScores, doMaxScore);
}
/// <summary>
- /// Just like <seealso cref="#search(Weight, int, Sort, boolean, boolean)"/>, but you choose
- /// whether or not the fields in the returned <seealso cref="FieldDoc"/> instances should
- /// be set by specifying fillFields.
+ /// Just like <see cref="Search(Weight, int, Sort, bool, bool)"/>, but you choose
+ /// whether or not the fields in the returned <see cref="FieldDoc"/> instances should
+ /// be set by specifying <paramref name="fillFields"/>.
/// </summary>
protected virtual TopFieldDocs Search(Weight weight, FieldDoc after, int nDocs, Sort sort, bool fillFields, bool doDocScores, bool doMaxScore)
{
@@ -597,9 +590,9 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// Just like <seealso cref="#search(Weight, int, Sort, boolean, boolean)"/>, but you choose
- /// whether or not the fields in the returned <seealso cref="FieldDoc"/> instances should
- /// be set by specifying fillFields.
+ /// Just like <see cref="Search(Weight, int, Sort, bool, bool)"/>, but you choose
+ /// whether or not the fields in the returned <see cref="FieldDoc"/> instances should
+ /// be set by specifying <paramref name="fillFields"/>.
/// </summary>
protected virtual TopFieldDocs Search(IList<AtomicReaderContext> leaves, Weight weight, FieldDoc after, int nDocs, Sort sort, bool fillFields, bool doDocScores, bool doMaxScore)
{
@@ -619,21 +612,21 @@ namespace Lucene.Net.Search
/// <summary>
/// Lower-level search API.
///
- /// <p>
- /// <seealso cref="ICollector#collect(int)"/> is called for every document. <br>
+ /// <para/>
+ /// <seealso cref="ICollector.Collect(int)"/> is called for every document.
///
- /// <p>
+ /// <para/>
/// NOTE: this method executes the searches on all given leaves exclusively.
- /// To search across all the searchers leaves use <seealso cref="#leafContexts"/>.
+ /// To search across all the searchers leaves use <see cref="m_leafContexts"/>.
/// </summary>
/// <param name="leaves">
- /// the searchers leaves to execute the searches on </param>
+ /// The searchers leaves to execute the searches on </param>
/// <param name="weight">
- /// to match documents </param>
+ /// To match documents </param>
/// <param name="collector">
- /// to receive hits </param>
+ /// To receive hits </param>
/// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
- /// <seealso cref="BooleanQuery#getMaxClauseCount()"/> clauses. </exception>
+ /// <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
protected virtual void Search(IList<AtomicReaderContext> leaves, Weight weight, ICollector collector)
{
// TODO: should we make this
@@ -670,7 +663,7 @@ namespace Lucene.Net.Search
/// <summary>
/// Expert: called to re-write queries into primitive queries. </summary>
/// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
- /// <seealso cref="BooleanQuery#getMaxClauseCount()"/> clauses. </exception>
+ /// <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
public virtual Query Rewrite(Query original)
{
Query query = original;
@@ -682,10 +675,10 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// Returns an Explanation that describes how <code>doc</code> scored against
- /// <code>query</code>.
+ /// Returns an <see cref="Explanation"/> that describes how <paramref name="doc"/> scored against
+ /// <paramref name="query"/>.
///
- /// <p>this is intended to be used in developing Similarity implementations,
+ /// <para/>This is intended to be used in developing <see cref="Similarities.Similarity"/> implementations,
/// and, for good performance, should not be displayed with every hit.
/// Computing an explanation is as expensive as executing the query over the
/// entire index.
@@ -697,16 +690,16 @@ namespace Lucene.Net.Search
/// <summary>
/// Expert: low-level implementation method
- /// Returns an Explanation that describes how <code>doc</code> scored against
- /// <code>weight</code>.
+ /// Returns an <see cref="Explanation"/> that describes how <paramref name="doc"/> scored against
+ /// <paramref name="weight"/>.
///
- /// <p>this is intended to be used in developing Similarity implementations,
+ /// <para/>This is intended to be used in developing <see cref="Similarities.Similarity"/> implementations,
/// and, for good performance, should not be displayed with every hit.
/// Computing an explanation is as expensive as executing the query over the
/// entire index.
- /// <p>Applications should call <seealso cref="IndexSearcher#explain(Query, int)"/>. </summary>
+ /// <para/>Applications should call <see cref="IndexSearcher.Explain(Query, int)"/>. </summary>
/// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
- /// <seealso cref="BooleanQuery#getMaxClauseCount()"/> clauses. </exception>
+ /// <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
protected virtual Explanation Explain(Weight weight, int doc)
{
int n = ReaderUtil.SubIndex(doc, m_leafContexts);
@@ -717,10 +710,11 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// Creates a normalized weight for a top-level <seealso cref="Query"/>.
- /// The query is rewritten by this method and <seealso cref="Query#createWeight"/> called,
- /// afterwards the <seealso cref="Weight"/> is normalized. The returned {@code Weight}
- /// can then directly be used to get a <seealso cref="Scorer"/>.
+ /// Creates a normalized weight for a top-level <see cref="Query"/>.
+ /// The query is rewritten by this method and <see cref="Query.CreateWeight(IndexSearcher)"/> called,
+ /// afterwards the <see cref="Weight"/> is normalized. The returned <see cref="Weight"/>
+ /// can then directly be used to get a <see cref="Scorer"/>.
+ /// <para/>
/// @lucene.internal
/// </summary>
public virtual Weight CreateNormalizedWeight(Query query)
@@ -738,8 +732,8 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// Returns this searchers the top-level <seealso cref="IndexReaderContext"/>. </summary>
- /// <seealso cref= IndexReader#getContext() </seealso>
+ /// Returns this searchers the top-level <see cref="IndexReaderContext"/>. </summary>
+ /// <seealso cref="IndexReader.Context"/>
/* sugar for #getReader().getTopReaderContext() */
public virtual IndexReaderContext TopReaderContext
@@ -870,11 +864,10 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// A helper class that wraps a <seealso cref="CompletionService"/> and provides an
- /// iterable interface to the completed <seealso cref="Callable"/> instances.
+ /// A helper class that wraps a <see cref="ICompletionService{T}"/> and provides an
+ /// iterable interface to the completed <see cref="ICallable{V}"/> instances.
/// </summary>
- /// @param <T>
- /// the type of the <seealso cref="Callable"/> return value </param>
+ /// <typeparam name="T">the type of the <see cref="ICallable{V}"/> return value</typeparam>
#if FEATURE_SERIALIZABLE
[Serializable]
#endif
@@ -969,9 +962,9 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// A class holding a subset of the <seealso cref="IndexSearcher"/>s leaf contexts to be
+ /// A class holding a subset of the <see cref="IndexSearcher"/>s leaf contexts to be
/// executed within a single thread.
- ///
+ /// <para/>
/// @lucene.experimental
/// </summary>
#if FEATURE_SERIALIZABLE
@@ -993,10 +986,11 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// Returns <seealso cref="TermStatistics"/> for a term.
- ///
- /// this can be overridden for example, to return a term's statistics
+ /// Returns <see cref="Search.TermStatistics"/> for a term.
+ /// <para/>
+ /// This can be overridden for example, to return a term's statistics
/// across a distributed collection.
+ /// <para/>
/// @lucene.experimental
/// </summary>
public virtual TermStatistics TermStatistics(Term term, TermContext context)
@@ -1005,10 +999,11 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// Returns <seealso cref="CollectionStatistics"/> for a field.
- ///
- /// this can be overridden for example, to return a field's statistics
+ /// Returns <see cref="Search.CollectionStatistics"/> for a field.
+ /// <para/>
+ /// This can be overridden for example, to return a field's statistics
/// across a distributed collection.
+ /// <para/>
/// @lucene.experimental
/// </summary>
public virtual CollectionStatistics CollectionStatistics(string field)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/LiveFieldValues.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/LiveFieldValues.cs b/src/Lucene.Net/Search/LiveFieldValues.cs
index 0251d10..3cfa3f7 100644
--- a/src/Lucene.Net/Search/LiveFieldValues.cs
+++ b/src/Lucene.Net/Search/LiveFieldValues.cs
@@ -23,15 +23,15 @@ namespace Lucene.Net.Search
/// <summary>
/// Tracks live field values across NRT reader reopens.
- /// this holds a map for all updated ids since
- /// the last reader reopen. Once the NRT reader is reopened,
- /// it prunes the map. this means you must reopen your NRT
- /// reader periodically otherwise the RAM consumption of
- /// this class will grow unbounded!
+ /// This holds a map for all updated ids since
+ /// the last reader reopen. Once the NRT reader is reopened,
+ /// it prunes the map. This means you must reopen your NRT
+ /// reader periodically otherwise the RAM consumption of
+ /// this class will grow unbounded!
///
- /// <p>NOTE: you must ensure the same id is never updated at
- /// the same time by two threads, because in this case you
- /// cannot in general know which thread "won".
+ /// <para/>NOTE: you must ensure the same id is never updated at
+ /// the same time by two threads, because in this case you
+ /// cannot in general know which thread "won".
/// </summary>
#if FEATURE_SERIALIZABLE
[Serializable]
@@ -79,8 +79,8 @@ namespace Lucene.Net.Search
/// <summary>
/// Call this after you've successfully added a document
- /// to the index, to record what value you just set the
- /// field to.
+ /// to the index, to record what value you just set the
+ /// field to.
/// </summary>
public virtual void Add(string id, T value)
{
@@ -89,7 +89,7 @@ namespace Lucene.Net.Search
/// <summary>
/// Call this after you've successfully deleted a document
- /// from the index.
+ /// from the index.
/// </summary>
public virtual void Delete(string id)
{
@@ -99,6 +99,7 @@ namespace Lucene.Net.Search
/// <summary>
/// Returns the [approximate] number of id/value pairs
/// buffered in RAM.
+ /// <para/>
/// NOTE: This was size() in Lucene.
/// </summary>
public virtual int Count
@@ -107,8 +108,8 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// Returns the current value for this id, or null if the
- /// id isn't in the index or was deleted.
+ /// Returns the current value for this id, or <c>null</c> if the
+ /// id isn't in the index or was deleted.
/// </summary>
public virtual T Get(string id)
{
@@ -157,10 +158,10 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// this is called when the id/value was already flushed & opened
- /// in an NRT IndexSearcher. You must implement this to
- /// go look up the value (eg, via doc values, field cache,
- /// stored fields, etc.).
+ /// This is called when the id/value was already flushed & opened
+ /// in an NRT IndexSearcher. You must implement this to
+ /// go look up the value (eg, via doc values, field cache,
+ /// stored fields, etc.).
/// </summary>
protected abstract T LookupFromSearcher(S s, string id);
}
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/MatchAllDocsQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/MatchAllDocsQuery.cs b/src/Lucene.Net/Search/MatchAllDocsQuery.cs
index 608586c..8c7bdcd 100644
--- a/src/Lucene.Net/Search/MatchAllDocsQuery.cs
+++ b/src/Lucene.Net/Search/MatchAllDocsQuery.cs
@@ -30,7 +30,6 @@ namespace Lucene.Net.Search
/// <summary>
/// A query that matches all documents.
- ///
/// </summary>
#if FEATURE_SERIALIZABLE
[Serializable]
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/MaxNonCompetitiveBoostAttribute.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/MaxNonCompetitiveBoostAttribute.cs b/src/Lucene.Net/Search/MaxNonCompetitiveBoostAttribute.cs
index 9aa36ea..7aa3e7e 100644
--- a/src/Lucene.Net/Search/MaxNonCompetitiveBoostAttribute.cs
+++ b/src/Lucene.Net/Search/MaxNonCompetitiveBoostAttribute.cs
@@ -1,4 +1,5 @@
-using System;
+using Lucene.Net.Util;
+using BytesRef = Lucene.Net.Util.BytesRef;
namespace Lucene.Net.Search
{
@@ -19,57 +20,28 @@ namespace Lucene.Net.Search
* limitations under the License.
*/
- using Attribute = Lucene.Net.Util.Attribute;
- using IAttribute = Lucene.Net.Util.IAttribute;
- using BytesRef = Lucene.Net.Util.BytesRef;
-
/// <summary>
- /// Implementation class for <seealso cref="MaxNonCompetitiveBoostAttribute"/>.
+ /// Add this <see cref="IAttribute"/> to a fresh <see cref="AttributeSource"/> before calling
+ /// <see cref="MultiTermQuery.GetTermsEnum(Index.Terms, AttributeSource)"/>.
+ /// <see cref="FuzzyQuery"/> is using this to control its internal behaviour
+ /// to only return competitive terms.
+ /// <para/><b>Please note:</b> this attribute is intended to be added by the <see cref="MultiTermQuery.RewriteMethod"/>
+ /// to an empty <see cref="AttributeSource"/> that is shared for all segments
+ /// during query rewrite. This attribute source is passed to all segment enums
+ /// on <see cref="MultiTermQuery.GetTermsEnum(Index.Terms,AttributeSource)"/>.
+ /// <see cref="TopTermsRewrite{Q}"/> uses this attribute to
+ /// inform all enums about the current boost, that is not competitive.
+ /// <para/>
/// @lucene.internal
/// </summary>
-#if FEATURE_SERIALIZABLE
- [Serializable]
-#endif
- public sealed class MaxNonCompetitiveBoostAttribute : Attribute, IMaxNonCompetitiveBoostAttribute
+ public interface IMaxNonCompetitiveBoostAttribute : IAttribute
{
- private float maxNonCompetitiveBoost = float.NegativeInfinity;
- private BytesRef competitiveTerm = null;
-
- public float MaxNonCompetitiveBoost
- {
- set
- {
- this.maxNonCompetitiveBoost = value;
- }
- get
- {
- return maxNonCompetitiveBoost;
- }
- }
-
- public BytesRef CompetitiveTerm
- {
- set
- {
- this.competitiveTerm = value;
- }
- get
- {
- return competitiveTerm;
- }
- }
-
- public override void Clear()
- {
- maxNonCompetitiveBoost = float.NegativeInfinity;
- competitiveTerm = null;
- }
+ /// <summary>
+ /// This is the maximum boost that would not be competitive. </summary>
+ float MaxNonCompetitiveBoost { set; get; }
- public override void CopyTo(IAttribute target)
- {
- MaxNonCompetitiveBoostAttribute t = (MaxNonCompetitiveBoostAttribute)target;
- t.MaxNonCompetitiveBoost = maxNonCompetitiveBoost;
- t.CompetitiveTerm = competitiveTerm;
- }
+ /// <summary>
+ /// This is the term or <c>null</c> of the term that triggered the boost change. </summary>
+ BytesRef CompetitiveTerm { set; get; }
}
}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/MaxNonCompetitiveBoostAttributeImpl.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/MaxNonCompetitiveBoostAttributeImpl.cs b/src/Lucene.Net/Search/MaxNonCompetitiveBoostAttributeImpl.cs
new file mode 100644
index 0000000..7ce0318
--- /dev/null
+++ b/src/Lucene.Net/Search/MaxNonCompetitiveBoostAttributeImpl.cs
@@ -0,0 +1,76 @@
+using System;
+
+namespace Lucene.Net.Search
+{
+ /*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+ using Attribute = Lucene.Net.Util.Attribute;
+ using IAttribute = Lucene.Net.Util.IAttribute;
+ using BytesRef = Lucene.Net.Util.BytesRef;
+
+ /// <summary>
+ /// Implementation class for <see cref="IMaxNonCompetitiveBoostAttribute"/>.
+ /// <para/>
+ /// @lucene.internal
+ /// </summary>
+#if FEATURE_SERIALIZABLE
+ [Serializable]
+#endif
+ public sealed class MaxNonCompetitiveBoostAttribute : Attribute, IMaxNonCompetitiveBoostAttribute
+ {
+ private float maxNonCompetitiveBoost = float.NegativeInfinity;
+ private BytesRef competitiveTerm = null;
+
+ public float MaxNonCompetitiveBoost
+ {
+ set
+ {
+ this.maxNonCompetitiveBoost = value;
+ }
+ get
+ {
+ return maxNonCompetitiveBoost;
+ }
+ }
+
+ public BytesRef CompetitiveTerm
+ {
+ set
+ {
+ this.competitiveTerm = value;
+ }
+ get
+ {
+ return competitiveTerm;
+ }
+ }
+
+ public override void Clear()
+ {
+ maxNonCompetitiveBoost = float.NegativeInfinity;
+ competitiveTerm = null;
+ }
+
+ public override void CopyTo(IAttribute target)
+ {
+ MaxNonCompetitiveBoostAttribute t = (MaxNonCompetitiveBoostAttribute)target;
+ t.MaxNonCompetitiveBoost = maxNonCompetitiveBoost;
+ t.CompetitiveTerm = competitiveTerm;
+ }
+ }
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/MinShouldMatchSumScorer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/MinShouldMatchSumScorer.cs b/src/Lucene.Net/Search/MinShouldMatchSumScorer.cs
index b269756..c2b2760 100644
--- a/src/Lucene.Net/Search/MinShouldMatchSumScorer.cs
+++ b/src/Lucene.Net/Search/MinShouldMatchSumScorer.cs
@@ -26,12 +26,12 @@ namespace Lucene.Net.Search
using ArrayUtil = Lucene.Net.Util.ArrayUtil;
/// <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.
- ///
- /// this implementation uses the minimumMatch constraint actively to efficiently
- /// prune the number of candidates, it is hence a mixture between a pure DisjunctionScorer
- /// and a ConjunctionScorer.
+ /// 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.
+ /// <para/>
+ /// This implementation uses the minimumMatch constraint actively to efficiently
+ /// prune the number of candidates, it is hence a mixture between a pure <see cref="DisjunctionScorer"/>
+ /// and a <see cref="ConjunctionScorer"/>.
/// </summary>
#if FEATURE_SERIALIZABLE
[Serializable]
@@ -59,8 +59,8 @@ namespace Lucene.Net.Search
/// <summary>
/// mmStack is supposed to contain the most costly subScorers that still did
- /// not run out of docs, sorted by increasing sparsity of docs returned by that subScorer.
- /// For now, the cost of subscorers is assumed to be inversely correlated with sparsity.
+ /// not run out of docs, sorted by increasing sparsity of docs returned by that subScorer.
+ /// For now, the cost of subscorers is assumed to be inversely correlated with sparsity.
/// </summary>
private readonly Scorer[] mmStack; // of size mm-1: 0..mm-2, always full
@@ -75,16 +75,16 @@ namespace Lucene.Net.Search
private double score = float.NaN;
/// <summary>
- /// Construct a <code>MinShouldMatchSumScorer</code>.
+ /// Construct a <see cref="MinShouldMatchSumScorer"/>.
/// </summary>
/// <param name="weight"> The weight to be used. </param>
/// <param name="subScorers"> A collection of at least two subscorers. </param>
/// <param name="minimumNrMatchers"> The positive minimum number of subscorers that should
/// match to match this query.
- /// <br>When <code>minimumNrMatchers</code> is bigger than
- /// the number of <code>subScorers</code>, no matches will be produced.
- /// <br>When minimumNrMatchers equals the number of subScorers,
- /// it is more efficient to use <code>ConjunctionScorer</code>. </param>
+ /// <para/>When <paramref name="minimumNrMatchers"/> is bigger than
+ /// the number of <paramref name="subScorers"/>, no matches will be produced.
+ /// <para/>When <paramref name="minimumNrMatchers"/> equals the number of <paramref name="subScorers"/>,
+ /// it is more efficient to use <see cref="ConjunctionScorer"/>. </param>
public MinShouldMatchSumScorer(Weight weight, IList<Scorer> subScorers, int minimumNrMatchers)
: base(weight)
{
@@ -138,8 +138,8 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// Construct a <code>DisjunctionScorer</code>, using one as the minimum number
- /// of matching subscorers.
+ /// Construct a <see cref="DisjunctionScorer"/>, using one as the minimum number
+ /// of matching <paramref name="subScorers"/>.
/// </summary>
public MinShouldMatchSumScorer(Weight weight, IList<Scorer> subScorers)
: this(weight, subScorers, 1)
@@ -272,7 +272,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.
+ /// invalid, until <see cref="NextDoc()"/> is called the first time.
/// </summary>
public override float GetScore()
{
@@ -291,11 +291,12 @@ namespace Lucene.Net.Search
/// <summary>
/// Advances to the first match beyond the current whose document number is
- /// greater than or equal to a given target. <br>
- /// The implementation uses the advance() method on the subscorers.
+ /// greater than or equal to a given target.
+ /// <para/>
+ /// The implementation uses the Advance() method on the subscorers.
/// </summary>
- /// <param name="target"> the target document number. </param>
- /// <returns> the document whose number is greater than or equal to the given
+ /// <param name="target"> The target document number. </param>
+ /// <returns> The document whose number is greater than or equal to the given
/// target, or -1 if none exist. </returns>
public override int Advance(int target)
{
@@ -349,7 +350,7 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// Organize subScorers into a min heap with scorers generating the earliest document on top.
+ /// Organize <see cref="subScorers"/> into a min heap with scorers generating the earliest document on top.
/// </summary>
protected void MinheapHeapify()
{
@@ -360,7 +361,7 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// The subtree of subScorers at root is a min heap except possibly for its root element.
+ /// The subtree of <see cref="subScorers"/> at root is a min heap except possibly for its root element.
/// Bubble the root down as required to make the subtree a heap.
/// </summary>
protected void MinheapSiftDown(int root)
@@ -433,7 +434,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 <see cref="subScorers"/> and re-establish it as a heap
/// </summary>
protected void MinheapRemoveRoot()
{
@@ -452,7 +453,7 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// Removes a given Scorer from the heap by placing end of heap at that
+ /// Removes a given <see cref="Scorer"/> from the heap by placing end of heap at that
/// position and bubbling it either up or down
/// </summary>
protected bool MinheapRemove(Scorer scorer)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/MultiCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/MultiCollector.cs b/src/Lucene.Net/Search/MultiCollector.cs
index 6551bc3..00bbe2e 100644
--- a/src/Lucene.Net/Search/MultiCollector.cs
+++ b/src/Lucene.Net/Search/MultiCollector.cs
@@ -22,10 +22,10 @@ namespace Lucene.Net.Search
using AtomicReaderContext = Lucene.Net.Index.AtomicReaderContext;
/// <summary>
- /// A <seealso cref="ICollector"/> which allows running a search with several
- /// <seealso cref="ICollector"/>s. It offers a static <seealso cref="#wrap"/> method which accepts a
- /// list of collectors and wraps them with <seealso cref="MultiCollector"/>, while
- /// filtering out the <code>null</code> null ones.
+ /// A <see cref="ICollector"/> which allows running a search with several
+ /// <see cref="ICollector"/>s. It offers a static <see cref="Wrap(ICollector[])"/> method which accepts a
+ /// list of collectors and wraps them with <see cref="MultiCollector"/>, while
+ /// filtering out the <c>null</c> ones.
/// </summary>
#if FEATURE_SERIALIZABLE
[Serializable]
@@ -33,20 +33,20 @@ namespace Lucene.Net.Search
public class MultiCollector : ICollector
{
/// <summary>
- /// Wraps a list of <seealso cref="ICollector"/>s with a <seealso cref="MultiCollector"/>. this
+ /// Wraps a list of <see cref="ICollector"/>s with a <see cref="MultiCollector"/>. This
/// method works as follows:
- /// <ul>
- /// <li>Filters out the <code>null</code> collectors, so they are not used
- /// during search time.
- /// <li>If the input contains 1 real collector (i.e. non-<code>null</code> ),
- /// it is returned.
- /// <li>Otherwise the method returns a <seealso cref="MultiCollector"/> which wraps the
- /// non-<code>null</code> ones.
- /// </ul>
+ /// <list type="bullet">
+ /// <item><description>Filters out the <c>null</c> collectors, so they are not used
+ /// during search time.</description></item>
+ /// <item><description>If the input contains 1 real collector (i.e. non-<c>null</c> ),
+ /// it is returned.</description></item>
+ /// <item><description>Otherwise the method returns a <see cref="MultiCollector"/> which wraps the
+ /// non-<code>null</code> ones.</description></item>
+ /// </list>
/// </summary>
- /// <exception cref="IllegalArgumentException">
+ /// <exception cref="ArgumentException">
/// if either 0 collectors were input, or all collectors are
- /// <code>null</code>. </exception>
+ /// <c>null</c>. </exception>
public static ICollector Wrap(params ICollector[] collectors)
{
// For the user's convenience, we allow null collectors to be passed.
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/MultiPhraseQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/MultiPhraseQuery.cs b/src/Lucene.Net/Search/MultiPhraseQuery.cs
index cb98931..5e2491d 100644
--- a/src/Lucene.Net/Search/MultiPhraseQuery.cs
+++ b/src/Lucene.Net/Search/MultiPhraseQuery.cs
@@ -44,13 +44,13 @@ namespace Lucene.Net.Search
using ToStringUtils = Lucene.Net.Util.ToStringUtils;
/// <summary>
- /// MultiPhraseQuery is a generalized version of PhraseQuery, with an added
- /// method <seealso cref="#add(Term[])"/>.
+ /// <see cref="MultiPhraseQuery"/> is a generalized version of <see cref="PhraseQuery"/>, with an added
+ /// method <see cref="Add(Term[])"/>.
+ /// <para/>
/// To use this class, to search for the phrase "Microsoft app*" first use
- /// add(Term) on the term "Microsoft", then find all terms that have "app" as
- /// prefix using IndexReader.terms(Term), and use MultiPhraseQuery.add(Term[]
- /// terms) to add them to the query.
- ///
+ /// <see cref="Add(Term)"/> on the term "Microsoft", then find all terms that have "app" as
+ /// prefix using <c>MultiFields.GetFields(IndexReader).GetTerms(string)</c>, and use <see cref="MultiPhraseQuery.Add(Term[])"/>
+ /// to add them to the query.
/// </summary>
#if FEATURE_SERIALIZABLE
[Serializable]
@@ -65,7 +65,7 @@ namespace Lucene.Net.Search
/// <summary>
/// Sets the phrase slop for this query. </summary>
- /// <seealso cref= PhraseQuery#setSlop(int) </seealso>
+ /// <seealso cref="PhraseQuery.Slop"/>
public virtual int Slop
{
set
@@ -84,7 +84,7 @@ namespace Lucene.Net.Search
/// <summary>
/// Add a single term at the next position in the phrase. </summary>
- /// <seealso cref= PhraseQuery#add(Term) </seealso>
+ /// <seealso cref="PhraseQuery.Add(Term)"/>
public virtual void Add(Term term)
{
Add(new Term[] { term });
@@ -94,7 +94,7 @@ namespace Lucene.Net.Search
/// Add multiple terms at the next position in the phrase. Any of the terms
/// may match.
/// </summary>
- /// <seealso cref= PhraseQuery#add(Term) </seealso>
+ /// <seealso cref="PhraseQuery.Add(Term)"/>
public virtual void Add(Term[] terms)
{
int position = 0;
@@ -109,7 +109,7 @@ namespace Lucene.Net.Search
/// <summary>
/// Allows to specify the relative position of terms within the phrase.
/// </summary>
- /// <seealso cref= PhraseQuery#add(Term, int) </seealso>
+ /// <seealso cref="PhraseQuery.Add(Term, int)"/>
public virtual void Add(Term[] terms, int position)
{
if (termArrays.Count == 0)
@@ -151,7 +151,11 @@ namespace Lucene.Net.Search
return result;
}
- // 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 (Term[] arr in termArrays)
@@ -436,7 +440,7 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// Returns true if <code>o</code> is equal to this. </summary>
+ /// Returns <c>true</c> if <paramref name="o"/> is equal to this. </summary>
public override bool Equals(object o)
{
if (!(o is MultiPhraseQuery))
@@ -502,7 +506,7 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// Takes the logical union of multiple DocsEnum iterators.
+ /// Takes the logical union of multiple <see cref="DocsEnum"/> iterators.
/// </summary>
// TODO: if ever we allow subclassing of the *PhraseScorer
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/MultiTermQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Search/MultiTermQuery.cs b/src/Lucene.Net/Search/MultiTermQuery.cs
index 199e46f..8fbad5e 100644
--- a/src/Lucene.Net/Search/MultiTermQuery.cs
+++ b/src/Lucene.Net/Search/MultiTermQuery.cs
@@ -28,37 +28,37 @@ namespace Lucene.Net.Search
using TermsEnum = Lucene.Net.Index.TermsEnum;
/// <summary>
- /// An abstract <seealso cref="Query"/> that matches documents
- /// containing a subset of terms provided by a {@link
- /// FilteredTermsEnum} enumeration.
+ /// An abstract <see cref="Query"/> that matches documents
+ /// containing a subset of terms provided by a
+ /// <see cref="Index.FilteredTermsEnum"/> enumeration.
///
- /// <p>this query cannot be used directly; you must subclass
- /// it and define <seealso cref="#getTermsEnum(Terms,AttributeSource)"/> to provide a {@link
- /// FilteredTermsEnum} that iterates through the terms to be
+ /// <para/>This query cannot be used directly; you must subclass
+ /// it and define <see cref="GetTermsEnum(Terms,AttributeSource)"/> to provide a
+ /// <see cref="Index.FilteredTermsEnum"/> that iterates through the terms to be
/// matched.
///
- /// <p><b>NOTE</b>: if <seealso cref="#setRewriteMethod"/> is either
- /// <seealso cref="#CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE"/> or {@link
- /// #SCORING_BOOLEAN_QUERY_REWRITE}, you may encounter a
- /// <seealso cref="BooleanQuery.TooManyClausesException"/> exception during
+ /// <para/><b>NOTE</b>: if <see cref="MultiTermRewriteMethod"/> is either
+ /// <see cref="CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE"/> or
+ /// <see cref="SCORING_BOOLEAN_QUERY_REWRITE"/>, you may encounter a
+ /// <see cref="BooleanQuery.TooManyClausesException"/> exception during
/// searching, which happens when the number of terms to be
- /// searched exceeds {@link
- /// BooleanQuery#getMaxClauseCount()}. Setting {@link
- /// #setRewriteMethod} to <seealso cref="#CONSTANT_SCORE_FILTER_REWRITE"/>
+ /// searched exceeds
+ /// <see cref="BooleanQuery.MaxClauseCount"/>. Setting
+ /// <see cref="MultiTermRewriteMethod"/> to <see cref="CONSTANT_SCORE_FILTER_REWRITE"/>
/// prevents this.
///
- /// <p>The recommended rewrite method is {@link
- /// #CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}: it doesn't spend CPU
+ /// <para/>The recommended rewrite method is
+ /// <see cref="CONSTANT_SCORE_AUTO_REWRITE_DEFAULT"/>: it doesn't spend CPU
/// computing unhelpful scores, and it tries to pick the most
/// performant rewrite method given the query. If you
- /// need scoring (like <seealso cref="FuzzyQuery"/>, use
- /// <seealso cref="TopTermsScoringBooleanQueryRewrite"/> which uses
+ /// need scoring (like <seea cref="FuzzyQuery"/>, use
+ /// <see cref="TopTermsScoringBooleanQueryRewrite"/> which uses
/// a priority queue to only collect competitive terms
/// and not hit this limitation.
///
- /// Note that queryparser.classic.QueryParser produces
- /// MultiTermQueries using {@link
- /// #CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} by default.
+ /// <para/>Note that QueryParsers.Classic.QueryParser produces
+ /// <see cref="MultiTermQuery"/>s using
+ /// <see cref="CONSTANT_SCORE_AUTO_REWRITE_DEFAULT"/> by default.
/// </summary>
#if FEATURE_SERIALIZABLE
[Serializable]
@@ -78,8 +78,8 @@ namespace Lucene.Net.Search
public abstract Query Rewrite(IndexReader reader, MultiTermQuery query);
/// <summary>
- /// Returns the <seealso cref="MultiTermQuery"/>s <seealso cref="TermsEnum"/> </summary>
- /// <seealso cref= MultiTermQuery#getTermsEnum(Terms, AttributeSource) </seealso>
+ /// Returns the <see cref="MultiTermQuery"/>s <see cref="TermsEnum"/> </summary>
+ /// <seealso cref="MultiTermQuery.GetTermsEnum(Terms, AttributeSource)"/>
protected virtual TermsEnum GetTermsEnum(MultiTermQuery query, Terms terms, AttributeSource atts)
{
return query.GetTermsEnum(terms, atts); // allow RewriteMethod subclasses to pull a TermsEnum from the MTQ
@@ -87,18 +87,18 @@ namespace Lucene.Net.Search
}
/// <summary>
- /// A rewrite method that first creates a private Filter,
- /// by visiting each term in sequence and marking all docs
- /// for that term. Matching documents are assigned a
- /// constant score equal to the query's boost.
+ /// A rewrite method that first creates a private <see cref="Filter"/>,
+ /// by visiting each term in sequence and marking all docs
+ /// for that term. Matching documents are assigned a
+ /// constant score equal to the query's boost.
///
- /// <p> this method is faster than the BooleanQuery
- /// rewrite methods when the number of matched terms or
- /// matched documents is non-trivial. Also, it will never
- /// hit an errant <seealso cref="BooleanQuery.TooManyClausesException"/>
- /// exception.
+ /// <para/> This method is faster than the <see cref="BooleanQuery"/>
+ /// rewrite methods when the number of matched terms or
+ /// matched documents is non-trivial. Also, it will never
+ /// hit an errant <see cref="BooleanQuery.TooManyClausesException"/>
+ /// exception.
/// </summary>
- /// <seealso cref= #setRewriteMethod </seealso>
+ /// <seealso cref="MultiTermRewriteMethod"/>
public static readonly RewriteMethod CONSTANT_SCORE_FILTER_REWRITE = new RewriteMethodAnonymousInnerClassHelper();
#if FEATURE_SERIALIZABLE
@@ -120,55 +120,55 @@ namespace Lucene.Net.Search
/// <summary>
/// A rewrite method that first translates each term into
- /// <seealso cref="Occur#SHOULD"/> clause in a
- /// BooleanQuery, and keeps the scores as computed by the
- /// query. Note that typically such scores are
- /// meaningless to the user, and require non-trivial CPU
- /// to compute, so it's almost always better to use {@link
- /// #CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} instead.
+ /// <see cref="Occur.SHOULD"/> clause in a
+ /// <see cref="BooleanQuery"/>, and keeps the scores as computed by the
+ /// query. Note that typically such scores are
+ /// meaningless to the user, and require non-trivial CPU
+ /// to compute, so it's almost always better to use
+ /// <see cref="CONSTANT_SCORE_AUTO_REWRITE_DEFAULT"/> instead.
///
- /// <p><b>NOTE</b>: this rewrite method will hit {@link
- /// BooleanQuery.TooManyClauses} if the number of terms
- /// exceeds <seealso cref="BooleanQuery#getMaxClauseCount"/>.
+ /// <para/><b>NOTE</b>: this rewrite method will hit
+ /// <see cref="BooleanQuery.TooManyClausesException"/> if the number of terms
+ /// exceeds <see cref="BooleanQuery.MaxClauseCount"/>.
/// </summary>
- /// <seealso cref= #setRewriteMethod </seealso>
+ /// <seealso cref="MultiTermRewriteMethod"/>
public static readonly RewriteMethod SCORING_BOOLEAN_QUERY_REWRITE = ScoringRewrite<MultiTermQuery>.SCORING_BOOLEAN_QUERY_REWRITE;
/// <summary>
- /// Like <seealso cref="#SCORING_BOOLEAN_QUERY_REWRITE"/> except
- /// scores are not computed. Instead, each matching
- /// document receives a constant score equal to the
- /// query's boost.
+ /// Like <see cref="SCORING_BOOLEAN_QUERY_REWRITE"/> except
+ /// scores are not computed. Instead, each matching
+ /// document receives a constant score equal to the
+ /// query's boost.
///
- /// <p><b>NOTE</b>: this rewrite method will hit {@link
- /// BooleanQuery.TooManyClauses} if the number of terms
- /// exceeds <seealso cref="BooleanQuery#getMaxClauseCount"/>.
+ /// <para/><b>NOTE</b>: this rewrite method will hit
+ /// <see cref="BooleanQuery.TooManyClausesException"/> if the number of terms
+ /// exceeds <see cref="BooleanQuery.MaxClauseCount"/>.
/// </summary>
- /// <seealso cref= #setRewriteMethod </seealso>
+ /// <seealso cref="MultiTermRewriteMethod"/>
public static readonly RewriteMethod CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE = ScoringRewrite<MultiTermQuery>.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE;
/// <summary>
/// A rewrite method that first translates each term into
- /// <seealso cref="Occur#SHOULD"/> clause in a BooleanQuery, and keeps the
+ /// <see cref="Occur.SHOULD"/> clause in a <see cref="BooleanQuery"/>, and keeps the
/// scores as computed by the query.
///
- /// <p>
- /// this rewrite method only uses the top scoring terms so it will not overflow
+ /// <para/>
+ /// This rewrite method only uses the top scoring terms so it will not overflow
/// the boolean max clause count. It is the default rewrite method for
- /// <seealso cref="FuzzyQuery"/>.
+ /// <see cref="FuzzyQuery"/>.
/// </summary>
- /// <seealso cref= #setRewriteMethod </seealso>
+ /// <seealso cref="MultiTermRewriteMethod"/>
#if FEATURE_SERIALIZABLE
[Serializable]
#endif
public sealed class TopTermsScoringBooleanQueryRewrite : TopTermsRewrite<BooleanQuery>
{
/// <summary>
- /// Create a TopTermsScoringBooleanQueryRewrite for
- /// at most <code>size</code> terms.
- /// <p>
- /// NOTE: if <seealso cref="BooleanQuery#getMaxClauseCount"/> is smaller than
- /// <code>size</code>, then it will be used instead.
+ /// Create a <see cref="TopTermsScoringBooleanQueryRewrite"/> for
+ /// at most <paramref name="size"/> terms.
+ /// <para/>
+ /// NOTE: if <see cref="BooleanQuery.MaxClauseCount"/> is smaller than
+ /// <paramref name="size"/>, then it will be used instead.
/// </summary>
public TopTermsScoringBooleanQueryRewrite(int size)
: base(size)
@@ -198,24 +198,24 @@ namespace Lucene.Net.Search
/// <summary>
/// A rewrite method that first translates each term into
- /// <seealso cref="Occur#SHOULD"/> clause in a BooleanQuery, but the scores
+ /// <see cref="Occur.SHOULD"/> clause in a <see cref="BooleanQuery"/>, but the scores
/// are only computed as the boost.
- /// <p>
- /// this rewrite method only uses the top scoring terms so it will not overflow
+ /// <para/>
+ /// This rewrite method only uses the top scoring terms so it will not overflow
/// the boolean max clause count.
/// </summary>
- /// <seealso cref= #setRewriteMethod </seealso>
+ /// <seealso cref="MultiTermRewriteMethod"/>
#if FEATURE_SERIALIZABLE
[Serializable]
#endif
public sealed class TopTermsBoostOnlyBooleanQueryRewrite : TopTermsRewrite<BooleanQuery>
{
/// <summary>
- /// Create a TopTermsBoostOnlyBooleanQueryRewrite for
- /// at most <code>size</code> terms.
- /// <p>
- /// NOTE: if <seealso cref="BooleanQuery#getMaxClauseCount"/> is smaller than
- /// <code>size</code>, then it will be used instead.
+ /// Create a <see cref="TopTermsBoostOnlyBooleanQueryRewrite"/> for
+ /// at most <paramref name="size"/> terms.
+ /// <para/>
+ /// NOTE: if <see cref="BooleanQuery.MaxClauseCount"/> is smaller than
+ /// <paramref name="size"/>, then it will be used instead.
/// </summary>
public TopTermsBoostOnlyBooleanQueryRewrite(int size)
: base(size)
@@ -245,33 +245,31 @@ namespace Lucene.Net.Search
/// <summary>
/// A rewrite method that tries to pick the best
- /// constant-score rewrite method based on term and
- /// document counts from the query. If both the number of
- /// terms and documents is small enough, then {@link
- /// #CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE} is used.
- /// Otherwise, <seealso cref="#CONSTANT_SCORE_FILTER_REWRITE"/> is
- /// used.
+ /// constant-score rewrite method based on term and
+ /// document counts from the query. If both the number of
+ /// terms and documents is small enough, then
+ /// <see cref="CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE"/> is used.
+ /// Otherwise, <see cref="CONSTANT_SCORE_FILTER_REWRITE"/> is
+ /// used.
/// </summary>
#if FEATURE_SERIALIZABLE
[Serializable]
#endif
- public class ConstantScoreAutoRewrite : Lucene.Net.Search.ConstantScoreAutoRewrite
+ public class ConstantScoreAutoRewrite : Lucene.Net.Search.ConstantScoreAutoRewrite // LUCENENET TODO: API Remove duplicate type with same name (confusing)
{
}
/// <summary>
- /// Read-only default instance of {@link
- /// ConstantScoreAutoRewrite}, with {@link
- /// ConstantScoreAutoRewrite#setTermCountCutoff} set to
- /// {@link
- /// ConstantScoreAutoRewrite#DEFAULT_TERM_COUNT_CUTOFF}
- /// and {@link
- /// ConstantScoreAutoRewrite#setDocCountPercent} set to
- /// {@link
- /// ConstantScoreAutoRewrite#DEFAULT_DOC_COUNT_PERCENT}.
- /// Note that you cannot alter the configuration of this
- /// instance; you'll need to create a private instance
- /// instead.
+ /// Read-only default instance of
+ /// <see cref="ConstantScoreAutoRewrite"/>, with
+ /// <see cref="Search.ConstantScoreAutoRewrite.TermCountCutoff"/> set to
+ /// <see cref="Search.ConstantScoreAutoRewrite.DEFAULT_TERM_COUNT_CUTOFF"/>
+ /// and
+ /// <see cref="Search.ConstantScoreAutoRewrite.DocCountPercent"/> set to
+ /// <see cref="Search.ConstantScoreAutoRewrite.DEFAULT_DOC_COUNT_PERCENT"/>.
+ /// Note that you cannot alter the configuration of this
+ /// instance; you'll need to create a private instance
+ /// instead.
/// </summary>
public static readonly RewriteMethod CONSTANT_SCORE_AUTO_REWRITE_DEFAULT = new ConstantScoreAutoRewriteAnonymousInnerClassHelper();
@@ -311,7 +309,7 @@ namespace Lucene.Net.Search
/// <summary>
/// Constructs a query matching terms that cannot be represented with a single
- /// Term.
+ /// <see cref="Term"/>.
/// </summary>
public MultiTermQuery(string field)
{
@@ -334,22 +332,22 @@ namespace Lucene.Net.Search
/// <summary>
/// Construct the enumeration to be used, expanding the
- /// pattern term. this method should only be called if
- /// the field exists (ie, implementations can assume the
- /// field does exist). this method should not return null
- /// (should instead return <seealso cref="TermsEnum#EMPTY"/> if no
- /// terms match). The TermsEnum must already be
- /// positioned to the first matching term.
- /// The given <seealso cref="AttributeSource"/> is passed by the <seealso cref="RewriteMethod"/> to
+ /// pattern term. this method should only be called if
+ /// the field exists (ie, implementations can assume the
+ /// field does exist). this method should not return null
+ /// (should instead return <see cref="TermsEnum.EMPTY"/> if no
+ /// terms match). The <see cref="TermsEnum"/> must already be
+ /// positioned to the first matching term.
+ /// The given <see cref="AttributeSource"/> is passed by the <see cref="RewriteMethod"/> to
/// provide attributes, the rewrite method uses to inform about e.g. maximum competitive boosts.
- /// this is currently only used by <seealso cref="TopTermsRewrite"/>
+ /// this is currently only used by <see cref="TopTermsRewrite{Q}"/>.
/// </summary>
protected abstract TermsEnum GetTermsEnum(Terms terms, AttributeSource atts);
/// <summary>
/// Convenience method, if no attributes are needed:
/// this simply passes empty attributes and is equal to:
- /// <code>getTermsEnum(terms, new AttributeSource())</code>
+ /// <code>GetTermsEnum(terms, new AttributeSource())</code>
/// </summary>
public TermsEnum GetTermsEnum(Terms terms)
{
@@ -358,8 +356,8 @@ namespace Lucene.Net.Search
/// <summary>
/// To rewrite to a simpler form, instead return a simpler
- /// enum from <seealso cref="#getTermsEnum(Terms, AttributeSource)"/>. For example,
- /// to rewrite to a single term, return a <seealso cref="SingleTermsEnum"/>
+ /// enum from <see cref="GetTermsEnum(Terms, AttributeSource)"/>. For example,
+ /// to rewrite to a single term, return a <see cref="Index.SingleTermsEnum"/>.
/// </summary>
public override sealed Query Rewrite(IndexReader reader)
{