lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [14/27] lucenenet git commit: Lucene.Net.Suggest: fix documentation comment formatting problems
Date Sun, 05 Feb 2017 16:51:49 GMT
Lucene.Net.Suggest: fix documentation comment formatting problems


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

Branch: refs/heads/api-work
Commit: bcc0d170fc8d49b963bfd1d6b7d007ab20d5a344
Parents: c95f6ab
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Sun Feb 5 13:56:49 2017 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Sun Feb 5 14:47:55 2017 +0700

----------------------------------------------------------------------
 .../Spell/DirectSpellChecker.cs                   | 18 +++++++++---------
 src/Lucene.Net.Suggest/Spell/SpellChecker.cs      | 14 +++++++-------
 .../Suggest/Analyzing/AnalyzingSuggester.cs       |  6 +++---
 .../Suggest/Analyzing/FreeTextSuggester.cs        |  4 ++--
 .../Suggest/Analyzing/FuzzySuggester.cs           | 12 ++++++------
 .../Suggest/DocumentDictionary.cs                 |  2 +-
 .../Suggest/Fst/FSTCompletion.cs                  | 16 ++++++++--------
 .../Suggest/Fst/FSTCompletionBuilder.cs           |  2 +-
 .../Suggest/Fst/FSTCompletionLookup.cs            |  2 +-
 .../Suggest/Fst/WFSTCompletionLookup.cs           |  2 +-
 .../Suggest/Jaspell/JaspellTernarySearchTrie.cs   | 17 ++++++-----------
 11 files changed, 45 insertions(+), 50 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/bcc0d170/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 433a502..e808424 100644
--- a/src/Lucene.Net.Suggest/Spell/DirectSpellChecker.cs
+++ b/src/Lucene.Net.Suggest/Spell/DirectSpellChecker.cs
@@ -180,12 +180,12 @@ namespace Lucene.Net.Search.Spell
 
         /// <summary>
         /// Gets or sets the minimal threshold of documents a term must appear for a match.
-        /// <p>
+        /// <para/>
         /// 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>
+        /// as <c>1</c> can be very useful towards improving quality.
+        /// <para/>
         /// 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.
@@ -209,7 +209,7 @@ namespace Lucene.Net.Search.Spell
 
         /// <summary>
         /// Gets or sets the minimum length of a query term (default: 4) needed to return
suggestions.
-        /// <p>
+        /// <para/>
         /// Very short query terms will often cause only bad suggestions with any distance
         /// metric.
         /// </summary>
@@ -229,11 +229,11 @@ namespace Lucene.Net.Search.Spell
         /// <summary>
         /// Gets or sets the maximum threshold (default: 0.01f) of documents a query term
can 
         /// appear in order to provide suggestions.
-        /// <p>
+        /// <para/>
         /// 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>
+        /// <para/>
         /// 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.
@@ -257,12 +257,12 @@ namespace Lucene.Net.Search.Spell
 
         /// <summary>
         /// True if the spellchecker should lowercase terms (default: true)
-        /// <p>
+        /// <para/>
         /// 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>
+        /// <para/>
         /// If this option is not on, case differences count as an edit!
         /// </summary>
         public virtual bool LowerCaseTerms
@@ -298,7 +298,7 @@ namespace Lucene.Net.Search.Spell
         /// <summary>
         /// Gets or sets the string distance metric.
         /// The default is <see cref="INTERNAL_LEVENSHTEIN"/>.
-        /// <p>
+        /// <para/>
         /// 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,

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/bcc0d170/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 76b02e6..801488d 100644
--- a/src/Lucene.Net.Suggest/Spell/SpellChecker.cs
+++ b/src/Lucene.Net.Suggest/Spell/SpellChecker.cs
@@ -226,7 +226,7 @@ namespace Lucene.Net.Search.Spell
         /// </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="System.IO.IOException"> if the underlying index throws
an <see cref="IOException"/> </exception>
+        /// <exception cref="System.IO.IOException"> if the underlying index throws
an <see cref="System.IO.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
@@ -253,7 +253,7 @@ namespace Lucene.Net.Search.Spell
         /// <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="System.IO.IOException"> if the underlying index throws
an <see cref="IOException"/> </exception>
+        /// <exception cref="System.IO.IOException"> if the underlying index throws
an <see cref="System.IO.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
@@ -295,8 +295,8 @@ 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="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>
+        /// <exception cref="System.IO.IOException"> if the underlying index throws
an <see cref="System.IO.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
@@ -475,7 +475,7 @@ namespace Lucene.Net.Search.Spell
         /// Check whether the word exists in the index. </summary>
         /// <param name="word"> word to check </param>
         /// <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>
+        /// <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)
         {
@@ -498,7 +498,7 @@ namespace Lucene.Net.Search.Spell
         /// <param name="dict"> Dictionary to index </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 <see cref="Spellchecker"/>
is already disposed </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>
         public void IndexDictionary(IDictionary dict, IndexWriterConfig config, bool fullMerge)
         {
@@ -674,7 +674,7 @@ namespace Lucene.Net.Search.Spell
 
         /// <summary>
         /// 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="System.IO.IOException"> if the close operation causes
an <see cref="System.IO.IOException"/> </exception>
         /// <exception cref="AlreadyClosedException"> if the <see cref="SpellChecker"/>
is already disposed </exception>
         public void Dispose()
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/bcc0d170/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 dd163ac..8eef805 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 
-    /// <paramref name="preservePositionIncrements"/> parameter set to 
+    /// <see cref="preservePositionIncrements"/> parameter set to 
     /// false
     /// 
     /// </para>
@@ -164,7 +164,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         private long count = 0;
 
         /// <summary>
-        /// Calls <see cref="AnalyzingSuggester(Analyzer,Analyzer,Options,int,int,bool)">
+        /// Calls <see cref="AnalyzingSuggester(Analyzer, Analyzer, SuggesterOptions,
int, int, bool)">
         /// AnalyzingSuggester(analyzer, analyzer, SuggesterOptions.EXACT_FIRST | SuggesterOptions.PRESERVE_SEP,
256, -1, true)
         /// </see>
         /// </summary>
@@ -174,7 +174,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         }
 
         /// <summary>
-        /// Calls <see cref="AnalyzingSuggester(Analyzer,Analyzer,Options,int,int,bool)">
+        /// Calls <see cref="AnalyzingSuggester(Analyzer,Analyzer,SuggesterOptions,int,int,bool)">
         /// AnalyzingSuggester(indexAnalyzer, queryAnalyzer, SuggesterOptions.EXACT_FIRST
| SuggesterOptions.PRESERVE_SEP, 256, -1, true)
         /// </see>
         /// </summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/bcc0d170/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 18242df..0a29651 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
@@ -66,7 +66,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
     /// point, cast to long).  Divide by <see cref="long.MaxValue"/> to get
     /// the score back, which ranges from 0.0 to 1.0.
     /// 
-    /// <paramref name="onlyMorePopular"/> is unused.
+    /// <c>onlyMorePopular</c> is unused.
     /// 
     /// @lucene.experimental
     /// </para>
@@ -166,7 +166,7 @@ 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 <see cref="ShingleFilter.TokenSeparator"/>
+        /// trigram ,etc.).  The <paramref name="separator"/> is passed to <see
cref="ShingleFilter.SetTokenSeparator(string)"/>
         /// to join multiple
         /// tokens into a single ngram token; it must be an ascii
         /// (7-bit-clean) byte.  No input tokens should have this

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/bcc0d170/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 dac0de3..5f202fb 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/FuzzySuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/FuzzySuggester.cs
@@ -29,12 +29,12 @@ namespace Lucene.Net.Search.Suggest.Analyzing
     /// 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 <c>false</c>
-    /// for the <paramref name="transpositions"/> parameter.
+    /// for the <see cref="transpositions"/> parameter.
     /// <para>
     /// 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 <see cref="TokenStream"/>'s <see cref="Analysis.Tokenattributes.ITermToBytesRefAttribute"/>,

+    /// 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
@@ -42,7 +42,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
     /// 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,
+    /// If <see cref="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. 
     /// 
@@ -71,8 +71,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         private readonly bool unicodeAware;
 
         /// <summary>
-        /// Measure <paramref name="maxEdits"/>, <paramref name="minFuzzyLength"/>,

-        /// <paramref name="transpositions"/>, and <paramref name="nonFuzzyPrefix"/>

+        /// Measure <see cref="maxEdits"/>, <see cref="minFuzzyLength"/>, 
+        /// <see cref="transpositions"/>, and <see cref="nonFuzzyPrefix"/> 
         /// parameters in Unicode code points (actual letters)
         /// instead of bytes.
         /// </summary>
@@ -110,7 +110,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         }
 
         /// <summary>
-        /// Creates a <see cref="FuzzySuggester"/> instance with an index & a query
analyzer initialized with default values.
+        /// Creates a <see cref="FuzzySuggester"/> instance with an index &amp;
a query analyzer initialized with default values.
         /// </summary>
         /// <param name="indexAnalyzer">
         ///           <see cref="Analyzer"/> that will be used for analyzing suggestions
while building the index. </param>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/bcc0d170/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 f70c0d2..1688ddc 100644
--- a/src/Lucene.Net.Suggest/Suggest/DocumentDictionary.cs
+++ b/src/Lucene.Net.Suggest/Suggest/DocumentDictionary.cs
@@ -87,7 +87,7 @@ namespace Lucene.Net.Search.Suggest
         /// 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.
+        /// for the entry and <paramref name="contextsField"/> for associated contexts.
         /// </summary>
         public DocumentDictionary(IndexReader reader, string field, string weightField, string
payloadField, string contextsField)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/bcc0d170/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 792b682..5c5edd6 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs
@@ -64,7 +64,7 @@ namespace Lucene.Net.Search.Suggest.Fst
                 return Utf8.Utf8ToString() + "/" + Bucket.ToString("0.0", CultureInfo.InvariantCulture);
             }
 
-            /// <seealso cref="BytesRef.CompareTo(BytesRef)"></seealso>
+            /// <seealso cref="BytesRef.CompareTo(object)"></seealso>
             public int CompareTo(Completion o)
             {
                 return this.Utf8.CompareTo(o.Utf8);
@@ -77,7 +77,7 @@ namespace Lucene.Net.Search.Suggest.Fst
         public const int DEFAULT_BUCKETS = 10;
 
         /// <summary>
-        /// An empty result. Keep this an <see cref="List"/> to keep all the returned
+        /// An empty result. Keep this an <see cref="List{T}"/> to keep all the returned
         /// lists of single type (monomorphic calls).
         /// </summary>
         private static readonly List<Completion> EMPTY_RESULT = new List<Completion>();
@@ -94,10 +94,10 @@ namespace Lucene.Net.Search.Suggest.Fst
         /// </summary>
         private readonly FST.Arc<object>[] rootArcs;
 
-        /// <seealso cref="FSTCompletion(FST, bool, bool)" />
+        /// <seealso cref="FSTCompletion(FST{object}, bool, bool)" />
         private readonly bool exactFirst;
 
-        /// <seealso cref="FSTCompletion(FST, bool, bool)" />
+        /// <seealso cref="FSTCompletion(FST{object}, bool, bool)" />
         private readonly bool higherWeightsFirst;
 
         // LUCENENET SPECIFIC: We need some thread safety to execute atomic list operations
@@ -107,7 +107,7 @@ namespace Lucene.Net.Search.Suggest.Fst
         /// Constructs an FSTCompletion, specifying higherWeightsFirst and exactFirst. </summary>
         /// <param name="automaton">
         ///          Automaton with completions. See <see cref="FSTCompletionBuilder"/>.
</param>
-        /// <param name="exactFirst">
+        /// <param name="higherWeightsFirst">
         ///          Return most popular suggestions first. This is the default
         ///          behavior for this implementation. Setting it to <c>false</c>
         ///          has no effect (use constant term weights to sort alphabetically
@@ -132,7 +132,7 @@ namespace Lucene.Net.Search.Suggest.Fst
 
         /// <summary>
         /// Defaults to higher weights first and exact first. </summary>
-        /// <seealso cref="FSTCompletion(FST, bool, bool)"/>
+        /// <seealso cref="FSTCompletion(FST{object}, bool, bool)"/>
         public FSTCompletion(FST<object> automaton)
             : this(automaton, true, true)
         {
@@ -339,7 +339,7 @@ namespace Lucene.Net.Search.Suggest.Fst
         /// position.
         /// </summary>
         /// <returns> 
-        /// Returns <c>true<c> if and only if <paramref name="list"/> contained
+        /// Returns <c>true</c> if and only if <paramref name="list"/>
contained
         /// <paramref name="key"/>.
         /// </returns>
         private bool CheckExistingAndReorder(IList<Completion> list, BytesRef key)
@@ -376,7 +376,7 @@ namespace Lucene.Net.Search.Suggest.Fst
         /// <param name="utf8">
         ///          The term to descend along. </param>
         /// <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
+        ///         matching last byte of <c>term</c>. <c>false</c>
is
         ///         returned if no such prefix exists. </returns>
         private bool DescendWithPrefix(FST.Arc<object> arc, BytesRef utf8)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/bcc0d170/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 6652b9d..7bac69c 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionBuilder.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionBuilder.cs
@@ -28,7 +28,7 @@ namespace Lucene.Net.Search.Suggest.Fst
     /// <h2>Implementation details</h2>
     /// 
     /// <para>
-    /// The construction step in <see cref="Finalize"/> works as follows:
+    /// The construction step in the object finalizer 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

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/bcc0d170/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 bc0da9d..7d30394 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionLookup.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionLookup.cs
@@ -60,7 +60,7 @@ namespace Lucene.Net.Search.Suggest.Fst
         /// An invalid bucket count if we're creating an object
         /// of this class from an existing FST.
         /// </summary>
-        /// <seealso cref="FSTCompletionLookup(FSTCompletion, bool)"/> </seealso>
+        /// <seealso cref="FSTCompletionLookup(FSTCompletion, bool)"/>
         private static int INVALID_BUCKETS_COUNT = -1;
 
         /// <summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/bcc0d170/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 fd4ac67..72e0bef 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
@@ -41,7 +41,7 @@ namespace Lucene.Net.Search.Suggest.Fst
     {
 
         /// <summary>
-        /// FST<Long>, weights are encoded as costs: (Integer.MAX_VALUE-weight)
+        /// FST{long?}, weights are encoded as costs: (int.MaxValue-weight)
         /// </summary>
         // NOTE: like FSTSuggester, this is really a WFSA, if you want to
         // customize the code to add some output you should use PairOutputs.

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/bcc0d170/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 4d4568e..29e5276 100644
--- a/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellTernarySearchTrie.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellTernarySearchTrie.cs
@@ -40,7 +40,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
     /// Implementation of a Ternary Search Trie, a data structure for storing
     /// <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>
+    /// practical use in sorting and searching data.
     /// <para>
     /// 
     /// This data structure is faster than hashing for many typical search problems,
@@ -87,6 +87,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
             /// <summary>
             /// Constructor method.
             /// </summary>
+            /// <param name="outerInstance">The containing <see cref="JaspellTernarySearchTrie"/></param>
             /// <param name="splitchar">
             ///          The char used in the split. </param>
             /// <param name="parent">
@@ -174,7 +175,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
 
         /// <summary>
         /// the number of differences allowed in a call to the <see cref="MatchAlmost"/>
-        /// <paramref cref="key"/>.
+        /// <c>key</c>.
         /// </summary>
         private int matchAlmostDiff;
 
@@ -497,12 +498,11 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         }
 
         /// <summary>
-        /// Retrieve the <see cref="System.Nullable{float}"/> indexed by key, increment
it by one unit
-        /// and store the new <see cref="System.Nullable{float}"/>.
+        /// Retrieve the <see cref="T:float?"/> indexed by key, increment it by one
unit
+        /// and store the new <see cref="T:float?"/>.
         /// </summary>
         /// <param name="key"> A <see cref="string"/> index. </param>
-        /// <param name="culture">The culture used for lowercasing.</param>
-        /// <returns> The <see cref="System.Nullable{float}"/> retrieved from
the Ternary Search Trie. </returns>
+        /// <returns> The <see cref="T:float?"/> retrieved from the Ternary Search
Trie. </returns>
         public virtual float? GetAndIncrement(string key)
         {
             string key2 = culture.TextInfo.ToLower(key.Trim());
@@ -906,9 +906,6 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         /// 
         /// </para>
         /// </summary>
-        /// <param name="diff">
-        ///          The number of characters by which words can differ from target
-        ///          word. </param>
         public virtual int MatchAlmostDiff
         {
             get // LUCENENET NOTE: Added property get per MSDN guidelines
@@ -942,8 +939,6 @@ namespace Lucene.Net.Search.Suggest.Jaspell
         /// case this value is temporarily overridden.
         /// </para>
         /// </summary>
-        /// <param name="num"> The number of values that will be returned when calling
the
-        ///          methods above. </param>
         public virtual int NumReturnValues
         {
             get // LUCENENET NOTE: Added property get per MSDN guidelines


Mime
View raw message