lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From synhers...@apache.org
Subject [24/50] [abbrv] lucenenet git commit: Updated Suggest documentation links to code elements and made corrections.
Date Sun, 02 Oct 2016 14:35:42 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Analyzing/FuzzySuggester.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/FuzzySuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/FuzzySuggester.cs
index 3dd4b90..a01da75 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/FuzzySuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/FuzzySuggester.cs
@@ -26,24 +26,23 @@ namespace Lucene.Net.Search.Suggest.Analyzing
      */
 
     /// <summary>
-    /// Implements a fuzzy <seealso cref="AnalyzingSuggester"/>. The similarity measurement is
+    /// Implements a fuzzy <see cref="AnalyzingSuggester"/>. The similarity measurement is
     /// based on the Damerau-Levenshtein (optimal string alignment) algorithm, though
-    /// you can explicitly choose classic Levenshtein by passing <code>false</code>
-    /// for the <code>transpositions</code> parameter.
+    /// you can explicitly choose classic Levenshtein by passing <c>false</c>
+    /// for the <paramref name="transpositions"/> parameter.
     /// <para>
-    /// At most, this query will match terms up to
-    /// {@value org.apache.lucene.util.automaton.LevenshteinAutomata#MAXIMUM_SUPPORTED_DISTANCE}
+    /// At most, this query will match terms up to <see cref="LevenshteinAutomata.MAXIMUM_SUPPORTED_DISTANCE"/>
     /// edits. Higher distances are not supported.  Note that the
     /// fuzzy distance is measured in "byte space" on the bytes
-    /// returned by the <seealso cref="TokenStream"/>'s {@link
-    /// TermToBytesRefAttribute}, usually UTF8.  By default
-    /// the analyzed bytes must be at least 3 {@link
-    /// #DEFAULT_MIN_FUZZY_LENGTH} bytes before any edits are
-    /// considered.  Furthermore, the first 1 {@link
-    /// #DEFAULT_NON_FUZZY_PREFIX} byte is not allowed to be
-    /// edited.  We allow up to 1 (@link
-    /// #DEFAULT_MAX_EDITS} edit.
-    /// If <seealso cref="#unicodeAware"/> parameter in the constructor is set to true, maxEdits,
+    /// returned by the <see cref="TokenStream"/>'s <see cref="Analysis.Tokenattributes.ITermToBytesRefAttribute"/>, 
+    /// usually UTF8.  By default
+    /// the analyzed bytes must be at least 3 <see cref="DEFAULT_MIN_FUZZY_LENGTH"/>
+    /// bytes before any edits are
+    /// considered.  Furthermore, the first 1 <see cref="DEFAULT_NON_FUZZY_PREFIX"/>
+    /// byte is not allowed to be
+    /// edited.  We allow up to 1 <see cref="DEFAULT_MAX_EDITS"/>
+    /// edit.
+    /// If <paramref name="unicodeAware"/> parameter in the constructor is set to true, maxEdits,
     /// minFuzzyLength, transpositions and nonFuzzyPrefix are measured in Unicode code 
     /// points (actual letters) instead of bytes. 
     /// 
@@ -72,15 +71,16 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         private readonly bool unicodeAware;
 
         /// <summary>
-        /// Measure maxEdits, minFuzzyLength, transpositions and nonFuzzyPrefix 
-        ///  parameters in Unicode code points (actual letters)
-        ///  instead of bytes. 
+        /// Measure <paramref name="maxEdits"/>, <paramref name="minFuzzyLength"/>, 
+        /// <paramref name="transpositions"/>, and <paramref name="nonFuzzyPrefix"/> 
+        /// parameters in Unicode code points (actual letters)
+        /// instead of bytes.
         /// </summary>
         public const bool DEFAULT_UNICODE_AWARE = false;
 
         /// <summary>
-        /// The default minimum length of the key passed to {@link
-        /// #lookup} before any edits are allowed.
+        /// The default minimum length of the key passed to <see cref="Lookup"/>
+        /// before any edits are allowed.
         /// </summary>
         public const int DEFAULT_MIN_FUZZY_LENGTH = 3;
 
@@ -96,39 +96,39 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         public const int DEFAULT_MAX_EDITS = 1;
 
         /// <summary>
-        /// The default transposition value passed to <seealso cref="LevenshteinAutomata"/>
+        /// The default transposition value passed to <see cref="LevenshteinAutomata"/>
         /// </summary>
         public const bool DEFAULT_TRANSPOSITIONS = true;
 
         /// <summary>
-        /// Creates a <seealso cref="FuzzySuggester"/> instance initialized with default values.
+        /// Creates a <see cref="FuzzySuggester"/> instance initialized with default values.
         /// </summary>
-        /// <param name="analyzer"> the analyzer used for this suggester </param>
+        /// <param name="analyzer"> The <see cref="Analyzer"/> used for this suggester. </param>
         public FuzzySuggester(Analyzer analyzer)
             : this(analyzer, analyzer)
         {
         }
 
         /// <summary>
-        /// Creates a <seealso cref="FuzzySuggester"/> instance with an index & a query analyzer initialized with default values.
+        /// Creates a <see cref="FuzzySuggester"/> instance with an index & a query analyzer initialized with default values.
         /// </summary>
         /// <param name="indexAnalyzer">
-        ///           Analyzer that will be used for analyzing suggestions while building the index. </param>
+        ///           <see cref="Analyzer"/> that will be used for analyzing suggestions while building the index. </param>
         /// <param name="queryAnalyzer">
-        ///           Analyzer that will be used for analyzing query text during lookup </param>
+        ///           <see cref="Analyzer"/> that will be used for analyzing query text during lookup </param>
         public FuzzySuggester(Analyzer indexAnalyzer, Analyzer queryAnalyzer)
             : this(indexAnalyzer, queryAnalyzer, EXACT_FIRST | PRESERVE_SEP, 256, -1, true, DEFAULT_MAX_EDITS, DEFAULT_TRANSPOSITIONS, DEFAULT_NON_FUZZY_PREFIX, DEFAULT_MIN_FUZZY_LENGTH, DEFAULT_UNICODE_AWARE)
         {
         }
 
         /// <summary>
-        /// Creates a <seealso cref="FuzzySuggester"/> instance.
+        /// Creates a <see cref="FuzzySuggester"/> instance.
         /// </summary>
-        /// <param name="indexAnalyzer"> Analyzer that will be used for
+        /// <param name="indexAnalyzer"> The <see cref="Analyzer"/> that will be used for
         ///        analyzing suggestions while building the index. </param>
-        /// <param name="queryAnalyzer"> Analyzer that will be used for
+        /// <param name="queryAnalyzer"> The <see cref="Analyzer"/> that will be used for
         ///        analyzing query text during lookup </param>
-        /// <param name="options"> see <seealso cref="#EXACT_FIRST"/>, <seealso cref="#PRESERVE_SEP"/> </param>
+        /// <param name="options"> see <see cref="EXACT_FIRST"/>, <see cref="PRESERVE_SEP"/> </param>
         /// <param name="maxSurfaceFormsPerAnalyzedForm"> Maximum number of
         ///        surface forms to keep for a single analyzed form.
         ///        When there are too many surface forms we discard the
@@ -137,12 +137,12 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         ///        to expand from the analyzed form.  Set this to -1 for
         ///        no limit. </param>
         /// <param name="preservePositionIncrements"> Whether position holes should appear in the automaton </param>
-        /// <param name="maxEdits"> must be >= 0 and <= <seealso cref="LevenshteinAutomata#MAXIMUM_SUPPORTED_DISTANCE"/> . </param>
-        /// <param name="transpositions"> <code>true</code> if transpositions should be treated as a primitive 
+        /// <param name="maxEdits"> must be &gt;= 0 and &lt;= <see cref="LevenshteinAutomata.MAXIMUM_SUPPORTED_DISTANCE"/>. </param>
+        /// <param name="transpositions"> <c>true</c> if transpositions should be treated as a primitive 
         ///        edit operation. If this is false, comparisons will implement the classic
         ///        Levenshtein algorithm. </param>
-        /// <param name="nonFuzzyPrefix"> length of common (non-fuzzy) prefix (see default <seealso cref="#DEFAULT_NON_FUZZY_PREFIX"/> </param>
-        /// <param name="minFuzzyLength"> minimum length of lookup key before any edits are allowed (see default <seealso cref="#DEFAULT_MIN_FUZZY_LENGTH"/>) </param>
+        /// <param name="nonFuzzyPrefix"> length of common (non-fuzzy) prefix (see default <see cref="DEFAULT_NON_FUZZY_PREFIX"/> </param>
+        /// <param name="minFuzzyLength"> minimum length of lookup key before any edits are allowed (see default <see cref="DEFAULT_MIN_FUZZY_LENGTH"/>) </param>
         /// <param name="unicodeAware"> operate Unicode code points instead of bytes. </param>
         public FuzzySuggester(Analyzer indexAnalyzer, Analyzer queryAnalyzer, int options, int maxSurfaceFormsPerAnalyzedForm, int maxGraphExpansions, bool preservePositionIncrements, int maxEdits, bool transpositions, int nonFuzzyPrefix, int minFuzzyLength, bool unicodeAware)
             : base(indexAnalyzer, queryAnalyzer, options, maxSurfaceFormsPerAnalyzedForm, maxGraphExpansions, preservePositionIncrements)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs
index 6e8c08b..59d7836 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs
@@ -23,17 +23,18 @@ namespace Lucene.Net.Search.Suggest.Analyzing
      */
 
     /// <summary>
-    /// Like <seealso cref="StopFilter"/> except it will not remove the
-    ///  last token if that token was not followed by some token
-    ///  separator.  For example, a query 'find the' would
-    ///  preserve the 'the' since it was not followed by a space or
-    ///  punctuation or something, and mark it KEYWORD so future
-    ///  stemmers won't touch it either while a query like "find
-    ///  the popsicle' would remove 'the' as a stopword.
+    /// Like <see cref="Analysis.Core.StopFilter"/> except it will not remove the
+    /// last token if that token was not followed by some token
+    /// separator.  For example, a query 'find the' would
+    /// preserve the 'the' since it was not followed by a space or
+    /// punctuation or something, and mark it KEYWORD so future
+    /// stemmers won't touch it either while a query like "find
+    /// the popsicle' would remove 'the' as a stopword.
     /// 
-    ///  <para>Normally you'd use the ordinary <seealso cref="StopFilter"/>
-    ///  in your indexAnalyzer and then this class in your
-    ///  queryAnalyzer, when using one of the analyzing suggesters. 
+    /// <para>
+    /// Normally you'd use the ordinary <see cref="Analysis.Core.StopFilter"/>
+    /// in your indexAnalyzer and then this class in your
+    /// queryAnalyzer, when using one of the analyzing suggesters. 
     /// </para>
     /// </summary>
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/BufferedInputIterator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/BufferedInputIterator.cs b/src/Lucene.Net.Suggest/Suggest/BufferedInputIterator.cs
index 7518591..71590d8 100644
--- a/src/Lucene.Net.Suggest/Suggest/BufferedInputIterator.cs
+++ b/src/Lucene.Net.Suggest/Suggest/BufferedInputIterator.cs
@@ -40,7 +40,7 @@ namespace Lucene.Net.Search.Suggest
         /// current buffer position </summary>
         protected internal int curPos = -1;
         /// <summary>
-        /// buffered weights, parallel with <seealso cref="#entries"/> </summary>
+        /// buffered weights, parallel with <see cref="entries"/> </summary>
         protected internal long[] freqs = new long[1];
         private readonly BytesRef spare = new BytesRef();
         private readonly BytesRef payloadSpare = new BytesRef();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/BufferingTermFreqIteratorWrapper.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/BufferingTermFreqIteratorWrapper.cs b/src/Lucene.Net.Suggest/Suggest/BufferingTermFreqIteratorWrapper.cs
index deaeca4..fa929be 100644
--- a/src/Lucene.Net.Suggest/Suggest/BufferingTermFreqIteratorWrapper.cs
+++ b/src/Lucene.Net.Suggest/Suggest/BufferingTermFreqIteratorWrapper.cs
@@ -35,7 +35,7 @@ namespace Lucene.Net.Search.Suggest
         /// current buffer position </summary>
         protected internal int curPos = -1;
         /// <summary>
-        /// buffered weights, parallel with <seealso cref="#entries"/> </summary>
+        /// buffered weights, parallel with <see cref="entries"/> </summary>
         protected internal long[] freqs = new long[1];
         private readonly BytesRef spare = new BytesRef();
         private readonly IComparer<BytesRef> comp;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/DocumentDictionary.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/DocumentDictionary.cs b/src/Lucene.Net.Suggest/Suggest/DocumentDictionary.cs
index ee7ddc4..ff7bc3d 100644
--- a/src/Lucene.Net.Suggest/Suggest/DocumentDictionary.cs
+++ b/src/Lucene.Net.Suggest/Suggest/DocumentDictionary.cs
@@ -30,27 +30,27 @@ namespace Lucene.Net.Search.Suggest
     /// information taken from stored/indexed fields in a Lucene index.
     /// </para>
     /// <b>NOTE:</b> 
-    ///  <ul>
-    ///    <li>
+    ///  <list type="bullet">
+    ///    <item>
     ///      The term and (optionally) payload fields have to be
     ///      stored
-    ///    </li>
-    ///    <li>
-    ///      The weight field can be stored or can be a <seealso cref="NumericDocValues"/>.
-    ///      If the weight field is not defined, the value of the weight is <code>0</code>
-    ///    </li>
-    ///    <li>
+    ///    </item>
+    ///    <item>
+    ///      The weight field can be stored or can be a <see cref="NumericDocValues"/>.
+    ///      If the weight field is not defined, the value of the weight is <c>0</c>
+    ///    </item>
+    ///    <item>
     ///      if any of the term or (optionally) payload fields supplied
     ///      do not have a value for a document, then the document is 
     ///      skipped by the dictionary
-    ///    </li>
-    ///  </ul>
+    ///    </item>
+    ///  </list>
     /// </summary>
     public class DocumentDictionary : IDictionary
     {
 
         /// <summary>
-        /// <seealso cref="IndexReader"/> to load documents from </summary>
+        /// <see cref="IndexReader"/> to load documents from </summary>
         protected internal readonly IndexReader reader;
 
         /// <summary>
@@ -63,8 +63,8 @@ namespace Lucene.Net.Search.Suggest
         private readonly string weightField;
 
         /// <summary>
-        /// Creates a new dictionary with the contents of the fields named <code>field</code>
-        /// for the terms and <code>weightField</code> for the weights that will be used for
+        /// Creates a new dictionary with the contents of the fields named <paramref name="field"/>
+        /// for the terms and <paramref name="weightField"/> for the weights that will be used for
         /// the corresponding terms.
         /// </summary>
         public DocumentDictionary(IndexReader reader, string field, string weightField)
@@ -73,9 +73,9 @@ namespace Lucene.Net.Search.Suggest
         }
 
         /// <summary>
-        /// Creates a new dictionary with the contents of the fields named <code>field</code>
-        /// for the terms, <code>weightField</code> for the weights that will be used for the 
-        /// the corresponding terms and <code>payloadField</code> for the corresponding payloads
+        /// Creates a new dictionary with the contents of the fields named <paramref name="field"/>
+        /// for the terms, <paramref name="weightField"/> for the weights that will be used for the 
+        /// the corresponding terms and <paramref name="payloadField"/> for the corresponding payloads
         /// for the entry.
         /// </summary>
         public DocumentDictionary(IndexReader reader, string field, string weightField, string payloadField)
@@ -84,10 +84,10 @@ namespace Lucene.Net.Search.Suggest
         }
 
         /// <summary>
-        /// Creates a new dictionary with the contents of the fields named <code>field</code>
-        /// for the terms, <code>weightField</code> for the weights that will be used for the 
-        /// the corresponding terms, <code>payloadField</code> for the corresponding payloads
-        /// for the entry and <code>contextsFeild</code> for associated contexts.
+        /// Creates a new dictionary with the contents of the fields named <paramref name="field"/>
+        /// for the terms, <paramref name="weightField"/> for the weights that will be used for the 
+        /// the corresponding terms, <paramref name="payloadField"/> for the corresponding payloads
+        /// for the entry and <paramref name="contextsFeild"/> for associated contexts.
         /// </summary>
         public DocumentDictionary(IndexReader reader, string field, string weightField, string payloadField, string contextsField)
         {
@@ -107,7 +107,7 @@ namespace Lucene.Net.Search.Suggest
         }
 
         /// <summary>
-        /// Implements <seealso cref="InputIterator"/> from stored fields. </summary>
+        /// Implements <see cref="IInputIterator"/> from stored fields. </summary>
         protected internal class DocumentInputIterator : IInputIterator
         {
             private readonly DocumentDictionary outerInstance;
@@ -127,7 +127,7 @@ namespace Lucene.Net.Search.Suggest
 
             /// <summary>
             /// Creates an iterator over term, weight and payload fields from the lucene
-            /// index. setting <code>withPayload</code> to false, implies an iterator
+            /// index. setting <see cref="HasPayloads"/> to false, implies an iterator
             /// over only term and weight.
             /// </summary>
             public DocumentInputIterator(DocumentDictionary outerInstance, bool hasPayloads, bool hasContexts)
@@ -223,9 +223,9 @@ namespace Lucene.Net.Search.Suggest
             }
 
             /// <summary>
-            /// Returns the value of the <code>weightField</code> for the current document.
-            /// Retrieves the value for the <code>weightField</code> if its stored (using <code>doc</code>)
-            /// or if its indexed as <seealso cref="NumericDocValues"/> (using <code>docId</code>) for the document.
+            /// Returns the value of the <see cref="Weight"/> property for the current document.
+            /// Retrieves the value for the <see cref="Weight"/> property if its stored (using <paramref name="doc"/>)
+            /// or if its indexed as <see cref="NumericDocValues"/> (using <paramref name="docId"/>) for the document.
             /// If no value is found, then the weight is 0.
             /// </summary>
             protected internal virtual long GetWeight(Document doc, int docId)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/DocumentValueSourceDictionary.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/DocumentValueSourceDictionary.cs b/src/Lucene.Net.Suggest/Suggest/DocumentValueSourceDictionary.cs
index 0c0165e..b8252ec 100644
--- a/src/Lucene.Net.Suggest/Suggest/DocumentValueSourceDictionary.cs
+++ b/src/Lucene.Net.Suggest/Suggest/DocumentValueSourceDictionary.cs
@@ -28,32 +28,32 @@ namespace Lucene.Net.Search.Suggest
     /// <para>
     /// Dictionary with terms and optionally payload information 
     /// taken from stored fields in a Lucene index. Similar to 
-    /// <seealso cref="DocumentDictionary"/>, except it obtains the weight
-    /// of the terms in a document based on a <seealso cref="ValueSource"/>.
+    /// <see cref="DocumentDictionary"/>, except it obtains the weight
+    /// of the terms in a document based on a <see cref="ValueSource"/>.
     /// </para>
     /// <b>NOTE:</b> 
-    ///  <ul>
-    ///    <li>
+    ///  <list type="bullet">
+    ///    <item>
     ///      The term and (optionally) payload fields have to be
     ///      stored
-    ///    </li>
-    ///    <li>
+    ///    </item>
+    ///    <item>
     ///      if the term or (optionally) payload fields supplied
     ///      do not have a value for a document, then the document is 
     ///      rejected by the dictionary
-    ///    </li>
-    ///  </ul>
+    ///    </item>
+    ///  </list>
     ///  <para>
-    ///  In practice the <seealso cref="ValueSource"/> will likely be obtained
+    ///  In practice the <see cref="ValueSource"/> will likely be obtained
     ///  using the lucene expression module. The following example shows
-    ///  how to create a <seealso cref="ValueSource"/> from a simple addition of two
+    ///  how to create a <see cref="ValueSource"/> from a simple addition of two
     ///  fields:
     ///  <code>
-    ///    Expression expression = JavascriptCompiler.compile("f1 + f2");
+    ///    Expression expression = JavascriptCompiler.Compile("f1 + f2");
     ///    SimpleBindings bindings = new SimpleBindings();
-    ///    bindings.add(new SortField("f1", SortField.Type.LONG));
-    ///    bindings.add(new SortField("f2", SortField.Type.LONG));
-    ///    ValueSource valueSource = expression.getValueSource(bindings);
+    ///    bindings.Add(new SortField("f1", SortField.Type_e.LONG));
+    ///    bindings.Add(new SortField("f2", SortField.Type_e.LONG));
+    ///    ValueSource valueSource = expression.GetValueSource(bindings);
     ///  </code>
     ///  </para>
     /// 
@@ -64,9 +64,9 @@ namespace Lucene.Net.Search.Suggest
         private readonly ValueSource weightsValueSource;
 
         /// <summary>
-        /// Creates a new dictionary with the contents of the fields named <code>field</code>
-        /// for the terms, <code>payload</code> for the corresponding payloads, <code>contexts</code>
-        /// for the associated contexts and uses the <code>weightsValueSource</code> supplied 
+        /// Creates a new dictionary with the contents of the fields named <paramref name="field"/>
+        /// for the terms, <paramref name="payload"/> for the corresponding payloads, <paramref name="contexts"/>
+        /// for the associated contexts and uses the <paramref name="weightsValueSource"/> supplied 
         /// to determine the score.
         /// </summary>
         public DocumentValueSourceDictionary(IndexReader reader, string field, ValueSource weightsValueSource, string payload, string contexts)
@@ -75,9 +75,9 @@ namespace Lucene.Net.Search.Suggest
             this.weightsValueSource = weightsValueSource;
         }
         /// <summary>
-        /// Creates a new dictionary with the contents of the fields named <code>field</code>
-        /// for the terms, <code>payloadField</code> for the corresponding payloads
-        /// and uses the <code>weightsValueSource</code> supplied to determine the 
+        /// Creates a new dictionary with the contents of the fields named <paramref name="field"/>
+        /// for the terms, <paramref name="payload"/> for the corresponding payloads
+        /// and uses the <paramref name="weightsValueSource"/> supplied to determine the 
         /// score.
         /// </summary>
         public DocumentValueSourceDictionary(IndexReader reader, string field, ValueSource weightsValueSource, string payload)
@@ -87,8 +87,8 @@ namespace Lucene.Net.Search.Suggest
         }
 
         /// <summary>
-        /// Creates a new dictionary with the contents of the fields named <code>field</code>
-        /// for the terms and uses the <code>weightsValueSource</code> supplied to determine the 
+        /// Creates a new dictionary with the contents of the fields named <paramref name="field"/>
+        /// for the terms and uses the <paramref name="weightsValueSource"/> supplied to determine the 
         /// score.
         /// </summary>
         public DocumentValueSourceDictionary(IndexReader reader, string field, ValueSource weightsValueSource)
@@ -136,9 +136,8 @@ namespace Lucene.Net.Search.Suggest
             }
 
             /// <summary>
-            /// Returns the weight for the current <code>docId</code> as computed 
-            /// by the <code>weightsValueSource</code>
-            /// 
+            /// Returns the weight for the current <paramref name="docId"/> as computed 
+            /// by the <see cref="weightsValueSource"/>
             /// </summary>
             protected internal override long GetWeight(Document doc, int docId)
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/FileDictionary.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/FileDictionary.cs b/src/Lucene.Net.Suggest/Suggest/FileDictionary.cs
index a43cb37..9db60c8 100644
--- a/src/Lucene.Net.Suggest/Suggest/FileDictionary.cs
+++ b/src/Lucene.Net.Suggest/Suggest/FileDictionary.cs
@@ -27,29 +27,29 @@ namespace Lucene.Net.Search.Suggest
     /// <summary>
     /// Dictionary represented by a text file.
     /// 
-    /// <p/>Format allowed: 1 entry per line:<br/>
-    /// An entry can be: <br/>
-    /// <ul>
-    /// <li>suggestion</li>
-    /// <li>suggestion <code>fieldDelimiter</code> weight</li>
-    /// <li>suggestion <code>fieldDelimiter</code> weight <code>fieldDelimiter</code> payload</li>
-    /// </ul>
-    /// where the default <code>fieldDelimiter</code> is {@value #DEFAULT_FIELD_DELIMITER}<br/>
-    /// <p/>
+    /// <para>Format allowed: 1 entry per line:</para>
+    /// <para>An entry can be: </para>
+    /// <list type="number">
+    /// <item>suggestion</item>
+    /// <item>suggestion <see cref="fieldDelimiter"/> weight</item>
+    /// <item>suggestion <see cref="fieldDelimiter"/> weight <see cref="fieldDelimiter"/> payload</item>
+    /// </list>
+    /// where the default <see cref="fieldDelimiter"/> is <see cref="DEFAULT_FIELD_DELIMITER"/> (a tab)
+    /// <para>
     /// <b>NOTE:</b> 
-    /// <ul>
-    /// <li>In order to have payload enabled, the first entry has to have a payload</li>
-    /// <li>If the weight for an entry is not specified then a value of 1 is used</li>
-    /// <li>A payload cannot be specified without having the weight specified for an entry</li>
-    /// <li>If the payload for an entry is not specified (assuming payload is enabled) 
-    ///  then an empty payload is returned</li>
-    /// <li>An entry cannot have more than two <code>fieldDelimiter</code></li>
-    /// </ul>
-    /// <p/>
-    /// <b>Example:</b><br/>
-    /// word1 word2 TAB 100 TAB payload1<br/>
-    /// word3 TAB 101<br/>
-    /// word4 word3 TAB 102<br/>
+    /// <list type="number">
+    /// <item>In order to have payload enabled, the first entry has to have a payload</item>
+    /// <item>If the weight for an entry is not specified then a value of 1 is used</item>
+    /// <item>A payload cannot be specified without having the weight specified for an entry</item>
+    /// <item>If the payload for an entry is not specified (assuming payload is enabled) 
+    ///  then an empty payload is returned</item>
+    /// <item>An entry cannot have more than two <see cref="fieldDelimiter"/>s</item>
+    /// </list>
+    /// </para>
+    /// <c>Example:</c><para/>
+    /// word1 word2 TAB 100 TAB payload1<para/>
+    /// word3 TAB 101<para/>
+    /// word4 word3 TAB 102<para/>
     /// </summary>
     public class FileDictionary : IDictionary
     {
@@ -65,7 +65,7 @@ namespace Lucene.Net.Search.Suggest
 
         /// <summary>
         /// Creates a dictionary based on an inputstream.
-        /// Using <seealso cref="#DEFAULT_FIELD_DELIMITER"/> as the 
+        /// Using <see cref="DEFAULT_FIELD_DELIMITER"/> as the 
         /// field seperator in a line.
         /// <para>
         /// NOTE: content is treated as UTF-8
@@ -78,7 +78,7 @@ namespace Lucene.Net.Search.Suggest
 
         /// <summary>
         /// Creates a dictionary based on a reader.
-        /// Using <seealso cref="#DEFAULT_FIELD_DELIMITER"/> as the 
+        /// Using <see cref="DEFAULT_FIELD_DELIMITER"/> as the 
         /// field seperator in a line.
         /// </summary>
         public FileDictionary(TextReader reader)
@@ -88,7 +88,7 @@ namespace Lucene.Net.Search.Suggest
 
         /// <summary>
         /// Creates a dictionary based on a reader. 
-        /// Using <code>fieldDelimiter</code> to seperate out the
+        /// Using <paramref name="fieldDelimiter"/> to seperate out the
         /// fields in a line.
         /// </summary>
         public FileDictionary(TextReader reader, string fieldDelimiter)
@@ -99,7 +99,7 @@ namespace Lucene.Net.Search.Suggest
 
         /// <summary>
         /// Creates a dictionary based on an inputstream.
-        /// Using <code>fieldDelimiter</code> to seperate out the
+        /// Using <paramref name="fieldDelimiter"/> to seperate out the
         /// fields in a line.
         /// <para>
         /// NOTE: content is treated as UTF-8

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Fst/BytesRefSorter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Fst/BytesRefSorter.cs b/src/Lucene.Net.Suggest/Suggest/Fst/BytesRefSorter.cs
index dbf4361..2d7c952 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/BytesRefSorter.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/BytesRefSorter.cs
@@ -21,7 +21,7 @@ namespace Lucene.Net.Search.Suggest.Fst
      */
 
     /// <summary>
-    /// Collects <seealso cref="BytesRef"/> and then allows one to iterate over their sorted order. Implementations
+    /// Collects <see cref="BytesRef"/> and then allows one to iterate over their sorted order. Implementations
     /// of this interface will be called in a single-threaded scenario.
     /// </summary>
     public interface IBytesRefSorter
@@ -29,16 +29,16 @@ namespace Lucene.Net.Search.Suggest.Fst
         /// <summary>
         /// Adds a single suggestion entry (possibly compound with its bucket).
         /// </summary>
-        /// <exception cref="IOException"> If an I/O exception occurs. </exception>
-        /// <exception cref="InvalidOperationException"> If an addition attempt is performed after
-        /// a call to <seealso cref="#iterator()"/> has been made. </exception>
+        /// <exception cref="System.IO.IOException"> If an I/O exception occurs. </exception>
+        /// <exception cref="System.InvalidOperationException"> If an addition attempt is performed after
+        /// a call to <see cref="GetEnumerator"/> has been made. </exception>
         void Add(BytesRef utf8);
 
         /// <summary>
-        /// Sorts the entries added in <seealso cref="#add(BytesRef)"/> and returns 
-        /// an iterator over all sorted entries.
+        /// Sorts the entries added in <see cref="Add(BytesRef)"/> and returns 
+        /// an enumerator over all sorted entries.
         /// </summary>
-        /// <exception cref="IOException"> If an I/O exception occurs. </exception>
+        /// <exception cref="System.IO.IOException"> If an I/O exception occurs. </exception>
         BytesRefIterator GetEnumerator();
 
         /// <summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs
index 954a7cc..aba5fdd 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs
@@ -30,8 +30,8 @@ namespace Lucene.Net.Search.Suggest.Fst
     /// <summary>
     /// Finite state automata based implementation of "autocomplete" functionality.
     /// </summary>
-    /// <seealso cref=FSTCompletionBuilder
-    /// @lucene.experimental </seealso>
+    /// <seealso cref="FSTCompletionBuilder"/>
+    /// @lucene.experimental
 
     // TODO: we could store exact weights as outputs from the FST (int4 encoded
     // floats). This would provide exact outputs from this method and to some
@@ -77,7 +77,7 @@ namespace Lucene.Net.Search.Suggest.Fst
         public const int DEFAULT_BUCKETS = 10;
 
         /// <summary>
-        /// An empty result. Keep this an <seealso cref="ArrayList"/> to keep all the returned
+        /// An empty result. Keep this an <see cref="List"/> to keep all the returned
         /// lists of single type (monomorphic calls).
         /// </summary>
         private static readonly IList<Completion> EMPTY_RESULT = new List<Completion>();
@@ -106,10 +106,10 @@ namespace Lucene.Net.Search.Suggest.Fst
         /// <summary>
         /// Constructs an FSTCompletion, specifying higherWeightsFirst and exactFirst. </summary>
         /// <param name="automaton">
-        ///          Automaton with completions. See <seealso cref="FSTCompletionBuilder"/>. </param>
+        ///          Automaton with completions. See <see cref="FSTCompletionBuilder"/>. </param>
         /// <param name="exactFirst">
         ///          Return most popular suggestions first. This is the default
-        ///          behavior for this implementation. Setting it to <code>false</code>
+        ///          behavior for this implementation. Setting it to <c>false</c>
         ///          has no effect (use constant term weights to sort alphabetically
         ///          only). </param>
         /// <param name="exactFirst">
@@ -132,7 +132,7 @@ namespace Lucene.Net.Search.Suggest.Fst
 
         /// <summary>
         /// Defaults to higher weights first and exact first. </summary>
-        /// <seealso cref= #FSTCompletion(FST, boolean, boolean) </seealso>
+        /// <seealso cref="FSTCompletion(FST, bool, bool)"/>
         public FSTCompletion(FST<object> automaton)
             : this(automaton, true, true)
         {
@@ -171,10 +171,10 @@ namespace Lucene.Net.Search.Suggest.Fst
 
         /// <summary>
         /// Returns the first exact match by traversing root arcs, starting from the
-        /// arc <code>rootArcIndex</code>.
+        /// arc <paramref name="rootArcIndex"/>.
         /// </summary>
         /// <param name="rootArcIndex">
-        ///          The first root arc index in <seealso cref="#rootArcs"/> to consider when
+        ///          The first root arc index in <see cref="rootArcs"/> to consider when
         ///          matching.
         /// </param>
         /// <param name="utf8">
@@ -217,7 +217,7 @@ namespace Lucene.Net.Search.Suggest.Fst
         }
 
         /// <summary>
-        /// Lookup suggestions to <code>key</code>.
+        /// Lookup suggestions to <paramref name="key"/>.
         /// </summary>
         /// <param name="key">
         ///          The prefix to which suggestions should be sought. </param>
@@ -257,8 +257,8 @@ namespace Lucene.Net.Search.Suggest.Fst
         }
 
         /// <summary>
-        /// Lookup suggestions sorted alphabetically <b>if weights are not
-        /// constant</b>. This is a workaround: in general, use constant weights for
+        /// Lookup suggestions sorted alphabetically <c>if weights are not
+        /// constant</c>. This is a workaround: in general, use constant weights for
         /// alphabetically sorted result.
         /// </summary>
         private IList<Completion> LookupSortedAlphabetically(BytesRef key, int num)
@@ -270,7 +270,6 @@ namespace Lucene.Net.Search.Suggest.Fst
             res.Sort();
             if (res.Count > num)
             {
-                //res = res.SubList(0, num);
                 res = new List<Completion>(res.SubList(0, num));
             }
             return res;
@@ -280,10 +279,10 @@ namespace Lucene.Net.Search.Suggest.Fst
         /// Lookup suggestions sorted by weight (descending order).
         /// </summary>
         /// <param name="collectAll">
-        ///          If <code>true</code>, the routine terminates immediately when
-        ///          <code>num</code> suggestions have been collected. If
-        ///          <code>false</code>, it will collect suggestions from all weight
-        ///          arcs (needed for <seealso cref="#lookupSortedAlphabetically"/>. </param>
+        ///          If <c>true</c>, the routine terminates immediately when
+        ///          <paramref name="num"/> suggestions have been collected. If
+        ///          <c>false</c>, it will collect suggestions from all weight
+        ///          arcs (needed for <see cref="LookupSortedAlphabetically"/>. </param>
         private IList<Completion> LookupSortedByWeight(BytesRef key, int num, bool collectAll)
         {
             // Don't overallocate the results buffers. This also serves the purpose of
@@ -334,13 +333,15 @@ namespace Lucene.Net.Search.Suggest.Fst
 
         /// <summary>
         /// Checks if the list of
-        /// <seealso cref="Suggest.Lookup.LookupResult"/>s already has a
-        /// <code>key</code>. If so, reorders that
-        /// <seealso cref="Suggest.Lookup.LookupResult"/> to the first
+        /// <see cref="Lookup.LookupResult"/>s already has a
+        /// <paramref name="key"/>. If so, reorders that
+        /// <see cref="Lookup.LookupResult"/> to the first
         /// position.
         /// </summary>
-        /// <returns> Returns <code>true<code> if and only if <code>list</code> contained
-        ///         <code>key</code>. </returns>
+        /// <returns> 
+        /// Returns <c>true<c> if and only if <paramref name="list"/> contained
+        /// <paramref name="key"/>.
+        /// </returns>
         private bool CheckExistingAndReorder(List<Completion> list, BytesRef key)
         {
             // We assume list does not have duplicates (because of how the FST is created).
@@ -367,15 +368,15 @@ namespace Lucene.Net.Search.Suggest.Fst
         }
 
         /// <summary>
-        /// Descend along the path starting at <code>arc</code> and going through bytes
+        /// Descend along the path starting at <paramref name="arc"/> and going through bytes
         /// in the argument.
         /// </summary>
         /// <param name="arc">
         ///          The starting arc. This argument is modified in-place. </param>
         /// <param name="utf8">
         ///          The term to descend along. </param>
-        /// <returns> If <code>true</code>, <code>arc</code> will be set to the arc
-        ///         matching last byte of <code>term</code>. <code>false</code> is
+        /// <returns> If <c>true</c>, <paramref name="arc"/> will be set to the arc
+        ///         matching last byte of <paramref name="term"/>. <c>false</c> is
         ///         returned if no such prefix exists. </returns>
         private bool DescendWithPrefix(FST.Arc<object> arc, BytesRef utf8)
         {
@@ -396,7 +397,7 @@ namespace Lucene.Net.Search.Suggest.Fst
 
         /// <summary>
         /// Recursive collect lookup results from the automaton subgraph starting at
-        /// <code>arc</code>.
+        /// <paramref name="arc"/>.
         /// </summary>
         /// <param name="num">
         ///          Maximum number of results needed (early termination). </param>
@@ -451,7 +452,7 @@ namespace Lucene.Net.Search.Suggest.Fst
         }
 
         /// <summary>
-        /// Returns the bucket assigned to a given key (if found) or <code>-1</code> if
+        /// Returns the bucket assigned to a given key (if found) or <c>-1</c> if
         /// no exact match exists.
         /// </summary>
         public virtual int GetBucket(string key)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionBuilder.cs b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionBuilder.cs
index ea39004..aeb3f22 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionBuilder.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionBuilder.cs
@@ -28,41 +28,41 @@ namespace Lucene.Net.Search.Suggest.Fst
     /// <h2>Implementation details</h2>
     /// 
     /// <para>
-    /// The construction step in <seealso cref="#finalize()"/> works as follows:
-    /// <ul>
-    /// <li>A set of input terms and their buckets is given.</li>
-    /// <li>All terms in the input are prefixed with a synthetic pseudo-character
+    /// The construction step in <see cref="Finalize"/> works as follows:
+    /// <list type="bullet">
+    /// <item>A set of input terms and their buckets is given.</item>
+    /// <item>All terms in the input are prefixed with a synthetic pseudo-character
     /// (code) of the weight bucket the term fell into. For example a term
-    /// <code>abc</code> with a discretized weight equal '1' would become
-    /// <code>1abc</code>.</li>
-    /// <li>The terms are then sorted by their raw value of UTF-8 character values
-    /// (including the synthetic bucket code in front).</li>
-    /// <li>A finite state automaton (<seealso cref="FST"/>) is constructed from the input. The
+    /// <c>abc</c> with a discretized weight equal '1' would become
+    /// <c>1abc</c>.</item>
+    /// <item>The terms are then sorted by their raw value of UTF-8 character values
+    /// (including the synthetic bucket code in front).</item>
+    /// <item>A finite state automaton (<see cref="FST"/>) is constructed from the input. The
     /// root node has arcs labeled with all possible weights. We cache all these
-    /// arcs, highest-weight first.</li>
-    /// </ul>
+    /// arcs, highest-weight first.</item>
+    /// </list>
     /// 
     /// </para>
     /// <para>
-    /// At runtime, in <seealso cref="FSTCompletion.DoLookup(string, int)"/>, 
+    /// At runtime, in <see cref="FSTCompletion.DoLookup(string, int)"/>, 
     /// the automaton is utilized as follows:
-    /// <ul>
-    /// <li>For each possible term weight encoded in the automaton (cached arcs from
+    /// <list type="bullet">
+    /// <item>For each possible term weight encoded in the automaton (cached arcs from
     /// the root above), starting with the highest one, we descend along the path of
     /// the input key. If the key is not a prefix of a sequence in the automaton
-    /// (path ends prematurely), we exit immediately -- no completions.</li>
-    /// <li>Otherwise, we have found an internal automaton node that ends the key.
+    /// (path ends prematurely), we exit immediately -- no completions.</item>
+    /// <item>Otherwise, we have found an internal automaton node that ends the key.
     /// <b>The entire subautomaton (all paths) starting from this node form the key's
     /// completions.</b> We start the traversal of this subautomaton. Every time we
     /// reach a final state (arc), we add a single suggestion to the list of results
     /// (the weight of this suggestion is constant and equal to the root path we
     /// started from). The tricky part is that because automaton edges are sorted and
     /// we scan depth-first, we can terminate the entire procedure as soon as we
-    /// collect enough suggestions the user requested.</li>
-    /// <li>In case the number of suggestions collected in the step above is still
+    /// collect enough suggestions the user requested.</item>
+    /// <item>In case the number of suggestions collected in the step above is still
     /// insufficient, we proceed to the next (smaller) weight leaving the root node
-    /// and repeat the same algorithm again.</li>
-    /// </ul>
+    /// and repeat the same algorithm again.</item>
+    /// </list>
     /// 
     /// <h2>Runtime behavior and performance characteristic</h2>
     /// 
@@ -102,8 +102,8 @@ namespace Lucene.Net.Search.Suggest.Fst
     /// 
     /// </para>
     /// </summary>
-    /// <seealso cref= FSTCompletion
-    /// @lucene.experimental </seealso>
+    /// <seealso cref="FSTCompletion"/>
+    /// @lucene.experimental
     public class FSTCompletionBuilder
     {
         /// <summary>
@@ -139,7 +139,7 @@ namespace Lucene.Net.Search.Suggest.Fst
         private readonly IBytesRefSorter sorter;
 
         /// <summary>
-        /// Scratch buffer for <seealso cref="#add(BytesRef, int)"/>.
+        /// Scratch buffer for <see cref="Add(BytesRef, int)"/>.
         /// </summary>
         private readonly BytesRef scratch = new BytesRef();
 
@@ -149,9 +149,9 @@ namespace Lucene.Net.Search.Suggest.Fst
         private readonly int shareMaxTailLength;
 
         /// <summary>
-        /// Creates an <seealso cref="FSTCompletion"/> with default options: 10 buckets, exact match
-        /// promoted to first position and <seealso cref="InMemorySorter"/> with a comparator obtained from
-        /// <seealso cref="BytesRef#getUTF8SortedAsUnicodeComparator()"/>.
+        /// Creates an <see cref="FSTCompletion"/> with default options: 10 buckets, exact match
+        /// promoted to first position and <see cref="InMemorySorter"/> with a comparator obtained from
+        /// <see cref="BytesRef.UTF8SortedAsUnicodeComparator"/>.
         /// </summary>
         public FSTCompletionBuilder()
             : this(DEFAULT_BUCKETS, new InMemorySorter(BytesRef.UTF8SortedAsUnicodeComparer), int.MaxValue)
@@ -162,22 +162,22 @@ namespace Lucene.Net.Search.Suggest.Fst
         /// Creates an FSTCompletion with the specified options. </summary>
         /// <param name="buckets">
         ///          The number of buckets for weight discretization. Buckets are used
-        ///          in <seealso cref="#add(BytesRef, int)"/> and must be smaller than the number
+        ///          in <see cref="Add(BytesRef, int)"/> and must be smaller than the number
         ///          given here.
         /// </param>
         /// <param name="sorter">
-        ///          <seealso cref="IBytesRefSorter"/> used for re-sorting input for the automaton.
+        ///          <see cref="IBytesRefSorter"/> used for re-sorting input for the automaton.
         ///          For large inputs, use on-disk sorting implementations. The sorter
-        ///          is closed automatically in <seealso cref="#build()"/> if it implements
-        ///          <seealso cref="Closeable"/>.
+        ///          is closed automatically in <see cref="Build()"/> if it implements
+        ///          <see cref="IDisposable"/>.
         /// </param>
         /// <param name="shareMaxTailLength">
         ///          Max shared suffix sharing length.
         ///          
-        ///          See the description of this parameter in <seealso cref="Builder"/>'s constructor.
+        ///          See the description of this parameter in <see cref="Builder"/>'s constructor.
         ///          In general, for very large inputs you'll want to construct a non-minimal
         ///          automaton which will be larger, but the construction will take far less ram.
-        ///          For minimal automata, set it to <seealso cref="Integer#MAX_VALUE"/>. </param>
+        ///          For minimal automata, set it to <see cref="int.MaxValue"/>. </param>
         public FSTCompletionBuilder(int buckets, IBytesRefSorter sorter, int shareMaxTailLength)
         {
             if (buckets < 1 || buckets > 255)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionLookup.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionLookup.cs b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionLookup.cs
index ae71771..6cbb8ae 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionLookup.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionLookup.cs
@@ -26,12 +26,12 @@ namespace Lucene.Net.Search.Suggest.Fst
      */
 
     /// <summary>
-    /// An adapter from <seealso cref="Lookup"/> API to <seealso cref="FSTCompletion"/>.
+    /// An adapter from <see cref="Lookup"/> API to <see cref="FSTCompletion"/>.
     /// 
-    /// <para>This adapter differs from <seealso cref="FSTCompletion"/> in that it attempts
-    /// to discretize any "weights" as passed from in <seealso cref="InputIterator#weight()"/>
+    /// <para>This adapter differs from <see cref="FSTCompletion"/> in that it attempts
+    /// to discretize any "weights" as passed from in <see cref="IInputIterator.Weight"/>
     /// to match the number of buckets. For the rationale for bucketing, see
-    /// <seealso cref="FSTCompletion"/>.
+    /// <see cref="FSTCompletion"/>.
     /// 
     /// </para>
     /// <para><b>Note:</b>Discretization requires an additional sorting pass.
@@ -48,25 +48,25 @@ namespace Lucene.Net.Search.Suggest.Fst
     /// 
     /// </para>
     /// <para>For fine-grained control over which weights are assigned to which buckets,
-    /// use <seealso cref="FSTCompletion"/> directly or <seealso cref="TSTLookup"/>, for example.
+    /// use <see cref="FSTCompletion"/> directly or <see cref="Tst.TSTLookup"/>, for example.
     /// 
     /// </para>
     /// </summary>
-    /// <seealso cref= FSTCompletion
-    /// @lucene.experimental </seealso>
+    /// <seealso cref="FSTCompletion"/>
+    /// @lucene.experimental
     public class FSTCompletionLookup : Lookup
     {
         /// <summary>
         /// An invalid bucket count if we're creating an object
         /// of this class from an existing FST.
         /// </summary>
-        /// <seealso cref= #FSTCompletionLookup(FSTCompletion, boolean) </seealso>
+        /// <seealso cref="FSTCompletionLookup(FSTCompletion, bool)"/> </seealso>
         private static int INVALID_BUCKETS_COUNT = -1;
 
         /// <summary>
         /// Shared tail length for conflating in the created automaton. Setting this
-        /// to larger values (<seealso cref="Integer#MAX_VALUE"/>) will create smaller (or minimal) 
-        /// automata at the cost of RAM for keeping nodes hash in the <seealso cref="FST"/>. 
+        /// to larger values (<see cref="int.MaxValue"/>) will create smaller (or minimal) 
+        /// automata at the cost of RAM for keeping nodes hash in the <see cref="FST"/>. 
         ///  
         /// <para>Empirical pick.
         /// </para>
@@ -92,8 +92,8 @@ namespace Lucene.Net.Search.Suggest.Fst
 
         /// <summary>
         /// This constructor prepares for creating a suggested FST using the
-        /// <seealso cref="#build(InputIterator)"/> method. The number of weight
-        /// discretization buckets is set to <seealso cref="FSTCompletion#DEFAULT_BUCKETS"/> and
+        /// <see cref="Build(IInputIterator)"/> method. The number of weight
+        /// discretization buckets is set to <see cref="FSTCompletion.DEFAULT_BUCKETS"/> and
         /// exact matches are promoted to the top of the suggestions list.
         /// </summary>
         public FSTCompletionLookup()
@@ -103,14 +103,14 @@ namespace Lucene.Net.Search.Suggest.Fst
 
         /// <summary>
         /// This constructor prepares for creating a suggested FST using the
-        /// <seealso cref="#build(InputIterator)"/> method.
+        /// <see cref="Build(IInputIterator)"/> method.
         /// </summary>
         /// <param name="buckets">
         ///          The number of weight discretization buckets (see
-        ///          <seealso cref="FSTCompletion"/> for details).
+        ///          <see cref="FSTCompletion"/> for details).
         /// </param>
         /// <param name="exactMatchFirst">
-        ///          If <code>true</code> exact matches are promoted to the top of the
+        ///          If <c>true</c> exact matches are promoted to the top of the
         ///          suggestions list. Otherwise they appear in the order of
         ///          discretized weight and alphabetical within the bucket. </param>
         public FSTCompletionLookup(int buckets, bool exactMatchFirst)
@@ -123,7 +123,7 @@ namespace Lucene.Net.Search.Suggest.Fst
         /// This constructor takes a pre-built automaton.
         /// </summary>
         ///  <param name="completion"> 
-        ///          An instance of <seealso cref="FSTCompletion"/>. </param>
+        ///          An instance of <see cref="FSTCompletion"/>. </param>
         ///  <param name="exactMatchFirst">
         ///          If <code>true</code> exact matches are promoted to the top of the
         ///          suggestions list. Otherwise they appear in the order of

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs b/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
index 40defba..7186ad5 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
@@ -31,7 +31,7 @@ namespace Lucene.Net.Search.Suggest.Fst
     /// suggestions.
     /// <para>
     /// <b>NOTE</b>:
-    /// Input weights must be between 0 and <seealso cref="Integer#MAX_VALUE"/>, any
+    /// Input weights must be between 0 and <see cref="int.MaxValue"/>, any
     /// other values will be rejected.
     /// 
     /// @lucene.experimental
@@ -57,7 +57,7 @@ namespace Lucene.Net.Search.Suggest.Fst
         private long count = 0;
 
         /// <summary>
-        /// Calls <seealso cref="#WFSTCompletionLookup(boolean) WFSTCompletionLookup(true)"/>
+        /// Calls <see cref="WFSTCompletionLookup(bool)">WFSTCompletionLookup(true)</see>
         /// </summary>
         public WFSTCompletionLookup()
             : this(true)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/InMemorySorter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/InMemorySorter.cs b/src/Lucene.Net.Suggest/Suggest/InMemorySorter.cs
index 9ec4e6e..f5de243 100644
--- a/src/Lucene.Net.Suggest/Suggest/InMemorySorter.cs
+++ b/src/Lucene.Net.Suggest/Suggest/InMemorySorter.cs
@@ -23,7 +23,7 @@ namespace Lucene.Net.Search.Suggest
      */
 
     /// <summary>
-    /// An <seealso cref="IBytesRefSorter"/> that keeps all the entries in memory.
+    /// An <see cref="IBytesRefSorter"/> that keeps all the entries in memory.
     /// @lucene.experimental
     /// @lucene.internal
     /// </summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/InputIterator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/InputIterator.cs b/src/Lucene.Net.Suggest/Suggest/InputIterator.cs
index 45b64e3..9e460d2 100644
--- a/src/Lucene.Net.Suggest/Suggest/InputIterator.cs
+++ b/src/Lucene.Net.Suggest/Suggest/InputIterator.cs
@@ -22,8 +22,8 @@ namespace Lucene.Net.Search.Suggest
 
     /// <summary>
     /// Interface for enumerating term,weight,payload triples for suggester consumption;
-    /// currently only <seealso cref="AnalyzingSuggester"/>, <seealso cref="FuzzySuggester"/>
-    /// and <seealso cref="AnalyzingInfixSuggester"/> support payloads.
+    /// currently only <see cref="Analyzing.AnalyzingSuggester"/>, <see cref="Analyzing.FuzzySuggester"/>
+    /// and <see cref="Analyzing.AnalyzingInfixSuggester"/> support payloads.
     /// </summary>
     public interface IInputIterator : BytesRefIterator
     {
@@ -34,8 +34,8 @@ namespace Lucene.Net.Search.Suggest
 
         /// <summary>
         /// An arbitrary byte[] to record per suggestion.  See
-        ///  <seealso cref="Lookup.LookupResult#payload"/> to retrieve the payload
-        ///  for each suggestion. 
+        /// <see cref="Lookup.LookupResult.payload"/> to retrieve the payload
+        /// for each suggestion. 
         /// </summary>
         BytesRef Payload { get; }
 
@@ -55,7 +55,7 @@ namespace Lucene.Net.Search.Suggest
     }
 
     /// <summary>
-    /// Singleton IInputIterator that iterates over 0 BytesRefs.
+    /// Singleton <see cref="IInputIterator"/> that iterates over 0 BytesRefs.
     /// </summary>
     public static class EmptyInputIterator
     {
@@ -63,8 +63,8 @@ namespace Lucene.Net.Search.Suggest
     }
 
     /// <summary>
-    /// Wraps a BytesRefIterator as a suggester IInputIterator, with all weights
-    /// set to <code>1</code> and carries no payload
+    /// Wraps a <see cref="BytesRefIterator"/> as a suggester <see cref="IInputIterator"/>, with all weights
+    /// set to <c>1</c> and carries no payload
     /// </summary>
     public class InputIteratorWrapper : IInputIterator
     {
@@ -72,7 +72,7 @@ namespace Lucene.Net.Search.Suggest
 
         /// <summary>
         /// Creates a new wrapper, wrapping the specified iterator and 
-        /// specifying a weight value of <code>1</code> for all terms 
+        /// specifying a weight value of <c>1</c> for all terms 
         /// and nullifies associated payloads.
         /// </summary>
         public InputIteratorWrapper(BytesRefIterator wrapped)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellLookup.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellLookup.cs b/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellLookup.cs
index a272add..d5a32fd 100644
--- a/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellLookup.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellLookup.cs
@@ -26,7 +26,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
     /// Suggest implementation based on 
     /// <a href="http://jaspell.sourceforge.net/">JaSpell</a>.
     /// </summary>
-    /// <seealso cref= JaspellTernarySearchTrie </seealso>
+    /// <seealso cref="JaspellTernarySearchTrie"/>
     public class JaspellLookup : Lookup
     {
         internal JaspellTernarySearchTrie trie = new JaspellTernarySearchTrie();
@@ -38,9 +38,9 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         private long count = 0;
 
         /// <summary>
-        /// Creates a new empty trie </summary>
-        /// <seealso cref= #build(InputIterator)
-        ///  </seealso>
+        /// Creates a new empty trie
+        /// </summary>
+        /// <seealso cref="Build(IInputIterator)"/>
         public JaspellLookup()
         {
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellTernarySearchTrie.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellTernarySearchTrie.cs b/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellTernarySearchTrie.cs
index 7bc7995..ef67e00 100644
--- a/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellTernarySearchTrie.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellTernarySearchTrie.cs
@@ -38,7 +38,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
 {
     /// <summary>
     /// Implementation of a Ternary Search Trie, a data structure for storing
-    /// <code>String</code> objects that combines the compact size of a binary search
+    /// <see cref="string"/>s that combines the compact size of a binary search
     /// tree with the speed of a digital search trie, and is therefore ideal for
     /// practical use in sorting and searching data.</p>
     /// <para>
@@ -166,14 +166,14 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         */
 
         /// <summary>
-        /// The default number of values returned by the <code>matchAlmost</code>
+        /// The default number of values returned by the <see cref="MatchAlmost"/>
         /// method.
         /// </summary>
         private int defaultNumReturnValues = -1;
 
         /// <summary>
-        /// the number of differences allowed in a call to the
-        /// <code>matchAlmostKey</code> method.
+        /// the number of differences allowed in a call to the <see cref="MatchAlmost"/>
+        /// <paramref cref="key"/>.
         /// </summary>
         private int matchAlmostDiff;
 
@@ -215,13 +215,13 @@ namespace Lucene.Net.Search.Suggest.Jaspell
 
 
         /// <summary>
-        /// Constructs a Ternary Search Trie and loads data from a <code>File</code>
+        /// Constructs a Ternary Search Trie and loads data from a <see cref="FileInfo"/>
         /// into the Trie. The file is a normal text document, where each line is of
         /// the form word TAB float.
         /// </summary>
         /// <param name="file">
-        ///          The <code>File</code> with the data to load into the Trie. </param>
-        /// <exception cref="IOException">
+        ///          The <see cref="FileInfo"/> with the data to load into the Trie. </param>
+        /// <exception cref="System.IO.IOException">
         ///              A problem occured while reading the data. </exception>
         public JaspellTernarySearchTrie(FileInfo file)
             : this(file, false)
@@ -229,16 +229,16 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         }
 
         /// <summary>
-        /// Constructs a Ternary Search Trie and loads data from a <code>File</code>
+        /// Constructs a Ternary Search Trie and loads data from a <see cref="FileInfo"/>
         /// into the Trie. The file is a normal text document, where each line is of
         /// the form "word TAB float".
         /// </summary>
         /// <param name="file">
-        ///          The <code>File</code> with the data to load into the Trie. </param>
+        ///          The <see cref="FileInfo"/> with the data to load into the Trie. </param>
         /// <param name="compression">
         ///          If true, the file is compressed with the GZIP algorithm, and if
         ///          false, the file is a normal text document. </param>
-        /// <exception cref="IOException">
+        /// <exception cref="System.IO.IOException">
         ///              A problem occured while reading the data. </exception>
         public JaspellTernarySearchTrie(FileInfo file, bool compression)
             : this()
@@ -339,11 +339,11 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         /// method, then pass the node returned by this method into this method (make
         /// sure you don't delete the data of any of the nodes returned from this
         /// method!) and continue in this fashion until the node returned by this
-        /// method is <code>null</code>.
+        /// method is <c>null</c>.
         /// 
         /// The TSTNode instance returned by this method will be next node to be
-        /// operated on by <code>deleteNodeRecursion</code> (This emulates recursive
-        /// method call while avoiding the JVM overhead normally associated with a
+        /// operated on by <see cref="DeleteNodeRecursion(TSTNode)"/> (This emulates recursive
+        /// method call while avoiding the overhead normally associated with a
         /// recursive method.)
         /// </summary>
         /// <param name="currentNode">
@@ -445,7 +445,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         /// Retrieve the object indexed by a key.
         /// </summary>
         /// <param name="key">
-        ///          A <code>String</code> index. </param>
+        ///          A <see cref="string"/> index. </param>
         /// <returns> The object retrieved from the Ternary Search Trie. </returns>
         public virtual object Get(string key)
         {
@@ -462,7 +462,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         /// and store the new <code>Float</code>.
         /// </summary>
         /// <param name="key">
-        ///          A <code>String</code> index. </param>
+        ///          A <see cref="string"/> index. </param>
         /// <returns> The <code>Float</code> retrieved from the Ternary Search Trie. </returns>
         public virtual float? GetAndIncrement(string key)
         {
@@ -490,7 +490,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         /// </summary>
         /// <param name="node">
         ///          The node whose index is to be calculated. </param>
-        /// <returns> The <code>String</code> that indexes the node argument. </returns>
+        /// <returns> The <see cref="string"/> that indexes the node argument. </returns>
         protected internal virtual string GetKey(TSTNode node)
         {
             StringBuilder getKeyBuffer = new StringBuilder();
@@ -510,34 +510,34 @@ namespace Lucene.Net.Search.Suggest.Jaspell
                 currentNode = currentNode.relatives[TSTNode.PARENT];
             }
 
-            // LUCENENET NOTE: Reverse doesn't happen in place in .NET,
+            // LUCENENET NOTE: Reverse doesn't happen in place in a .NET StringBuilder,
             // so we need to return the reversed result.
             return getKeyBuffer.Reverse().ToString();
         }
 
         /// <summary>
-        /// Returns the node indexed by key, or <code>null</code> if that node doesn't
+        /// Returns the node indexed by key, or <c>null</c> if that node doesn't
         /// exist. Search begins at root node.
         /// </summary>
         /// <param name="key">
-        ///          A <code>String</code> that indexes the node that is returned. </param>
+        ///          A <see cref="string"/> that indexes the node that is returned. </param>
         /// <returns> The node object indexed by key. This object is an instance of an
-        ///         inner class named <code>TernarySearchTrie.TSTNode</code>. </returns>
+        ///         inner class named <see cref="TSTNode"/>. </returns>
         public virtual TSTNode GetNode(string key)
         {
             return GetNode(key, rootNode);
         }
 
         /// <summary>
-        /// Returns the node indexed by key, or <code>null</code> if that node doesn't
+        /// Returns the node indexed by key, or <c>null</c> if that node doesn't
         /// exist. The search begins at root node.
         /// </summary>
         /// <param name="key">
-        ///          A <code>String</code> that indexes the node that is returned. </param>
+        ///          A <see cref="string"/> that indexes the node that is returned. </param>
         /// <param name="startNode">
         ///          The top node defining the subtrie to be searched. </param>
         /// <returns> The node object indexed by key. This object is an instance of an
-        ///         inner class named <code>TernarySearchTrie.TSTNode</code>. </returns>
+        ///         inner class named <see cref="TSTNode"/>. </returns>
         protected internal virtual TSTNode GetNode(string key, TSTNode startNode)
         {
             if (key == null || startNode == null || key.Length == 0)
@@ -578,13 +578,13 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         /// and creating any required intermediate nodes if they don't exist.
         /// </summary>
         /// <param name="key">
-        ///          A <code>String</code> that indexes the node that is returned. </param>
+        ///          A <see cref="string"/> that indexes the node that is returned. </param>
         /// <returns> The node object indexed by key. This object is an instance of an
-        ///         inner class named <code>TernarySearchTrie.TSTNode</code>. </returns>
-        /// <exception cref="NullPointerException">
-        ///              If the key is <code>null</code>. </exception>
-        /// <exception cref="IllegalArgumentException">
-        ///              If the key is an empty <code>String</code>. </exception>
+        ///         inner class named <see cref="TSTNode"/>. </returns>
+        /// <exception cref="NullReferenceException">
+        ///              If the key is <c>null</c>. </exception>
+        /// <exception cref="ArgumentException">
+        ///              If the key is an empty <see cref="string"/>. </exception>
         protected internal virtual TSTNode GetOrCreateNode(string key)
         {
             if (key == null)
@@ -637,33 +637,33 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         }
 
         /// <summary>
-        /// Returns a <code>List</code> of keys that almost match the argument key.
+        /// Returns a <see cref="List{String}"/> of keys that almost match the argument key.
         /// Keys returned will have exactly diff characters that do not match the
-        /// target key, where diff is equal to the last value passed in as an argument
-        /// to the <code>setMatchAlmostDiff</code> method.
+        /// target key, where diff is equal to the last value set
+        /// to the <see cref="MatchAlmostDiff"/> property.
         /// <para>
-        /// If the <code>matchAlmost</code> method is called before the
-        /// <code>setMatchAlmostDiff</code> method has been called for the first time,
+        /// If the <see cref="MatchAlmost"/> method is called before the
+        /// <see cref="MatchAlmostDiff"/> property has been called for the first time,
         /// then diff = 0.
         /// 
         /// </para>
         /// </summary>
         /// <param name="key">
         ///          The target key. </param>
-        /// <returns> A <code>List</code> with the results. </returns>
+        /// <returns> A <see cref="List{String}"/> with the results. </returns>
         public virtual IList<string> MatchAlmost(string key)
         {
             return MatchAlmost(key, defaultNumReturnValues);
         }
 
         /// <summary>
-        /// Returns a <code>List</code> of keys that almost match the argument key.
+        /// Returns a <see cref="List{String}"/> of keys that almost match the argument key.
         /// Keys returned will have exactly diff characters that do not match the
-        /// target key, where diff is equal to the last value passed in as an argument
-        /// to the <code>setMatchAlmostDiff</code> method.
+        /// target key, where diff is equal to the last value set
+        /// to the <see cref="MatchAlmostDiff"/> property.
         /// <para>
-        /// If the <code>matchAlmost</code> method is called before the
-        /// <code>setMatchAlmostDiff</code> method has been called for the first time,
+        /// If the <see cref="MatchAlmost"/> method is called before the
+        /// <see cref="MatchAlmostDiff"/> property has been called for the first time,
         /// then diff = 0.
         /// 
         /// </para>
@@ -672,7 +672,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         ///          The target key. </param>
         /// <param name="numReturnValues">
         ///          The maximum number of values returned by this method. </param>
-        /// <returns> A <code>List</code> with the results </returns>
+        /// <returns> A <see cref="List{String}"/> with the results </returns>
         public virtual IList<string> MatchAlmost(string key, int numReturnValues)
         {
             return MatchAlmostRecursion(rootNode, 0, matchAlmostDiff, key, ((numReturnValues < 0) ? -1 : numReturnValues), new List<string>(), false);
@@ -689,18 +689,18 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         /// <param name="d">
         ///          The number of differences so far. </param>
         /// <param name="matchAlmostNumReturnValues">
-        ///          The maximum number of values in the result <code>List</code>. </param>
+        ///          The maximum number of values in the result <see cref="List{String}"/>. </param>
         /// <param name="matchAlmostResult2">
         ///          The results so far. </param>
         /// <param name="upTo">
-        ///          If true all keys having up to and including matchAlmostDiff
+        ///          If true all keys having up to and including <see cref="MatchAlmostDiff"/> 
         ///          mismatched letters will be included in the result (including a key
         ///          that is exactly the same as the target string) otherwise keys will
         ///          be included in the result only if they have exactly
-        ///          matchAlmostDiff number of mismatched letters. </param>
+        ///          <see cref="MatchAlmostDiff"/> number of mismatched letters. </param>
         /// <param name="matchAlmostKey">
         ///          The key being searched. </param>
-        /// <returns> A <code>List</code> with the results. </returns>
+        /// <returns> A <see cref="List{String}"/> with the results. </returns>
         private IList<string> MatchAlmostRecursion(TSTNode currentNode, int charIndex, int d, string matchAlmostKey, int matchAlmostNumReturnValues, IList<string> matchAlmostResult2, bool upTo)
         {
             if ((currentNode == null) || (matchAlmostNumReturnValues != -1 && matchAlmostResult2.Count >= matchAlmostNumReturnValues) || (d < 0) || (charIndex >= matchAlmostKey.Length))
@@ -728,30 +728,30 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         }
 
         /// <summary>
-        /// Returns an alphabetical <code>List</code> of all keys in the trie that
+        /// Returns an alphabetical <see cref="List{String}"/> of all keys in the trie that
         /// begin with a given prefix. Only keys for nodes having non-null data are
-        /// included in the <code>List</code>.
+        /// included in the <see cref="List{String}"/>.
         /// </summary>
         /// <param name="prefix">
         ///          Each key returned from this method will begin with the characters
         ///          in prefix. </param>
-        /// <returns> A <code>List</code> with the results. </returns>
+        /// <returns> A <see cref="List{String}"/> with the results. </returns>
         public virtual IList<string> MatchPrefix(string prefix)
         {
             return MatchPrefix(prefix, defaultNumReturnValues);
         }
 
         /// <summary>
-        /// Returns an alphabetical <code>List</code> of all keys in the trie that
+        /// Returns an alphabetical <see cref="List{String}"/> of all keys in the trie that
         /// begin with a given prefix. Only keys for nodes having non-null data are
-        /// included in the <code>List</code>.
+        /// included in the <see cref="List{String}"/>.
         /// </summary>
         /// <param name="prefix">
         ///          Each key returned from this method will begin with the characters
         ///          in prefix. </param>
         /// <param name="numReturnValues">
         ///          The maximum number of values returned from this method. </param>
-        /// <returns> A <code>List</code> with the results </returns>
+        /// <returns> A <see cref="List{String}"/> with the results </returns>
         public virtual IList<string> MatchPrefix(string prefix, int numReturnValues)
         {
             List<string> sortKeysResult = new List<string>();
@@ -814,7 +814,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         /// Stores a value in the trie. The value may be retrieved using the key.
         /// </summary>
         /// <param name="key">
-        ///          A <code>String</code> that indexes the object to be stored. </param>
+        ///          A <see cref="string"/> that indexes the object to be stored. </param>
         /// <param name="value">
         ///          The object to be stored in the Trie. </param>
         public virtual void Put(string key, object value)
@@ -828,7 +828,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         /// <param name="currentNode">
         ///          The current node. </param>
         /// <param name="checkData">
-        ///          If true we check the data to be different of <code>null</code>. </param>
+        ///          If true we check the data to be different of <c>null</c>. </param>
         /// <param name="numNodes2">
         ///          The number of nodes so far. </param>
         /// <returns> The number of nodes accounted. </returns>
@@ -860,7 +860,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         /// unnecessary by the removal of this data.
         /// </summary>
         /// <param name="key">
-        ///          A <code>string</code> that indexes the object to be removed from
+        ///          A <see cref="string"/> that indexes the object to be removed from
         ///          the Trie. </param>
         public virtual void Remove(string key)
         {
@@ -869,7 +869,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
 
         /// <summary>
         /// Sets the number of characters by which words can differ from target word
-        /// when calling the <code>matchAlmost</code> method.
+        /// when calling the <see cref="MatchAlmost"/> method.
         /// <para>
         /// Arguments less than 0 will set the char difference to 0, and arguments
         /// greater than 3 will set the char difference to 3.
@@ -900,13 +900,12 @@ namespace Lucene.Net.Search.Suggest.Jaspell
 
         /// <summary>
         /// Sets the default maximum number of values returned from the
-        /// <code>matchPrefix</code> and <code>matchAlmost</code> methods.
+        /// <see cref="MatchPrefix"/> and <see cref="MatchAlmost"/> methods.
         /// <para>
         /// The value should be set this to -1 to get an unlimited number of return
         /// values. note that the methods mentioned above provide overloaded versions
         /// that allow you to specify the maximum number of return values, in which
         /// case this value is temporarily overridden.
-        /// 
         /// </para>
         /// </summary>
         /// **<param name="num">
@@ -933,7 +932,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         ///          The top node defining the subtrie to be searched. </param>
         /// <param name="numReturnValues">
         ///          The maximum number of values returned from this method. </param>
-        /// <returns> A <code>List</code> with the results. </returns>
+        /// <returns> A <see cref="List{String}"/> with the results. </returns>
         protected internal virtual IList<string> SortKeys(TSTNode startNode, int numReturnValues)
         {
             return SortKeysRecursion(startNode, ((numReturnValues < 0) ? -1 : numReturnValues), new List<string>());
@@ -943,9 +942,9 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         /// Returns keys sorted in alphabetical order. This includes the current Node
         /// and all nodes connected to the current Node.
         /// <para>
-        /// Sorted keys will be appended to the end of the resulting <code>List</code>.
+        /// Sorted keys will be appended to the end of the resulting <see cref="List{String}"/>.
         /// The result may be empty when this method is invoked, but may not be
-        /// <code>null</code>.
+        /// <c>null</c>.
         /// 
         /// </para>
         /// </summary>
@@ -955,7 +954,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         ///          The maximum number of values in the result. </param>
         /// <param name="sortKeysResult2">
         ///          The results so far. </param>
-        /// <returns> A <code>List</code> with the results. </returns>
+        /// <returns> A <see cref="List{String}"/> with the results. </returns>
         private IList<string> SortKeysRecursion(TSTNode currentNode, int sortKeysNumReturnValues, IList<string> sortKeysResult2)
         {
             if (currentNode == null)
@@ -976,7 +975,8 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         }
 
         /// <summary>
-        /// Return an approximate memory usage for this trie. </summary>
+        /// Return an approximate memory usage for this trie.
+        /// </summary>
         public virtual long GetSizeInBytes()
         {
             long mem = RamUsageEstimator.ShallowSizeOf(this);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Lookup.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Lookup.cs b/src/Lucene.Net.Suggest/Suggest/Lookup.cs
index 7cdb951..50867c8 100644
--- a/src/Lucene.Net.Suggest/Suggest/Lookup.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Lookup.cs
@@ -25,7 +25,7 @@ namespace Lucene.Net.Search.Suggest
      */
 
     /// <summary>
-    /// Simple Lookup interface for <seealso cref="string"/> suggestions.
+    /// Simple Lookup interface for <see cref="string"/> suggestions.
     /// @lucene.experimental
     /// </summary>
     public abstract class Lookup
@@ -43,7 +43,7 @@ namespace Lucene.Net.Search.Suggest
 
             /// <summary>
             /// Expert: custom Object to hold the result of a
-            ///  highlighted suggestion. 
+            /// highlighted suggestion. 
             /// </summary>
             public readonly object highlightKey;
 
@@ -125,7 +125,7 @@ namespace Lucene.Net.Search.Suggest
         }
 
         /// <summary>
-        /// A simple char-by-char comparator for <seealso cref="CharSequence"/>
+        /// A simple char-by-char comparator for <see cref="string"/>
         /// </summary>
         public static readonly IComparer<string> CHARSEQUENCE_COMPARATOR = new CharSequenceComparator();
 
@@ -153,7 +153,7 @@ namespace Lucene.Net.Search.Suggest
         }
 
         /// <summary>
-        /// A <seealso cref="PriorityQueue"/> collecting a fixed size of high priority <seealso cref="LookupResult"/>
+        /// A <see cref="PriorityQueue{LookupResult}"/> collecting a fixed size of high priority <see cref="LookupResult"/>s.
         /// </summary>
         public sealed class LookupPriorityQueue : PriorityQueue<LookupResult>
         {
@@ -200,8 +200,8 @@ namespace Lucene.Net.Search.Suggest
         /// <summary>
         /// Build lookup from a dictionary. Some implementations may require sorted
         /// or unsorted keys from the dictionary's iterator - use
-        /// <seealso cref="SortedInputIterator"/> or
-        /// <seealso cref="UnsortedInputIterator"/> in such case.
+        /// <see cref="SortedInputIterator"/> or
+        /// <see cref="UnsortedInputIterator"/> in such case.
         /// </summary>
         public virtual void Build(IDictionary dict)
         {
@@ -209,8 +209,8 @@ namespace Lucene.Net.Search.Suggest
         }
 
         /// <summary>
-        /// Calls <seealso cref="#load(DataInput)"/> after converting
-        /// <seealso cref="InputStream"/> to <seealso cref="DataInput"/>
+        /// Calls <see cref="Load(DataInput)"/> after converting
+        /// <see cref="Stream"/> to <see cref="DataInput"/>
         /// </summary>
         public virtual bool Load(Stream input)
         {
@@ -226,8 +226,8 @@ namespace Lucene.Net.Search.Suggest
         }
 
         /// <summary>
-        /// Calls <seealso cref="#store(DataOutput)"/> after converting
-        /// <seealso cref="OutputStream"/> to <seealso cref="DataOutput"/>
+        /// Calls <see cref="Store(DataOutput)"/> after converting
+        /// <see cref="Stream"/> to <see cref="DataOutput"/>
         /// </summary>
         public virtual bool Store(Stream output)
         {
@@ -248,7 +248,7 @@ namespace Lucene.Net.Search.Suggest
         public abstract long Count { get; }
 
         /// <summary>
-        /// Builds up a new internal <seealso cref="Lookup"/> representation based on the given <seealso cref="InputIterator"/>.
+        /// Builds up a new internal <see cref="Lookup"/> representation based on the given <see cref="IInputIterator"/>.
         /// The implementation might re-sort the data internally.
         /// </summary>
         public abstract void Build(IInputIterator inputIterator);
@@ -277,17 +277,17 @@ namespace Lucene.Net.Search.Suggest
 
         /// <summary>
         /// Persist the constructed lookup data to a directory. Optional operation. </summary>
-        /// <param name="output"> <seealso cref="DataOutput"/> to write the data to. </param>
+        /// <param name="output"> <see cref="DataOutput"/> to write the data to. </param>
         /// <returns> true if successful, false if unsuccessful or not supported. </returns>
-        /// <exception cref="IOException"> when fatal IO error occurs. </exception>
+        /// <exception cref="System.IO.IOException"> when fatal IO error occurs. </exception>
         public abstract bool Store(DataOutput output);
 
         /// <summary>
         /// Discard current lookup data and load it from a previously saved copy.
         /// Optional operation. </summary>
-        /// <param name="input"> the <seealso cref="DataInput"/> to load the lookup data. </param>
+        /// <param name="input"> the <see cref="DataInput"/> to load the lookup data. </param>
         /// <returns> true if completed successfully, false if unsuccessful or not supported. </returns>
-        /// <exception cref="IOException"> when fatal IO error occurs. </exception>
+        /// <exception cref="System.IO.IOException"> when fatal IO error occurs. </exception>
         public abstract bool Load(DataInput input);
 
         /// <summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/SortedInputIterator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/SortedInputIterator.cs b/src/Lucene.Net.Suggest/Suggest/SortedInputIterator.cs
index c6d730e..8e2e8dc 100644
--- a/src/Lucene.Net.Suggest/Suggest/SortedInputIterator.cs
+++ b/src/Lucene.Net.Suggest/Suggest/SortedInputIterator.cs
@@ -46,9 +46,8 @@ namespace Lucene.Net.Search.Suggest
         private ISet<BytesRef> contexts = null;
 
         /// <summary>
-        /// Creates a new sorted wrapper, using {@link
-        /// BytesRef#getUTF8SortedAsUnicodeComparator} for
-        /// sorting. 
+        /// Creates a new sorted wrapper, using <see cref="BytesRef.UTF8SortedAsUnicodeComparer"/>
+        /// for sorting. 
         /// </summary>
         public SortedInputIterator(IInputIterator source)
             : this(source, BytesRef.UTF8SortedAsUnicodeComparer)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/SortedTermFreqIteratorWrapper.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/SortedTermFreqIteratorWrapper.cs b/src/Lucene.Net.Suggest/Suggest/SortedTermFreqIteratorWrapper.cs
index cf54a57..a9b8efc 100644
--- a/src/Lucene.Net.Suggest/Suggest/SortedTermFreqIteratorWrapper.cs
+++ b/src/Lucene.Net.Suggest/Suggest/SortedTermFreqIteratorWrapper.cs
@@ -42,9 +42,8 @@ namespace Lucene.Net.Search.Suggest
         private readonly BytesRef scratch = new BytesRef();
 
         /// <summary>
-        /// Creates a new sorted wrapper, using {@link
-        /// BytesRef#getUTF8SortedAsUnicodeComparator} for
-        /// sorting. 
+        /// Creates a new sorted wrapper, using <see cref="BytesRef.UTF8SortedAsUnicodeComparer"/>
+        /// for sorting. 
         /// </summary>
         public SortedTermFreqIteratorWrapper(ITermFreqIterator source)
             : this(source, BytesRef.UTF8SortedAsUnicodeComparer)
@@ -139,7 +138,6 @@ namespace Lucene.Net.Search.Suggest
                 {
                     return cmp;
                 }
-                //return long.Compare(leftCost, rightCost);
                 return leftCost.CompareTo(rightCost);
             }
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Tst/TSTAutocomplete.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Tst/TSTAutocomplete.cs b/src/Lucene.Net.Suggest/Suggest/Tst/TSTAutocomplete.cs
index 9f1f6c9..f4a6137 100644
--- a/src/Lucene.Net.Suggest/Suggest/Tst/TSTAutocomplete.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Tst/TSTAutocomplete.cs
@@ -22,7 +22,7 @@ namespace Lucene.Net.Search.Suggest.Tst
     /// <summary>
     /// Ternary Search Trie implementation.
     /// </summary>
-    /// <seealso cref= TernaryTreeNode </seealso>
+    /// <seealso cref="TernaryTreeNode"/>
     public class TSTAutocomplete
     {
 
@@ -66,7 +66,7 @@ namespace Lucene.Net.Search.Suggest.Tst
         ///          key to be inserted in TST. </param>
         /// <param name="x">
         ///          index of character in key to be inserted currently. </param>
-        /// <returns> currentNode The new reference to root node of TST </returns>
+        /// <returns> The new reference to root node of TST </returns>
         public virtual TernaryTreeNode Insert(TernaryTreeNode currentNode, string s, object val, int x)
         {
             if (s == null || s.Length <= x)


Mime
View raw message