http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/MultiTermQueryWrapperFilter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/MultiTermQueryWrapperFilter.cs b/src/Lucene.Net/Search/MultiTermQueryWrapperFilter.cs index 0b3401e..d172657 100644 --- a/src/Lucene.Net/Search/MultiTermQueryWrapperFilter.cs +++ b/src/Lucene.Net/Search/MultiTermQueryWrapperFilter.cs @@ -31,17 +31,17 @@ namespace Lucene.Net.Search using TermsEnum = Lucene.Net.Index.TermsEnum; /// <summary> - /// A wrapper for <seealso cref="MultiTermQuery"/>, that exposes its - /// functionality as a <seealso cref="Filter"/>. - /// <P> - /// <code>MultiTermQueryWrapperFilter</code> is not designed to - /// be used by itself. Normally you subclass it to provide a Filter - /// counterpart for a <seealso cref="MultiTermQuery"/> subclass. - /// <P> - /// For example, <seealso cref="TermRangeFilter"/> and <seealso cref="PrefixFilter"/> extend - /// <code>MultiTermQueryWrapperFilter</code>. - /// this class also provides the functionality behind - /// <seealso cref="MultiTermQuery#CONSTANT_SCORE_FILTER_REWRITE"/>; + /// A wrapper for <see cref="MultiTermQuery"/>, that exposes its + /// functionality as a <see cref="Filter"/>. + /// <para/> + /// <see cref="MultiTermQueryWrapperFilter{Q}"/> is not designed to + /// be used by itself. Normally you subclass it to provide a <see cref="Filter"/> + /// counterpart for a <see cref="MultiTermQuery"/> subclass. + /// <para/> + /// For example, <see cref="TermRangeFilter"/> and <see cref="PrefixFilter"/> extend + /// <see cref="MultiTermQueryWrapperFilter{Q}"/>. + /// This class also provides the functionality behind + /// <see cref="MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE"/>; /// this is why it is not abstract. /// </summary> #if FEATURE_SERIALIZABLE @@ -52,7 +52,7 @@ namespace Lucene.Net.Search protected readonly Q m_query; /// <summary> - /// Wrap a <seealso cref="MultiTermQuery"/> as a Filter. + /// Wrap a <see cref="MultiTermQuery"/> as a <see cref="Filter"/>. /// </summary> protected internal MultiTermQueryWrapperFilter(Q query) { @@ -98,7 +98,7 @@ namespace Lucene.Net.Search } /// <summary> - /// Returns a DocIdSet with documents that should be permitted in search + /// Returns a <see cref="DocIdSet"/> with documents that should be permitted in search /// results. /// </summary> public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/NGramPhraseQuery.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/NGramPhraseQuery.cs b/src/Lucene.Net/Search/NGramPhraseQuery.cs index 2ce79ee..2f208ae 100644 --- a/src/Lucene.Net/Search/NGramPhraseQuery.cs +++ b/src/Lucene.Net/Search/NGramPhraseQuery.cs @@ -24,12 +24,11 @@ namespace Lucene.Net.Search using Term = Lucene.Net.Index.Term; /// <summary> - /// this is a <seealso cref="PhraseQuery"/> which is optimized for n-gram phrase query. + /// This is a <see cref="PhraseQuery"/> which is optimized for n-gram phrase query. /// For example, when you query "ABCD" on a 2-gram field, you may want to use - /// NGramPhraseQuery rather than <seealso cref="PhraseQuery"/>, because NGramPhraseQuery - /// will <seealso cref="#rewrite(IndexReader)"/> the query to "AB/0 CD/2", while <seealso cref="PhraseQuery"/> + /// <see cref="NGramPhraseQuery"/> rather than <see cref="PhraseQuery"/>, because <see cref="NGramPhraseQuery"/> + /// will <see cref="Rewrite(IndexReader)"/> the query to "AB/0 CD/2", while <see cref="PhraseQuery"/> /// will query "AB/0 BC/1 CD/2" (where term/position). - /// /// </summary> #if FEATURE_SERIALIZABLE [Serializable] @@ -93,7 +92,7 @@ namespace Lucene.Net.Search } /// <summary> - /// Returns true iff <code>o</code> is equal to this. </summary> + /// Returns <c>true</c> if <paramref name="o"/> is equal to this. </summary> public override bool Equals(object o) { if (!(o is NGramPhraseQuery)) http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/NumericRangeFilter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/NumericRangeFilter.cs b/src/Lucene.Net/Search/NumericRangeFilter.cs index 5900506..f42c87d 100644 --- a/src/Lucene.Net/Search/NumericRangeFilter.cs +++ b/src/Lucene.Net/Search/NumericRangeFilter.cs @@ -20,26 +20,25 @@ namespace Lucene.Net.Search */ /// <summary> - /// A <seealso cref="Filter"/> that only accepts numeric values within + /// A <see cref="Filter"/> that only accepts numeric values within /// a specified range. To use this, you must first index the - /// numeric values using <seealso cref="IntField"/>, {@link - /// FloatField}, <seealso cref="LongField"/> or <seealso cref="DoubleField"/> (expert: {@link - /// NumericTokenStream}). + /// numeric values using <see cref="Documents.Int32Field"/>, + /// <see cref="Documents.SingleField"/>, <see cref="Documents.Int64Field"/> or <see cref="Documents.DoubleField"/> (expert: + /// <see cref="Analysis.NumericTokenStream"/>). /// - /// <p>You create a new NumericRangeFilter with the static + /// <para/>You create a new <see cref="NumericRangeFilter"/> with the static /// factory methods, eg: /// - /// <pre class="prettyprint"> - /// Filter f = NumericRangeFilter.newFloatRange("weight", 0.03f, 0.10f, true, true); - /// </pre> + /// <code> + /// Filter f = NumericRangeFilter.NewFloatRange("weight", 0.03f, 0.10f, true, true); + /// </code> /// - /// accepts all documents whose float valued "weight" field + /// Accepts all documents whose float valued "weight" field /// ranges from 0.03 to 0.10, inclusive. - /// See <seealso cref="NumericRangeQuery"/> for details on how Lucene + /// See <see cref="NumericRangeQuery"/> for details on how Lucene /// indexes and searches numeric valued fields. - /// + /// <para/> /// @since 2.9 - /// /// </summary> #if FEATURE_SERIALIZABLE [Serializable] @@ -56,14 +55,14 @@ namespace Lucene.Net.Search // LUCENENET NOTE: Static methods were moved into NumericRangeFilter class /// <summary> - /// Returns <code>true</code> if the lower endpoint is inclusive </summary> + /// Returns <c>true</c> if the lower endpoint is inclusive </summary> public bool IncludesMin { get { return m_query.IncludesMin; } } /// <summary> - /// Returns <code>true</code> if the upper endpoint is inclusive </summary> + /// Returns <c>true</c> if the upper endpoint is inclusive </summary> public bool IncludesMax { get { return m_query.IncludesMax; } @@ -100,13 +99,17 @@ namespace Lucene.Net.Search } } + /// <summary> + /// LUCENENET specific static class to provide access to static methods without referring to the + /// <see cref="NumericRangeFilter{T}"/>'s generic closing type. + /// </summary> public static class NumericRangeFilter { /// <summary> - /// Factory that creates a <code>NumericRangeFilter</code>, that filters a <code>long</code> - /// range using the given <a href="NumericRangeQuery.html#precisionStepDesc"><code>precisionStep</code></a>. + /// Factory that creates a <see cref="NumericRangeFilter"/>, that filters a <see cref="long"/> + /// range using the given <see cref="NumericRangeQuery{T}.PrecisionStep"/>. /// You can have half-open ranges (which are in fact </<= or >/>= queries) - /// by setting the min or max value to <code>null</code>. By setting inclusive to false, it will + /// by setting the min or max value to <c>null</c>. By setting inclusive to <c>false</c>, it will /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. /// <para/> /// NOTE: This was newLongRange() in Lucene @@ -117,10 +120,10 @@ namespace Lucene.Net.Search } /// <summary> - /// Factory that creates a <code>NumericRangeFilter</code>, that queries a <code>long</code> - /// range using the default <code>precisionStep</code> <seealso cref="NumericUtils#PRECISION_STEP_DEFAULT"/> (4). + /// Factory that creates a <see cref="NumericRangeFilter"/>, that queries a <see cref="long"/> + /// range using the default <see cref="NumericRangeQuery{T}.PrecisionStep"/> <see cref="Util.NumericUtils.PRECISION_STEP_DEFAULT"/> (4). /// You can have half-open ranges (which are in fact </<= or >/>= queries) - /// by setting the min or max value to <code>null</code>. By setting inclusive to false, it will + /// by setting the min or max value to <c>null</c>. By setting inclusive to <c>false</c>, it will /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. /// <para/> /// NOTE: This was newLongRange() in Lucene @@ -131,10 +134,10 @@ namespace Lucene.Net.Search } /// <summary> - /// Factory that creates a <code>NumericRangeFilter</code>, that filters a <code>int</code> - /// range using the given <a href="NumericRangeQuery.html#precisionStepDesc"><code>precisionStep</code></a>. + /// Factory that creates a <see cref="NumericRangeFilter"/>, that filters a <see cref="int"/> + /// range using the given <see cref="NumericRangeQuery{T}.PrecisionStep"/>. /// You can have half-open ranges (which are in fact </<= or >/>= queries) - /// by setting the min or max value to <code>null</code>. By setting inclusive to false, it will + /// by setting the min or max value to <c>null</c>. By setting inclusive to <c>false</c>, it will /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. /// <para/> /// NOTE: This was newIntRange() in Lucene @@ -145,10 +148,10 @@ namespace Lucene.Net.Search } /// <summary> - /// Factory that creates a <code>NumericRangeFilter</code>, that queries a <code>int</code> - /// range using the default <code>precisionStep</code> <seealso cref="NumericUtils#PRECISION_STEP_DEFAULT"/> (4). + /// Factory that creates a <see cref="NumericRangeFilter"/>, that queries a <see cref="int"/> + /// range using the default <see cref="NumericRangeQuery{T}.PrecisionStep"/> <see cref="Util.NumericUtils.PRECISION_STEP_DEFAULT"/> (4). /// You can have half-open ranges (which are in fact </<= or >/>= queries) - /// by setting the min or max value to <code>null</code>. By setting inclusive to false, it will + /// by setting the min or max value to <c>null</c>. By setting inclusive to <c>false</c>, it will /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. /// <para/> /// NOTE: This was newIntRange() in Lucene @@ -159,12 +162,12 @@ namespace Lucene.Net.Search } /// <summary> - /// Factory that creates a <code>NumericRangeFilter</code>, that filters a <code>double</code> - /// range using the given <a href="NumericRangeQuery.html#precisionStepDesc"><code>precisionStep</code></a>. + /// Factory that creates a <see cref="NumericRangeFilter"/>, that filters a <see cref="double"/> + /// range using the given <see cref="NumericRangeQuery{T}.PrecisionStep"/>. /// You can have half-open ranges (which are in fact </<= or >/>= queries) - /// by setting the min or max value to <code>null</code>. - /// <seealso cref="Double#NaN"/> will never match a half-open range, to hit {@code NaN} use a query - /// with {@code min == max == Double.NaN}. By setting inclusive to false, it will + /// by setting the min or max value to <c>null</c>. + /// <see cref="double.NaN"/> will never match a half-open range, to hit <c>NaN</c> use a query + /// with <c>min == max == System.Double.NaN</c>. By setting inclusive to <c>false</c>, it will /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. /// </summary> public static NumericRangeFilter<double> NewDoubleRange(string field, int precisionStep, double? min, double? max, bool minInclusive, bool maxInclusive) @@ -173,12 +176,12 @@ namespace Lucene.Net.Search } /// <summary> - /// Factory that creates a <code>NumericRangeFilter</code>, that queries a <code>double</code> - /// range using the default <code>precisionStep</code> <seealso cref="NumericUtils#PRECISION_STEP_DEFAULT"/> (4). + /// Factory that creates a <see cref="NumericRangeFilter"/>, that queries a <see cref="double"/> + /// range using the default <see cref="NumericRangeQuery{T}.PrecisionStep"/> <see cref="Util.NumericUtils.PRECISION_STEP_DEFAULT"/> (4). /// You can have half-open ranges (which are in fact </<= or >/>= queries) - /// by setting the min or max value to <code>null</code>. - /// <seealso cref="Double#NaN"/> will never match a half-open range, to hit {@code NaN} use a query - /// with {@code min == max == Double.NaN}. By setting inclusive to false, it will + /// by setting the min or max value to <c>null</c>. + /// <see cref="double.NaN"/> will never match a half-open range, to hit <c>NaN</c> use a query + /// with <c>min == max == System.Double.NaN</c>. By setting inclusive to <c>false</c>, it will /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. /// </summary> public static NumericRangeFilter<double> NewDoubleRange(string field, double? min, double? max, bool minInclusive, bool maxInclusive) @@ -187,12 +190,12 @@ namespace Lucene.Net.Search } /// <summary> - /// Factory that creates a <code>NumericRangeFilter</code>, that filters a <code>float</code> - /// range using the given <a href="NumericRangeQuery.html#precisionStepDesc"><code>precisionStep</code></a>. + /// Factory that creates a <see cref="NumericRangeFilter"/>, that filters a <see cref="float"/> + /// range using the given <see cref="NumericRangeQuery{T}.PrecisionStep"/>. /// You can have half-open ranges (which are in fact </<= or >/>= queries) - /// by setting the min or max value to <code>null</code>. - /// <seealso cref="Float#NaN"/> will never match a half-open range, to hit {@code NaN} use a query - /// with {@code min == max == Float.NaN}. By setting inclusive to false, it will + /// by setting the min or max value to <c>null</c>. + /// <see cref="float.NaN"/> will never match a half-open range, to hit <c>NaN</c> use a query + /// with <c>min == max == System.Single.NaN</c>. By setting inclusive to <c>false</c>, it will /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. /// <para/> /// NOTE: This was newFloatRange() in Lucene @@ -203,12 +206,12 @@ namespace Lucene.Net.Search } /// <summary> - /// Factory that creates a <code>NumericRangeFilter</code>, that queries a <code>float</code> - /// range using the default <code>precisionStep</code> <seealso cref="NumericUtils#PRECISION_STEP_DEFAULT"/> (4). + /// Factory that creates a <see cref="NumericRangeFilter"/>, that queries a <see cref="float"/> + /// range using the default <see cref="NumericRangeQuery{T}.PrecisionStep"/> <see cref="Util.NumericUtils.PRECISION_STEP_DEFAULT"/> (4). /// You can have half-open ranges (which are in fact </<= or >/>= queries) - /// by setting the min or max value to <code>null</code>. - /// <seealso cref="Float#NaN"/> will never match a half-open range, to hit {@code NaN} use a query - /// with {@code min == max == Float.NaN}. By setting inclusive to false, it will + /// by setting the min or max value to <c>null</c>. + /// <see cref="float.NaN"/> will never match a half-open range, to hit <c>NaN</c> use a query + /// with <c>min == max == System.Single.NaN</c>. By setting inclusive to <c>false</c>, it will /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. /// <para/> /// NOTE: This was newFloatRange() in Lucene http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/NumericRangeQuery.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/NumericRangeQuery.cs b/src/Lucene.Net/Search/NumericRangeQuery.cs index 2c97b1a..344bc4d 100644 --- a/src/Lucene.Net/Search/NumericRangeQuery.cs +++ b/src/Lucene.Net/Search/NumericRangeQuery.cs @@ -32,135 +32,135 @@ namespace Lucene.Net.Search using ToStringUtils = Lucene.Net.Util.ToStringUtils; /// <summary> - /// <p>A <seealso cref="Query"/> that matches numeric values within a + /// <para>A <see cref="Query"/> that matches numeric values within a /// specified range. To use this, you must first index the - /// numeric values using <seealso cref="Int32Field"/>, {@link - /// FloatField}, <seealso cref="Int64Field"/> or <seealso cref="DoubleField"/> (expert: {@link - /// NumericTokenStream}). If your terms are instead textual, - /// you should use <seealso cref="TermRangeQuery"/>. {@link - /// NumericRangeFilter} is the filter equivalent of this - /// query.</p> + /// numeric values using <see cref="Int32Field"/>, + /// <see cref="SingleField"/>, <see cref="Int64Field"/> or <see cref="DoubleField"/> (expert: + /// <see cref="Analysis.NumericTokenStream"/>). If your terms are instead textual, + /// you should use <see cref="TermRangeQuery"/>. + /// <see cref="NumericRangeFilter"/> is the filter equivalent of this + /// query.</para> /// - /// <p>You create a new NumericRangeQuery with the static + /// <para>You create a new <see cref="NumericRangeQuery{T}"/> with the static /// factory methods, eg: /// - /// <pre class="prettyprint"> - /// Query q = NumericRangeQuery.newFloatRange("weight", 0.03f, 0.10f, true, true); - /// </pre> + /// <code> + /// Query q = NumericRangeQuery.NewFloatRange("weight", 0.03f, 0.10f, true, true); + /// </code> /// - /// matches all documents whose float valued "weight" field - /// ranges from 0.03 to 0.10, inclusive. + /// matches all documents whose <see cref="float"/> valued "weight" field + /// ranges from 0.03 to 0.10, inclusive.</para> /// - /// <p>The performance of NumericRangeQuery is much better - /// than the corresponding <seealso cref="TermRangeQuery"/> because the + /// <para>The performance of <see cref="NumericRangeQuery{T}"/> is much better + /// than the corresponding <see cref="TermRangeQuery"/> because the /// number of terms that must be searched is usually far - /// fewer, thanks to trie indexing, described below.</p> + /// fewer, thanks to trie indexing, described below.</para> /// - /// <p>You can optionally specify a <a - /// href="#precisionStepDesc"><code>precisionStep</code></a> - /// when creating this query. this is necessary if you've + /// <para>You can optionally specify a <a + /// href="#precisionStepDesc"><see cref="precisionStep"/></a> + /// when creating this query. This is necessary if you've /// changed this configuration from its default (4) during /// indexing. Lower values consume more disk space but speed /// up searching. Suitable values are between <b>1</b> and /// <b>8</b>. A good starting point to test is <b>4</b>, - /// which is the default value for all <code>Numeric*</code> + /// which is the default value for all <c>Numeric*</c> /// classes. See <a href="#precisionStepDesc">below</a> for - /// details. + /// details.</para> /// - /// <p>this query defaults to {@linkplain - /// MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}. + /// <para>This query defaults to + /// <see cref="MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT"/>. /// With precision steps of <=4, this query can be run with - /// one of the BooleanQuery rewrite methods without changing - /// BooleanQuery's default max clause count. + /// one of the <see cref="BooleanQuery"/> rewrite methods without changing + /// <see cref="BooleanQuery"/>'s default max clause count.</para> /// - /// <br><h3>How it works</h3> - /// - /// <p>See the publication about <a target="_blank" href="http://www.panfmp.org";>panFMP</a>, - /// where this algorithm was described (referred to as <code>TrieRangeQuery</code>): + /// <para/><h3>How it works</h3> /// + /// <para>See the publication about <a target="_blank" href="http://www.panfmp.org";>panFMP</a>, + /// where this algorithm was described (referred to as <c>TrieRangeQuery</c>): + /// </para> /// <blockquote><strong>Schindler, U, Diepenbroek, M</strong>, 2008. /// <em>Generic XML-based Framework for Metadata Portals.</em> /// Computers & Geosciences 34 (12), 1947-1955. /// <a href="http://dx.doi.org/10.1016/j.cageo.2008.02.023"; /// target="_blank">doi:10.1016/j.cageo.2008.02.023</a></blockquote> /// - /// <p><em>A quote from this paper:</em> Because Apache Lucene is a full-text + /// <para><em>A quote from this paper:</em> Because Apache Lucene is a full-text /// search engine and not a conventional database, it cannot handle numerical ranges /// (e.g., field value is inside user defined bounds, even dates are numerical values). /// We have developed an extension to Apache Lucene that stores /// the numerical values in a special string-encoded format with variable precision - /// (all numerical values like doubles, longs, floats, and ints are converted to + /// (all numerical values like <see cref="double"/>s, <see cref="long"/>s, <see cref="float"/>s, and <see cref="int"/>s are converted to /// lexicographic sortable string representations and stored with different precisions /// (for a more detailed description of how the values are stored, - /// see <seealso cref="NumericUtils"/>). A range is then divided recursively into multiple intervals for searching: + /// see <see cref="NumericUtils"/>). A range is then divided recursively into multiple intervals for searching: /// The center of the range is searched only with the lowest possible precision in the <em>trie</em>, - /// while the boundaries are matched more exactly. this reduces the number of terms dramatically.</p> + /// while the boundaries are matched more exactly. This reduces the number of terms dramatically.</para> /// - /// <p>For the variant that stores long values in 8 different precisions (each reduced by 8 bits) that + /// <para>For the variant that stores long values in 8 different precisions (each reduced by 8 bits) that /// uses a lowest precision of 1 byte, the index contains only a maximum of 256 distinct values in the /// lowest precision. Overall, a range could consist of a theoretical maximum of /// <code>7*255*2 + 255 = 3825</code> distinct terms (when there is a term for every distinct value of an /// 8-byte-number in the index and the range covers almost all of them; a maximum of 255 distinct values is used /// because it would always be possible to reduce the full 256 values to one term with degraded precision). /// In practice, we have seen up to 300 terms in most cases (index with 500,000 metadata records - /// and a uniform value distribution).</p> + /// and a uniform value distribution).</para> /// - /// <a name="precisionStepDesc"><h3>Precision Step</h3> - /// <p>You can choose any <code>precisionStep</code> when encoding values. + /// <a name="precisionStepDesc"><h3>Precision Step</h3></a> + /// <para/>You can choose any <see cref="precisionStep"/> when encoding values. /// Lower step values mean more precisions and so more terms in index (and index gets larger). The number - /// of indexed terms per value is (those are generated by <seealso cref="NumericTokenStream"/>): - /// <p style="font-family:serif"> - /// indexedTermsPerValue = <b>ceil</b><big>(</big>bitsPerValue / precisionStep<big>)</big> - /// </p> + /// of indexed terms per value is (those are generated by <see cref="Analysis.NumericTokenStream"/>): + /// <para> + ///   indexedTermsPerValue = <b>ceil</b><big>(</big>bitsPerValue / precisionStep<big>)</big> + /// </para> /// As the lower precision terms are shared by many values, the additional terms only - /// slightly grow the term dictionary (approx. 7% for <code>precisionStep=4</code>), but have a larger + /// slightly grow the term dictionary (approx. 7% for <c>precisionStep=4</c>), but have a larger /// impact on the postings (the postings file will have more entries, as every document is linked to - /// <code>indexedTermsPerValue</code> terms instead of one). The formula to estimate the growth + /// <c>indexedTermsPerValue</c> terms instead of one). The formula to estimate the growth /// of the term dictionary in comparison to one term per value: - /// <p> + /// <para> /// <!-- the formula in the alt attribute was transformed from latex to PNG with http://1.618034.com/latex.php (with 110 dpi): --> - /// <img src="doc-files/nrq-formula-1.png" alt="\mathrm{termDictOverhead} = \sum\limits_{i=0}^{\mathrm{indexedTermsPerValue}-1} \frac{1}{2^{\mathrm{precisionStep}\cdot i}}" /> - /// </p> - /// <p>On the other hand, if the <code>precisionStep</code> is smaller, the maximum number of terms to match reduces, + ///   <img src="doc-files/nrq-formula-1.png" alt="\mathrm{termDictOverhead} = \sum\limits_{i=0}^{\mathrm{indexedTermsPerValue}-1} \frac{1}{2^{\mathrm{precisionStep}\cdot i}}" /> + /// </para> + /// <para>On the other hand, if the <see cref="precisionStep"/> is smaller, the maximum number of terms to match reduces, /// which optimizes query speed. The formula to calculate the maximum number of terms that will be visited while /// executing the query is: - /// <p> + /// </para> + /// <para> /// <!-- the formula in the alt attribute was transformed from latex to PNG with http://1.618034.com/latex.php (with 110 dpi): --> - /// <img src="doc-files/nrq-formula-2.png" alt="\mathrm{maxQueryTerms} = \left[ \left( \mathrm{indexedTermsPerValue} - 1 \right) \cdot \left(2^\mathrm{precisionStep} - 1 \right) \cdot 2 \right] + \left( 2^\mathrm{precisionStep} - 1 \right)" /> - /// </p> - /// <p>For longs stored using a precision step of 4, <code>maxQueryTerms = 15*15*2 + 15 = 465</code>, and for a precision - /// step of 2, <code>maxQueryTerms = 31*3*2 + 3 = 189</code>. But the faster search speed is reduced by more seeking - /// in the term enum of the index. Because of this, the ideal <code>precisionStep</code> value can only + ///   <img src="doc-files/nrq-formula-2.png" alt="\mathrm{maxQueryTerms} = \left[ \left( \mathrm{indexedTermsPerValue} - 1 \right) \cdot \left(2^\mathrm{precisionStep} - 1 \right) \cdot 2 \right] + \left( 2^\mathrm{precisionStep} - 1 \right)" /> + /// </para> + /// <para>For longs stored using a precision step of 4, <c>maxQueryTerms = 15*15*2 + 15 = 465</c>, and for a precision + /// step of 2, <c>maxQueryTerms = 31*3*2 + 3 = 189</c>. But the faster search speed is reduced by more seeking + /// in the term enum of the index. Because of this, the ideal <see cref="precisionStep"/> value can only /// be found out by testing. <b>Important:</b> You can index with a lower precision step value and test search speed - /// using a multiple of the original step value.</p> + /// using a multiple of the original step value.</para> /// - /// <p>Good values for <code>precisionStep</code> are depending on usage and data type: - /// <ul> - /// <li>The default for all data types is <b>4</b>, which is used, when no <code>precisionStep</code> is given. - /// <li>Ideal value in most cases for <em>64 bit</em> data types <em>(long, double)</em> is <b>6</b> or <b>8</b>. - /// <li>Ideal value in most cases for <em>32 bit</em> data types <em>(int, float)</em> is <b>4</b>. - /// <li>For low cardinality fields larger precision steps are good. If the cardinality is < 100, it is - /// fair to use <seealso cref="int.MaxValue"/> (see below). - /// <li>Steps <b>>=64</b> for <em>long/double</em> and <b>>=32</b> for <em>int/float</em> produces one token - /// per value in the index and querying is as slow as a conventional <seealso cref="TermRangeQuery"/>. But it can be used - /// to produce fields, that are solely used for sorting (in this case simply use <seealso cref="int.MaxValue"/> as - /// <code>precisionStep</code>). Using <seealso cref="Int32Field"/>, - /// <seealso cref="Int64Field"/>, <seealso cref="SingleField"/> or <seealso cref="DoubleField"/> for sorting + /// <para>Good values for <see cref="precisionStep"/> are depending on usage and data type:</para> + /// <list type="bullet"> + /// <item><description>The default for all data types is <b>4</b>, which is used, when no <code>precisionStep</code> is given.</description></item> + /// <item><description>Ideal value in most cases for <em>64 bit</em> data types <em>(long, double)</em> is <b>6</b> or <b>8</b>.</description></item> + /// <item><description>Ideal value in most cases for <em>32 bit</em> data types <em>(int, float)</em> is <b>4</b>.</description></item> + /// <item><description>For low cardinality fields larger precision steps are good. If the cardinality is < 100, it is + /// fair to use <see cref="int.MaxValue"/> (see below).</description></item> + /// <item><description>Steps <b>>=64</b> for <em>long/double</em> and <b>>=32</b> for <em>int/float</em> produces one token + /// per value in the index and querying is as slow as a conventional <see cref="TermRangeQuery"/>. But it can be used + /// to produce fields, that are solely used for sorting (in this case simply use <see cref="int.MaxValue"/> as + /// <see cref="precisionStep"/>). Using <see cref="Int32Field"/>, + /// <see cref="Int64Field"/>, <see cref="SingleField"/> or <see cref="DoubleField"/> for sorting /// is ideal, because building the field cache is much faster than with text-only numbers. /// These fields have one term per value and therefore also work with term enumeration for building distinct lists /// (e.g. facets / preselected values to search for). - /// Sorting is also possible with range query optimized fields using one of the above <code>precisionSteps</code>. - /// </ul> + /// Sorting is also possible with range query optimized fields using one of the above <see cref="precisionStep"/>s.</description></item> + /// </list> /// - /// <p>Comparisons of the different types of RangeQueries on an index with about 500,000 docs showed - /// that <seealso cref="TermRangeQuery"/> in boolean rewrite mode (with raised <seealso cref="BooleanQuery"/> clause count) - /// took about 30-40 secs to complete, <seealso cref="TermRangeQuery"/> in constant score filter rewrite mode took 5 secs + /// <para>Comparisons of the different types of RangeQueries on an index with about 500,000 docs showed + /// that <see cref="TermRangeQuery"/> in boolean rewrite mode (with raised <see cref="BooleanQuery"/> clause count) + /// took about 30-40 secs to complete, <see cref="TermRangeQuery"/> in constant score filter rewrite mode took 5 secs /// and executing this class took <100ms to complete (on an Opteron64 machine, Java 1.5, 8 bit - /// precision step). this query type was developed for a geographic portal, where the performance for - /// e.g. bounding boxes or exact date/time stamps is important.</p> + /// precision step). This query type was developed for a geographic portal, where the performance for + /// e.g. bounding boxes or exact date/time stamps is important.</para> /// /// @since 2.9 - /// /// </summary> #if FEATURE_SERIALIZABLE [Serializable] @@ -196,14 +196,14 @@ namespace Lucene.Net.Search } /// <summary> - /// Returns <code>true</code> if the lower endpoint is inclusive </summary> + /// Returns <c>true</c> if the lower endpoint is inclusive </summary> public bool IncludesMin { get { return minInclusive; } } /// <summary> - /// Returns <code>true</code> if the upper endpoint is inclusive </summary> + /// Returns <c>true</c> if the upper endpoint is inclusive </summary> public bool IncludesMax { get { return maxInclusive; } @@ -311,14 +311,14 @@ namespace Lucene.Net.Search internal static readonly int INT32_POSITIVE_INFINITY = NumericUtils.SingleToSortableInt32(float.PositiveInfinity); /// <summary> - /// Subclass of FilteredTermsEnum for enumerating all terms that match the + /// Subclass of <see cref="FilteredTermsEnum"/> for enumerating all terms that match the /// sub-ranges for trie range queries, using flex API. - /// <p> + /// <para/> /// WARNING: this term enumeration is not guaranteed to be always ordered by - /// <seealso cref="Term#compareTo"/>. - /// The ordering depends on how <seealso cref="NumericUtils#splitLongRange"/> and - /// <seealso cref="NumericUtils#splitIntRange"/> generates the sub-ranges. For - /// <seealso cref="MultiTermQuery"/> ordering is not relevant. + /// <see cref="Index.Term.CompareTo(Index.Term)"/>. + /// The ordering depends on how <see cref="NumericUtils.SplitInt64Range(NumericUtils.Int64RangeBuilder, int, long, long)"/> and + /// <see cref="NumericUtils.SplitInt32Range(NumericUtils.Int32RangeBuilder, int, int, int)"/> generates the sub-ranges. For + /// <see cref="MultiTermQuery"/> ordering is not relevant. /// </summary> #if FEATURE_SERIALIZABLE [Serializable] @@ -532,13 +532,17 @@ namespace Lucene.Net.Search } } + /// <summary> + /// LUCENENET specific class to provide access to static factory metods of <see cref="NumericRangeQuery{T}"/> + /// without referring to its genereic closing type. + /// </summary> public static class NumericRangeQuery { /// <summary> - /// Factory that creates a <code>NumericRangeQuery</code>, that queries a <code>long</code> - /// range using the given <a href="#precisionStepDesc"><code>precisionStep</code></a>. + /// Factory that creates a <see cref="NumericRangeQuery{T}"/>, that queries a <see cref="long"/> + /// range using the given <a href="#precisionStepDesc"><see cref="NumericRangeQuery{T}.precisionStep"/></a>. /// You can have half-open ranges (which are in fact </<= or >/>= queries) - /// by setting the min or max value to <code>null</code>. By setting inclusive to false, it will + /// by setting the min or max value to <c>null</c>. By setting inclusive to <c>false</c>, it will /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. /// <para/> /// NOTE: This was newLongRange() in Lucene @@ -549,10 +553,10 @@ namespace Lucene.Net.Search } /// <summary> - /// Factory that creates a <code>NumericRangeQuery</code>, that queries a <code>long</code> - /// range using the default <code>precisionStep</code> <seealso cref="NumericUtils#PRECISION_STEP_DEFAULT"/> (4). + /// Factory that creates a <see cref="NumericRangeQuery{T}"/>, that queries a <see cref="long"/> + /// range using the default <see cref="NumericRangeQuery{T}.precisionStep"/> <see cref="NumericUtils.PRECISION_STEP_DEFAULT"/> (4). /// You can have half-open ranges (which are in fact </<= or >/>= queries) - /// by setting the min or max value to <code>null</code>. By setting inclusive to false, it will + /// by setting the min or max value to <c>null</c>. By setting inclusive to <c>false</c>, it will /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. /// <para/> /// NOTE: This was newLongRange() in Lucene @@ -563,10 +567,10 @@ namespace Lucene.Net.Search } /// <summary> - /// Factory that creates a <code>NumericRangeQuery</code>, that queries a <code>int</code> - /// range using the given <a href="#precisionStepDesc"><code>precisionStep</code></a>. + /// Factory that creates a <see cref="NumericRangeQuery{T}"/>, that queries a <see cref="int"/> + /// range using the given <a href="#precisionStepDesc"><see cref="NumericRangeQuery{T}.precisionStep"/></a>. /// You can have half-open ranges (which are in fact </<= or >/>= queries) - /// by setting the min or max value to <code>null</code>. By setting inclusive to false, it will + /// by setting the min or max value to <c>null</c>. By setting inclusive to <c>false</c>, it will /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. /// <para/> /// NOTE: This was newIntRange() in Lucene @@ -577,10 +581,10 @@ namespace Lucene.Net.Search } /// <summary> - /// Factory that creates a <code>NumericRangeQuery</code>, that queries a <code>int</code> - /// range using the default <code>precisionStep</code> <seealso cref="NumericUtils#PRECISION_STEP_DEFAULT"/> (4). + /// Factory that creates a <see cref="NumericRangeQuery{T}"/>, that queries a <see cref="int"/> + /// range using the default <see cref="NumericRangeQuery{T}.precisionStep"/> <see cref="NumericUtils.PRECISION_STEP_DEFAULT"/> (4). /// You can have half-open ranges (which are in fact </<= or >/>= queries) - /// by setting the min or max value to <code>null</code>. By setting inclusive to false, it will + /// by setting the min or max value to <c>null</c>. By setting inclusive to <c>false</c>, it will /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. /// <para/> /// NOTE: This was newIntRange() in Lucene @@ -591,12 +595,12 @@ namespace Lucene.Net.Search } /// <summary> - /// Factory that creates a <code>NumericRangeQuery</code>, that queries a <code>double</code> - /// range using the given <a href="#precisionStepDesc"><code>precisionStep</code></a>. + /// Factory that creates a <see cref="NumericRangeQuery{T}"/>, that queries a <see cref="double"/> + /// range using the given <a href="#precisionStepDesc"><see cref="NumericRangeQuery{T}.precisionStep"/></a>. /// You can have half-open ranges (which are in fact </<= or >/>= queries) - /// by setting the min or max value to <code>null</code>. - /// <seealso cref="Double#NaN"/> will never match a half-open range, to hit {@code NaN} use a query - /// with {@code min == max == Double.NaN}. By setting inclusive to false, it will + /// by setting the min or max value to <c>null</c>. + /// <see cref="double.NaN"/> will never match a half-open range, to hit <c>NaN</c> use a query + /// with <c>min == max == System.Double.NaN</c>. By setting inclusive to <c>false</c>, it will /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. /// </summary> public static NumericRangeQuery<double> NewDoubleRange(string field, int precisionStep, double? min, double? max, bool minInclusive, bool maxInclusive) @@ -605,12 +609,12 @@ namespace Lucene.Net.Search } /// <summary> - /// Factory that creates a <code>NumericRangeQuery</code>, that queries a <code>double</code> - /// range using the default <code>precisionStep</code> <seealso cref="NumericUtils#PRECISION_STEP_DEFAULT"/> (4). + /// Factory that creates a <see cref="NumericRangeQuery{T}"/>, that queries a <see cref="double"/> + /// range using the default <see cref="NumericRangeQuery{T}.precisionStep"/> <see cref="NumericUtils.PRECISION_STEP_DEFAULT"/> (4). /// You can have half-open ranges (which are in fact </<= or >/>= queries) - /// by setting the min or max value to <code>null</code>. - /// <seealso cref="Double#NaN"/> will never match a half-open range, to hit {@code NaN} use a query - /// with {@code min == max == Double.NaN}. By setting inclusive to false, it will + /// by setting the min or max value to <c>null</c>. + /// <see cref="double.NaN"/> will never match a half-open range, to hit <c>NaN</c> use a query + /// with <c>min == max == System.Double.NaN</c>. By setting inclusive to <c>false</c>, it will /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. /// </summary> public static NumericRangeQuery<double> NewDoubleRange(string field, double? min, double? max, bool minInclusive, bool maxInclusive) @@ -619,12 +623,12 @@ namespace Lucene.Net.Search } /// <summary> - /// Factory that creates a <code>NumericRangeQuery</code>, that queries a <code>float</code> - /// range using the given <a href="#precisionStepDesc"><code>precisionStep</code></a>. + /// Factory that creates a <see cref="NumericRangeQuery{T}"/>, that queries a <see cref="float"/> + /// range using the given <a href="#precisionStepDesc"><see cref="NumericRangeQuery{T}.precisionStep"/></a>. /// You can have half-open ranges (which are in fact </<= or >/>= queries) - /// by setting the min or max value to <code>null</code>. - /// <seealso cref="Float#NaN"/> will never match a half-open range, to hit {@code NaN} use a query - /// with {@code min == max == Float.NaN}. By setting inclusive to false, it will + /// by setting the min or max value to <c>null</c>. + /// <see cref="float.NaN"/> will never match a half-open range, to hit <c>NaN</c> use a query + /// with <c>min == max == System.Single.NaN</c>. By setting inclusive to <c>false</c>, it will /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. /// <para/> /// NOTE: This was newFloatRange() in Lucene @@ -635,12 +639,12 @@ namespace Lucene.Net.Search } /// <summary> - /// Factory that creates a <code>NumericRangeQuery</code>, that queries a <code>float</code> - /// range using the default <code>precisionStep</code> <seealso cref="NumericUtils#PRECISION_STEP_DEFAULT"/> (4). + /// Factory that creates a <see cref="NumericRangeQuery{T}"/>, that queries a <see cref="float"/> + /// range using the default <see cref="NumericRangeQuery{T}.precisionStep"/> <see cref="NumericUtils.PRECISION_STEP_DEFAULT"/> (4). /// You can have half-open ranges (which are in fact </<= or >/>= queries) - /// by setting the min or max value to <code>null</code>. - /// <seealso cref="Float#NaN"/> will never match a half-open range, to hit {@code NaN} use a query - /// with {@code min == max == Float.NaN}. By setting inclusive to false, it will + /// by setting the min or max value to <c>null</c>. + /// <see cref="float.NaN"/> will never match a half-open range, to hit <c>NaN</c> use a query + /// with <c>min == max == System.Single.NaN</c>. By setting inclusive to <c>false</c>, it will /// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. /// <para/> /// NOTE: This was newFloatRange() in Lucene http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/PhrasePositions.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/PhrasePositions.cs b/src/Lucene.Net/Search/PhrasePositions.cs index 3e875c0..dc9619a 100644 --- a/src/Lucene.Net/Search/PhrasePositions.cs +++ b/src/Lucene.Net/Search/PhrasePositions.cs @@ -75,9 +75,9 @@ namespace Lucene.Net.Search /// <summary> /// Go to next location of this term current document, and set - /// <code>position</code> as <code>location - offset</code>, so that a - /// matching exact phrase is easily identified when all PhrasePositions - /// have exactly the same <code>position</code>. + /// <c>position</c> as <c>location - offset</c>, so that a + /// matching exact phrase is easily identified when all <see cref="PhrasePositions"/> + /// have exactly the same <c>position</c>. /// </summary> internal bool NextPosition() { @@ -93,7 +93,7 @@ namespace Lucene.Net.Search } /// <summary> - /// for debug purposes </summary> + /// For debug purposes </summary> public override string ToString() { string s = "d:" + doc + " o:" + offset + " p:" + position + " c:" + count; http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/PhraseQuery.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/PhraseQuery.cs b/src/Lucene.Net/Search/PhraseQuery.cs index 99186db..224eef3 100644 --- a/src/Lucene.Net/Search/PhraseQuery.cs +++ b/src/Lucene.Net/Search/PhraseQuery.cs @@ -43,10 +43,10 @@ namespace Lucene.Net.Search using ToStringUtils = Lucene.Net.Util.ToStringUtils; /// <summary> - /// A Query that matches documents containing a particular sequence of terms. - /// A PhraseQuery is built by QueryParser for input like <code>"new york"</code>. + /// A <see cref="Query"/> that matches documents containing a particular sequence of terms. + /// A <see cref="PhraseQuery"/> is built by QueryParser for input like <c>"new york"</c>. /// - /// <p>this query may be combined with other terms or queries with a <seealso cref="BooleanQuery"/>. + /// <para/>This query may be combined with other terms or queries with a <see cref="BooleanQuery"/>. /// </summary> #if FEATURE_SERIALIZABLE [Serializable] @@ -67,19 +67,19 @@ namespace Lucene.Net.Search /// <summary> /// Sets the number of other words permitted between words in query phrase. - /// If zero, then this is an exact phrase search. For larger values this works - /// like a <code>WITHIN</code> or <code>NEAR</code> operator. + /// If zero, then this is an exact phrase search. For larger values this works + /// like a <c>WITHIN</c> or <c>NEAR</c> operator. /// - /// <p>The slop is in fact an edit-distance, where the units correspond to - /// moves of terms in the query phrase out of position. For example, to switch - /// the order of two words requires two moves (the first move places the words - /// atop one another), so to permit re-orderings of phrases, the slop must be - /// at least two. + /// <para/>The slop is in fact an edit-distance, where the units correspond to + /// moves of terms in the query phrase out of position. For example, to switch + /// the order of two words requires two moves (the first move places the words + /// atop one another), so to permit re-orderings of phrases, the slop must be + /// at least two. /// - /// <p>More exact matches are scored higher than sloppier matches, thus search - /// results are sorted by exactness. + /// <para/>More exact matches are scored higher than sloppier matches, thus search + /// results are sorted by exactness. /// - /// <p>The slop is zero by default, requiring exact matches. + /// <para/>The slop is zero by default, requiring exact matches. /// </summary> public virtual int Slop { @@ -117,7 +117,6 @@ namespace Lucene.Net.Search /// The relative position of the term within the phrase is specified explicitly. /// this allows e.g. phrases with more than one term at the same position /// or phrases with gaps (e.g. in connection with stopwords). - /// /// </summary> public virtual void Add(Term term, int position) { @@ -438,7 +437,7 @@ namespace Lucene.Net.Search return new PhraseWeight(this, searcher); } - /// <seealso cref= Lucene.Net.Search.Query#extractTerms(Set) </seealso> + /// <seealso cref="Lucene.Net.Search.Query.ExtractTerms(ISet{Term})"/> public override void ExtractTerms(ISet<Term> queryTerms) { queryTerms.UnionWith(terms); @@ -501,7 +500,7 @@ namespace Lucene.Net.Search } /// <summary> - /// Returns true iff <code>o</code> is equal to this. </summary> + /// Returns <c>true</c> if <paramref name="o"/> is equal to this. </summary> public override bool Equals(object o) { if (!(o is PhraseQuery)) http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/PositiveScoresOnlyCollector.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/PositiveScoresOnlyCollector.cs b/src/Lucene.Net/Search/PositiveScoresOnlyCollector.cs index e50e75d..8f5c289 100644 --- a/src/Lucene.Net/Search/PositiveScoresOnlyCollector.cs +++ b/src/Lucene.Net/Search/PositiveScoresOnlyCollector.cs @@ -22,8 +22,8 @@ namespace Lucene.Net.Search using AtomicReaderContext = Lucene.Net.Index.AtomicReaderContext; /// <summary> - /// A <seealso cref="ICollector"/> implementation which wraps another - /// <seealso cref="ICollector"/> and makes sure only documents with + /// A <see cref="ICollector"/> implementation which wraps another + /// <see cref="ICollector"/> and makes sure only documents with /// scores > 0 are collected. /// </summary> #if FEATURE_SERIALIZABLE http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/PrefixFilter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/PrefixFilter.cs b/src/Lucene.Net/Search/PrefixFilter.cs index 8c7ee56..7f39e69 100644 --- a/src/Lucene.Net/Search/PrefixFilter.cs +++ b/src/Lucene.Net/Search/PrefixFilter.cs @@ -23,7 +23,7 @@ namespace Lucene.Net.Search using Term = Lucene.Net.Index.Term; /// <summary> - /// A Filter that restricts search results to values that have a matching prefix in a given + /// A <see cref="Filter"/> that restricts search results to values that have a matching prefix in a given /// field. /// </summary> #if FEATURE_SERIALIZABLE http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/PrefixQuery.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/PrefixQuery.cs b/src/Lucene.Net/Search/PrefixQuery.cs index 5381aaf..6db8c34 100644 --- a/src/Lucene.Net/Search/PrefixQuery.cs +++ b/src/Lucene.Net/Search/PrefixQuery.cs @@ -27,11 +27,11 @@ namespace Lucene.Net.Search using ToStringUtils = Lucene.Net.Util.ToStringUtils; /// <summary> - /// A Query that matches documents containing terms with a specified prefix. A PrefixQuery - /// is built by QueryParser for input like <code>app*</code>. + /// A <see cref="Query"/> that matches documents containing terms with a specified prefix. A <see cref="PrefixQuery"/> + /// is built by QueryParser for input like <c>app*</c>. /// - /// <p>this query uses the {@link - /// MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} + /// <para/>This query uses the + /// <see cref="MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT"/> /// rewrite method. /// </summary> #if FEATURE_SERIALIZABLE @@ -42,7 +42,7 @@ namespace Lucene.Net.Search private readonly Term _prefix; /// <summary> - /// Constructs a query for terms starting with <code>prefix</code>. </summary> + /// Constructs a query for terms starting with <paramref name="prefix"/>. </summary> public PrefixQuery(Term prefix) : base(prefix.Field) { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/PrefixTermsEnum.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/PrefixTermsEnum.cs b/src/Lucene.Net/Search/PrefixTermsEnum.cs index 025d43f..12888b0 100644 --- a/src/Lucene.Net/Search/PrefixTermsEnum.cs +++ b/src/Lucene.Net/Search/PrefixTermsEnum.cs @@ -25,11 +25,11 @@ namespace Lucene.Net.Search using TermsEnum = Lucene.Net.Index.TermsEnum; /// <summary> - /// Subclass of FilteredTermEnum for enumerating all terms that match the + /// Subclass of <see cref="FilteredTermsEnum"/> for enumerating all terms that match the /// specified prefix filter term. - /// <p>Term enumerations are always ordered by - /// <seealso cref="#getComparer"/>. Each term in the enumeration is - /// greater than all that precede it.</p> + /// <para>Term enumerations are always ordered by + /// <see cref="TermsEnum.Comparer"/>. Each term in the enumeration is + /// greater than all that precede it.</para> /// </summary> #if FEATURE_SERIALIZABLE [Serializable] http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/Query.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Query.cs b/src/Lucene.Net/Search/Query.cs index 93bfb21..14a8db3 100644 --- a/src/Lucene.Net/Search/Query.cs +++ b/src/Lucene.Net/Search/Query.cs @@ -26,23 +26,23 @@ namespace Lucene.Net.Search /// <summary> /// The abstract base class for queries. - /// <p>Instantiable subclasses are: - /// <ul> - /// <li> <seealso cref="TermQuery"/> - /// <li> <seealso cref="BooleanQuery"/> - /// <li> <seealso cref="WildcardQuery"/> - /// <li> <seealso cref="PhraseQuery"/> - /// <li> <seealso cref="PrefixQuery"/> - /// <li> <seealso cref="MultiPhraseQuery"/> - /// <li> <seealso cref="FuzzyQuery"/> - /// <li> <seealso cref="RegexpQuery"/> - /// <li> <seealso cref="TermRangeQuery"/> - /// <li> <seealso cref="NumericRangeQuery"/> - /// <li> <seealso cref="ConstantScoreQuery"/> - /// <li> <seealso cref="DisjunctionMaxQuery"/> - /// <li> <seealso cref="MatchAllDocsQuery"/> - /// </ul> - /// <p>See also the family of <seealso cref="Lucene.Net.Search.Spans Span Queries"/> + /// <para/>Instantiable subclasses are: + /// <list type="bullet"> + /// <item><description> <seealso cref="TermQuery"/> </description></item> + /// <item><description> <seealso cref="BooleanQuery"/> </description></item> + /// <item><description> <seealso cref="WildcardQuery"/> </description></item> + /// <item><description> <seealso cref="PhraseQuery"/> </description></item> + /// <item><description> <seealso cref="PrefixQuery"/> </description></item> + /// <item><description> <seealso cref="MultiPhraseQuery"/> </description></item> + /// <item><description> <seealso cref="FuzzyQuery"/> </description></item> + /// <item><description> <seealso cref="RegexpQuery"/> </description></item> + /// <item><description> <seealso cref="TermRangeQuery"/> </description></item> + /// <item><description> <seealso cref="NumericRangeQuery"/> </description></item> + /// <item><description> <seealso cref="ConstantScoreQuery"/> </description></item> + /// <item><description> <seealso cref="DisjunctionMaxQuery"/> </description></item> + /// <item><description> <seealso cref="MatchAllDocsQuery"/> </description></item> + /// </list> + /// <para/>See also the family of Span Queries (<see cref="Lucene.Net.Search.Spans"/>) /// and additional queries available in the <a href="{@docRoot}/../queries/overview-summary.html">Queries module</a> /// </summary> #if FEATURE_SERIALIZABLE @@ -56,9 +56,9 @@ namespace Lucene.Net.Search /// <summary> - /// Sets the boost for this query clause to <code>b</code>. Documents + /// Gets or Sets the boost for this query clause. Documents /// matching this clause will (in addition to the normal weightings) have - /// their score multiplied by <code>b</code>. + /// their score multiplied by <see cref="Boost"/>. The boost is 1.0 by default. /// </summary> public virtual float Boost { @@ -67,7 +67,7 @@ namespace Lucene.Net.Search } /// <summary> - /// Prints a query to a string, with <code>field</code> assumed to be the + /// Prints a query to a string, with <paramref name="field"/> assumed to be the /// default field and omitted. /// </summary> public abstract string ToString(string field); @@ -80,9 +80,9 @@ namespace Lucene.Net.Search } /// <summary> - /// Expert: Constructs an appropriate Weight implementation for this query. + /// Expert: Constructs an appropriate <see cref="Weight"/> implementation for this query. /// - /// <p> + /// <para/> /// Only implemented by primitive queries, which re-write to themselves. /// </summary> public virtual Weight CreateWeight(IndexSearcher searcher) @@ -92,8 +92,8 @@ namespace Lucene.Net.Search /// <summary> /// Expert: called to re-write queries into primitive queries. For example, - /// a PrefixQuery will be rewritten into a BooleanQuery that consists - /// of TermQuerys. + /// a <see cref="PrefixQuery"/> will be rewritten into a <see cref="BooleanQuery"/> that consists + /// of <see cref="TermQuery"/>s. /// </summary> public virtual Query Rewrite(IndexReader reader) { @@ -102,9 +102,9 @@ namespace Lucene.Net.Search /// <summary> /// Expert: adds all terms occurring in this query to the terms set. Only - /// works if this query is in its <seealso cref="#rewrite rewritten"/> form. + /// works if this query is in its rewritten (<see cref="Rewrite(IndexReader)"/>) form. /// </summary> - /// <exception cref="InvalidOperationException"> if this query is not yet rewritten </exception> + /// <exception cref="InvalidOperationException"> If this query is not yet rewritten </exception> public virtual void ExtractTerms(ISet<Term> terms) { // needs to be implemented by query subclasses http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/QueryRescorer.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/QueryRescorer.cs b/src/Lucene.Net/Search/QueryRescorer.cs index 0455789..d434881 100644 --- a/src/Lucene.Net/Search/QueryRescorer.cs +++ b/src/Lucene.Net/Search/QueryRescorer.cs @@ -24,9 +24,9 @@ namespace Lucene.Net.Search using AtomicReaderContext = Lucene.Net.Index.AtomicReaderContext; /// <summary> - /// A <seealso cref="Rescorer"/> that uses a provided Query to assign - /// scores to the first-pass hits. - /// + /// A <see cref="Rescorer"/> that uses a provided <see cref="Query"/> to assign + /// scores to the first-pass hits. + /// <para/> /// @lucene.experimental /// </summary> #if FEATURE_SERIALIZABLE @@ -38,7 +38,7 @@ namespace Lucene.Net.Search /// <summary> /// Sole constructor, passing the 2nd pass query to - /// assign scores to the 1st pass hits. + /// assign scores to the 1st pass hits. /// </summary> public QueryRescorer(Query query) { @@ -47,10 +47,10 @@ namespace Lucene.Net.Search /// <summary> /// Implement this in a subclass to combine the first pass and - /// second pass scores. If secondPassMatches is false then + /// second pass scores. If <paramref name="secondPassMatches"/> is <c>false</c> then /// the second pass query failed to match a hit from the /// first pass query, and you should ignore the - /// secondPassScore. + /// <paramref name="secondPassScore"/>. /// </summary> protected abstract float Combine(float firstPassScore, bool secondPassMatches, float secondPassScore); @@ -214,8 +214,8 @@ namespace Lucene.Net.Search } /// <summary> - /// Sugar API, calling {#rescore} using a simple linear - /// combination of firstPassScore + weight * secondPassScore + /// Sugar API, calling <see cref="QueryRescorer.Rescore(IndexSearcher, TopDocs, int)"/> using a simple linear + /// combination of firstPassScore + <paramref name="weight"/> * secondPassScore /// </summary> public static TopDocs Rescore(IndexSearcher searcher, TopDocs topDocs, Query query, double weight, int topN) { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/QueryWrapperFilter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/QueryWrapperFilter.cs b/src/Lucene.Net/Search/QueryWrapperFilter.cs index fe3f70e..727291f 100644 --- a/src/Lucene.Net/Search/QueryWrapperFilter.cs +++ b/src/Lucene.Net/Search/QueryWrapperFilter.cs @@ -26,10 +26,10 @@ namespace Lucene.Net.Search /// Constrains search results to only match those which also match a provided /// query. /// - /// <p> this could be used, for example, with a <seealso cref="NumericRangeQuery"/> on a suitably + /// <para/> This could be used, for example, with a <see cref="NumericRangeQuery"/> on a suitably /// formatted date field to implement date filtering. One could re-use a single - /// CachingWrapperFilter(QueryWrapperFilter) that matches, e.g., only documents modified - /// within the last week. this would only need to be reconstructed once per day. + /// <c>CachingWrapperFilter(QueryWrapperFilter)</c> that matches, e.g., only documents modified + /// within the last week. This would only need to be reconstructed once per day. /// </summary> #if FEATURE_SERIALIZABLE [Serializable] @@ -40,7 +40,7 @@ namespace Lucene.Net.Search /// <summary> /// Constructs a filter which only matches documents matching - /// <code>query</code>. + /// <paramref name="query"/>. /// </summary> public QueryWrapperFilter(Query query) { @@ -52,7 +52,7 @@ namespace Lucene.Net.Search } /// <summary> - /// returns the inner Query </summary> + /// Returns the inner Query </summary> public Query Query { get http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/ReferenceManager.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/ReferenceManager.cs b/src/Lucene.Net/Search/ReferenceManager.cs index 6f4e2f8..8cc4174 100644 --- a/src/Lucene.Net/Search/ReferenceManager.cs +++ b/src/Lucene.Net/Search/ReferenceManager.cs @@ -26,16 +26,15 @@ namespace Lucene.Net.Search /// <summary> /// Utility class to safely share instances of a certain type across multiple - /// threads, while periodically refreshing them. this class ensures each + /// threads, while periodically refreshing them. This class ensures each /// reference is closed only once all threads have finished using it. It is - /// recommended to consult the documentation of <seealso cref="ReferenceManager"/> - /// implementations for their <seealso cref="#maybeRefresh()"/> semantics. + /// recommended to consult the documentation of <see cref="ReferenceManager{G}"/> + /// implementations for their <see cref="MaybeRefresh()"/> semantics. + /// <para/> + /// @lucene.experimental /// </summary> - /// @param <G> - /// the concrete type that will be <seealso cref="#acquire() acquired"/> and - /// <seealso cref="#release(Object) released"/>. - /// - /// @lucene.experimental </param> + /// <typeparam name="G">The concrete type that will be <see cref="Acquire()"/>d and + /// <see cref="Release(G)"/>d.</typeparam> #if FEATURE_SERIALIZABLE [Serializable] #endif @@ -49,6 +48,9 @@ namespace Lucene.Net.Search // fields are not CLS compliant private volatile G current; + /// <summary> + /// The current reference + /// </summary> protected G Current { get { return current; } @@ -80,29 +82,28 @@ namespace Lucene.Net.Search /// <summary> /// Decrement reference counting on the given reference. </summary> - /// <exception cref="IOException"> if reference decrement on the given resource failed. - /// </exception> + /// <exception cref="System.IO.IOException"> If reference decrement on the given resource failed.</exception> protected abstract void DecRef(G reference); /// <summary> - /// Refresh the given reference if needed. Returns {@code null} if no refresh + /// Refresh the given reference if needed. Returns <c>null</c> if no refresh /// was needed, otherwise a new refreshed reference. </summary> - /// <exception cref="ObjectDisposedException"> if the reference manager has been <seealso cref="#close() closed"/>. </exception> - /// <exception cref="IOException"> if the refresh operation failed </exception> + /// <exception cref="ObjectDisposedException"> If the reference manager has been <see cref="Dispose()"/>d. </exception> + /// <exception cref="System.IO.IOException"> If the refresh operation failed </exception> protected abstract G RefreshIfNeeded(G referenceToRefresh); /// <summary> - /// Try to increment reference counting on the given reference. Return true if + /// Try to increment reference counting on the given reference. Returns <c>true</c> if /// the operation was successful. </summary> - /// <exception cref="ObjectDisposedException"> if the reference manager has been <seealso cref="#close() closed"/>. </exception> + /// <exception cref="ObjectDisposedException"> if the reference manager has been <see cref="Dispose()"/>d. </exception> protected abstract bool TryIncRef(G reference); /// <summary> /// Obtain the current reference. You must match every call to acquire with one - /// call to <seealso cref="#release"/>; it's best to do so in a finally clause, and set - /// the reference to {@code null} to prevent accidental usage after it has been + /// call to <see cref="Release(G)"/>; it's best to do so in a finally clause, and set + /// the reference to <c>null</c> to prevent accidental usage after it has been /// released. </summary> - /// <exception cref="ObjectDisposedException"> if the reference manager has been <seealso cref="#close() closed"/>. </exception> + /// <exception cref="ObjectDisposedException"> If the reference manager has been <see cref="Dispose()"/>d. </exception> public G Acquire() { G @ref; @@ -135,25 +136,25 @@ namespace Lucene.Net.Search } /// <summary> - /// <p> - /// Closes this ReferenceManager to prevent future <seealso cref="#acquire() acquiring"/>. A - /// reference manager should be closed if the reference to the managed resource - /// should be disposed or the application using the <seealso cref="ReferenceManager"/> + /// <para> + /// Closes this ReferenceManager to prevent future <see cref="Acquire()"/>ing. A + /// reference manager should be disposed if the reference to the managed resource + /// should be disposed or the application using the <see cref="ReferenceManager{G}"/> /// is shutting down. The managed resource might not be released immediately, - /// if the <seealso cref="ReferenceManager"/> user is holding on to a previously - /// <seealso cref="#acquire() acquired"/> reference. The resource will be released once - /// when the last reference is <seealso cref="#release(Object) released"/>. Those + /// if the <see cref="ReferenceManager{G}"/> user is holding on to a previously + /// <see cref="Acquire()"/>d reference. The resource will be released once + /// when the last reference is <see cref="Release(G)"/>d. Those /// references can still be used as if the manager was still active. - /// </p> - /// <p> - /// Applications should not <seealso cref="#acquire() acquire"/> new references from this - /// manager once this method has been called. <seealso cref="#acquire() Acquiring"/> a - /// resource on a closed <seealso cref="ReferenceManager"/> will throw an + /// </para> + /// <para> + /// Applications should not <see cref="Acquire()"/> new references from this + /// manager once this method has been called. <see cref="Acquire()"/>ing a + /// resource on a disposed <see cref="ReferenceManager{G}"/> will throw an /// <seealso cref="ObjectDisposedException"/>. - /// </p> + /// </para> /// </summary> - /// <exception cref="IOException"> - /// if the underlying reader of the current reference could not be closed </exception> + /// <exception cref="System.IO.IOException"> + /// If the underlying reader of the current reference could not be disposed </exception> public void Dispose() { lock (this) @@ -175,10 +176,10 @@ namespace Lucene.Net.Search protected abstract int GetRefCount(G reference); /// <summary> - /// Called after close(), so subclass can free any resources. </summary> - /// <exception cref="IOException"> if the after close operation in a sub-class throws an <seealso cref="IOException"/> - /// </exception> - protected virtual void AfterClose() + /// Called after <see cref="Dispose()"/>, so subclass can free any resources. </summary> + /// <exception cref="System.IO.IOException"> if the after dispose operation in a sub-class throws an <see cref="System.IO.IOException"/> + /// </exception> + protected virtual void AfterClose() // LUCENENET TODO: API: Rename AfterDispose() ? Or perhaps just use dispose pattern. { } @@ -230,24 +231,24 @@ namespace Lucene.Net.Search } /// <summary> - /// You must call this (or <seealso cref="#maybeRefreshBlocking()"/>), periodically, if - /// you want that <seealso cref="#acquire()"/> will return refreshed instances. + /// You must call this (or <see cref="MaybeRefreshBlocking()"/>), periodically, if + /// you want that <see cref="Acquire()"/> will return refreshed instances. /// - /// <p> + /// <para> /// <b>Threads</b>: it's fine for more than one thread to call this at once. /// Only the first thread will attempt the refresh; subsequent threads will see /// that another thread is already handling refresh and will return /// immediately. Note that this means if another thread is already refreshing /// then subsequent threads will return right away without waiting for the /// refresh to complete. - /// - /// <p> - /// If this method returns true it means the calling thread either refreshed or - /// that there were no changes to refresh. If it returns false it means another + /// </para> + /// <para> + /// If this method returns <c>true</c> it means the calling thread either refreshed or + /// that there were no changes to refresh. If it returns <c>false</c> it means another /// thread is currently refreshing. - /// </p> </summary> - /// <exception cref="IOException"> if refreshing the resource causes an <seealso cref="IOException"/> </exception> - /// <exception cref="ObjectDisposedException"> if the reference manager has been <seealso cref="#close() closed"/>. </exception> + /// </para> </summary> + /// <exception cref="System.IO.IOException"> If refreshing the resource causes an <see cref="System.IO.IOException"/> </exception> + /// <exception cref="ObjectDisposedException"> If the reference manager has been <see cref="Dispose()"/>d. </exception> public bool MaybeRefresh() { EnsureOpen(); @@ -270,17 +271,17 @@ namespace Lucene.Net.Search } /// <summary> - /// You must call this (or <seealso cref="#maybeRefresh()"/>), periodically, if you want - /// that <seealso cref="#acquire()"/> will return refreshed instances. + /// You must call this (or <see cref="MaybeRefresh()"/>), periodically, if you want + /// that <see cref="Acquire()"/> will return refreshed instances. /// - /// <p> - /// <b>Threads</b>: unlike <seealso cref="#maybeRefresh()"/>, if another thread is + /// <para/> + /// <b>Threads</b>: unlike <see cref="MaybeRefresh()"/>, if another thread is /// currently refreshing, this method blocks until that thread completes. It is - /// useful if you want to guarantee that the next call to <seealso cref="#acquire()"/> + /// useful if you want to guarantee that the next call to <see cref="Acquire()"/> /// will return a refreshed instance. Otherwise, consider using the - /// non-blocking <seealso cref="#maybeRefresh()"/>. </summary> - /// <exception cref="IOException"> if refreshing the resource causes an <seealso cref="IOException"/> </exception> - /// <exception cref="ObjectDisposedException"> if the reference manager has been <seealso cref="#close() closed"/>. </exception> + /// non-blocking <see cref="MaybeRefresh()"/>. </summary> + /// <exception cref="System.IO.IOException"> If refreshing the resource causes an <see cref="System.IO.IOException"/> </exception> + /// <exception cref="ObjectDisposedException"> If the reference manager has been <see cref="Dispose()"/>d. </exception> public void MaybeRefreshBlocking() { EnsureOpen(); @@ -299,18 +300,17 @@ namespace Lucene.Net.Search /// <summary> /// Called after a refresh was attempted, regardless of - /// whether a new reference was in fact created. </summary> - /// <exception cref="IOException"> if a low level I/O exception occurs - /// </exception> + /// whether a new reference was in fact created. </summary> + /// <exception cref="System.IO.IOException"> if a low level I/O exception occurs</exception> protected virtual void AfterMaybeRefresh() { } /// <summary> - /// Release the reference previously obtained via <seealso cref="#acquire()"/>. - /// <p> - /// <b>NOTE:</b> it's safe to call this after <seealso cref="#close()"/>. </summary> - /// <exception cref="IOException"> if the release operation on the given resource throws an <seealso cref="IOException"/> </exception> + /// Release the reference previously obtained via <see cref="Acquire()"/>. + /// <para/> + /// <b>NOTE:</b> it's safe to call this after <see cref="Dispose()"/>. </summary> + /// <exception cref="System.IO.IOException"> If the release operation on the given resource throws an <see cref="System.IO.IOException"/> </exception> public void Release(G reference) { Debug.Assert(reference != null); @@ -346,7 +346,7 @@ namespace Lucene.Net.Search } /// <summary> - /// Remove a listener added with <seealso cref="#addListener(RefreshListener)"/>. + /// Remove a listener added with <see cref="AddListener(ReferenceManager.IRefreshListener)"/>. /// </summary> public virtual void RemoveListener(ReferenceManager.IRefreshListener listener) { @@ -358,12 +358,15 @@ namespace Lucene.Net.Search } } - // .NET Port: non-generic type to hold RefreshListener + /// <summary> + /// LUCENENET specific class used to provide static access to <see cref="ReferenceManager.IRefreshListener"/> + /// without having to specifiy the generic closing type of <see cref="ReferenceManager{G}"/>. + /// </summary> public static class ReferenceManager { /// <summary> /// Use to receive notification when a refresh has - /// finished. See <seealso cref="#addListener"/>. + /// finished. See <see cref="ReferenceManager{G}.AddListener(IRefreshListener)"/>. /// </summary> public interface IRefreshListener { @@ -373,8 +376,8 @@ namespace Lucene.Net.Search /// <summary> /// Called after the attempted refresh; if the refresh - /// did open a new reference then didRefresh will be true - /// and <seealso cref="#acquire()"/> is guaranteed to return the new + /// did open a new reference then didRefresh will be <c>true</c> + /// and <see cref="ReferenceManager{G}.Acquire()"/> is guaranteed to return the new /// reference. /// </summary> void AfterRefresh(bool didRefresh); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/RegexpQuery.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/RegexpQuery.cs b/src/Lucene.Net/Search/RegexpQuery.cs index fc4fc29..7981730 100644 --- a/src/Lucene.Net/Search/RegexpQuery.cs +++ b/src/Lucene.Net/Search/RegexpQuery.cs @@ -29,25 +29,26 @@ namespace Lucene.Net.Search /// <summary> /// A fast regular expression query based on the - /// <seealso cref="Lucene.Net.Util.Automaton"/> package. - /// <ul> - /// <li>Comparisons are <a - /// href="http://tusker.org/regex/regex_benchmark.html";>fast</a> - /// <li>The term dictionary is enumerated in an intelligent way, to avoid - /// comparisons. See <seealso cref="AutomatonQuery"/> for more details. - /// </ul> - /// <p> - /// The supported syntax is documented in the <seealso cref="RegExp"/> class. + /// <see cref="Lucene.Net.Util.Automaton"/> package. + /// <list type="bullet"> + /// <item><description>Comparisons are <a + /// href="http://tusker.org/regex/regex_benchmark.html";>fast</a></description></item> + /// <item><description>The term dictionary is enumerated in an intelligent way, to avoid + /// comparisons. See <see cref="AutomatonQuery"/> for more details.</description></item> + /// </list> + /// <para> + /// The supported syntax is documented in the <see cref="RegExp"/> class. /// Note this might be different than other regular expression implementations. /// For some alternatives with different syntax, look under the sandbox. - /// </p> - /// <p> + /// </para> + /// <para> /// Note this query can be slow, as it needs to iterate over many terms. In order - /// to prevent extremely slow RegexpQueries, a Regexp term should not start with - /// the expression <code>.*</code> + /// to prevent extremely slow <see cref="RegexpQuery"/>s, a <see cref="RegExp"/> term should not start with + /// the expression <c>.*</c> + /// </para> + /// @lucene.experimental /// </summary> - /// <seealso cref= RegExp - /// @lucene.experimental </seealso> + /// <seealso cref="RegExp"/> #if FEATURE_SERIALIZABLE [Serializable] #endif @@ -70,33 +71,33 @@ namespace Lucene.Net.Search } /// <summary> - /// Constructs a query for terms matching <code>term</code>. - /// <p> + /// Constructs a query for terms matching <paramref name="term"/>. + /// <para> /// By default, all regular expression features are enabled. - /// </p> + /// </para> /// </summary> - /// <param name="term"> regular expression. </param> + /// <param name="term"> Regular expression. </param> public RegexpQuery(Term term) : this(term, RegExpSyntax.ALL) { } /// <summary> - /// Constructs a query for terms matching <code>term</code>. + /// Constructs a query for terms matching <paramref name="term"/>. /// </summary> - /// <param name="term"> regular expression. </param> - /// <param name="flags"> optional RegExp features from <see cref="RegExpSyntax"/> </param> + /// <param name="term"> Regular expression. </param> + /// <param name="flags"> Optional <see cref="RegExp"/> features from <see cref="RegExpSyntax"/> </param> public RegexpQuery(Term term, RegExpSyntax flags) : this(term, flags, defaultProvider) { } /// <summary> - /// Constructs a query for terms matching <code>term</code>. + /// Constructs a query for terms matching <paramref name="term"/>. /// </summary> - /// <param name="term"> regular expression. </param> - /// <param name="flags"> optional RegExp features from <see cref="RegExpSyntax"/> </param> - /// <param name="provider"> custom AutomatonProvider for named automata </param> + /// <param name="term"> Regular expression. </param> + /// <param name="flags"> Optional <see cref="RegExp"/> features from <see cref="RegExpSyntax"/> </param> + /// <param name="provider"> Custom <see cref="IAutomatonProvider"/> for named automata </param> public RegexpQuery(Term term, RegExpSyntax flags, IAutomatonProvider provider) : base(term, (new RegExp(term.Text(), flags)).ToAutomaton(provider)) { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/ReqExclScorer.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/ReqExclScorer.cs b/src/Lucene.Net/Search/ReqExclScorer.cs index a5d3822..dac790c 100644 --- a/src/Lucene.Net/Search/ReqExclScorer.cs +++ b/src/Lucene.Net/Search/ReqExclScorer.cs @@ -21,11 +21,11 @@ namespace Lucene.Net.Search */ /// <summary> - /// A Scorer for queries with a required subscorer - /// and an excluding (prohibited) sub DocIdSetIterator. - /// <br> - /// this <code>Scorer</code> implements <seealso cref="Scorer#advance(int)"/>, - /// and it uses the skipTo() on the given scorers. + /// A <see cref="Scorer"/> for queries with a required subscorer + /// and an excluding (prohibited) sub <see cref="DocIdSetIterator"/>. + /// <para/> + /// This <see cref="Scorer"/> implements <see cref="DocIdSetIterator.Advance(int)"/>, + /// and it uses the SkipTo() on the given scorers. /// </summary> #if FEATURE_SERIALIZABLE [Serializable] @@ -37,9 +37,9 @@ namespace Lucene.Net.Search private int doc = -1; /// <summary> - /// Construct a <code>ReqExclScorer</code>. </summary> + /// Construct a <see cref="ReqExclScorer"/>. </summary> /// <param name="reqScorer"> The scorer that must match, except where </param> - /// <param name="exclDisi"> indicates exclusion. </param> + /// <param name="exclDisi"> Indicates exclusion. </param> public ReqExclScorer(Scorer reqScorer, DocIdSetIterator exclDisi) : base(reqScorer.m_weight) { @@ -68,15 +68,15 @@ namespace Lucene.Net.Search /// <summary> /// Advance to non excluded doc. - /// <br>On entry: - /// <ul> - /// <li>reqScorer != null, - /// <li>exclScorer != null, - /// <li>reqScorer was advanced once via next() or skipTo() - /// and reqScorer.doc() may still be excluded. - /// </ul> + /// <para/>On entry: + /// <list type="bullet"> + /// <item><description>reqScorer != null,</description></item> + /// <item><description>exclScorer != null,</description></item> + /// <item><description>reqScorer was advanced once via Next() or SkipTo() + /// and reqScorer.Doc may still be excluded.</description></item> + /// </list> /// Advances reqScorer a non excluded required doc, if any. </summary> - /// <returns> true iff there is a non excluded required doc. </returns> + /// <returns> <c>true</c> if there is a non excluded required doc. </returns> private int ToNonExcluded() { int exclDoc = exclDisi.DocID; @@ -112,7 +112,7 @@ namespace Lucene.Net.Search /// <summary> /// Returns the score of the current document matching the query. - /// Initially invalid, until <seealso cref="#nextDoc()"/> is called the first time. </summary> + /// Initially invalid, until <see cref="NextDoc()"/> is called the first time. </summary> /// <returns> The score of the required scorer. </returns> public override float GetScore() { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b2db5313/src/Lucene.Net/Search/ReqOptSumScorer.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/ReqOptSumScorer.cs b/src/Lucene.Net/Search/ReqOptSumScorer.cs index 679e5a7..af31188 100644 --- a/src/Lucene.Net/Search/ReqOptSumScorer.cs +++ b/src/Lucene.Net/Search/ReqOptSumScorer.cs @@ -22,10 +22,10 @@ namespace Lucene.Net.Search */ /// <summary> - /// A Scorer for queries with a required part and an optional part. - /// Delays skipTo() on the optional part until a score() is needed. - /// <br> - /// this <code>Scorer</code> implements <seealso cref="Scorer#advance(int)"/>. + /// A <see cref="Scorer"/> for queries with a required part and an optional part. + /// Delays SkipTo() on the optional part until a GetScore() is needed. + /// <para/> + /// This <see cref="Scorer"/> implements <see cref="DocIdSetIterator.Advance(int)"/>. /// </summary> #if FEATURE_SERIALIZABLE [Serializable] @@ -34,16 +34,16 @@ namespace Lucene.Net.Search { /// <summary> /// The scorers passed from the constructor. - /// These are set to null as soon as their next() or skipTo() returns false. + /// These are set to <c>null</c> as soon as their Next() or SkipTo() returns <c>false</c>. /// </summary> private Scorer reqScorer; private Scorer optScorer; /// <summary> - /// Construct a <code>ReqOptScorer</code>. </summary> - /// <param name="reqScorer"> The required scorer. this must match. </param> - /// <param name="optScorer"> The optional scorer. this is used for scoring only. </param> + /// Construct a <see cref="ReqOptSumScorer"/>. </summary> + /// <param name="reqScorer"> The required scorer. This must match. </param> + /// <param name="optScorer"> The optional scorer. This is used for scoring only. </param> public ReqOptSumScorer(Scorer reqScorer, Scorer optScorer) : base(reqScorer.m_weight) { @@ -70,7 +70,7 @@ namespace Lucene.Net.Search /// <summary> /// Returns the score of the current document matching the query. - /// Initially invalid, until <seealso cref="#nextDoc()"/> is called the first time. </summary> + /// Initially invalid, until <see cref="NextDoc()"/> is called the first time. </summary> /// <returns> The score of the required scorer, eventually increased by the score /// of the optional scorer when it also matches the current document. </returns> public override float GetScore()
