You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by sy...@apache.org on 2016/10/02 14:35:42 UTC
[24/50] [abbrv] lucenenet git commit: Updated Suggest documentation
links to code elements and made corrections.
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Analyzing/FuzzySuggester.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/FuzzySuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/FuzzySuggester.cs
index 3dd4b90..a01da75 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/FuzzySuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/FuzzySuggester.cs
@@ -26,24 +26,23 @@ namespace Lucene.Net.Search.Suggest.Analyzing
*/
/// <summary>
- /// Implements a fuzzy <seealso cref="AnalyzingSuggester"/>. The similarity measurement is
+ /// Implements a fuzzy <see cref="AnalyzingSuggester"/>. The similarity measurement is
/// based on the Damerau-Levenshtein (optimal string alignment) algorithm, though
- /// you can explicitly choose classic Levenshtein by passing <code>false</code>
- /// for the <code>transpositions</code> parameter.
+ /// you can explicitly choose classic Levenshtein by passing <c>false</c>
+ /// for the <paramref name="transpositions"/> parameter.
/// <para>
- /// At most, this query will match terms up to
- /// {@value org.apache.lucene.util.automaton.LevenshteinAutomata#MAXIMUM_SUPPORTED_DISTANCE}
+ /// At most, this query will match terms up to <see cref="LevenshteinAutomata.MAXIMUM_SUPPORTED_DISTANCE"/>
/// edits. Higher distances are not supported. Note that the
/// fuzzy distance is measured in "byte space" on the bytes
- /// returned by the <seealso cref="TokenStream"/>'s {@link
- /// TermToBytesRefAttribute}, usually UTF8. By default
- /// the analyzed bytes must be at least 3 {@link
- /// #DEFAULT_MIN_FUZZY_LENGTH} bytes before any edits are
- /// considered. Furthermore, the first 1 {@link
- /// #DEFAULT_NON_FUZZY_PREFIX} byte is not allowed to be
- /// edited. We allow up to 1 (@link
- /// #DEFAULT_MAX_EDITS} edit.
- /// If <seealso cref="#unicodeAware"/> parameter in the constructor is set to true, maxEdits,
+ /// returned by the <see cref="TokenStream"/>'s <see cref="Analysis.Tokenattributes.ITermToBytesRefAttribute"/>,
+ /// usually UTF8. By default
+ /// the analyzed bytes must be at least 3 <see cref="DEFAULT_MIN_FUZZY_LENGTH"/>
+ /// bytes before any edits are
+ /// considered. Furthermore, the first 1 <see cref="DEFAULT_NON_FUZZY_PREFIX"/>
+ /// byte is not allowed to be
+ /// edited. We allow up to 1 <see cref="DEFAULT_MAX_EDITS"/>
+ /// edit.
+ /// If <paramref name="unicodeAware"/> parameter in the constructor is set to true, maxEdits,
/// minFuzzyLength, transpositions and nonFuzzyPrefix are measured in Unicode code
/// points (actual letters) instead of bytes.
///
@@ -72,15 +71,16 @@ namespace Lucene.Net.Search.Suggest.Analyzing
private readonly bool unicodeAware;
/// <summary>
- /// Measure maxEdits, minFuzzyLength, transpositions and nonFuzzyPrefix
- /// parameters in Unicode code points (actual letters)
- /// instead of bytes.
+ /// Measure <paramref name="maxEdits"/>, <paramref name="minFuzzyLength"/>,
+ /// <paramref name="transpositions"/>, and <paramref name="nonFuzzyPrefix"/>
+ /// parameters in Unicode code points (actual letters)
+ /// instead of bytes.
/// </summary>
public const bool DEFAULT_UNICODE_AWARE = false;
/// <summary>
- /// The default minimum length of the key passed to {@link
- /// #lookup} before any edits are allowed.
+ /// The default minimum length of the key passed to <see cref="Lookup"/>
+ /// before any edits are allowed.
/// </summary>
public const int DEFAULT_MIN_FUZZY_LENGTH = 3;
@@ -96,39 +96,39 @@ namespace Lucene.Net.Search.Suggest.Analyzing
public const int DEFAULT_MAX_EDITS = 1;
/// <summary>
- /// The default transposition value passed to <seealso cref="LevenshteinAutomata"/>
+ /// The default transposition value passed to <see cref="LevenshteinAutomata"/>
/// </summary>
public const bool DEFAULT_TRANSPOSITIONS = true;
/// <summary>
- /// Creates a <seealso cref="FuzzySuggester"/> instance initialized with default values.
+ /// Creates a <see cref="FuzzySuggester"/> instance initialized with default values.
/// </summary>
- /// <param name="analyzer"> the analyzer used for this suggester </param>
+ /// <param name="analyzer"> The <see cref="Analyzer"/> used for this suggester. </param>
public FuzzySuggester(Analyzer analyzer)
: this(analyzer, analyzer)
{
}
/// <summary>
- /// Creates a <seealso cref="FuzzySuggester"/> instance with an index & a query analyzer initialized with default values.
+ /// Creates a <see cref="FuzzySuggester"/> instance with an index & a query analyzer initialized with default values.
/// </summary>
/// <param name="indexAnalyzer">
- /// Analyzer that will be used for analyzing suggestions while building the index. </param>
+ /// <see cref="Analyzer"/> that will be used for analyzing suggestions while building the index. </param>
/// <param name="queryAnalyzer">
- /// Analyzer that will be used for analyzing query text during lookup </param>
+ /// <see cref="Analyzer"/> that will be used for analyzing query text during lookup </param>
public FuzzySuggester(Analyzer indexAnalyzer, Analyzer queryAnalyzer)
: this(indexAnalyzer, queryAnalyzer, EXACT_FIRST | PRESERVE_SEP, 256, -1, true, DEFAULT_MAX_EDITS, DEFAULT_TRANSPOSITIONS, DEFAULT_NON_FUZZY_PREFIX, DEFAULT_MIN_FUZZY_LENGTH, DEFAULT_UNICODE_AWARE)
{
}
/// <summary>
- /// Creates a <seealso cref="FuzzySuggester"/> instance.
+ /// Creates a <see cref="FuzzySuggester"/> instance.
/// </summary>
- /// <param name="indexAnalyzer"> Analyzer that will be used for
+ /// <param name="indexAnalyzer"> The <see cref="Analyzer"/> that will be used for
/// analyzing suggestions while building the index. </param>
- /// <param name="queryAnalyzer"> Analyzer that will be used for
+ /// <param name="queryAnalyzer"> The <see cref="Analyzer"/> that will be used for
/// analyzing query text during lookup </param>
- /// <param name="options"> see <seealso cref="#EXACT_FIRST"/>, <seealso cref="#PRESERVE_SEP"/> </param>
+ /// <param name="options"> see <see cref="EXACT_FIRST"/>, <see cref="PRESERVE_SEP"/> </param>
/// <param name="maxSurfaceFormsPerAnalyzedForm"> Maximum number of
/// surface forms to keep for a single analyzed form.
/// When there are too many surface forms we discard the
@@ -137,12 +137,12 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// to expand from the analyzed form. Set this to -1 for
/// no limit. </param>
/// <param name="preservePositionIncrements"> Whether position holes should appear in the automaton </param>
- /// <param name="maxEdits"> must be >= 0 and <= <seealso cref="LevenshteinAutomata#MAXIMUM_SUPPORTED_DISTANCE"/> . </param>
- /// <param name="transpositions"> <code>true</code> if transpositions should be treated as a primitive
+ /// <param name="maxEdits"> must be >= 0 and <= <see cref="LevenshteinAutomata.MAXIMUM_SUPPORTED_DISTANCE"/>. </param>
+ /// <param name="transpositions"> <c>true</c> if transpositions should be treated as a primitive
/// edit operation. If this is false, comparisons will implement the classic
/// Levenshtein algorithm. </param>
- /// <param name="nonFuzzyPrefix"> length of common (non-fuzzy) prefix (see default <seealso cref="#DEFAULT_NON_FUZZY_PREFIX"/> </param>
- /// <param name="minFuzzyLength"> minimum length of lookup key before any edits are allowed (see default <seealso cref="#DEFAULT_MIN_FUZZY_LENGTH"/>) </param>
+ /// <param name="nonFuzzyPrefix"> length of common (non-fuzzy) prefix (see default <see cref="DEFAULT_NON_FUZZY_PREFIX"/> </param>
+ /// <param name="minFuzzyLength"> minimum length of lookup key before any edits are allowed (see default <see cref="DEFAULT_MIN_FUZZY_LENGTH"/>) </param>
/// <param name="unicodeAware"> operate Unicode code points instead of bytes. </param>
public FuzzySuggester(Analyzer indexAnalyzer, Analyzer queryAnalyzer, int options, int maxSurfaceFormsPerAnalyzedForm, int maxGraphExpansions, bool preservePositionIncrements, int maxEdits, bool transpositions, int nonFuzzyPrefix, int minFuzzyLength, bool unicodeAware)
: base(indexAnalyzer, queryAnalyzer, options, maxSurfaceFormsPerAnalyzedForm, maxGraphExpansions, preservePositionIncrements)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs
index 6e8c08b..59d7836 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs
@@ -23,17 +23,18 @@ namespace Lucene.Net.Search.Suggest.Analyzing
*/
/// <summary>
- /// Like <seealso cref="StopFilter"/> except it will not remove the
- /// last token if that token was not followed by some token
- /// separator. For example, a query 'find the' would
- /// preserve the 'the' since it was not followed by a space or
- /// punctuation or something, and mark it KEYWORD so future
- /// stemmers won't touch it either while a query like "find
- /// the popsicle' would remove 'the' as a stopword.
+ /// Like <see cref="Analysis.Core.StopFilter"/> except it will not remove the
+ /// last token if that token was not followed by some token
+ /// separator. For example, a query 'find the' would
+ /// preserve the 'the' since it was not followed by a space or
+ /// punctuation or something, and mark it KEYWORD so future
+ /// stemmers won't touch it either while a query like "find
+ /// the popsicle' would remove 'the' as a stopword.
///
- /// <para>Normally you'd use the ordinary <seealso cref="StopFilter"/>
- /// in your indexAnalyzer and then this class in your
- /// queryAnalyzer, when using one of the analyzing suggesters.
+ /// <para>
+ /// Normally you'd use the ordinary <see cref="Analysis.Core.StopFilter"/>
+ /// in your indexAnalyzer and then this class in your
+ /// queryAnalyzer, when using one of the analyzing suggesters.
/// </para>
/// </summary>
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/BufferedInputIterator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/BufferedInputIterator.cs b/src/Lucene.Net.Suggest/Suggest/BufferedInputIterator.cs
index 7518591..71590d8 100644
--- a/src/Lucene.Net.Suggest/Suggest/BufferedInputIterator.cs
+++ b/src/Lucene.Net.Suggest/Suggest/BufferedInputIterator.cs
@@ -40,7 +40,7 @@ namespace Lucene.Net.Search.Suggest
/// current buffer position </summary>
protected internal int curPos = -1;
/// <summary>
- /// buffered weights, parallel with <seealso cref="#entries"/> </summary>
+ /// buffered weights, parallel with <see cref="entries"/> </summary>
protected internal long[] freqs = new long[1];
private readonly BytesRef spare = new BytesRef();
private readonly BytesRef payloadSpare = new BytesRef();
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/BufferingTermFreqIteratorWrapper.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/BufferingTermFreqIteratorWrapper.cs b/src/Lucene.Net.Suggest/Suggest/BufferingTermFreqIteratorWrapper.cs
index deaeca4..fa929be 100644
--- a/src/Lucene.Net.Suggest/Suggest/BufferingTermFreqIteratorWrapper.cs
+++ b/src/Lucene.Net.Suggest/Suggest/BufferingTermFreqIteratorWrapper.cs
@@ -35,7 +35,7 @@ namespace Lucene.Net.Search.Suggest
/// current buffer position </summary>
protected internal int curPos = -1;
/// <summary>
- /// buffered weights, parallel with <seealso cref="#entries"/> </summary>
+ /// buffered weights, parallel with <see cref="entries"/> </summary>
protected internal long[] freqs = new long[1];
private readonly BytesRef spare = new BytesRef();
private readonly IComparer<BytesRef> comp;
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/DocumentDictionary.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/DocumentDictionary.cs b/src/Lucene.Net.Suggest/Suggest/DocumentDictionary.cs
index ee7ddc4..ff7bc3d 100644
--- a/src/Lucene.Net.Suggest/Suggest/DocumentDictionary.cs
+++ b/src/Lucene.Net.Suggest/Suggest/DocumentDictionary.cs
@@ -30,27 +30,27 @@ namespace Lucene.Net.Search.Suggest
/// information taken from stored/indexed fields in a Lucene index.
/// </para>
/// <b>NOTE:</b>
- /// <ul>
- /// <li>
+ /// <list type="bullet">
+ /// <item>
/// The term and (optionally) payload fields have to be
/// stored
- /// </li>
- /// <li>
- /// The weight field can be stored or can be a <seealso cref="NumericDocValues"/>.
- /// If the weight field is not defined, the value of the weight is <code>0</code>
- /// </li>
- /// <li>
+ /// </item>
+ /// <item>
+ /// The weight field can be stored or can be a <see cref="NumericDocValues"/>.
+ /// If the weight field is not defined, the value of the weight is <c>0</c>
+ /// </item>
+ /// <item>
/// if any of the term or (optionally) payload fields supplied
/// do not have a value for a document, then the document is
/// skipped by the dictionary
- /// </li>
- /// </ul>
+ /// </item>
+ /// </list>
/// </summary>
public class DocumentDictionary : IDictionary
{
/// <summary>
- /// <seealso cref="IndexReader"/> to load documents from </summary>
+ /// <see cref="IndexReader"/> to load documents from </summary>
protected internal readonly IndexReader reader;
/// <summary>
@@ -63,8 +63,8 @@ namespace Lucene.Net.Search.Suggest
private readonly string weightField;
/// <summary>
- /// Creates a new dictionary with the contents of the fields named <code>field</code>
- /// for the terms and <code>weightField</code> for the weights that will be used for
+ /// Creates a new dictionary with the contents of the fields named <paramref name="field"/>
+ /// for the terms and <paramref name="weightField"/> for the weights that will be used for
/// the corresponding terms.
/// </summary>
public DocumentDictionary(IndexReader reader, string field, string weightField)
@@ -73,9 +73,9 @@ namespace Lucene.Net.Search.Suggest
}
/// <summary>
- /// Creates a new dictionary with the contents of the fields named <code>field</code>
- /// for the terms, <code>weightField</code> for the weights that will be used for the
- /// the corresponding terms and <code>payloadField</code> for the corresponding payloads
+ /// Creates a new dictionary with the contents of the fields named <paramref name="field"/>
+ /// for the terms, <paramref name="weightField"/> for the weights that will be used for the
+ /// the corresponding terms and <paramref name="payloadField"/> for the corresponding payloads
/// for the entry.
/// </summary>
public DocumentDictionary(IndexReader reader, string field, string weightField, string payloadField)
@@ -84,10 +84,10 @@ namespace Lucene.Net.Search.Suggest
}
/// <summary>
- /// Creates a new dictionary with the contents of the fields named <code>field</code>
- /// for the terms, <code>weightField</code> for the weights that will be used for the
- /// the corresponding terms, <code>payloadField</code> for the corresponding payloads
- /// for the entry and <code>contextsFeild</code> for associated contexts.
+ /// Creates a new dictionary with the contents of the fields named <paramref name="field"/>
+ /// for the terms, <paramref name="weightField"/> for the weights that will be used for the
+ /// the corresponding terms, <paramref name="payloadField"/> for the corresponding payloads
+ /// for the entry and <paramref name="contextsFeild"/> for associated contexts.
/// </summary>
public DocumentDictionary(IndexReader reader, string field, string weightField, string payloadField, string contextsField)
{
@@ -107,7 +107,7 @@ namespace Lucene.Net.Search.Suggest
}
/// <summary>
- /// Implements <seealso cref="InputIterator"/> from stored fields. </summary>
+ /// Implements <see cref="IInputIterator"/> from stored fields. </summary>
protected internal class DocumentInputIterator : IInputIterator
{
private readonly DocumentDictionary outerInstance;
@@ -127,7 +127,7 @@ namespace Lucene.Net.Search.Suggest
/// <summary>
/// Creates an iterator over term, weight and payload fields from the lucene
- /// index. setting <code>withPayload</code> to false, implies an iterator
+ /// index. setting <see cref="HasPayloads"/> to false, implies an iterator
/// over only term and weight.
/// </summary>
public DocumentInputIterator(DocumentDictionary outerInstance, bool hasPayloads, bool hasContexts)
@@ -223,9 +223,9 @@ namespace Lucene.Net.Search.Suggest
}
/// <summary>
- /// Returns the value of the <code>weightField</code> for the current document.
- /// Retrieves the value for the <code>weightField</code> if its stored (using <code>doc</code>)
- /// or if its indexed as <seealso cref="NumericDocValues"/> (using <code>docId</code>) for the document.
+ /// Returns the value of the <see cref="Weight"/> property for the current document.
+ /// Retrieves the value for the <see cref="Weight"/> property if its stored (using <paramref name="doc"/>)
+ /// or if its indexed as <see cref="NumericDocValues"/> (using <paramref name="docId"/>) for the document.
/// If no value is found, then the weight is 0.
/// </summary>
protected internal virtual long GetWeight(Document doc, int docId)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/DocumentValueSourceDictionary.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/DocumentValueSourceDictionary.cs b/src/Lucene.Net.Suggest/Suggest/DocumentValueSourceDictionary.cs
index 0c0165e..b8252ec 100644
--- a/src/Lucene.Net.Suggest/Suggest/DocumentValueSourceDictionary.cs
+++ b/src/Lucene.Net.Suggest/Suggest/DocumentValueSourceDictionary.cs
@@ -28,32 +28,32 @@ namespace Lucene.Net.Search.Suggest
/// <para>
/// Dictionary with terms and optionally payload information
/// taken from stored fields in a Lucene index. Similar to
- /// <seealso cref="DocumentDictionary"/>, except it obtains the weight
- /// of the terms in a document based on a <seealso cref="ValueSource"/>.
+ /// <see cref="DocumentDictionary"/>, except it obtains the weight
+ /// of the terms in a document based on a <see cref="ValueSource"/>.
/// </para>
/// <b>NOTE:</b>
- /// <ul>
- /// <li>
+ /// <list type="bullet">
+ /// <item>
/// The term and (optionally) payload fields have to be
/// stored
- /// </li>
- /// <li>
+ /// </item>
+ /// <item>
/// if the term or (optionally) payload fields supplied
/// do not have a value for a document, then the document is
/// rejected by the dictionary
- /// </li>
- /// </ul>
+ /// </item>
+ /// </list>
/// <para>
- /// In practice the <seealso cref="ValueSource"/> will likely be obtained
+ /// In practice the <see cref="ValueSource"/> will likely be obtained
/// using the lucene expression module. The following example shows
- /// how to create a <seealso cref="ValueSource"/> from a simple addition of two
+ /// how to create a <see cref="ValueSource"/> from a simple addition of two
/// fields:
/// <code>
- /// Expression expression = JavascriptCompiler.compile("f1 + f2");
+ /// Expression expression = JavascriptCompiler.Compile("f1 + f2");
/// SimpleBindings bindings = new SimpleBindings();
- /// bindings.add(new SortField("f1", SortField.Type.LONG));
- /// bindings.add(new SortField("f2", SortField.Type.LONG));
- /// ValueSource valueSource = expression.getValueSource(bindings);
+ /// bindings.Add(new SortField("f1", SortField.Type_e.LONG));
+ /// bindings.Add(new SortField("f2", SortField.Type_e.LONG));
+ /// ValueSource valueSource = expression.GetValueSource(bindings);
/// </code>
/// </para>
///
@@ -64,9 +64,9 @@ namespace Lucene.Net.Search.Suggest
private readonly ValueSource weightsValueSource;
/// <summary>
- /// Creates a new dictionary with the contents of the fields named <code>field</code>
- /// for the terms, <code>payload</code> for the corresponding payloads, <code>contexts</code>
- /// for the associated contexts and uses the <code>weightsValueSource</code> supplied
+ /// Creates a new dictionary with the contents of the fields named <paramref name="field"/>
+ /// for the terms, <paramref name="payload"/> for the corresponding payloads, <paramref name="contexts"/>
+ /// for the associated contexts and uses the <paramref name="weightsValueSource"/> supplied
/// to determine the score.
/// </summary>
public DocumentValueSourceDictionary(IndexReader reader, string field, ValueSource weightsValueSource, string payload, string contexts)
@@ -75,9 +75,9 @@ namespace Lucene.Net.Search.Suggest
this.weightsValueSource = weightsValueSource;
}
/// <summary>
- /// Creates a new dictionary with the contents of the fields named <code>field</code>
- /// for the terms, <code>payloadField</code> for the corresponding payloads
- /// and uses the <code>weightsValueSource</code> supplied to determine the
+ /// Creates a new dictionary with the contents of the fields named <paramref name="field"/>
+ /// for the terms, <paramref name="payload"/> for the corresponding payloads
+ /// and uses the <paramref name="weightsValueSource"/> supplied to determine the
/// score.
/// </summary>
public DocumentValueSourceDictionary(IndexReader reader, string field, ValueSource weightsValueSource, string payload)
@@ -87,8 +87,8 @@ namespace Lucene.Net.Search.Suggest
}
/// <summary>
- /// Creates a new dictionary with the contents of the fields named <code>field</code>
- /// for the terms and uses the <code>weightsValueSource</code> supplied to determine the
+ /// Creates a new dictionary with the contents of the fields named <paramref name="field"/>
+ /// for the terms and uses the <paramref name="weightsValueSource"/> supplied to determine the
/// score.
/// </summary>
public DocumentValueSourceDictionary(IndexReader reader, string field, ValueSource weightsValueSource)
@@ -136,9 +136,8 @@ namespace Lucene.Net.Search.Suggest
}
/// <summary>
- /// Returns the weight for the current <code>docId</code> as computed
- /// by the <code>weightsValueSource</code>
- ///
+ /// Returns the weight for the current <paramref name="docId"/> as computed
+ /// by the <see cref="weightsValueSource"/>
/// </summary>
protected internal override long GetWeight(Document doc, int docId)
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/FileDictionary.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/FileDictionary.cs b/src/Lucene.Net.Suggest/Suggest/FileDictionary.cs
index a43cb37..9db60c8 100644
--- a/src/Lucene.Net.Suggest/Suggest/FileDictionary.cs
+++ b/src/Lucene.Net.Suggest/Suggest/FileDictionary.cs
@@ -27,29 +27,29 @@ namespace Lucene.Net.Search.Suggest
/// <summary>
/// Dictionary represented by a text file.
///
- /// <p/>Format allowed: 1 entry per line:<br/>
- /// An entry can be: <br/>
- /// <ul>
- /// <li>suggestion</li>
- /// <li>suggestion <code>fieldDelimiter</code> weight</li>
- /// <li>suggestion <code>fieldDelimiter</code> weight <code>fieldDelimiter</code> payload</li>
- /// </ul>
- /// where the default <code>fieldDelimiter</code> is {@value #DEFAULT_FIELD_DELIMITER}<br/>
- /// <p/>
+ /// <para>Format allowed: 1 entry per line:</para>
+ /// <para>An entry can be: </para>
+ /// <list type="number">
+ /// <item>suggestion</item>
+ /// <item>suggestion <see cref="fieldDelimiter"/> weight</item>
+ /// <item>suggestion <see cref="fieldDelimiter"/> weight <see cref="fieldDelimiter"/> payload</item>
+ /// </list>
+ /// where the default <see cref="fieldDelimiter"/> is <see cref="DEFAULT_FIELD_DELIMITER"/> (a tab)
+ /// <para>
/// <b>NOTE:</b>
- /// <ul>
- /// <li>In order to have payload enabled, the first entry has to have a payload</li>
- /// <li>If the weight for an entry is not specified then a value of 1 is used</li>
- /// <li>A payload cannot be specified without having the weight specified for an entry</li>
- /// <li>If the payload for an entry is not specified (assuming payload is enabled)
- /// then an empty payload is returned</li>
- /// <li>An entry cannot have more than two <code>fieldDelimiter</code></li>
- /// </ul>
- /// <p/>
- /// <b>Example:</b><br/>
- /// word1 word2 TAB 100 TAB payload1<br/>
- /// word3 TAB 101<br/>
- /// word4 word3 TAB 102<br/>
+ /// <list type="number">
+ /// <item>In order to have payload enabled, the first entry has to have a payload</item>
+ /// <item>If the weight for an entry is not specified then a value of 1 is used</item>
+ /// <item>A payload cannot be specified without having the weight specified for an entry</item>
+ /// <item>If the payload for an entry is not specified (assuming payload is enabled)
+ /// then an empty payload is returned</item>
+ /// <item>An entry cannot have more than two <see cref="fieldDelimiter"/>s</item>
+ /// </list>
+ /// </para>
+ /// <c>Example:</c><para/>
+ /// word1 word2 TAB 100 TAB payload1<para/>
+ /// word3 TAB 101<para/>
+ /// word4 word3 TAB 102<para/>
/// </summary>
public class FileDictionary : IDictionary
{
@@ -65,7 +65,7 @@ namespace Lucene.Net.Search.Suggest
/// <summary>
/// Creates a dictionary based on an inputstream.
- /// Using <seealso cref="#DEFAULT_FIELD_DELIMITER"/> as the
+ /// Using <see cref="DEFAULT_FIELD_DELIMITER"/> as the
/// field seperator in a line.
/// <para>
/// NOTE: content is treated as UTF-8
@@ -78,7 +78,7 @@ namespace Lucene.Net.Search.Suggest
/// <summary>
/// Creates a dictionary based on a reader.
- /// Using <seealso cref="#DEFAULT_FIELD_DELIMITER"/> as the
+ /// Using <see cref="DEFAULT_FIELD_DELIMITER"/> as the
/// field seperator in a line.
/// </summary>
public FileDictionary(TextReader reader)
@@ -88,7 +88,7 @@ namespace Lucene.Net.Search.Suggest
/// <summary>
/// Creates a dictionary based on a reader.
- /// Using <code>fieldDelimiter</code> to seperate out the
+ /// Using <paramref name="fieldDelimiter"/> to seperate out the
/// fields in a line.
/// </summary>
public FileDictionary(TextReader reader, string fieldDelimiter)
@@ -99,7 +99,7 @@ namespace Lucene.Net.Search.Suggest
/// <summary>
/// Creates a dictionary based on an inputstream.
- /// Using <code>fieldDelimiter</code> to seperate out the
+ /// Using <paramref name="fieldDelimiter"/> to seperate out the
/// fields in a line.
/// <para>
/// NOTE: content is treated as UTF-8
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Fst/BytesRefSorter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Fst/BytesRefSorter.cs b/src/Lucene.Net.Suggest/Suggest/Fst/BytesRefSorter.cs
index dbf4361..2d7c952 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/BytesRefSorter.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/BytesRefSorter.cs
@@ -21,7 +21,7 @@ namespace Lucene.Net.Search.Suggest.Fst
*/
/// <summary>
- /// Collects <seealso cref="BytesRef"/> and then allows one to iterate over their sorted order. Implementations
+ /// Collects <see cref="BytesRef"/> and then allows one to iterate over their sorted order. Implementations
/// of this interface will be called in a single-threaded scenario.
/// </summary>
public interface IBytesRefSorter
@@ -29,16 +29,16 @@ namespace Lucene.Net.Search.Suggest.Fst
/// <summary>
/// Adds a single suggestion entry (possibly compound with its bucket).
/// </summary>
- /// <exception cref="IOException"> If an I/O exception occurs. </exception>
- /// <exception cref="InvalidOperationException"> If an addition attempt is performed after
- /// a call to <seealso cref="#iterator()"/> has been made. </exception>
+ /// <exception cref="System.IO.IOException"> If an I/O exception occurs. </exception>
+ /// <exception cref="System.InvalidOperationException"> If an addition attempt is performed after
+ /// a call to <see cref="GetEnumerator"/> has been made. </exception>
void Add(BytesRef utf8);
/// <summary>
- /// Sorts the entries added in <seealso cref="#add(BytesRef)"/> and returns
- /// an iterator over all sorted entries.
+ /// Sorts the entries added in <see cref="Add(BytesRef)"/> and returns
+ /// an enumerator over all sorted entries.
/// </summary>
- /// <exception cref="IOException"> If an I/O exception occurs. </exception>
+ /// <exception cref="System.IO.IOException"> If an I/O exception occurs. </exception>
BytesRefIterator GetEnumerator();
/// <summary>
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs
index 954a7cc..aba5fdd 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs
@@ -30,8 +30,8 @@ namespace Lucene.Net.Search.Suggest.Fst
/// <summary>
/// Finite state automata based implementation of "autocomplete" functionality.
/// </summary>
- /// <seealso cref=FSTCompletionBuilder
- /// @lucene.experimental </seealso>
+ /// <seealso cref="FSTCompletionBuilder"/>
+ /// @lucene.experimental
// TODO: we could store exact weights as outputs from the FST (int4 encoded
// floats). This would provide exact outputs from this method and to some
@@ -77,7 +77,7 @@ namespace Lucene.Net.Search.Suggest.Fst
public const int DEFAULT_BUCKETS = 10;
/// <summary>
- /// An empty result. Keep this an <seealso cref="ArrayList"/> to keep all the returned
+ /// An empty result. Keep this an <see cref="List"/> to keep all the returned
/// lists of single type (monomorphic calls).
/// </summary>
private static readonly IList<Completion> EMPTY_RESULT = new List<Completion>();
@@ -106,10 +106,10 @@ namespace Lucene.Net.Search.Suggest.Fst
/// <summary>
/// Constructs an FSTCompletion, specifying higherWeightsFirst and exactFirst. </summary>
/// <param name="automaton">
- /// Automaton with completions. See <seealso cref="FSTCompletionBuilder"/>. </param>
+ /// Automaton with completions. See <see cref="FSTCompletionBuilder"/>. </param>
/// <param name="exactFirst">
/// Return most popular suggestions first. This is the default
- /// behavior for this implementation. Setting it to <code>false</code>
+ /// behavior for this implementation. Setting it to <c>false</c>
/// has no effect (use constant term weights to sort alphabetically
/// only). </param>
/// <param name="exactFirst">
@@ -132,7 +132,7 @@ namespace Lucene.Net.Search.Suggest.Fst
/// <summary>
/// Defaults to higher weights first and exact first. </summary>
- /// <seealso cref= #FSTCompletion(FST, boolean, boolean) </seealso>
+ /// <seealso cref="FSTCompletion(FST, bool, bool)"/>
public FSTCompletion(FST<object> automaton)
: this(automaton, true, true)
{
@@ -171,10 +171,10 @@ namespace Lucene.Net.Search.Suggest.Fst
/// <summary>
/// Returns the first exact match by traversing root arcs, starting from the
- /// arc <code>rootArcIndex</code>.
+ /// arc <paramref name="rootArcIndex"/>.
/// </summary>
/// <param name="rootArcIndex">
- /// The first root arc index in <seealso cref="#rootArcs"/> to consider when
+ /// The first root arc index in <see cref="rootArcs"/> to consider when
/// matching.
/// </param>
/// <param name="utf8">
@@ -217,7 +217,7 @@ namespace Lucene.Net.Search.Suggest.Fst
}
/// <summary>
- /// Lookup suggestions to <code>key</code>.
+ /// Lookup suggestions to <paramref name="key"/>.
/// </summary>
/// <param name="key">
/// The prefix to which suggestions should be sought. </param>
@@ -257,8 +257,8 @@ namespace Lucene.Net.Search.Suggest.Fst
}
/// <summary>
- /// Lookup suggestions sorted alphabetically <b>if weights are not
- /// constant</b>. This is a workaround: in general, use constant weights for
+ /// Lookup suggestions sorted alphabetically <c>if weights are not
+ /// constant</c>. This is a workaround: in general, use constant weights for
/// alphabetically sorted result.
/// </summary>
private IList<Completion> LookupSortedAlphabetically(BytesRef key, int num)
@@ -270,7 +270,6 @@ namespace Lucene.Net.Search.Suggest.Fst
res.Sort();
if (res.Count > num)
{
- //res = res.SubList(0, num);
res = new List<Completion>(res.SubList(0, num));
}
return res;
@@ -280,10 +279,10 @@ namespace Lucene.Net.Search.Suggest.Fst
/// Lookup suggestions sorted by weight (descending order).
/// </summary>
/// <param name="collectAll">
- /// If <code>true</code>, the routine terminates immediately when
- /// <code>num</code> suggestions have been collected. If
- /// <code>false</code>, it will collect suggestions from all weight
- /// arcs (needed for <seealso cref="#lookupSortedAlphabetically"/>. </param>
+ /// If <c>true</c>, the routine terminates immediately when
+ /// <paramref name="num"/> suggestions have been collected. If
+ /// <c>false</c>, it will collect suggestions from all weight
+ /// arcs (needed for <see cref="LookupSortedAlphabetically"/>. </param>
private IList<Completion> LookupSortedByWeight(BytesRef key, int num, bool collectAll)
{
// Don't overallocate the results buffers. This also serves the purpose of
@@ -334,13 +333,15 @@ namespace Lucene.Net.Search.Suggest.Fst
/// <summary>
/// Checks if the list of
- /// <seealso cref="Suggest.Lookup.LookupResult"/>s already has a
- /// <code>key</code>. If so, reorders that
- /// <seealso cref="Suggest.Lookup.LookupResult"/> to the first
+ /// <see cref="Lookup.LookupResult"/>s already has a
+ /// <paramref name="key"/>. If so, reorders that
+ /// <see cref="Lookup.LookupResult"/> to the first
/// position.
/// </summary>
- /// <returns> Returns <code>true<code> if and only if <code>list</code> contained
- /// <code>key</code>. </returns>
+ /// <returns>
+ /// Returns <c>true<c> if and only if <paramref name="list"/> contained
+ /// <paramref name="key"/>.
+ /// </returns>
private bool CheckExistingAndReorder(List<Completion> list, BytesRef key)
{
// We assume list does not have duplicates (because of how the FST is created).
@@ -367,15 +368,15 @@ namespace Lucene.Net.Search.Suggest.Fst
}
/// <summary>
- /// Descend along the path starting at <code>arc</code> and going through bytes
+ /// Descend along the path starting at <paramref name="arc"/> and going through bytes
/// in the argument.
/// </summary>
/// <param name="arc">
/// The starting arc. This argument is modified in-place. </param>
/// <param name="utf8">
/// The term to descend along. </param>
- /// <returns> If <code>true</code>, <code>arc</code> will be set to the arc
- /// matching last byte of <code>term</code>. <code>false</code> is
+ /// <returns> If <c>true</c>, <paramref name="arc"/> will be set to the arc
+ /// matching last byte of <paramref name="term"/>. <c>false</c> is
/// returned if no such prefix exists. </returns>
private bool DescendWithPrefix(FST.Arc<object> arc, BytesRef utf8)
{
@@ -396,7 +397,7 @@ namespace Lucene.Net.Search.Suggest.Fst
/// <summary>
/// Recursive collect lookup results from the automaton subgraph starting at
- /// <code>arc</code>.
+ /// <paramref name="arc"/>.
/// </summary>
/// <param name="num">
/// Maximum number of results needed (early termination). </param>
@@ -451,7 +452,7 @@ namespace Lucene.Net.Search.Suggest.Fst
}
/// <summary>
- /// Returns the bucket assigned to a given key (if found) or <code>-1</code> if
+ /// Returns the bucket assigned to a given key (if found) or <c>-1</c> if
/// no exact match exists.
/// </summary>
public virtual int GetBucket(string key)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionBuilder.cs b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionBuilder.cs
index ea39004..aeb3f22 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionBuilder.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionBuilder.cs
@@ -28,41 +28,41 @@ namespace Lucene.Net.Search.Suggest.Fst
/// <h2>Implementation details</h2>
///
/// <para>
- /// The construction step in <seealso cref="#finalize()"/> works as follows:
- /// <ul>
- /// <li>A set of input terms and their buckets is given.</li>
- /// <li>All terms in the input are prefixed with a synthetic pseudo-character
+ /// The construction step in <see cref="Finalize"/> works as follows:
+ /// <list type="bullet">
+ /// <item>A set of input terms and their buckets is given.</item>
+ /// <item>All terms in the input are prefixed with a synthetic pseudo-character
/// (code) of the weight bucket the term fell into. For example a term
- /// <code>abc</code> with a discretized weight equal '1' would become
- /// <code>1abc</code>.</li>
- /// <li>The terms are then sorted by their raw value of UTF-8 character values
- /// (including the synthetic bucket code in front).</li>
- /// <li>A finite state automaton (<seealso cref="FST"/>) is constructed from the input. The
+ /// <c>abc</c> with a discretized weight equal '1' would become
+ /// <c>1abc</c>.</item>
+ /// <item>The terms are then sorted by their raw value of UTF-8 character values
+ /// (including the synthetic bucket code in front).</item>
+ /// <item>A finite state automaton (<see cref="FST"/>) is constructed from the input. The
/// root node has arcs labeled with all possible weights. We cache all these
- /// arcs, highest-weight first.</li>
- /// </ul>
+ /// arcs, highest-weight first.</item>
+ /// </list>
///
/// </para>
/// <para>
- /// At runtime, in <seealso cref="FSTCompletion.DoLookup(string, int)"/>,
+ /// At runtime, in <see cref="FSTCompletion.DoLookup(string, int)"/>,
/// the automaton is utilized as follows:
- /// <ul>
- /// <li>For each possible term weight encoded in the automaton (cached arcs from
+ /// <list type="bullet">
+ /// <item>For each possible term weight encoded in the automaton (cached arcs from
/// the root above), starting with the highest one, we descend along the path of
/// the input key. If the key is not a prefix of a sequence in the automaton
- /// (path ends prematurely), we exit immediately -- no completions.</li>
- /// <li>Otherwise, we have found an internal automaton node that ends the key.
+ /// (path ends prematurely), we exit immediately -- no completions.</item>
+ /// <item>Otherwise, we have found an internal automaton node that ends the key.
/// <b>The entire subautomaton (all paths) starting from this node form the key's
/// completions.</b> We start the traversal of this subautomaton. Every time we
/// reach a final state (arc), we add a single suggestion to the list of results
/// (the weight of this suggestion is constant and equal to the root path we
/// started from). The tricky part is that because automaton edges are sorted and
/// we scan depth-first, we can terminate the entire procedure as soon as we
- /// collect enough suggestions the user requested.</li>
- /// <li>In case the number of suggestions collected in the step above is still
+ /// collect enough suggestions the user requested.</item>
+ /// <item>In case the number of suggestions collected in the step above is still
/// insufficient, we proceed to the next (smaller) weight leaving the root node
- /// and repeat the same algorithm again.</li>
- /// </ul>
+ /// and repeat the same algorithm again.</item>
+ /// </list>
///
/// <h2>Runtime behavior and performance characteristic</h2>
///
@@ -102,8 +102,8 @@ namespace Lucene.Net.Search.Suggest.Fst
///
/// </para>
/// </summary>
- /// <seealso cref= FSTCompletion
- /// @lucene.experimental </seealso>
+ /// <seealso cref="FSTCompletion"/>
+ /// @lucene.experimental
public class FSTCompletionBuilder
{
/// <summary>
@@ -139,7 +139,7 @@ namespace Lucene.Net.Search.Suggest.Fst
private readonly IBytesRefSorter sorter;
/// <summary>
- /// Scratch buffer for <seealso cref="#add(BytesRef, int)"/>.
+ /// Scratch buffer for <see cref="Add(BytesRef, int)"/>.
/// </summary>
private readonly BytesRef scratch = new BytesRef();
@@ -149,9 +149,9 @@ namespace Lucene.Net.Search.Suggest.Fst
private readonly int shareMaxTailLength;
/// <summary>
- /// Creates an <seealso cref="FSTCompletion"/> with default options: 10 buckets, exact match
- /// promoted to first position and <seealso cref="InMemorySorter"/> with a comparator obtained from
- /// <seealso cref="BytesRef#getUTF8SortedAsUnicodeComparator()"/>.
+ /// Creates an <see cref="FSTCompletion"/> with default options: 10 buckets, exact match
+ /// promoted to first position and <see cref="InMemorySorter"/> with a comparator obtained from
+ /// <see cref="BytesRef.UTF8SortedAsUnicodeComparator"/>.
/// </summary>
public FSTCompletionBuilder()
: this(DEFAULT_BUCKETS, new InMemorySorter(BytesRef.UTF8SortedAsUnicodeComparer), int.MaxValue)
@@ -162,22 +162,22 @@ namespace Lucene.Net.Search.Suggest.Fst
/// Creates an FSTCompletion with the specified options. </summary>
/// <param name="buckets">
/// The number of buckets for weight discretization. Buckets are used
- /// in <seealso cref="#add(BytesRef, int)"/> and must be smaller than the number
+ /// in <see cref="Add(BytesRef, int)"/> and must be smaller than the number
/// given here.
/// </param>
/// <param name="sorter">
- /// <seealso cref="IBytesRefSorter"/> used for re-sorting input for the automaton.
+ /// <see cref="IBytesRefSorter"/> used for re-sorting input for the automaton.
/// For large inputs, use on-disk sorting implementations. The sorter
- /// is closed automatically in <seealso cref="#build()"/> if it implements
- /// <seealso cref="Closeable"/>.
+ /// is closed automatically in <see cref="Build()"/> if it implements
+ /// <see cref="IDisposable"/>.
/// </param>
/// <param name="shareMaxTailLength">
/// Max shared suffix sharing length.
///
- /// See the description of this parameter in <seealso cref="Builder"/>'s constructor.
+ /// See the description of this parameter in <see cref="Builder"/>'s constructor.
/// In general, for very large inputs you'll want to construct a non-minimal
/// automaton which will be larger, but the construction will take far less ram.
- /// For minimal automata, set it to <seealso cref="Integer#MAX_VALUE"/>. </param>
+ /// For minimal automata, set it to <see cref="int.MaxValue"/>. </param>
public FSTCompletionBuilder(int buckets, IBytesRefSorter sorter, int shareMaxTailLength)
{
if (buckets < 1 || buckets > 255)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionLookup.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionLookup.cs b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionLookup.cs
index ae71771..6cbb8ae 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionLookup.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionLookup.cs
@@ -26,12 +26,12 @@ namespace Lucene.Net.Search.Suggest.Fst
*/
/// <summary>
- /// An adapter from <seealso cref="Lookup"/> API to <seealso cref="FSTCompletion"/>.
+ /// An adapter from <see cref="Lookup"/> API to <see cref="FSTCompletion"/>.
///
- /// <para>This adapter differs from <seealso cref="FSTCompletion"/> in that it attempts
- /// to discretize any "weights" as passed from in <seealso cref="InputIterator#weight()"/>
+ /// <para>This adapter differs from <see cref="FSTCompletion"/> in that it attempts
+ /// to discretize any "weights" as passed from in <see cref="IInputIterator.Weight"/>
/// to match the number of buckets. For the rationale for bucketing, see
- /// <seealso cref="FSTCompletion"/>.
+ /// <see cref="FSTCompletion"/>.
///
/// </para>
/// <para><b>Note:</b>Discretization requires an additional sorting pass.
@@ -48,25 +48,25 @@ namespace Lucene.Net.Search.Suggest.Fst
///
/// </para>
/// <para>For fine-grained control over which weights are assigned to which buckets,
- /// use <seealso cref="FSTCompletion"/> directly or <seealso cref="TSTLookup"/>, for example.
+ /// use <see cref="FSTCompletion"/> directly or <see cref="Tst.TSTLookup"/>, for example.
///
/// </para>
/// </summary>
- /// <seealso cref= FSTCompletion
- /// @lucene.experimental </seealso>
+ /// <seealso cref="FSTCompletion"/>
+ /// @lucene.experimental
public class FSTCompletionLookup : Lookup
{
/// <summary>
/// An invalid bucket count if we're creating an object
/// of this class from an existing FST.
/// </summary>
- /// <seealso cref= #FSTCompletionLookup(FSTCompletion, boolean) </seealso>
+ /// <seealso cref="FSTCompletionLookup(FSTCompletion, bool)"/> </seealso>
private static int INVALID_BUCKETS_COUNT = -1;
/// <summary>
/// Shared tail length for conflating in the created automaton. Setting this
- /// to larger values (<seealso cref="Integer#MAX_VALUE"/>) will create smaller (or minimal)
- /// automata at the cost of RAM for keeping nodes hash in the <seealso cref="FST"/>.
+ /// to larger values (<see cref="int.MaxValue"/>) will create smaller (or minimal)
+ /// automata at the cost of RAM for keeping nodes hash in the <see cref="FST"/>.
///
/// <para>Empirical pick.
/// </para>
@@ -92,8 +92,8 @@ namespace Lucene.Net.Search.Suggest.Fst
/// <summary>
/// This constructor prepares for creating a suggested FST using the
- /// <seealso cref="#build(InputIterator)"/> method. The number of weight
- /// discretization buckets is set to <seealso cref="FSTCompletion#DEFAULT_BUCKETS"/> and
+ /// <see cref="Build(IInputIterator)"/> method. The number of weight
+ /// discretization buckets is set to <see cref="FSTCompletion.DEFAULT_BUCKETS"/> and
/// exact matches are promoted to the top of the suggestions list.
/// </summary>
public FSTCompletionLookup()
@@ -103,14 +103,14 @@ namespace Lucene.Net.Search.Suggest.Fst
/// <summary>
/// This constructor prepares for creating a suggested FST using the
- /// <seealso cref="#build(InputIterator)"/> method.
+ /// <see cref="Build(IInputIterator)"/> method.
/// </summary>
/// <param name="buckets">
/// The number of weight discretization buckets (see
- /// <seealso cref="FSTCompletion"/> for details).
+ /// <see cref="FSTCompletion"/> for details).
/// </param>
/// <param name="exactMatchFirst">
- /// If <code>true</code> exact matches are promoted to the top of the
+ /// If <c>true</c> exact matches are promoted to the top of the
/// suggestions list. Otherwise they appear in the order of
/// discretized weight and alphabetical within the bucket. </param>
public FSTCompletionLookup(int buckets, bool exactMatchFirst)
@@ -123,7 +123,7 @@ namespace Lucene.Net.Search.Suggest.Fst
/// This constructor takes a pre-built automaton.
/// </summary>
/// <param name="completion">
- /// An instance of <seealso cref="FSTCompletion"/>. </param>
+ /// An instance of <see cref="FSTCompletion"/>. </param>
/// <param name="exactMatchFirst">
/// If <code>true</code> exact matches are promoted to the top of the
/// suggestions list. Otherwise they appear in the order of
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs b/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
index 40defba..7186ad5 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
@@ -31,7 +31,7 @@ namespace Lucene.Net.Search.Suggest.Fst
/// suggestions.
/// <para>
/// <b>NOTE</b>:
- /// Input weights must be between 0 and <seealso cref="Integer#MAX_VALUE"/>, any
+ /// Input weights must be between 0 and <see cref="int.MaxValue"/>, any
/// other values will be rejected.
///
/// @lucene.experimental
@@ -57,7 +57,7 @@ namespace Lucene.Net.Search.Suggest.Fst
private long count = 0;
/// <summary>
- /// Calls <seealso cref="#WFSTCompletionLookup(boolean) WFSTCompletionLookup(true)"/>
+ /// Calls <see cref="WFSTCompletionLookup(bool)">WFSTCompletionLookup(true)</see>
/// </summary>
public WFSTCompletionLookup()
: this(true)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/InMemorySorter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/InMemorySorter.cs b/src/Lucene.Net.Suggest/Suggest/InMemorySorter.cs
index 9ec4e6e..f5de243 100644
--- a/src/Lucene.Net.Suggest/Suggest/InMemorySorter.cs
+++ b/src/Lucene.Net.Suggest/Suggest/InMemorySorter.cs
@@ -23,7 +23,7 @@ namespace Lucene.Net.Search.Suggest
*/
/// <summary>
- /// An <seealso cref="IBytesRefSorter"/> that keeps all the entries in memory.
+ /// An <see cref="IBytesRefSorter"/> that keeps all the entries in memory.
/// @lucene.experimental
/// @lucene.internal
/// </summary>
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/InputIterator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/InputIterator.cs b/src/Lucene.Net.Suggest/Suggest/InputIterator.cs
index 45b64e3..9e460d2 100644
--- a/src/Lucene.Net.Suggest/Suggest/InputIterator.cs
+++ b/src/Lucene.Net.Suggest/Suggest/InputIterator.cs
@@ -22,8 +22,8 @@ namespace Lucene.Net.Search.Suggest
/// <summary>
/// Interface for enumerating term,weight,payload triples for suggester consumption;
- /// currently only <seealso cref="AnalyzingSuggester"/>, <seealso cref="FuzzySuggester"/>
- /// and <seealso cref="AnalyzingInfixSuggester"/> support payloads.
+ /// currently only <see cref="Analyzing.AnalyzingSuggester"/>, <see cref="Analyzing.FuzzySuggester"/>
+ /// and <see cref="Analyzing.AnalyzingInfixSuggester"/> support payloads.
/// </summary>
public interface IInputIterator : BytesRefIterator
{
@@ -34,8 +34,8 @@ namespace Lucene.Net.Search.Suggest
/// <summary>
/// An arbitrary byte[] to record per suggestion. See
- /// <seealso cref="Lookup.LookupResult#payload"/> to retrieve the payload
- /// for each suggestion.
+ /// <see cref="Lookup.LookupResult.payload"/> to retrieve the payload
+ /// for each suggestion.
/// </summary>
BytesRef Payload { get; }
@@ -55,7 +55,7 @@ namespace Lucene.Net.Search.Suggest
}
/// <summary>
- /// Singleton IInputIterator that iterates over 0 BytesRefs.
+ /// Singleton <see cref="IInputIterator"/> that iterates over 0 BytesRefs.
/// </summary>
public static class EmptyInputIterator
{
@@ -63,8 +63,8 @@ namespace Lucene.Net.Search.Suggest
}
/// <summary>
- /// Wraps a BytesRefIterator as a suggester IInputIterator, with all weights
- /// set to <code>1</code> and carries no payload
+ /// Wraps a <see cref="BytesRefIterator"/> as a suggester <see cref="IInputIterator"/>, with all weights
+ /// set to <c>1</c> and carries no payload
/// </summary>
public class InputIteratorWrapper : IInputIterator
{
@@ -72,7 +72,7 @@ namespace Lucene.Net.Search.Suggest
/// <summary>
/// Creates a new wrapper, wrapping the specified iterator and
- /// specifying a weight value of <code>1</code> for all terms
+ /// specifying a weight value of <c>1</c> for all terms
/// and nullifies associated payloads.
/// </summary>
public InputIteratorWrapper(BytesRefIterator wrapped)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellLookup.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellLookup.cs b/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellLookup.cs
index a272add..d5a32fd 100644
--- a/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellLookup.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellLookup.cs
@@ -26,7 +26,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
/// Suggest implementation based on
/// <a href="http://jaspell.sourceforge.net/">JaSpell</a>.
/// </summary>
- /// <seealso cref= JaspellTernarySearchTrie </seealso>
+ /// <seealso cref="JaspellTernarySearchTrie"/>
public class JaspellLookup : Lookup
{
internal JaspellTernarySearchTrie trie = new JaspellTernarySearchTrie();
@@ -38,9 +38,9 @@ namespace Lucene.Net.Search.Suggest.Jaspell
private long count = 0;
/// <summary>
- /// Creates a new empty trie </summary>
- /// <seealso cref= #build(InputIterator)
- /// </seealso>
+ /// Creates a new empty trie
+ /// </summary>
+ /// <seealso cref="Build(IInputIterator)"/>
public JaspellLookup()
{
}
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellTernarySearchTrie.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellTernarySearchTrie.cs b/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellTernarySearchTrie.cs
index 7bc7995..ef67e00 100644
--- a/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellTernarySearchTrie.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Jaspell/JaspellTernarySearchTrie.cs
@@ -38,7 +38,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
{
/// <summary>
/// Implementation of a Ternary Search Trie, a data structure for storing
- /// <code>String</code> objects that combines the compact size of a binary search
+ /// <see cref="string"/>s that combines the compact size of a binary search
/// tree with the speed of a digital search trie, and is therefore ideal for
/// practical use in sorting and searching data.</p>
/// <para>
@@ -166,14 +166,14 @@ namespace Lucene.Net.Search.Suggest.Jaspell
*/
/// <summary>
- /// The default number of values returned by the <code>matchAlmost</code>
+ /// The default number of values returned by the <see cref="MatchAlmost"/>
/// method.
/// </summary>
private int defaultNumReturnValues = -1;
/// <summary>
- /// the number of differences allowed in a call to the
- /// <code>matchAlmostKey</code> method.
+ /// the number of differences allowed in a call to the <see cref="MatchAlmost"/>
+ /// <paramref cref="key"/>.
/// </summary>
private int matchAlmostDiff;
@@ -215,13 +215,13 @@ namespace Lucene.Net.Search.Suggest.Jaspell
/// <summary>
- /// Constructs a Ternary Search Trie and loads data from a <code>File</code>
+ /// Constructs a Ternary Search Trie and loads data from a <see cref="FileInfo"/>
/// into the Trie. The file is a normal text document, where each line is of
/// the form word TAB float.
/// </summary>
/// <param name="file">
- /// The <code>File</code> with the data to load into the Trie. </param>
- /// <exception cref="IOException">
+ /// The <see cref="FileInfo"/> with the data to load into the Trie. </param>
+ /// <exception cref="System.IO.IOException">
/// A problem occured while reading the data. </exception>
public JaspellTernarySearchTrie(FileInfo file)
: this(file, false)
@@ -229,16 +229,16 @@ namespace Lucene.Net.Search.Suggest.Jaspell
}
/// <summary>
- /// Constructs a Ternary Search Trie and loads data from a <code>File</code>
+ /// Constructs a Ternary Search Trie and loads data from a <see cref="FileInfo"/>
/// into the Trie. The file is a normal text document, where each line is of
/// the form "word TAB float".
/// </summary>
/// <param name="file">
- /// The <code>File</code> with the data to load into the Trie. </param>
+ /// The <see cref="FileInfo"/> with the data to load into the Trie. </param>
/// <param name="compression">
/// If true, the file is compressed with the GZIP algorithm, and if
/// false, the file is a normal text document. </param>
- /// <exception cref="IOException">
+ /// <exception cref="System.IO.IOException">
/// A problem occured while reading the data. </exception>
public JaspellTernarySearchTrie(FileInfo file, bool compression)
: this()
@@ -339,11 +339,11 @@ namespace Lucene.Net.Search.Suggest.Jaspell
/// method, then pass the node returned by this method into this method (make
/// sure you don't delete the data of any of the nodes returned from this
/// method!) and continue in this fashion until the node returned by this
- /// method is <code>null</code>.
+ /// method is <c>null</c>.
///
/// The TSTNode instance returned by this method will be next node to be
- /// operated on by <code>deleteNodeRecursion</code> (This emulates recursive
- /// method call while avoiding the JVM overhead normally associated with a
+ /// operated on by <see cref="DeleteNodeRecursion(TSTNode)"/> (This emulates recursive
+ /// method call while avoiding the overhead normally associated with a
/// recursive method.)
/// </summary>
/// <param name="currentNode">
@@ -445,7 +445,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
/// Retrieve the object indexed by a key.
/// </summary>
/// <param name="key">
- /// A <code>String</code> index. </param>
+ /// A <see cref="string"/> index. </param>
/// <returns> The object retrieved from the Ternary Search Trie. </returns>
public virtual object Get(string key)
{
@@ -462,7 +462,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
/// and store the new <code>Float</code>.
/// </summary>
/// <param name="key">
- /// A <code>String</code> index. </param>
+ /// A <see cref="string"/> index. </param>
/// <returns> The <code>Float</code> retrieved from the Ternary Search Trie. </returns>
public virtual float? GetAndIncrement(string key)
{
@@ -490,7 +490,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
/// </summary>
/// <param name="node">
/// The node whose index is to be calculated. </param>
- /// <returns> The <code>String</code> that indexes the node argument. </returns>
+ /// <returns> The <see cref="string"/> that indexes the node argument. </returns>
protected internal virtual string GetKey(TSTNode node)
{
StringBuilder getKeyBuffer = new StringBuilder();
@@ -510,34 +510,34 @@ namespace Lucene.Net.Search.Suggest.Jaspell
currentNode = currentNode.relatives[TSTNode.PARENT];
}
- // LUCENENET NOTE: Reverse doesn't happen in place in .NET,
+ // LUCENENET NOTE: Reverse doesn't happen in place in a .NET StringBuilder,
// so we need to return the reversed result.
return getKeyBuffer.Reverse().ToString();
}
/// <summary>
- /// Returns the node indexed by key, or <code>null</code> if that node doesn't
+ /// Returns the node indexed by key, or <c>null</c> if that node doesn't
/// exist. Search begins at root node.
/// </summary>
/// <param name="key">
- /// A <code>String</code> that indexes the node that is returned. </param>
+ /// A <see cref="string"/> that indexes the node that is returned. </param>
/// <returns> The node object indexed by key. This object is an instance of an
- /// inner class named <code>TernarySearchTrie.TSTNode</code>. </returns>
+ /// inner class named <see cref="TSTNode"/>. </returns>
public virtual TSTNode GetNode(string key)
{
return GetNode(key, rootNode);
}
/// <summary>
- /// Returns the node indexed by key, or <code>null</code> if that node doesn't
+ /// Returns the node indexed by key, or <c>null</c> if that node doesn't
/// exist. The search begins at root node.
/// </summary>
/// <param name="key">
- /// A <code>String</code> that indexes the node that is returned. </param>
+ /// A <see cref="string"/> that indexes the node that is returned. </param>
/// <param name="startNode">
/// The top node defining the subtrie to be searched. </param>
/// <returns> The node object indexed by key. This object is an instance of an
- /// inner class named <code>TernarySearchTrie.TSTNode</code>. </returns>
+ /// inner class named <see cref="TSTNode"/>. </returns>
protected internal virtual TSTNode GetNode(string key, TSTNode startNode)
{
if (key == null || startNode == null || key.Length == 0)
@@ -578,13 +578,13 @@ namespace Lucene.Net.Search.Suggest.Jaspell
/// and creating any required intermediate nodes if they don't exist.
/// </summary>
/// <param name="key">
- /// A <code>String</code> that indexes the node that is returned. </param>
+ /// A <see cref="string"/> that indexes the node that is returned. </param>
/// <returns> The node object indexed by key. This object is an instance of an
- /// inner class named <code>TernarySearchTrie.TSTNode</code>. </returns>
- /// <exception cref="NullPointerException">
- /// If the key is <code>null</code>. </exception>
- /// <exception cref="IllegalArgumentException">
- /// If the key is an empty <code>String</code>. </exception>
+ /// inner class named <see cref="TSTNode"/>. </returns>
+ /// <exception cref="NullReferenceException">
+ /// If the key is <c>null</c>. </exception>
+ /// <exception cref="ArgumentException">
+ /// If the key is an empty <see cref="string"/>. </exception>
protected internal virtual TSTNode GetOrCreateNode(string key)
{
if (key == null)
@@ -637,33 +637,33 @@ namespace Lucene.Net.Search.Suggest.Jaspell
}
/// <summary>
- /// Returns a <code>List</code> of keys that almost match the argument key.
+ /// Returns a <see cref="List{String}"/> of keys that almost match the argument key.
/// Keys returned will have exactly diff characters that do not match the
- /// target key, where diff is equal to the last value passed in as an argument
- /// to the <code>setMatchAlmostDiff</code> method.
+ /// target key, where diff is equal to the last value set
+ /// to the <see cref="MatchAlmostDiff"/> property.
/// <para>
- /// If the <code>matchAlmost</code> method is called before the
- /// <code>setMatchAlmostDiff</code> method has been called for the first time,
+ /// If the <see cref="MatchAlmost"/> method is called before the
+ /// <see cref="MatchAlmostDiff"/> property has been called for the first time,
/// then diff = 0.
///
/// </para>
/// </summary>
/// <param name="key">
/// The target key. </param>
- /// <returns> A <code>List</code> with the results. </returns>
+ /// <returns> A <see cref="List{String}"/> with the results. </returns>
public virtual IList<string> MatchAlmost(string key)
{
return MatchAlmost(key, defaultNumReturnValues);
}
/// <summary>
- /// Returns a <code>List</code> of keys that almost match the argument key.
+ /// Returns a <see cref="List{String}"/> of keys that almost match the argument key.
/// Keys returned will have exactly diff characters that do not match the
- /// target key, where diff is equal to the last value passed in as an argument
- /// to the <code>setMatchAlmostDiff</code> method.
+ /// target key, where diff is equal to the last value set
+ /// to the <see cref="MatchAlmostDiff"/> property.
/// <para>
- /// If the <code>matchAlmost</code> method is called before the
- /// <code>setMatchAlmostDiff</code> method has been called for the first time,
+ /// If the <see cref="MatchAlmost"/> method is called before the
+ /// <see cref="MatchAlmostDiff"/> property has been called for the first time,
/// then diff = 0.
///
/// </para>
@@ -672,7 +672,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
/// The target key. </param>
/// <param name="numReturnValues">
/// The maximum number of values returned by this method. </param>
- /// <returns> A <code>List</code> with the results </returns>
+ /// <returns> A <see cref="List{String}"/> with the results </returns>
public virtual IList<string> MatchAlmost(string key, int numReturnValues)
{
return MatchAlmostRecursion(rootNode, 0, matchAlmostDiff, key, ((numReturnValues < 0) ? -1 : numReturnValues), new List<string>(), false);
@@ -689,18 +689,18 @@ namespace Lucene.Net.Search.Suggest.Jaspell
/// <param name="d">
/// The number of differences so far. </param>
/// <param name="matchAlmostNumReturnValues">
- /// The maximum number of values in the result <code>List</code>. </param>
+ /// The maximum number of values in the result <see cref="List{String}"/>. </param>
/// <param name="matchAlmostResult2">
/// The results so far. </param>
/// <param name="upTo">
- /// If true all keys having up to and including matchAlmostDiff
+ /// If true all keys having up to and including <see cref="MatchAlmostDiff"/>
/// mismatched letters will be included in the result (including a key
/// that is exactly the same as the target string) otherwise keys will
/// be included in the result only if they have exactly
- /// matchAlmostDiff number of mismatched letters. </param>
+ /// <see cref="MatchAlmostDiff"/> number of mismatched letters. </param>
/// <param name="matchAlmostKey">
/// The key being searched. </param>
- /// <returns> A <code>List</code> with the results. </returns>
+ /// <returns> A <see cref="List{String}"/> with the results. </returns>
private IList<string> MatchAlmostRecursion(TSTNode currentNode, int charIndex, int d, string matchAlmostKey, int matchAlmostNumReturnValues, IList<string> matchAlmostResult2, bool upTo)
{
if ((currentNode == null) || (matchAlmostNumReturnValues != -1 && matchAlmostResult2.Count >= matchAlmostNumReturnValues) || (d < 0) || (charIndex >= matchAlmostKey.Length))
@@ -728,30 +728,30 @@ namespace Lucene.Net.Search.Suggest.Jaspell
}
/// <summary>
- /// Returns an alphabetical <code>List</code> of all keys in the trie that
+ /// Returns an alphabetical <see cref="List{String}"/> of all keys in the trie that
/// begin with a given prefix. Only keys for nodes having non-null data are
- /// included in the <code>List</code>.
+ /// included in the <see cref="List{String}"/>.
/// </summary>
/// <param name="prefix">
/// Each key returned from this method will begin with the characters
/// in prefix. </param>
- /// <returns> A <code>List</code> with the results. </returns>
+ /// <returns> A <see cref="List{String}"/> with the results. </returns>
public virtual IList<string> MatchPrefix(string prefix)
{
return MatchPrefix(prefix, defaultNumReturnValues);
}
/// <summary>
- /// Returns an alphabetical <code>List</code> of all keys in the trie that
+ /// Returns an alphabetical <see cref="List{String}"/> of all keys in the trie that
/// begin with a given prefix. Only keys for nodes having non-null data are
- /// included in the <code>List</code>.
+ /// included in the <see cref="List{String}"/>.
/// </summary>
/// <param name="prefix">
/// Each key returned from this method will begin with the characters
/// in prefix. </param>
/// <param name="numReturnValues">
/// The maximum number of values returned from this method. </param>
- /// <returns> A <code>List</code> with the results </returns>
+ /// <returns> A <see cref="List{String}"/> with the results </returns>
public virtual IList<string> MatchPrefix(string prefix, int numReturnValues)
{
List<string> sortKeysResult = new List<string>();
@@ -814,7 +814,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
/// Stores a value in the trie. The value may be retrieved using the key.
/// </summary>
/// <param name="key">
- /// A <code>String</code> that indexes the object to be stored. </param>
+ /// A <see cref="string"/> that indexes the object to be stored. </param>
/// <param name="value">
/// The object to be stored in the Trie. </param>
public virtual void Put(string key, object value)
@@ -828,7 +828,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
/// <param name="currentNode">
/// The current node. </param>
/// <param name="checkData">
- /// If true we check the data to be different of <code>null</code>. </param>
+ /// If true we check the data to be different of <c>null</c>. </param>
/// <param name="numNodes2">
/// The number of nodes so far. </param>
/// <returns> The number of nodes accounted. </returns>
@@ -860,7 +860,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
/// unnecessary by the removal of this data.
/// </summary>
/// <param name="key">
- /// A <code>string</code> that indexes the object to be removed from
+ /// A <see cref="string"/> that indexes the object to be removed from
/// the Trie. </param>
public virtual void Remove(string key)
{
@@ -869,7 +869,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
/// <summary>
/// Sets the number of characters by which words can differ from target word
- /// when calling the <code>matchAlmost</code> method.
+ /// when calling the <see cref="MatchAlmost"/> method.
/// <para>
/// Arguments less than 0 will set the char difference to 0, and arguments
/// greater than 3 will set the char difference to 3.
@@ -900,13 +900,12 @@ namespace Lucene.Net.Search.Suggest.Jaspell
/// <summary>
/// Sets the default maximum number of values returned from the
- /// <code>matchPrefix</code> and <code>matchAlmost</code> methods.
+ /// <see cref="MatchPrefix"/> and <see cref="MatchAlmost"/> methods.
/// <para>
/// The value should be set this to -1 to get an unlimited number of return
/// values. note that the methods mentioned above provide overloaded versions
/// that allow you to specify the maximum number of return values, in which
/// case this value is temporarily overridden.
- ///
/// </para>
/// </summary>
/// **<param name="num">
@@ -933,7 +932,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
/// The top node defining the subtrie to be searched. </param>
/// <param name="numReturnValues">
/// The maximum number of values returned from this method. </param>
- /// <returns> A <code>List</code> with the results. </returns>
+ /// <returns> A <see cref="List{String}"/> with the results. </returns>
protected internal virtual IList<string> SortKeys(TSTNode startNode, int numReturnValues)
{
return SortKeysRecursion(startNode, ((numReturnValues < 0) ? -1 : numReturnValues), new List<string>());
@@ -943,9 +942,9 @@ namespace Lucene.Net.Search.Suggest.Jaspell
/// Returns keys sorted in alphabetical order. This includes the current Node
/// and all nodes connected to the current Node.
/// <para>
- /// Sorted keys will be appended to the end of the resulting <code>List</code>.
+ /// Sorted keys will be appended to the end of the resulting <see cref="List{String}"/>.
/// The result may be empty when this method is invoked, but may not be
- /// <code>null</code>.
+ /// <c>null</c>.
///
/// </para>
/// </summary>
@@ -955,7 +954,7 @@ namespace Lucene.Net.Search.Suggest.Jaspell
/// The maximum number of values in the result. </param>
/// <param name="sortKeysResult2">
/// The results so far. </param>
- /// <returns> A <code>List</code> with the results. </returns>
+ /// <returns> A <see cref="List{String}"/> with the results. </returns>
private IList<string> SortKeysRecursion(TSTNode currentNode, int sortKeysNumReturnValues, IList<string> sortKeysResult2)
{
if (currentNode == null)
@@ -976,7 +975,8 @@ namespace Lucene.Net.Search.Suggest.Jaspell
}
/// <summary>
- /// Return an approximate memory usage for this trie. </summary>
+ /// Return an approximate memory usage for this trie.
+ /// </summary>
public virtual long GetSizeInBytes()
{
long mem = RamUsageEstimator.ShallowSizeOf(this);
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Lookup.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Lookup.cs b/src/Lucene.Net.Suggest/Suggest/Lookup.cs
index 7cdb951..50867c8 100644
--- a/src/Lucene.Net.Suggest/Suggest/Lookup.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Lookup.cs
@@ -25,7 +25,7 @@ namespace Lucene.Net.Search.Suggest
*/
/// <summary>
- /// Simple Lookup interface for <seealso cref="string"/> suggestions.
+ /// Simple Lookup interface for <see cref="string"/> suggestions.
/// @lucene.experimental
/// </summary>
public abstract class Lookup
@@ -43,7 +43,7 @@ namespace Lucene.Net.Search.Suggest
/// <summary>
/// Expert: custom Object to hold the result of a
- /// highlighted suggestion.
+ /// highlighted suggestion.
/// </summary>
public readonly object highlightKey;
@@ -125,7 +125,7 @@ namespace Lucene.Net.Search.Suggest
}
/// <summary>
- /// A simple char-by-char comparator for <seealso cref="CharSequence"/>
+ /// A simple char-by-char comparator for <see cref="string"/>
/// </summary>
public static readonly IComparer<string> CHARSEQUENCE_COMPARATOR = new CharSequenceComparator();
@@ -153,7 +153,7 @@ namespace Lucene.Net.Search.Suggest
}
/// <summary>
- /// A <seealso cref="PriorityQueue"/> collecting a fixed size of high priority <seealso cref="LookupResult"/>
+ /// A <see cref="PriorityQueue{LookupResult}"/> collecting a fixed size of high priority <see cref="LookupResult"/>s.
/// </summary>
public sealed class LookupPriorityQueue : PriorityQueue<LookupResult>
{
@@ -200,8 +200,8 @@ namespace Lucene.Net.Search.Suggest
/// <summary>
/// Build lookup from a dictionary. Some implementations may require sorted
/// or unsorted keys from the dictionary's iterator - use
- /// <seealso cref="SortedInputIterator"/> or
- /// <seealso cref="UnsortedInputIterator"/> in such case.
+ /// <see cref="SortedInputIterator"/> or
+ /// <see cref="UnsortedInputIterator"/> in such case.
/// </summary>
public virtual void Build(IDictionary dict)
{
@@ -209,8 +209,8 @@ namespace Lucene.Net.Search.Suggest
}
/// <summary>
- /// Calls <seealso cref="#load(DataInput)"/> after converting
- /// <seealso cref="InputStream"/> to <seealso cref="DataInput"/>
+ /// Calls <see cref="Load(DataInput)"/> after converting
+ /// <see cref="Stream"/> to <see cref="DataInput"/>
/// </summary>
public virtual bool Load(Stream input)
{
@@ -226,8 +226,8 @@ namespace Lucene.Net.Search.Suggest
}
/// <summary>
- /// Calls <seealso cref="#store(DataOutput)"/> after converting
- /// <seealso cref="OutputStream"/> to <seealso cref="DataOutput"/>
+ /// Calls <see cref="Store(DataOutput)"/> after converting
+ /// <see cref="Stream"/> to <see cref="DataOutput"/>
/// </summary>
public virtual bool Store(Stream output)
{
@@ -248,7 +248,7 @@ namespace Lucene.Net.Search.Suggest
public abstract long Count { get; }
/// <summary>
- /// Builds up a new internal <seealso cref="Lookup"/> representation based on the given <seealso cref="InputIterator"/>.
+ /// Builds up a new internal <see cref="Lookup"/> representation based on the given <see cref="IInputIterator"/>.
/// The implementation might re-sort the data internally.
/// </summary>
public abstract void Build(IInputIterator inputIterator);
@@ -277,17 +277,17 @@ namespace Lucene.Net.Search.Suggest
/// <summary>
/// Persist the constructed lookup data to a directory. Optional operation. </summary>
- /// <param name="output"> <seealso cref="DataOutput"/> to write the data to. </param>
+ /// <param name="output"> <see cref="DataOutput"/> to write the data to. </param>
/// <returns> true if successful, false if unsuccessful or not supported. </returns>
- /// <exception cref="IOException"> when fatal IO error occurs. </exception>
+ /// <exception cref="System.IO.IOException"> when fatal IO error occurs. </exception>
public abstract bool Store(DataOutput output);
/// <summary>
/// Discard current lookup data and load it from a previously saved copy.
/// Optional operation. </summary>
- /// <param name="input"> the <seealso cref="DataInput"/> to load the lookup data. </param>
+ /// <param name="input"> the <see cref="DataInput"/> to load the lookup data. </param>
/// <returns> true if completed successfully, false if unsuccessful or not supported. </returns>
- /// <exception cref="IOException"> when fatal IO error occurs. </exception>
+ /// <exception cref="System.IO.IOException"> when fatal IO error occurs. </exception>
public abstract bool Load(DataInput input);
/// <summary>
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/SortedInputIterator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/SortedInputIterator.cs b/src/Lucene.Net.Suggest/Suggest/SortedInputIterator.cs
index c6d730e..8e2e8dc 100644
--- a/src/Lucene.Net.Suggest/Suggest/SortedInputIterator.cs
+++ b/src/Lucene.Net.Suggest/Suggest/SortedInputIterator.cs
@@ -46,9 +46,8 @@ namespace Lucene.Net.Search.Suggest
private ISet<BytesRef> contexts = null;
/// <summary>
- /// Creates a new sorted wrapper, using {@link
- /// BytesRef#getUTF8SortedAsUnicodeComparator} for
- /// sorting.
+ /// Creates a new sorted wrapper, using <see cref="BytesRef.UTF8SortedAsUnicodeComparer"/>
+ /// for sorting.
/// </summary>
public SortedInputIterator(IInputIterator source)
: this(source, BytesRef.UTF8SortedAsUnicodeComparer)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/SortedTermFreqIteratorWrapper.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/SortedTermFreqIteratorWrapper.cs b/src/Lucene.Net.Suggest/Suggest/SortedTermFreqIteratorWrapper.cs
index cf54a57..a9b8efc 100644
--- a/src/Lucene.Net.Suggest/Suggest/SortedTermFreqIteratorWrapper.cs
+++ b/src/Lucene.Net.Suggest/Suggest/SortedTermFreqIteratorWrapper.cs
@@ -42,9 +42,8 @@ namespace Lucene.Net.Search.Suggest
private readonly BytesRef scratch = new BytesRef();
/// <summary>
- /// Creates a new sorted wrapper, using {@link
- /// BytesRef#getUTF8SortedAsUnicodeComparator} for
- /// sorting.
+ /// Creates a new sorted wrapper, using <see cref="BytesRef.UTF8SortedAsUnicodeComparer"/>
+ /// for sorting.
/// </summary>
public SortedTermFreqIteratorWrapper(ITermFreqIterator source)
: this(source, BytesRef.UTF8SortedAsUnicodeComparer)
@@ -139,7 +138,6 @@ namespace Lucene.Net.Search.Suggest
{
return cmp;
}
- //return long.Compare(leftCost, rightCost);
return leftCost.CompareTo(rightCost);
}
}
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Tst/TSTAutocomplete.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Tst/TSTAutocomplete.cs b/src/Lucene.Net.Suggest/Suggest/Tst/TSTAutocomplete.cs
index 9f1f6c9..f4a6137 100644
--- a/src/Lucene.Net.Suggest/Suggest/Tst/TSTAutocomplete.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Tst/TSTAutocomplete.cs
@@ -22,7 +22,7 @@ namespace Lucene.Net.Search.Suggest.Tst
/// <summary>
/// Ternary Search Trie implementation.
/// </summary>
- /// <seealso cref= TernaryTreeNode </seealso>
+ /// <seealso cref="TernaryTreeNode"/>
public class TSTAutocomplete
{
@@ -66,7 +66,7 @@ namespace Lucene.Net.Search.Suggest.Tst
/// key to be inserted in TST. </param>
/// <param name="x">
/// index of character in key to be inserted currently. </param>
- /// <returns> currentNode The new reference to root node of TST </returns>
+ /// <returns> The new reference to root node of TST </returns>
public virtual TernaryTreeNode Insert(TernaryTreeNode currentNode, string s, object val, int x)
{
if (s == null || s.Length <= x)