lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [07/48] lucenenet git commit: Lucene.Net.Search: Fixed up documentation comments
Date Tue, 06 Jun 2017 00:11:40 GMT
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&lt;ScoreDoc&gt; 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 &gt; 0; i--) pq.pop();
+        /// // First, pop all the sentinel elements (there are pq.Count - totalHits).
+        /// for (int i = pq.Count - totalHits; i &gt; 0; i--) pq.Pop();
         ///
         /// // Now pop the truly added elements.
         /// ScoreDoc[] results = new ScoreDoc[totalHits];
-        /// for (int i = totalHits - 1; i &gt;= 0; i--) {
-        ///   results[i] = (ScoreDoc) pq.pop();
+        /// for (int i = totalHits - 1; i &gt;= 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 &amp; 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)
         {


Mime
View raw message