lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From synhers...@apache.org
Subject [25/50] [abbrv] lucenenet git commit: Updated Suggest documentation links to code elements and made corrections.
Date Sun, 02 Oct 2016 14:35:43 GMT
Updated Suggest documentation links to code elements and made corrections.


Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/9a6f9734
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/9a6f9734
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/9a6f9734

Branch: refs/heads/master
Commit: 9a6f9734347b004bd51b3521294ea779ff905d3f
Parents: 106a905
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Fri Sep 16 23:54:08 2016 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Sun Oct 2 17:44:41 2016 +0700

----------------------------------------------------------------------
 .../Spell/DirectSpellChecker.cs                 | 106 ++++++++++----
 .../Spell/HighFrequencyDictionary.cs            |   2 +-
 .../Spell/JaroWinklerDistance.cs                |  12 +-
 .../Spell/LevensteinDistance.cs                 |   3 +-
 .../Spell/LuceneLevenshteinDistance.cs          |  18 +--
 src/Lucene.Net.Suggest/Spell/NGramDistance.cs   |   3 +-
 .../Spell/PlainTextDictionary.cs                |   8 +-
 src/Lucene.Net.Suggest/Spell/SpellChecker.cs    | 143 ++++++++++---------
 src/Lucene.Net.Suggest/Spell/SuggestMode.cs     |   2 +-
 src/Lucene.Net.Suggest/Spell/SuggestWord.cs     |   2 +-
 .../Spell/SuggestWordFrequencyComparator.cs     |   4 +-
 .../Spell/SuggestWordQueue.cs                   |   5 +-
 .../Spell/SuggestWordScoreComparator.cs         |   4 +-
 .../Spell/WordBreakSpellChecker.cs              |  61 ++++----
 .../Analyzing/AnalyzingInfixSuggester.cs        | 103 ++++++-------
 .../Suggest/Analyzing/AnalyzingSuggester.cs     |  58 ++++----
 .../Suggest/Analyzing/BlendedInfixSuggester.cs  |  20 ++-
 .../Suggest/Analyzing/FSTUtil.cs                |   8 +-
 .../Suggest/Analyzing/FreeTextSuggester.cs      |  49 ++++---
 .../Suggest/Analyzing/FuzzySuggester.cs         |  66 ++++-----
 .../Suggest/Analyzing/SuggestStopFilter.cs      |  21 +--
 .../Suggest/BufferedInputIterator.cs            |   2 +-
 .../Suggest/BufferingTermFreqIteratorWrapper.cs |   2 +-
 .../Suggest/DocumentDictionary.cs               |  50 +++----
 .../Suggest/DocumentValueSourceDictionary.cs    |  49 ++++---
 .../Suggest/FileDictionary.cs                   |  52 +++----
 .../Suggest/Fst/BytesRefSorter.cs               |  14 +-
 .../Suggest/Fst/FSTCompletion.cs                |  53 +++----
 .../Suggest/Fst/FSTCompletionBuilder.cs         |  64 ++++-----
 .../Suggest/Fst/FSTCompletionLookup.cs          |  32 ++---
 .../Suggest/Fst/WFSTCompletionLookup.cs         |   4 +-
 .../Suggest/InMemorySorter.cs                   |   2 +-
 src/Lucene.Net.Suggest/Suggest/InputIterator.cs |  16 +--
 .../Suggest/Jaspell/JaspellLookup.cs            |   8 +-
 .../Suggest/Jaspell/JaspellTernarySearchTrie.cs | 124 ++++++++--------
 src/Lucene.Net.Suggest/Suggest/Lookup.cs        |  30 ++--
 .../Suggest/SortedInputIterator.cs              |   5 +-
 .../Suggest/SortedTermFreqIteratorWrapper.cs    |   6 +-
 .../Suggest/Tst/TSTAutocomplete.cs              |   4 +-
 src/Lucene.Net.Suggest/Suggest/Tst/TSTLookup.cs |   7 +-
 40 files changed, 636 insertions(+), 586 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/DirectSpellChecker.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/DirectSpellChecker.cs b/src/Lucene.Net.Suggest/Spell/DirectSpellChecker.cs
index 40ddfdf..1835909 100644
--- a/src/Lucene.Net.Suggest/Spell/DirectSpellChecker.cs
+++ b/src/Lucene.Net.Suggest/Spell/DirectSpellChecker.cs
@@ -29,9 +29,9 @@ namespace Lucene.Net.Search.Spell
     /// Simple automaton-based spellchecker.
     /// <para>
     /// Candidates are presented directly from the term dictionary, based on
-    /// Levenshtein distance. This is an alternative to <seealso cref="SpellChecker"/>
+    /// Levenshtein distance. This is an alternative to <see cref="SpellChecker"/>
     /// if you are using an edit-distance-like metric such as Levenshtein
-    /// or <seealso cref="JaroWinklerDistance"/>.
+    /// or <see cref="JaroWinklerDistance"/>.
     /// </para>
     /// <para>
     /// A practical benefit of this spellchecker is that it requires no additional
@@ -39,15 +39,15 @@ namespace Lucene.Net.Search.Spell
     /// 
     /// </para>
     /// </summary>
-    /// <seealso cref= LevenshteinAutomata </seealso>
-    /// <seealso cref= FuzzyTermsEnum
+    /// <seealso cref="LevenshteinAutomata"/>
+    /// <seealso cref="FuzzyTermsEnum"/>
     /// 
-    /// @lucene.experimental </seealso>
+    /// @lucene.experimental
     public class DirectSpellChecker
     {
         /// <summary>
         /// The default StringDistance, Damerau-Levenshtein distance implemented internally
-        ///  via <seealso cref="LevenshteinAutomata"/>.
+        ///  via <see cref="LevenshteinAutomata"/>.
         ///  <para>
         ///  Note: this is the fastest distance metric, because Damerau-Levenshtein is used
         ///  to draw candidates from the term dictionary: this just re-uses the scoring.
@@ -92,14 +92,19 @@ namespace Lucene.Net.Search.Spell
         private IStringDistance distance = INTERNAL_LEVENSHTEIN;
 
         /// <summary>
-        /// Creates a DirectSpellChecker with default configuration values </summary>
+        /// Creates a DirectSpellChecker with default configuration values 
+        /// </summary>
         public DirectSpellChecker()
         {
         }
 
         /// <summary>
-        /// Get the maximum number of Levenshtein edit-distances to draw
-        ///  candidate terms from. 
+        /// Gets or sets the maximum number of Levenshtein edit-distances to draw
+        /// candidate terms from.This value can be 1 or 2. The default is 2.
+        /// 
+        /// Note: a large number of spelling errors occur with an edit distance
+        /// of 1, by setting this value to 1 you can increase both performance
+        /// and precision at the cost of recall.
         /// </summary>
         public virtual int MaxEdits
         {
@@ -119,7 +124,10 @@ namespace Lucene.Net.Search.Spell
 
 
         /// <summary>
-        /// Get the minimal number of characters that must match exactly
+        /// Gets or sets the minimal number of characters that must match exactly.
+        /// 
+        /// This can improve both performance and accuracy of results, 
+        /// as misspellings are commonly not the first character.
         /// </summary>
         public virtual int MinPrefix
         {
@@ -135,7 +143,10 @@ namespace Lucene.Net.Search.Spell
 
 
         /// <summary>
-        /// Get the maximum number of top-N inspections per suggestion
+        /// Get the maximum number of top-N inspections per suggestion.
+        /// 
+        /// Increasing this number can improve the accuracy of results, at the cost 
+        /// of performance.
         /// </summary>
         public virtual int MaxInspections
         {
@@ -151,7 +162,8 @@ namespace Lucene.Net.Search.Spell
 
 
         /// <summary>
-        /// Get the minimal accuracy from the StringDistance for a match
+        /// Gets or sets the minimal accuracy required (default: 0.5f) from a StringDistance 
+        /// for a suggestion match.
         /// </summary>
         public virtual float Accuracy
         {
@@ -167,7 +179,16 @@ namespace Lucene.Net.Search.Spell
 
 
         /// <summary>
-        /// Get the minimal threshold of documents a term must appear for a match
+        /// Gets or sets the minimal threshold of documents a term must appear for a match.
+        /// <p>
+        /// This can improve quality by only suggesting high-frequency terms. Note that
+        /// very high values might decrease performance slightly, by forcing the spellchecker
+        /// to draw more candidates from the term dictionary, but a practical value such
+        /// as <code>1</code> can be very useful towards improving quality.
+        /// <p>
+        /// This can be specified as a relative percentage of documents such as 0.5f,
+        /// or it can be specified as an absolute whole document frequency, such as 4f.
+        /// Absolute document frequencies may not be fractional.
         /// </summary>
         public virtual float ThresholdFrequency
         {
@@ -187,7 +208,11 @@ namespace Lucene.Net.Search.Spell
 
 
         /// <summary>
-        /// Get the minimum length of a query term needed to return suggestions </summary>
+        /// Gets or sets the minimum length of a query term (default: 4) needed to return suggestions.
+        /// <p>
+        /// Very short query terms will often cause only bad suggestions with any distance
+        /// metric.
+        /// </summary>
         public virtual int MinQueryLength
         {
             get
@@ -202,8 +227,16 @@ namespace Lucene.Net.Search.Spell
 
 
         /// <summary>
-        /// Get the maximum threshold of documents a query term can appear in order
-        /// to provide suggestions.
+        /// Gets or sets the maximum threshold (default: 0.01f) of documents a query term can 
+        /// appear in order to provide suggestions.
+        /// <p>
+        /// Very high-frequency terms are typically spelled correctly. Additionally,
+        /// this can increase performance as it will do no work for the common case
+        /// of correctly-spelled input terms.
+        /// <p>
+        /// This can be specified as a relative percentage of documents such as 0.5f,
+        /// or it can be specified as an absolute whole document frequency, such as 4f.
+        /// Absolute document frequencies may not be fractional.
         /// </summary>
         public virtual float MaxQueryFrequency
         {
@@ -223,7 +256,15 @@ namespace Lucene.Net.Search.Spell
 
 
         /// <summary>
-        /// true if the spellchecker should lowercase terms </summary>
+        /// True if the spellchecker should lowercase terms (default: true)
+        /// <p>
+        /// This is a convenience method, if your index field has more complicated
+        /// analysis (such as StandardTokenizer removing punctuation), its probably
+        /// better to turn this off, and instead run your query terms through your
+        /// Analyzer first.
+        /// <p>
+        /// If this option is not on, case differences count as an edit!
+        /// </summary>
         public virtual bool LowerCaseTerms
         {
             get
@@ -238,7 +279,8 @@ namespace Lucene.Net.Search.Spell
 
 
         /// <summary>
-        /// Get the current comparator in use.
+        /// Gets or sets the comparator for sorting suggestions.
+        /// The default is <see cref="SuggestWordQueue.DEFAULT_COMPARATOR"/> 
         /// </summary>
         public virtual IComparer<SuggestWord> Comparator
         {
@@ -254,7 +296,14 @@ namespace Lucene.Net.Search.Spell
 
 
         /// <summary>
-        /// Get the string distance metric in use.
+        /// Gets or sets the string distance metric.
+        /// The default is <see cref="INTERNAL_LEVENSHTEIN"/>.
+        /// <p>
+        /// Note: because this spellchecker draws its candidates from the term
+        /// dictionary using Damerau-Levenshtein, it works best with an edit-distance-like
+        /// string metric. If you use a different metric than the default,
+        /// you might want to consider increasing <see cref="MaxInspections"/>
+        /// to draw more candidates for your metric to rank. 
         /// </summary>
         public virtual IStringDistance Distance
         {
@@ -270,8 +319,8 @@ namespace Lucene.Net.Search.Spell
 
 
         /// <summary>
-        /// Calls {@link #suggestSimilar(Term, int, IndexReader, SuggestMode) 
-        ///       suggestSimilar(term, numSug, ir, SuggestMode.SUGGEST_WHEN_NOT_IN_INDEX)}
+        /// Calls <see cref="SuggestSimilar(Term, int, IndexReader, SuggestMode)"/>
+        ///       SuggestSimilar(term, numSug, ir, SuggestMode.SUGGEST_WHEN_NOT_IN_INDEX)
         /// </summary>
         public virtual SuggestWord[] SuggestSimilar(Term term, int numSug, IndexReader ir)
         {
@@ -279,9 +328,8 @@ namespace Lucene.Net.Search.Spell
         }
 
         /// <summary>
-        /// Calls {@link #suggestSimilar(Term, int, IndexReader, SuggestMode, float) 
-        ///       suggestSimilar(term, numSug, ir, suggestMode, this.accuracy)}
-        /// 
+        /// Calls <see cref="SuggestSimilar(Term, int, IndexReader, SuggestMode, float)"/>
+        ///       SuggestSimilar(term, numSug, ir, suggestMode, this.accuracy)
         /// </summary>
         public virtual SuggestWord[] SuggestSimilar(Term term, int numSug, IndexReader ir, SuggestMode suggestMode)
         {
@@ -291,10 +339,10 @@ namespace Lucene.Net.Search.Spell
         /// <summary>
         /// Suggest similar words.
         /// 
-        /// <para>Unlike <seealso cref="SpellChecker"/>, the similarity used to fetch the most
+        /// <para>
+        /// Unlike <see cref="SpellChecker"/>, the similarity used to fetch the most
         /// relevant terms is an edit distance, therefore typically a low value
         /// for numSug will work very well.
-        /// 
         /// </para>
         /// </summary>
         /// <param name="term"> Term you want to spell check on </param>
@@ -303,7 +351,7 @@ namespace Lucene.Net.Search.Spell
         /// <param name="suggestMode"> specifies when to return suggested words </param>
         /// <param name="accuracy"> return only suggested words that match with this similarity </param>
         /// <returns> sorted list of the suggested words according to the comparator </returns>
-        /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
+        /// <exception cref="System.IO.IOException"> If there is a low-level I/O error. </exception>
         public virtual SuggestWord[] SuggestSimilar(Term term, int numSug, IndexReader ir, SuggestMode suggestMode, float accuracy)
         {
             CharsRef spare = new CharsRef();
@@ -402,7 +450,7 @@ namespace Lucene.Net.Search.Spell
         /// <param name="accuracy"> The minimum accuracy a suggested spelling correction needs to have in order to be included </param>
         /// <param name="spare"> a chars scratch </param>
         /// <returns> a collection of spelling corrections sorted by <code>ScoreTerm</code>'s natural order. </returns>
-        /// <exception cref="IOException"> If I/O related errors occur </exception>
+        /// <exception cref="System.IO.IOException"> If I/O related errors occur </exception>
         protected internal virtual IEnumerable<ScoreTerm> SuggestSimilar(Term term, int numSug, IndexReader ir, int docfreq, int editDistance, float accuracy, CharsRef spare)
         {
 
@@ -481,7 +529,7 @@ namespace Lucene.Net.Search.Spell
         }
 
         /// <summary>
-        /// Holds a spelling correction for internal usage inside <seealso cref="DirectSpellChecker"/>.
+        /// Holds a spelling correction for internal usage inside <see cref="DirectSpellChecker"/>.
         /// </summary>
         protected internal class ScoreTerm : IComparable<ScoreTerm>
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/HighFrequencyDictionary.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/HighFrequencyDictionary.cs b/src/Lucene.Net.Suggest/Spell/HighFrequencyDictionary.cs
index 6b84a47..9a7e243 100644
--- a/src/Lucene.Net.Suggest/Spell/HighFrequencyDictionary.cs
+++ b/src/Lucene.Net.Suggest/Spell/HighFrequencyDictionary.cs
@@ -29,7 +29,7 @@ namespace Lucene.Net.Search.Spell
     /// Threshold is a value in [0..1] representing the minimum
     /// number of documents (of the total) where a term should appear.
     /// 
-    /// Based on LuceneDictionary.
+    /// Based on <see cref="LuceneDictionary"/>.
     /// </summary>
     public class HighFrequencyDictionary : IDictionary
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/JaroWinklerDistance.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/JaroWinklerDistance.cs b/src/Lucene.Net.Suggest/Spell/JaroWinklerDistance.cs
index e43a64e..c17f7cd 100644
--- a/src/Lucene.Net.Suggest/Spell/JaroWinklerDistance.cs
+++ b/src/Lucene.Net.Suggest/Spell/JaroWinklerDistance.cs
@@ -22,10 +22,8 @@ namespace Lucene.Net.Search.Spell
 
     /// <summary>
     /// Similarity measure for short strings such as person names.
-    /// <para>
-    /// </para>
+    /// See <a href="http://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance">http://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance</a>
     /// </summary>
-    /// <seealso cref= <a href="http://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance">http://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance</a> </seealso>
     public class JaroWinklerDistance : IStringDistance
     {
 
@@ -34,7 +32,7 @@ namespace Lucene.Net.Search.Spell
         /// <summary>
         /// Creates a new distance metric with the default threshold
         /// for the Jaro Winkler bonus (0.7) </summary>
-        /// <seealso cref= #setThreshold(float) </seealso>
+        /// <seealso cref="Threshold"/>
         public JaroWinklerDistance()
         {
         }
@@ -126,9 +124,9 @@ namespace Lucene.Net.Search.Spell
         }
 
         /// <summary>
-        /// Sets the threshold used to determine when Winkler bonus should be used.
-        /// Set to a negative value to get the Jaro distance. </summary>
-        /// <param name="threshold"> the new value of the threshold </param>
+        /// Gets or sets the threshold used to determine when Winkler bonus should be used.
+        /// The default value is 0.7. Set to a negative value to get the Jaro distance. 
+        /// </summary>
         public virtual float Threshold
         {
             set

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/LevensteinDistance.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/LevensteinDistance.cs b/src/Lucene.Net.Suggest/Spell/LevensteinDistance.cs
index 4a1e281..65e3b12 100644
--- a/src/Lucene.Net.Suggest/Spell/LevensteinDistance.cs
+++ b/src/Lucene.Net.Suggest/Spell/LevensteinDistance.cs
@@ -22,11 +22,12 @@ namespace Lucene.Net.Search.Spell
     /// <summary>
     /// Levenstein edit distance class.
     /// </summary>
+    // LUCENENET NOTE: This class is misspelled: It should be Levenshtein
     public sealed class LevensteinDistance : IStringDistance
     {
 
         /// <summary>
-        /// Optimized to run a bit faster than the static getDistance().
+        /// Optimized to run a bit faster than the static GetDistance().
         /// In one benchmark times were 5.3sec using ctr vs 8.5sec w/ static method, thus 37% faster.
         /// </summary>
         public LevensteinDistance()

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/LuceneLevenshteinDistance.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/LuceneLevenshteinDistance.cs b/src/Lucene.Net.Suggest/Spell/LuceneLevenshteinDistance.cs
index bce0cc2..5ee47ea 100644
--- a/src/Lucene.Net.Suggest/Spell/LuceneLevenshteinDistance.cs
+++ b/src/Lucene.Net.Suggest/Spell/LuceneLevenshteinDistance.cs
@@ -26,15 +26,15 @@ namespace Lucene.Net.Search.Spell
     ///  way as Lucene's FuzzyTermsEnum with the transpositions option enabled.
     ///  
     ///  Notes:
-    ///  <ul>
-    ///    <li> This metric treats full unicode codepoints as characters
-    ///    <li> This metric scales raw edit distances into a floating point score
-    ///         based upon the shortest of the two terms
-    ///    <li> Transpositions of two adjacent codepoints are treated as primitive 
-    ///         edits.
-    ///    <li> Edits are applied in parallel: for example, "ab" and "bca" have 
-    ///         distance 3.
-    ///  </ul>
+    ///  <list type="bullet">
+    ///    <item> This metric treats full unicode codepoints as characters</item>
+    ///    <item> This metric scales raw edit distances into a floating point score
+    ///         based upon the shortest of the two terms</item>
+    ///    <item> Transpositions of two adjacent codepoints are treated as primitive 
+    ///         edits.</item>
+    ///    <item> Edits are applied in parallel: for example, "ab" and "bca" have 
+    ///         distance 3.</item>
+    ///  </list>
     ///  
     ///  NOTE: this class is not particularly efficient. It is only intended
     ///  for merging results from multiple DirectSpellCheckers.

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/NGramDistance.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/NGramDistance.cs b/src/Lucene.Net.Suggest/Spell/NGramDistance.cs
index b133fa4..7d52afe 100644
--- a/src/Lucene.Net.Suggest/Spell/NGramDistance.cs
+++ b/src/Lucene.Net.Suggest/Spell/NGramDistance.cs
@@ -24,14 +24,13 @@ namespace Lucene.Net.Search.Spell
     /// "N-gram similarity and distance". Proceedings of the Twelfth International 
     /// Conference on String Processing and Information Retrieval (SPIRE 2005), pp. 115-126, 
     /// Buenos Aires, Argentina, November 2005. 
-    /// http://www.cs.ualberta.ca/~kondrak/papers/spire05.pdf
+    /// <a href="http://www.cs.ualberta.ca/~kondrak/papers/spire05.pdf">http://www.cs.ualberta.ca/~kondrak/papers/spire05.pdf</a>
     /// 
     /// This implementation uses the position-based optimization to compute partial
     /// matches of n-gram sub-strings and adds a null-character prefix of size n-1 
     /// so that the first character is contained in the same number of n-grams as 
     /// a middle character.  Null-character prefix matches are discounted so that 
     /// strings with no matching characters will return a distance of 0.
-    /// 
     /// </summary>
     public class NGramDistance : IStringDistance
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/PlainTextDictionary.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/PlainTextDictionary.cs b/src/Lucene.Net.Suggest/Spell/PlainTextDictionary.cs
index 7e85d36..c25679e 100644
--- a/src/Lucene.Net.Suggest/Spell/PlainTextDictionary.cs
+++ b/src/Lucene.Net.Suggest/Spell/PlainTextDictionary.cs
@@ -26,10 +26,10 @@ namespace Lucene.Net.Search.Spell
     /// <summary>
     /// Dictionary represented by a text file.
     /// 
-    /// <p/>Format allowed: 1 word per line:<br/>
-    /// word1<br/>
-    /// word2<br/>
-    /// word3<br/>
+    /// <para/>Format allowed: 1 word per line:<para/>
+    /// word1<para/>
+    /// word2<para/>
+    /// word3<para/>
     /// </summary>
     public class PlainTextDictionary : IDictionary
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/SpellChecker.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/SpellChecker.cs b/src/Lucene.Net.Suggest/Spell/SpellChecker.cs
index b88cef1..524a40b 100644
--- a/src/Lucene.Net.Suggest/Spell/SpellChecker.cs
+++ b/src/Lucene.Net.Suggest/Spell/SpellChecker.cs
@@ -32,17 +32,16 @@ namespace Lucene.Net.Search.Spell
     ///  (initially inspired by the David Spencer code).
     /// </para>
     /// 
-    /// <para>Example Usage:
+    /// <para>Example Usage (C#):
     /// 
-    /// <pre class="prettyprint">
+    /// <code>
     ///  SpellChecker spellchecker = new SpellChecker(spellIndexDirectory);
     ///  // To index a field of a user index:
-    ///  spellchecker.indexDictionary(new LuceneDictionary(my_lucene_reader, a_field));
+    ///  spellchecker.IndexDictionary(new LuceneDictionary(my_lucene_reader, a_field));
     ///  // To index a file containing words:
-    ///  spellchecker.indexDictionary(new PlainTextDictionary(new File("myfile.txt")));
-    ///  String[] suggestions = spellchecker.suggestSimilar("misspelt", 5);
-    /// </pre>
-    /// 
+    ///  spellchecker.IndexDictionary(new PlainTextDictionary(new FileInfo("myfile.txt")));
+    ///  string[] suggestions = spellchecker.SuggestSimilar("misspelt", 5);
+    /// </code>
     /// 
     /// </para>
     /// </summary>
@@ -50,7 +49,8 @@ namespace Lucene.Net.Search.Spell
     {
 
         /// <summary>
-        /// The default minimum score to use, if not specified by calling <seealso cref="#setAccuracy(float)"/> .
+        /// The default minimum score to use, if not specified by setting <see cref="Accuracy"/>
+        /// or overriding with <see cref="SuggestSimilar(string, int, IndexReader, string, SuggestMode, float)"/> .
         /// </summary>
         public const float DEFAULT_ACCURACY = 0.5f;
 
@@ -62,7 +62,7 @@ namespace Lucene.Net.Search.Spell
         /// <summary>
         /// the spell index
         /// </summary>
-        // don't modify the directory directly - see #swapSearcher()
+        // don't modify the directory directly - see SwapSearcher()
         // TODO: why is this package private?
         internal Directory spellIndex;
         /// <summary>
@@ -71,8 +71,8 @@ namespace Lucene.Net.Search.Spell
         private float bStart = 2.0f;
 
         private float bEnd = 1.0f;
-        // don't use this searcher directly - see #swapSearcher()
 
+        // don't use this searcher directly - see SwapSearcher()
         private IndexSearcher searcher;
 
         /// <summary>
@@ -100,20 +100,20 @@ namespace Lucene.Net.Search.Spell
         /// Use the given directory as a spell checker index. The directory
         /// is created if it doesn't exist yet. </summary>
         /// <param name="spellIndex"> the spell index directory </param>
-        /// <param name="sd"> the <seealso cref="StringDistance"/> measurement to use </param>
-        /// <exception cref="IOException"> if Spellchecker can not open the directory </exception>
+        /// <param name="sd"> the <see cref="StringDistance"/> measurement to use </param>
+        /// <exception cref="System.IO.IOException"> if Spellchecker can not open the directory </exception>
         public SpellChecker(Directory spellIndex, IStringDistance sd)
             : this(spellIndex, sd, SuggestWordQueue.DEFAULT_COMPARATOR)
         {
         }
         /// <summary>
         /// Use the given directory as a spell checker index with a
-        /// <seealso cref="LevensteinDistance"/> as the default <seealso cref="StringDistance"/>. The
+        /// <see cref="LevensteinDistance"/> as the default <see cref="T:StringDistance"/>. The
         /// directory is created if it doesn't exist yet.
         /// </summary>
         /// <param name="spellIndex">
         ///          the spell index directory </param>
-        /// <exception cref="IOException">
+        /// <exception cref="System.IO.IOException">
         ///           if spellchecker can not open the directory </exception>
         public SpellChecker(Directory spellIndex)
             : this(spellIndex, new LevensteinDistance())
@@ -121,12 +121,12 @@ namespace Lucene.Net.Search.Spell
         }
 
         /// <summary>
-        /// Use the given directory as a spell checker index with the given <seealso cref="Lucene.Net.Search.Spell.IStringDistance"/> measure
-        /// and the given <seealso cref="System.Collections.Generic.IComparer{T}"/> for sorting the results. </summary>
+        /// Use the given directory as a spell checker index with the given <see cref="IStringDistance"/> measure
+        /// and the given <see cref="System.Collections.Generic.IComparer{T}"/> for sorting the results. </summary>
         /// <param name="spellIndex"> The spelling index </param>
         /// <param name="sd"> The distance </param>
         /// <param name="comparator"> The comparator </param>
-        /// <exception cref="IOException"> if there is a problem opening the index </exception>
+        /// <exception cref="System.IO.IOException"> if there is a problem opening the index </exception>
         public SpellChecker(Directory spellIndex, IStringDistance sd, IComparer<SuggestWord> comparator)
         {
             SpellIndex = spellIndex;
@@ -135,7 +135,7 @@ namespace Lucene.Net.Search.Spell
         }
 
         /// <summary>
-        /// Use a different index as the spell checker index or re-open
+        /// Sets a different index as the spell checker index or re-open
         /// the existing index if <code>spellIndex</code> is the same value
         /// as given in the constructor. </summary>
         /// <param name="spellIndexDir"> the spell directory to use </param>
@@ -163,8 +163,8 @@ namespace Lucene.Net.Search.Spell
         }
 
         /// <summary>
-        /// Sets the <seealso cref="java.util.Comparator"/> for the <seealso cref="SuggestWordQueue"/>. </summary>
-        /// <param name="comparator"> the comparator </param>
+        /// Gets or sets the <see cref="IComparer{T}"/> for the <see cref="SuggestWordQueue"/>.
+        /// </summary>
         public virtual IComparer<SuggestWord> Comparator
         {
             set
@@ -179,11 +179,9 @@ namespace Lucene.Net.Search.Spell
 
 
         /// <summary>
-        /// Sets the <seealso cref="StringDistance"/> implementation for this
-        /// <seealso cref="SpellChecker"/> instance.
+        /// Gets or sets the <see cref="T:StringDistance"/> implementation for this
+        /// <see cref="SpellChecker"/> instance.
         /// </summary>
-        /// <param name="sd"> the <seealso cref="StringDistance"/> implementation for this
-        /// <seealso cref="SpellChecker"/> instance </param>
         public virtual IStringDistance StringDistance
         {
             set
@@ -197,8 +195,11 @@ namespace Lucene.Net.Search.Spell
         }
 
         /// <summary>
-        /// Sets the accuracy 0 &lt; minScore &lt; 1; default <seealso cref="#DEFAULT_ACCURACY"/> </summary>
-        /// <param name="acc"> The new accuracy </param>
+        /// Gets or sets the accuracy (minimum score) to be used, unless overridden in 
+        /// <see cref="SuggestSimilar(string, int, IndexReader, string, SuggestMode, float)"/>, 
+        /// to decide whether a suggestion is included or not.
+        /// Sets the accuracy 0 &lt; minScore &lt; 1; default <see cref="DEFAULT_ACCURACY"/>
+        /// </summary>
         public virtual float Accuracy
         {
             set
@@ -214,25 +215,25 @@ namespace Lucene.Net.Search.Spell
 
         /// <summary>
         /// Suggest similar words.
-        /// 
-        /// <para>As the Lucene similarity that is used to fetch the most relevant n-grammed terms
+        /// <para>
+        /// As the Lucene similarity that is used to fetch the most relevant n-grammed terms
         /// is not the same as the edit distance strategy used to calculate the best
         /// matching spell-checked word from the hits that Lucene found, one usually has
         /// to retrieve a couple of numSug's in order to get the true best match.
-        /// 
         /// </para>
-        /// <para>I.e. if numSug == 1, don't count on that suggestion being the best one.
+        /// <para>
+        /// I.e. if numSug == 1, don't count on that suggestion being the best one.
         /// Thus, you should set this value to <b>at least</b> 5 for a good suggestion.
-        /// 
         /// </para>
         /// </summary>
         /// <param name="word"> the word you want a spell check done on </param>
         /// <param name="numSug"> the number of suggested words </param>
-        /// <exception cref="IOException"> if the underlying index throws an <seealso cref="IOException"/> </exception>
-        /// <exception cref="AlreadyClosedException"> if the Spellchecker is already closed </exception>
-        /// <returns> String[]
-        /// </returns>
-        /// <seealso cref= #suggestSimilar(String, int, IndexReader, String, SuggestMode, float)  </seealso>
+        /// <exception cref="System.IO.IOException"> if the underlying index throws an <see cref="IOException"/> </exception>
+        /// <exception cref="AlreadyClosedException"> if the Spellchecker is already disposed </exception>
+        /// <returns>string[] the sorted list of the suggest words with these 2 criteria:
+        /// first criteria: the edit distance, second criteria (only if restricted mode): the popularity
+        /// of the suggest words in the field of the user index</returns>
+        /// <seealso cref="SuggestSimilar(string, int, IndexReader, string, SuggestMode, float)"/>
         public virtual string[] SuggestSimilar(string word, int numSug)
         {
             return this.SuggestSimilar(word, numSug, null, null, SuggestMode.SUGGEST_WHEN_NOT_IN_INDEX);
@@ -240,34 +241,34 @@ namespace Lucene.Net.Search.Spell
 
         /// <summary>
         /// Suggest similar words.
-        /// 
-        /// <para>As the Lucene similarity that is used to fetch the most relevant n-grammed terms
+        /// <para>
+        /// As the Lucene similarity that is used to fetch the most relevant n-grammed terms
         /// is not the same as the edit distance strategy used to calculate the best
         /// matching spell-checked word from the hits that Lucene found, one usually has
         /// to retrieve a couple of numSug's in order to get the true best match.
-        /// 
         /// </para>
-        /// <para>I.e. if numSug == 1, don't count on that suggestion being the best one.
+        /// <para>
+        /// I.e. if numSug == 1, don't count on that suggestion being the best one.
         /// Thus, you should set this value to <b>at least</b> 5 for a good suggestion.
-        /// 
         /// </para>
         /// </summary>
         /// <param name="word"> the word you want a spell check done on </param>
         /// <param name="numSug"> the number of suggested words </param>
         /// <param name="accuracy"> The minimum score a suggestion must have in order to qualify for inclusion in the results </param>
-        /// <exception cref="IOException"> if the underlying index throws an <seealso cref="IOException"/> </exception>
-        /// <exception cref="AlreadyClosedException"> if the Spellchecker is already closed </exception>
-        /// <returns> String[]
-        /// </returns>
-        /// <seealso cref= #suggestSimilar(String, int, IndexReader, String, SuggestMode, float) </seealso>
+        /// <exception cref="System.IO.IOException"> if the underlying index throws an <see cref="IOException"/> </exception>
+        /// <exception cref="AlreadyClosedException"> if the Spellchecker is already disposed </exception>
+        /// <returns>string[] the sorted list of the suggest words with these 2 criteria:
+        /// first criteria: the edit distance, second criteria (only if restricted mode): the popularity
+        /// of the suggest words in the field of the user index</returns>
+        /// <seealso cref="SuggestSimilar(string, int, IndexReader, string, SuggestMode, float)"/>
         public virtual string[] SuggestSimilar(string word, int numSug, float accuracy)
         {
             return this.SuggestSimilar(word, numSug, null, null, SuggestMode.SUGGEST_WHEN_NOT_IN_INDEX, accuracy);
         }
 
         /// <summary>
-        /// Calls {@link #suggestSimilar(String, int, IndexReader, String, SuggestMode, float) 
-        ///       suggestSimilar(word, numSug, ir, suggestMode, field, this.accuracy)}
+        /// Calls <see cref="SuggestSimilar(string, int, IndexReader, string, SuggestMode, float)"/>
+        ///       SuggestSimilar(word, numSug, ir, suggestMode, field, this.accuracy)
         /// 
         /// </summary>
         public virtual string[] SuggestSimilar(string word, int numSug, IndexReader ir, string field, SuggestMode suggestMode)
@@ -277,16 +278,15 @@ namespace Lucene.Net.Search.Spell
 
         /// <summary>
         /// Suggest similar words (optionally restricted to a field of an index).
-        /// 
-        /// <para>As the Lucene similarity that is used to fetch the most relevant n-grammed terms
+        /// <para>
+        /// As the Lucene similarity that is used to fetch the most relevant n-grammed terms
         /// is not the same as the edit distance strategy used to calculate the best
         /// matching spell-checked word from the hits that Lucene found, one usually has
         /// to retrieve a couple of numSug's in order to get the true best match.
-        /// 
         /// </para>
-        /// <para>I.e. if numSug == 1, don't count on that suggestion being the best one.
+        /// <para>
+        /// I.e. if numSug == 1, don't count on that suggestion being the best one.
         /// Thus, you should set this value to <b>at least</b> 5 for a good suggestion.
-        /// 
         /// </para>
         /// </summary>
         /// <param name="word"> the word you want a spell check done on </param>
@@ -297,9 +297,9 @@ namespace Lucene.Net.Search.Spell
         /// <param name="suggestMode"> 
         /// (NOTE: if indexReader==null and/or field==null, then this is overridden with SuggestMode.SUGGEST_ALWAYS) </param>
         /// <param name="accuracy"> The minimum score a suggestion must have in order to qualify for inclusion in the results </param>
-        /// <exception cref="IOException"> if the underlying index throws an <seealso cref="IOException"/> </exception>
-        /// <exception cref="AlreadyClosedException"> if the Spellchecker is already closed </exception>
-        /// <returns> String[] the sorted list of the suggest words with these 2 criteria:
+        /// <exception cref="System.IO.IOException"> if the underlying index throws an <see cref="IOException"/> </exception>
+        /// <exception cref="AlreadyClosedException"> if the <see cref="Spellchecker"/> is already disposed </exception>
+        /// <returns> string[] the sorted list of the suggest words with these 2 criteria:
         /// first criteria: the edit distance, second criteria (only if restricted mode): the popularity
         /// of the suggest words in the field of the user index
         ///  </returns>
@@ -457,7 +457,7 @@ namespace Lucene.Net.Search.Spell
 
         /// <summary>
         /// Removes all terms from the spell check index. </summary>
-        /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
+        /// <exception cref="System.IO.IOException"> If there is a low-level I/O error. </exception>
         /// <exception cref="AlreadyClosedException"> if the Spellchecker is already closed </exception>
         public virtual void ClearIndex()
         {
@@ -474,8 +474,8 @@ namespace Lucene.Net.Search.Spell
         /// <summary>
         /// Check whether the word exists in the index. </summary>
         /// <param name="word"> word to check </param>
-        /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
-        /// <exception cref="AlreadyClosedException"> if the Spellchecker is already closed </exception>
+        /// <exception cref="System.IO.IOException"> If there is a low-level I/O error. </exception>
+        /// <exception cref="AlreadyClosedException"> if the <see cref="Spellchecker"/> is already disposed </exception>
         /// <returns> true if the word exists in the index </returns>
         public virtual bool Exist(string word)
         {
@@ -494,12 +494,13 @@ namespace Lucene.Net.Search.Spell
         }
 
         /// <summary>
-        /// Indexes the data from the given <seealso cref="IDictionary"/>. </summary>
+        /// Indexes the data from the given <see cref="IDictionary"/>. </summary>
         /// <param name="dict"> Dictionary to index </param>
-        /// <param name="config"> <seealso cref="IndexWriterConfig"/> to use </param>
+        /// <param name="config"> <see cref="IndexWriterConfig"/> to use </param>
         /// <param name="fullMerge"> whether or not the spellcheck index should be fully merged </param>
-        /// <exception cref="AlreadyClosedException"> if the Spellchecker is already closed </exception>
-        /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
+        /// <exception cref="AlreadyClosedException"> if the <see cref="Spellchecker"/> is already disposed </exception>
+        /// <exception cref="System.IO.IOException"> If there is a low-level I/O error. </exception>
+        // LUCENENET TODO: Replace all usage of AlreadyClosedException with System.ObjectDisposedException
         public void IndexDictionary(IDictionary dict, IndexWriterConfig config, bool fullMerge)
         {
             lock (modifyCurrentIndexLock)
@@ -673,9 +674,9 @@ namespace Lucene.Net.Search.Spell
         }
 
         /// <summary>
-        /// Close the IndexSearcher used by this SpellChecker </summary>
-        /// <exception cref="IOException"> if the close operation causes an <seealso cref="IOException"/> </exception>
-        /// <exception cref="AlreadyClosedException"> if the <seealso cref="SpellChecker"/> is already closed </exception>
+        /// Dispose the underlying IndexSearcher used by this SpellChecker </summary>
+        /// <exception cref="System.IO.IOException"> if the close operation causes an <see cref="IOException"/> </exception>
+        /// <exception cref="AlreadyClosedException"> if the <see cref="SpellChecker"/> is already disposed </exception>
         public void Dispose()
         {
             lock (searcherLock)
@@ -719,7 +720,7 @@ namespace Lucene.Net.Search.Spell
         /// Creates a new read-only IndexSearcher </summary>
         /// <param name="dir"> the directory used to open the searcher </param>
         /// <returns> a new read-only IndexSearcher </returns>
-        /// <exception cref="IOException"> f there is a low-level IO error </exception>
+        /// <exception cref="System.IO.IOException"> f there is a low-level IO error </exception>
         // for testing purposes
         internal virtual IndexSearcher CreateSearcher(Directory dir)
         {
@@ -727,11 +728,11 @@ namespace Lucene.Net.Search.Spell
         }
 
         /// <summary>
-        /// Returns <code>true</code> if and only if the <seealso cref="SpellChecker"/> is
-        /// disposed, otherwise <code>false</code>.
+        /// Returns <c>true</c> if and only if the <see cref="SpellChecker"/> is
+        /// disposed, otherwise <c>false</c>.
         /// </summary>
-        /// <returns> <code>true</code> if and only if the <seealso cref="SpellChecker"/> is
-        ///         disposed, otherwise <code>false</code>. </returns>
+        /// <returns> <c>true</c> if and only if the <see cref="SpellChecker"/> is
+        ///         disposed, otherwise <c>false</c>. </returns>
         internal virtual bool IsDisposed
         {
             get

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/SuggestMode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/SuggestMode.cs b/src/Lucene.Net.Suggest/Spell/SuggestMode.cs
index fdda563..a782b41 100644
--- a/src/Lucene.Net.Suggest/Spell/SuggestMode.cs
+++ b/src/Lucene.Net.Suggest/Spell/SuggestMode.cs
@@ -37,7 +37,7 @@
         /// <summary>
         /// Always attempt to offer suggestions (however, other parameters may limit
         /// suggestions. For example, see
-        /// <seealso cref="DirectSpellChecker#setMaxQueryFrequency(float)"/> ).
+        /// <see cref="DirectSpellChecker.MaxQueryFrequency"/> ).
         /// </summary>
         SUGGEST_ALWAYS
     }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/SuggestWord.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/SuggestWord.cs b/src/Lucene.Net.Suggest/Spell/SuggestWord.cs
index 1576a7b..ef5de3e 100644
--- a/src/Lucene.Net.Suggest/Spell/SuggestWord.cs
+++ b/src/Lucene.Net.Suggest/Spell/SuggestWord.cs
@@ -18,7 +18,7 @@
      */
 
     /// <summary>
-    ///  SuggestWord, used in suggestSimilar method in SpellChecker class.
+    /// SuggestWord, used in suggestSimilar method in <see cref="SpellChecker"/> class.
     /// <p/>
     /// Default sort is first by score, then by frequency.
     /// </summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/SuggestWordFrequencyComparator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/SuggestWordFrequencyComparator.cs b/src/Lucene.Net.Suggest/Spell/SuggestWordFrequencyComparator.cs
index 252233f..3ddf3e9 100644
--- a/src/Lucene.Net.Suggest/Spell/SuggestWordFrequencyComparator.cs
+++ b/src/Lucene.Net.Suggest/Spell/SuggestWordFrequencyComparator.cs
@@ -27,8 +27,8 @@ namespace Lucene.Net.Search.Spell
     {
 
         /// <summary>
-        /// Creates a new comparator that will compare by <seealso cref="SuggestWord#freq"/>,
-        /// then by <seealso cref="SuggestWord#score"/>, then by <seealso cref="SuggestWord#string"/>.
+        /// Creates a new comparator that will compare by <see cref="SuggestWord.Freq"/>,
+        /// then by <see cref="SuggestWord.Score"/>, then by <see cref="SuggestWord.String"/>.
         /// </summary>
         public SuggestWordFrequencyComparator()
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/SuggestWordQueue.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/SuggestWordQueue.cs b/src/Lucene.Net.Suggest/Spell/SuggestWordQueue.cs
index 3a0ebc9..ea9311f 100644
--- a/src/Lucene.Net.Suggest/Spell/SuggestWordQueue.cs
+++ b/src/Lucene.Net.Suggest/Spell/SuggestWordQueue.cs
@@ -25,19 +25,18 @@ namespace Lucene.Net.Search.Spell
     /// </summary>
     /// <seealso cref="SuggestWordScoreComparator"/>
     /// <seealso cref="SuggestWordFrequencyComparator"/>
-    ///  </seealso>
     public sealed class SuggestWordQueue : PriorityQueue<SuggestWord>
     {
         /// <summary>
         /// Default comparator: score then frequency. </summary>
-        /// <seealso cref= SuggestWordScoreComparator </seealso>
+        /// <seealso cref="SuggestWordScoreComparator"/>
         public static readonly IComparer<SuggestWord> DEFAULT_COMPARATOR = new SuggestWordScoreComparator();
 
 
         private readonly IComparer<SuggestWord> comparator;
 
         /// <summary>
-        /// Use the <seealso cref="#DEFAULT_COMPARATOR"/> </summary>
+        /// Use the <see cref="DEFAULT_COMPARATOR"/> </summary>
         /// <param name="size"> The size of the queue </param>
         public SuggestWordQueue(int size)
             : base(size)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/SuggestWordScoreComparator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/SuggestWordScoreComparator.cs b/src/Lucene.Net.Suggest/Spell/SuggestWordScoreComparator.cs
index 3d875db..b444e8f 100644
--- a/src/Lucene.Net.Suggest/Spell/SuggestWordScoreComparator.cs
+++ b/src/Lucene.Net.Suggest/Spell/SuggestWordScoreComparator.cs
@@ -27,8 +27,8 @@ namespace Lucene.Net.Search.Spell
     {
 
         /// <summary>
-        /// Creates a new comparator that will compare by <seealso cref="SuggestWord#score"/>,
-        /// then by <seealso cref="SuggestWord#freq"/>, then by <seealso cref="SuggestWord#string"/>.
+        /// Creates a new comparator that will compare by <see cref="SuggestWord.Score"/>,
+        /// then by <see cref="SuggestWord.Freq"/>, then by <see cref="SuggestWord.String"/>.
         /// </summary>
         public SuggestWordScoreComparator()
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/WordBreakSpellChecker.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/WordBreakSpellChecker.cs b/src/Lucene.Net.Suggest/Spell/WordBreakSpellChecker.cs
index fb79975..d1d1e0e 100644
--- a/src/Lucene.Net.Suggest/Spell/WordBreakSpellChecker.cs
+++ b/src/Lucene.Net.Suggest/Spell/WordBreakSpellChecker.cs
@@ -42,19 +42,17 @@ namespace Lucene.Net.Search.Spell
 
         /// <summary>
         /// Creates a new spellchecker with default configuration values </summary>
-        /// <seealso cref= #setMaxChanges(int) </seealso>
-        /// <seealso cref= #setMaxCombineWordLength(int) </seealso>
-        /// <seealso cref= #setMaxEvaluations(int) </seealso>
-        /// <seealso cref= #setMinBreakWordLength(int) </seealso>
-        /// <seealso cref= #setMinSuggestionFrequency(int) </seealso>
+        /// <seealso cref="MaxChanges"/>
+        /// <seealso cref="MaxCombineWordLength"/>
+        /// <seealso cref="MaxEvaluations"/>
+        /// <seealso cref="MinBreakWordLength"/>
+        /// <seealso cref="MinSuggestionFrequency"/>
         public WordBreakSpellChecker()
         {
         }
 
         /// <summary>
-        /// <para>
         /// Determines the order to list word break suggestions
-        /// </para>
         /// </summary>
         public enum BreakSuggestionSortMethod
         {
@@ -75,19 +73,16 @@ namespace Lucene.Net.Search.Spell
         }
 
         /// <summary>
-        /// <para>
         /// Generate suggestions by breaking the passed-in term into multiple words.
         /// The scores returned are equal to the number of word breaks needed so a
         /// lower score is generally preferred over a higher score.
-        /// </para>
         /// </summary>
         /// <param name="suggestMode">
-        ///          - default = <seealso cref="SuggestMode#SUGGEST_WHEN_NOT_IN_INDEX"/> </param>
+        ///          - default = <see cref="SuggestMode.SUGGEST_WHEN_NOT_IN_INDEX"/> </param>
         /// <param name="sortMethod">
-        ///          - default =
-        ///          <seealso cref="BreakSuggestionSortMethod#NUM_CHANGES_THEN_MAX_FREQUENCY"/> </param>
+        ///          - default = <see cref="BreakSuggestionSortMethod.NUM_CHANGES_THEN_MAX_FREQUENCY"/> </param>
         /// <returns> one or more arrays of words formed by breaking up the original term </returns>
-        /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
+        /// <exception cref="System.IO.IOException"> If there is a low-level I/O error. </exception>
         public virtual SuggestWord[][] SuggestWordBreaks(Term term, int maxSuggestions, IndexReader ir, SuggestMode suggestMode, BreakSuggestionSortMethod sortMethod)
         {
             if (maxSuggestions < 1)
@@ -135,30 +130,30 @@ namespace Lucene.Net.Search.Spell
         /// <summary>
         /// <para>
         /// Generate suggestions by combining one or more of the passed-in terms into
-        /// single words. The returned <seealso cref="CombineSuggestion"/> contains both a
-        /// <seealso cref="SuggestWord"/> and also an array detailing which passed-in terms were
+        /// single words. The returned <see cref="CombineSuggestion"/> contains both a
+        /// <see cref="SuggestWord"/> and also an array detailing which passed-in terms were
         /// involved in creating this combination. The scores returned are equal to the
         /// number of word combinations needed, also one less than the length of the
-        /// array <seealso cref="CombineSuggestion#originalTermIndexes"/>. Generally, a
+        /// array <see cref="CombineSuggestion.OriginalTermIndexes"/>. Generally, a
         /// suggestion with a lower score is preferred over a higher score.
         /// </para>
         /// <para>
         /// To prevent two adjacent terms from being combined (for instance, if one is
         /// mandatory and the other is prohibited), separate the two terms with
-        /// <seealso cref="WordBreakSpellChecker#SEPARATOR_TERM"/>
+        /// <see cref="WordBreakSpellChecker.SEPARATOR_TERM"/>
         /// </para>
         /// <para>
-        /// When suggestMode equals <seealso cref="SuggestMode#SUGGEST_WHEN_NOT_IN_INDEX"/>, each
+        /// When suggestMode equals <see cref="SuggestMode.SUGGEST_WHEN_NOT_IN_INDEX"/>, each
         /// suggestion will include at least one term not in the index.
         /// </para>
         /// <para>
-        /// When suggestMode equals <seealso cref="SuggestMode#SUGGEST_MORE_POPULAR"/>, each
+        /// When suggestMode equals <see cref="SuggestMode.SUGGEST_MORE_POPULAR"/>, each
         /// suggestion will have the same, or better frequency than the most-popular
         /// included term.
         /// </para>
         /// </summary>
         /// <returns> an array of words generated by combining original terms </returns>
-        /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
+        /// <exception cref="System.IO.IOException"> If there is a low-level I/O error. </exception>
         public virtual CombineSuggestion[] SuggestWordCombinations(Term[] terms, int maxSuggestions, IndexReader ir, SuggestMode suggestMode)
         {
             if (maxSuggestions < 1)
@@ -363,9 +358,10 @@ namespace Lucene.Net.Search.Spell
         }
 
         /// <summary>
-        /// Returns the minimum frequency a term must have
-        /// to be part of a suggestion. </summary>
-        /// <seealso cref= #setMinSuggestionFrequency(int) </seealso>
+        /// Gets or sets the minimum frequency a term must have to be 
+        /// included as part of a suggestion. Default=1 Not applicable when used with
+        /// <see cref="SuggestMode.SUGGEST_MORE_POPULAR"/>
+        /// </summary>
         public virtual int MinSuggestionFrequency
         {
             get
@@ -379,8 +375,9 @@ namespace Lucene.Net.Search.Spell
         }
 
         /// <summary>
-        /// Returns the maximum length of a combined suggestion </summary>
-        /// <seealso cref= #setMaxCombineWordLength(int) </seealso>
+        /// Gets or sets the maximum length of a suggestion made 
+        /// by combining 1 or more original terms. Default=20.
+        /// </summary>
         public virtual int MaxCombineWordLength
         {
             get
@@ -394,8 +391,8 @@ namespace Lucene.Net.Search.Spell
         }
 
         /// <summary>
-        /// Returns the minimum size of a broken word </summary>
-        /// <seealso cref= #setMinBreakWordLength(int) </seealso>
+        /// Gets or sets the minimum length to break words down to. Default=1.
+        /// </summary>
         public virtual int MinBreakWordLength
         {
             get
@@ -409,8 +406,9 @@ namespace Lucene.Net.Search.Spell
         }
 
         /// <summary>
-        /// Returns the maximum number of changes to perform on the input </summary>
-        /// <seealso cref= #setMaxChanges(int) </seealso>
+        /// Gets or sets the maximum numbers of changes (word breaks or combinations) to make 
+        /// on the original term(s). Default=1.
+        /// </summary>
         public virtual int MaxChanges
         {
             get
@@ -424,8 +422,9 @@ namespace Lucene.Net.Search.Spell
         }
 
         /// <summary>
-        /// Returns the maximum number of word combinations to evaluate. </summary>
-        /// <seealso cref= #setMaxEvaluations(int) </seealso>
+        /// Gets or sets the maximum number of word combinations to evaluate. Default=1000. A higher
+        /// value might improve result quality. A lower value might improve performance.
+        /// </summary>
         public virtual int MaxEvaluations
         {
             get

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingInfixSuggester.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingInfixSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingInfixSuggester.cs
index 23a38eb..4ce7e27 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingInfixSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingInfixSuggester.cs
@@ -70,13 +70,13 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         /// <summary>
         /// Field name used for the indexed text, as a
-        ///  StringField, for exact lookup. 
+        /// <see cref="StringField"/>, for exact lookup. 
         /// </summary>
         protected internal const string EXACT_TEXT_FIELD_NAME = "exacttext";
 
         /// <summary>
         /// Field name used for the indexed context, as a
-        ///  StringField and a SortedSetDVField, for filtering. 
+        /// <see cref="StringField"/> and a <see cref="SortedSetDocValuesField"/>, for filtering. 
         /// </summary>
         protected internal const string CONTEXTS_FIELD_NAME = "contexts";
 
@@ -95,7 +95,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         private IndexWriter writer;
 
         /// <summary>
-        /// <seealso cref="IndexSearcher"/> used for lookups. </summary>
+        /// <see cref="IndexSearcher"/> used for lookups. </summary>
         protected internal SearcherManager searcherMgr;
 
         /// <summary>
@@ -110,10 +110,11 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         /// <summary>
         /// Create a new instance, loading from a previously built
-        ///  AnalyzingInfixSuggester directory, if it exists.  This directory must be
-        ///  private to the infix suggester (i.e., not an external
-        ///  Lucene index).  Note that <seealso cref="#close"/>
-        ///  will also close the provided directory. 
+        /// <see cref="AnalyzingInfixSuggester"/> directory, if it exists. 
+        /// This directory must be
+        /// private to the infix suggester (i.e., not an external
+        /// Lucene index).  Note that <see cref="Dispose()"/>
+        /// will also dispose the provided directory. 
         /// </summary>
         public AnalyzingInfixSuggester(LuceneVersion matchVersion, Directory dir, Analyzer analyzer)
             : this(matchVersion, dir, analyzer, analyzer, DEFAULT_MIN_PREFIX_CHARS)
@@ -122,13 +123,13 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         /// <summary>
         /// Create a new instance, loading from a previously built
-        ///  AnalyzingInfixSuggester directory, if it exists.  This directory must be
-        ///  private to the infix suggester (i.e., not an external
-        ///  Lucene index).  Note that <seealso cref="#close"/>
-        ///  will also close the provided directory.
+        /// <see cref="AnalyzingInfixSuggester"/> directory, if it exists.  This directory must be
+        /// private to the infix suggester (i.e., not an external
+        /// Lucene index).  Note that <see cref="Dispose()"/>
+        /// will also dispose the provided directory.
         /// </summary>
         ///  <param name="minPrefixChars"> Minimum number of leading characters
-        ///     before PrefixQuery is used (default 4).
+        ///     before <see cref="PrefixQuery"/> is used (default 4).
         ///     Prefixes shorter than this are indexed as character
         ///     ngrams (increasing index size but making lookups
         ///     faster). </param>
@@ -156,7 +157,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         /// <summary>
         /// Override this to customize index settings, e.g. which
-        ///  codec to use. 
+        /// codec to use. 
         /// </summary>
         protected internal virtual IndexWriterConfig GetIndexWriterConfig(LuceneVersion matchVersion, Analyzer indexAnalyzer, IndexWriterConfig.OpenMode_e openMode)
         {
@@ -173,8 +174,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         }
 
         /// <summary>
-        /// Subclass can override to choose a specific {@link
-        ///  Directory} implementation. 
+        /// Subclass can override to choose a specific 
+        /// <see cref="Directory"/> implementation. 
         /// </summary>
         protected internal virtual Directory GetDirectory(DirectoryInfo path)
         {
@@ -283,11 +284,11 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         }
 
         /// <summary>
-        /// Adds a new suggestion.  Be sure to use <seealso cref="#update"/>
-        ///  instead if you want to replace a previous suggestion.
-        ///  After adding or updating a batch of new suggestions,
-        ///  you must call <seealso cref="#refresh"/> in the end in order to
-        ///  see the suggestions in <seealso cref="#lookup"/> 
+        /// Adds a new suggestion.  Be sure to use <see cref="Update"/>
+        /// instead if you want to replace a previous suggestion.
+        /// After adding or updating a batch of new suggestions,
+        /// you must call <see cref="Refresh()"/> in the end in order to
+        /// see the suggestions in <see cref="DoLookup"/> 
         /// </summary>
         public virtual void Add(BytesRef text, IEnumerable<BytesRef> contexts, long weight, BytesRef payload)
         {
@@ -296,12 +297,12 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         /// <summary>
         /// Updates a previous suggestion, matching the exact same
-        ///  text as before.  Use this to change the weight or
-        ///  payload of an already added suggstion.  If you know
-        ///  this text is not already present you can use {@link
-        ///  #add} instead.  After adding or updating a batch of
-        ///  new suggestions, you must call <seealso cref="#refresh"/> in the
-        ///  end in order to see the suggestions in <seealso cref="#lookup"/> 
+        /// text as before.  Use this to change the weight or
+        /// payload of an already added suggstion.  If you know
+        /// this text is not already present you can use <see cref="Add"/> 
+        /// instead.  After adding or updating a batch of
+        /// new suggestions, you must call <see cref="Refresh()"/> in the
+        /// end in order to see the suggestions in <see cref="DoLookup"/> 
         /// </summary>
         public virtual void Update(BytesRef text, IEnumerable<BytesRef> contexts, long weight, BytesRef payload)
         {
@@ -339,8 +340,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         /// <summary>
         /// Reopens the underlying searcher; it's best to "batch
-        ///  up" many additions/updates, and then call refresh
-        ///  once in the end. 
+        /// up" many additions/updates, and then call refresh
+        /// once in the end. 
         /// </summary>
         public virtual void Refresh()
         {
@@ -378,8 +379,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         /// <summary>
         /// This is called if the last token isn't ended
-        ///  (e.g. user did not type a space after it).  Return an
-        ///  appropriate Query clause to add to the BooleanQuery. 
+        /// (e.g. user did not type a space after it).  Return an
+        /// appropriate <see cref="Query"/> clause to add to the <see cref="BooleanQuery"/>. 
         /// </summary>
         protected internal virtual Query GetLastTokenQuery(string token)
         {
@@ -394,8 +395,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         /// <summary>
         /// Retrieve suggestions, specifying whether all terms
-        ///  must match ({@code allTermsRequired}) and whether the hits
-        ///  should be highlighted ({@code doHighlight}). 
+        ///  must match (<paramref name="allTermsRequired"/>) and whether the hits
+        ///  should be highlighted (<paramref name="doHighlight"/>). 
         /// </summary>
         public virtual IList<LookupResult> DoLookup(string key, IEnumerable<BytesRef> contexts, int num, bool allTermsRequired, bool doHighlight)
         {
@@ -541,7 +542,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         /// <summary>
         /// Create the results based on the search hits.
         /// Can be overridden by subclass to add particular behavior (e.g. weight transformation) </summary>
-        /// <exception cref="IOException"> If there are problems reading fields from the underlying Lucene index. </exception>
+        /// <exception cref="System.IO.IOException"> If there are problems reading fields from the underlying Lucene index. </exception>
         protected internal virtual IList<LookupResult> CreateResults(IndexSearcher searcher, TopFieldDocs hits, int num, string charSequence, bool doHighlight, IEnumerable<string> matchedTokens, string prefixToken)
         {
 
@@ -612,7 +613,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         /// <summary>
         /// Subclass can override this to tweak the Query before
-        ///  searching. 
+        /// searching. 
         /// </summary>
         protected internal virtual Query FinishQuery(BooleanQuery bq, bool allTermsRequired)
         {
@@ -621,9 +622,9 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         /// <summary>
         /// Override this method to customize the Object
-        ///  representing a single highlighted suggestions; the
-        ///  result is set on each {@link
-        ///  LookupResult#highlightKey} member. 
+        /// representing a single highlighted suggestions; the
+        /// result is set on each <see cref="Lookup.LookupResult.highlightKey"/>
+        /// member. 
         /// </summary>
         protected internal virtual object Highlight(string text, IEnumerable<string> matchedTokens, string prefixToken)
         {
@@ -678,10 +679,10 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         /// <summary>
         /// Called while highlighting a single result, to append a
-        ///  non-matching chunk of text from the suggestion to the
-        ///  provided fragments list. </summary>
-        ///  <param name="sb"> The {@code StringBuilder} to append to </param>
-        ///  <param name="text"> The text chunk to add </param>
+        /// non-matching chunk of text from the suggestion to the
+        /// provided fragments list. </summary>
+        /// <param name="sb"> The <see cref="StringBuilder"/> to append to </param>
+        /// <param name="text"> The text chunk to add </param>
         protected internal virtual void AddNonMatch(StringBuilder sb, string text)
         {
             sb.Append(text);
@@ -689,10 +690,10 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         /// <summary>
         /// Called while highlighting a single result, to append
-        ///  the whole matched token to the provided fragments list. </summary>
-        ///  <param name="sb"> The {@code StringBuilder} to append to </param>
-        ///  <param name="surface"> The surface form (original) text </param>
-        ///  <param name="analyzed"> The analyzed token corresponding to the surface form text </param>
+        /// the whole matched token to the provided fragments list. </summary>
+        /// <param name="sb"> The <see cref="StringBuilder"/> to append to </param>
+        /// <param name="surface"> The surface form (original) text </param>
+        /// <param name="analyzed"> The analyzed token corresponding to the surface form text </param>
         protected internal virtual void AddWholeMatch(StringBuilder sb, string surface, string analyzed)
         {
             sb.Append("<b>");
@@ -702,13 +703,13 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         /// <summary>
         /// Called while highlighting a single result, to append a
-        ///  matched prefix token, to the provided fragments list. </summary>
-        ///  <param name="sb"> The {@code StringBuilder} to append to </param>
-        ///  <param name="surface"> The fragment of the surface form
-        ///        (indexed during <seealso cref="#build"/>, corresponding to
+        /// matched prefix token, to the provided fragments list. </summary>
+        /// <param name="sb"> The <see cref="StringBuilder"/> to append to </param>
+        /// <param name="surface"> The fragment of the surface form
+        ///        (indexed during <see cref="Build(IInputIterator)"/>, corresponding to
         ///        this match </param>
-        ///  <param name="analyzed"> The analyzed token that matched </param>
-        ///  <param name="prefixToken"> The prefix of the token that matched </param>
+        /// <param name="analyzed"> The analyzed token that matched </param>
+        /// <param name="prefixToken"> The prefix of the token that matched </param>
         protected internal virtual void AddPrefixMatch(StringBuilder sb, string surface, string analyzed, string prefixToken)
         {
             // TODO: apps can try to invert their analysis logic

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
index d0f4a0d..95d4ff6 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
@@ -43,7 +43,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
     /// suggestion "The Ghost of Christmas Past". Note that
     /// position increments MUST NOT be preserved for this example
     /// to work, so you should call the constructor with 
-    /// <code>preservePositionIncrements</code> parameter set to 
+    /// <paramref name="preservePositionIncrements"/> parameter set to 
     /// false
     /// 
     /// </para>
@@ -63,24 +63,24 @@ namespace Lucene.Net.Search.Suggest.Analyzing
     /// </para>
     /// <para>
     /// There are some limitations:
-    /// <ul>
+    /// <list type="number">
     /// 
-    ///   <li> A lookup from a query like "net" in English won't
+    ///   <item> A lookup from a query like "net" in English won't
     ///        be any different than "net " (ie, user added a
     ///        trailing space) because analyzers don't reflect
     ///        when they've seen a token separator and when they
-    ///        haven't.
+    ///        haven't.</item>
     /// 
-    ///   <li> If you're using {@code StopFilter}, and the user will
+    ///   <item> If you're using <see cref="Analysis.Core.StopFilter"/>, and the user will
     ///        type "fast apple", but so far all they've typed is
     ///        "fast a", again because the analyzer doesn't convey whether
     ///        it's seen a token separator after the "a",
-    ///        {@code StopFilter} will remove that "a" causing
-    ///        far more matches than you'd expect.
+    ///        <see cref="Analysis.Core.StopFilter"/> will remove that "a" causing
+    ///        far more matches than you'd expect.</item>
     /// 
-    ///   <li> Lookups with the empty string return no results
-    ///        instead of all results.
-    /// </ul>
+    ///   <item> Lookups with the empty string return no results
+    ///        instead of all results.</item>
+    /// </list>
     /// 
     /// @lucene.experimental
     /// </para>
@@ -89,10 +89,10 @@ namespace Lucene.Net.Search.Suggest.Analyzing
     {
 
         /// <summary>
-        /// FST<Weight,Surface>: 
-        ///  input is the analyzed form, with a null byte between terms
-        ///  weights are encoded as costs: (Integer.MAX_VALUE-weight)
-        ///  surface is the original, unanalyzed form.
+        /// FST(Weight,Surface):
+        /// input is the analyzed form, with a null byte between terms
+        /// weights are encoded as costs: (<see cref="int.MaxValue"/> - weight)
+        /// surface is the original, unanalyzed form.
         /// </summary>
         private FST<PairOutputs<long?, BytesRef>.Pair> fst = null;
 
@@ -119,18 +119,18 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         private readonly bool preserveSep;
 
         /// <summary>
-        /// Include this flag in the options parameter to {@link
-        ///  #AnalyzingSuggester(Analyzer,Analyzer,int,int,int,boolean)} to always
-        ///  return the exact match first, regardless of score.  This
-        ///  has no performance impact but could result in
-        ///  low-quality suggestions. 
+        /// Include this flag in the options parameter to 
+        /// <see cref="AnalyzingSuggester(Analyzer,Analyzer,int,int,int,bool)"/> to always
+        /// return the exact match first, regardless of score.  This
+        /// has no performance impact but could result in
+        /// low-quality suggestions. 
         /// </summary>
         public const int EXACT_FIRST = 1;
 
         /// <summary>
-        /// Include this flag in the options parameter to {@link
-        ///  #AnalyzingSuggester(Analyzer,Analyzer,int,int,int,boolean)} to preserve
-        ///  token separators when matching. 
+        /// Include this flag in the options parameter to
+        /// <see cref="AnalyzingSuggester(Analyzer,Analyzer,int,int,int,bool)"/> to preserve
+        /// token separators when matching. 
         /// </summary>
         public const int PRESERVE_SEP = 2;
 
@@ -180,9 +180,9 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         private long count = 0;
 
         /// <summary>
-        /// Calls {@link #AnalyzingSuggester(Analyzer,Analyzer,int,int,int,boolean)
-        /// AnalyzingSuggester(analyzer, analyzer, EXACT_FIRST |
-        /// PRESERVE_SEP, 256, -1, true)}
+        /// Calls <see cref="AnalyzingSuggester(Analyzer,Analyzer,int,int,int,bool)">
+        /// AnalyzingSuggester(analyzer, analyzer, EXACT_FIRST | PRESERVE_SEP, 256, -1, true)
+        /// </see>
         /// </summary>
         public AnalyzingSuggester(Analyzer analyzer)
             : this(analyzer, analyzer, EXACT_FIRST | PRESERVE_SEP, 256, -1, true)
@@ -190,9 +190,9 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         }
 
         /// <summary>
-        /// Calls {@link #AnalyzingSuggester(Analyzer,Analyzer,int,int,int,boolean)
-        /// AnalyzingSuggester(indexAnalyzer, queryAnalyzer, EXACT_FIRST |
-        /// PRESERVE_SEP, 256, -1, true)}
+        /// Calls <see cref="AnalyzingSuggester(Analyzer,Analyzer,int,int,int,bool)">
+        /// AnalyzingSuggester(indexAnalyzer, queryAnalyzer, EXACT_FIRST | PRESERVE_SEP, 256, -1, true)
+        /// </see>
         /// </summary>
         public AnalyzingSuggester(Analyzer indexAnalyzer, Analyzer queryAnalyzer)
             : this(indexAnalyzer, queryAnalyzer, EXACT_FIRST | PRESERVE_SEP, 256, -1, true)
@@ -206,7 +206,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         ///   analyzing suggestions while building the index. </param>
         /// <param name="queryAnalyzer"> 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

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs
index 7c82ef1..fb3ba65 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs
@@ -31,7 +31,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
     // - allow to use the search score
 
     /// <summary>
-    /// Extension of the AnalyzingInfixSuggester which transforms the weight
+    /// Extension of the <see cref="AnalyzingInfixSuggester"/> which transforms the weight
     /// after search to take into account the position of the searched term into
     /// the indexed text.
     /// Please note that it increases the number of elements searched and applies the
@@ -68,20 +68,26 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         public enum BlenderType
         {
             /// <summary>
-            /// Application dependent; override {@link
-            ///  #calculateCoefficient} to compute it. 
+            /// Application dependent; override <see cref="CalculateCoefficient(int)"/>
+            /// to compute it. 
             /// </summary>
             CUSTOM,
             /// <summary>
-            /// weight*(1 - 0.10*position) </summary>
+            /// weight*(1 - 0.10*position)
+            /// </summary>
             POSITION_LINEAR,
             /// <summary>
-            /// weight/(1+position) </summary>
+            /// weight/(1+position)
+            /// </summary>
             POSITION_RECIPROCAL,
             // TODO:
             //SCORE
         }
 
+        /// <summary>
+        /// LUCENENET specific to ensure our Queue is only altered by a single
+        /// thread at a time.
+        /// </summary>
         private static readonly object syncLock = new object();
 
         /// <summary>
@@ -101,7 +107,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         /// </summary>
         /// <param name="blenderType"> Type of blending strategy, see BlenderType for more precisions </param>
         /// <param name="numFactor">   Factor to multiply the number of searched elements before ponderate </param>
-        /// <exception cref="IOException"> If there are problems opening the underlying Lucene index. </exception>
+        /// <exception cref="System.IO.IOException"> If there are problems opening the underlying Lucene index. </exception>
         public BlendedInfixSuggester(LuceneVersion matchVersion, Directory dir, Analyzer indexAnalyzer, Analyzer queryAnalyzer, int minPrefixChars, BlenderType blenderType, int numFactor)
             : base(matchVersion, dir, indexAnalyzer, queryAnalyzer, minPrefixChars)
         {
@@ -247,7 +253,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         /// <param name="matchedTokens"> tokens found in the query </param>
         /// <param name="prefixToken"> unfinished token in the query </param>
         /// <returns> the coefficient </returns>
-        /// <exception cref="IOException"> If there are problems reading term vectors from the underlying Lucene index. </exception>
+        /// <exception cref="System.IO.IOException"> If there are problems reading term vectors from the underlying Lucene index. </exception>
         private double CreateCoefficient(IndexSearcher searcher, int doc, IEnumerable<string> matchedTokens, string prefixToken)
         {
             Terms tv = searcher.IndexReader.GetTermVector(doc, TEXT_FIELD_NAME);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs
index 3255a36..3aed4d4 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs
@@ -28,7 +28,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
     /// <summary>
     /// Exposes a utility method to enumerate all paths
-    /// intersecting an <seealso cref="Automaton"/> with an <seealso cref="FST"/>.
+    /// intersecting an <see cref="Automaton"/> with an <see cref="FST"/>.
     /// </summary>
     public class FSTUtil
     {
@@ -45,7 +45,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
             public readonly State state;
 
             /// <summary>
-            /// Node in the FST where path ends: </summary>
+            /// Node in the <see cref="FST"/> where path ends: </summary>
             public readonly FST.Arc<T> fstNode;
 
             /// <summary>
@@ -68,8 +68,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         }
 
         /// <summary>
-        /// Enumerates all minimal prefix paths in the automaton that also intersect the FST,
-        /// accumulating the FST end node and output for each path.
+        /// Enumerates all minimal prefix paths in the automaton that also intersect the <see cref="FST"/>,
+        /// accumulating the <see cref="FST"/> end node and output for each path.
         /// </summary>
         public static IList<Path<T>> IntersectPrefixPaths<T>(Automaton a, FST<T> fst)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
index 0a52947..3bd5f4d 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
@@ -39,9 +39,9 @@ namespace Lucene.Net.Search.Suggest.Analyzing
     //   - add pruning of low-freq ngrams?   
 
     /// <summary>
-    /// Builds an ngram model from the text sent to {@link
-    /// #build} and predicts based on the last grams-1 tokens in
-    /// the request sent to <seealso cref="#lookup"/>.  This tries to
+    /// Builds an ngram model from the text sent to <see cref="Build"/>
+    /// and predicts based on the last grams-1 tokens in
+    /// the request sent to <see cref="DoLookup"/>.  This tries to
     /// handle the "long tail" of suggestions for when the
     /// incoming query is a never before seen query string.
     /// 
@@ -56,18 +56,17 @@ namespace Lucene.Net.Search.Suggest.Analyzing
     /// 
     /// </para>
     /// <para>This uses the stupid backoff language model to smooth
-    /// scores across ngram models; see
-    /// "Large language models in machine translation",
-    /// http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.76.1126
-    /// for details.
+    /// scores across ngram models; see 
+    /// <a href="http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.76.1126">
+    /// "Large language models in machine translation"</a> for details.
     /// 
     /// </para>
-    /// <para> From <seealso cref="#lookup"/>, the key of each result is the
-    /// ngram token; the value is Long.MAX_VALUE * score (fixed
-    /// point, cast to long).  Divide by Long.MAX_VALUE to get
+    /// <para> From <see cref="DoLookup"/>, the key of each result is the
+    /// ngram token; the value is <see cref="long.MaxValue"/> * score (fixed
+    /// point, cast to long).  Divide by <see cref="long.MaxValue"/> to get
     /// the score back, which ranges from 0.0 to 1.0.
     /// 
-    /// onlyMorePopular is unused.
+    /// <paramref name="onlyMorePopular"/> is unused.
     /// 
     /// @lucene.experimental
     /// </para>
@@ -131,14 +130,14 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         /// <summary>
         /// The default character used to join multiple tokens
-        ///  into a single ngram token.  The input tokens produced
-        ///  by the analyzer must not contain this character. 
+        /// into a single ngram token.  The input tokens produced
+        /// by the analyzer must not contain this character. 
         /// </summary>
         public const byte DEFAULT_SEPARATOR = 0x1e;
 
         /// <summary>
         /// Instantiate, using the provided analyzer for both
-        ///  indexing and lookup, using bigram model by default. 
+        /// indexing and lookup, using bigram model by default. 
         /// </summary>
         public FreeTextSuggester(Analyzer analyzer)
               : this(analyzer, analyzer, DEFAULT_GRAMS)
@@ -147,7 +146,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         /// <summary>
         /// Instantiate, using the provided indexing and lookup
-        ///  analyzers, using bigram model by default. 
+        /// analyzers, using bigram model by default. 
         /// </summary>
         public FreeTextSuggester(Analyzer indexAnalyzer, Analyzer queryAnalyzer)
               : this(indexAnalyzer, queryAnalyzer, DEFAULT_GRAMS)
@@ -156,8 +155,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         /// <summary>
         /// Instantiate, using the provided indexing and lookup
-        ///  analyzers, with the specified model (2
-        ///  = bigram, 3 = trigram, etc.). 
+        /// analyzers, with the specified model (2
+        /// = bigram, 3 = trigram, etc.). 
         /// </summary>
         public FreeTextSuggester(Analyzer indexAnalyzer, Analyzer queryAnalyzer, int grams)
               : this(indexAnalyzer, queryAnalyzer, grams, DEFAULT_SEPARATOR)
@@ -166,13 +165,13 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         /// <summary>
         /// Instantiate, using the provided indexing and lookup
-        ///  analyzers, and specified model (2 = bigram, 3 =
-        ///  trigram ,etc.).  The separator is passed to {@link
-        ///  ShingleFilter#setTokenSeparator} to join multiple
-        ///  tokens into a single ngram token; it must be an ascii
-        ///  (7-bit-clean) byte.  No input tokens should have this
-        ///  byte, otherwise {@code IllegalArgumentException} is
-        ///  thrown. 
+        /// analyzers, and specified model (2 = bigram, 3 =
+        /// trigram ,etc.).  The separator is passed to <see cref="ShingleFilter.TokenSeparator"/>
+        /// to join multiple
+        /// tokens into a single ngram token; it must be an ascii
+        /// (7-bit-clean) byte.  No input tokens should have this
+        /// byte, otherwise <see cref="ArgumentException"/> is
+        /// thrown. 
         /// </summary>
         public FreeTextSuggester(Analyzer indexAnalyzer, Analyzer queryAnalyzer, int grams, byte separator)
         {
@@ -886,7 +885,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         }
 
         // NOTE: copied from WFSTCompletionLookup & tweaked
-        private long? LookupPrefix(FST<long?> fst, FST.BytesReader bytesReader, BytesRef scratch, FST.Arc<long?> arc) //Bogus
+        private long? LookupPrefix(FST<long?> fst, FST.BytesReader bytesReader, BytesRef scratch, FST.Arc<long?> arc)
         {
 
             long? output = fst.Outputs.NoOutput;


Mime
View raw message