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) {
