You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by cc...@apache.org on 2011/11/06 06:24:44 UTC
[Lucene.Net] svn commit: r1198132 [13/17] - in /incubator/lucene.net/trunk/src:
contrib/Analyzers/AR/ contrib/Analyzers/BR/ contrib/Analyzers/CJK/
contrib/Analyzers/Cz/ contrib/Analyzers/De/ contrib/Analyzers/Fr/
contrib/Analyzers/Miscellaneous/ contrib/Analyzers/N...
Modified: incubator/lucene.net/trunk/src/core/Search/MultiTermQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/MultiTermQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/MultiTermQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/MultiTermQuery.cs Sun Nov 6 05:24:26 2011
@@ -26,33 +26,33 @@ using ToStringUtils = Lucene.Net.Util.To
namespace Lucene.Net.Search
{
- /// <summary> An abstract {@link Query} that matches documents
- /// containing a subset of terms provided by a {@link
- /// FilteredTermEnum} enumeration.
+ /// <summary> An abstract <see cref="Query" /> that matches documents
+ /// containing a subset of terms provided by a <see cref="FilteredTermEnum" />
+ /// enumeration.
///
/// <p/>This query cannot be used directly; you must subclass
- /// it and define {@link #getEnum} to provide a {@link
- /// FilteredTermEnum} that iterates through the terms to be
+ /// it and define <see cref="GetEnum" /> to provide a <see cref="FilteredTermEnum" />
+ /// that iterates through the terms to be
/// matched.
///
- /// <p/><b>NOTE</b>: if {@link #setRewriteMethod} is either
- /// {@link #CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE} or {@link
- /// #SCORING_BOOLEAN_QUERY_REWRITE}, you may encounter a
- /// {@link BooleanQuery.TooManyClauses} exception during
+ /// <p/><b>NOTE</b>: if <see cref="SetRewriteMethod" /> is either
+ /// <see cref="CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE" /> or <see cref="SCORING_BOOLEAN_QUERY_REWRITE" />
+ ///, you may encounter a
+ /// <see cref="BooleanQuery.TooManyClauses" /> exception during
/// searching, which happens when the number of terms to be
- /// searched exceeds {@link
- /// BooleanQuery#GetMaxClauseCount()}. Setting {@link
- /// #setRewriteMethod} to {@link #CONSTANT_SCORE_FILTER_REWRITE}
+ /// searched exceeds <see cref="BooleanQuery.GetMaxClauseCount()" />
+ ///. Setting <see cref="SetRewriteMethod" />
+ /// to <see cref="CONSTANT_SCORE_FILTER_REWRITE" />
/// prevents this.
///
- /// <p/>The recommended rewrite method is {@link
- /// #CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}: it doesn't spend CPU
+ /// <p/>The recommended rewrite method is <see cref="CONSTANT_SCORE_AUTO_REWRITE_DEFAULT" />
+ ///: it doesn't spend CPU
/// computing unhelpful scores, and it tries to pick the most
/// performant rewrite method given the query.
///
- /// Note that {@link QueryParser} produces
- /// MultiTermQueries using {@link
- /// #CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} by default.
+ /// Note that <see cref="QueryParser" /> produces
+ /// MultiTermQueries using <see cref="CONSTANT_SCORE_AUTO_REWRITE_DEFAULT" />
+ /// by default.
/// </summary>
[Serializable]
public abstract class MultiTermQuery:Query
@@ -76,7 +76,7 @@ namespace Lucene.Net.Search
return Lucene.Net.Search.MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT;
}
}
- /* @deprecated move to sub class */
+ // @deprecated move to sub class
protected internal Term term;
protected internal RewriteMethod rewriteMethod = CONSTANT_SCORE_AUTO_REWRITE_DEFAULT;
[NonSerialized]
@@ -114,11 +114,11 @@ namespace Lucene.Net.Search
/// <p/> This method is faster than the BooleanQuery
/// rewrite methods when the number of matched terms or
/// matched documents is non-trivial. Also, it will never
- /// hit an errant {@link BooleanQuery.TooManyClauses}
+ /// hit an errant <see cref="BooleanQuery.TooManyClauses" />
/// exception.
///
/// </summary>
- /// <seealso cref="setRewriteMethod">
+ /// <seealso cref="SetRewriteMethod">
/// </seealso>
public static readonly RewriteMethod CONSTANT_SCORE_FILTER_REWRITE = new ConstantScoreFilterRewrite();
@@ -162,19 +162,19 @@ namespace Lucene.Net.Search
}
/// <summary>A rewrite method that first translates each term into
- /// {@link BooleanClause.Occur#SHOULD} clause in a
+ /// <see cref="BooleanClause.Occur.SHOULD" /> clause in a
/// BooleanQuery, and keeps the scores as computed by the
/// query. Note that typically such scores are
/// meaningless to the user, and require non-trivial CPU
- /// to compute, so it's almost always better to use {@link
- /// #CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} instead.
+ /// to compute, so it's almost always better to use <see cref="CONSTANT_SCORE_AUTO_REWRITE_DEFAULT" />
+ /// instead.
///
- /// <p/><b>NOTE</b>: This rewrite method will hit {@link
- /// BooleanQuery.TooManyClauses} if the number of terms
- /// exceeds {@link BooleanQuery#getMaxClauseCount}.
+ /// <p/><b>NOTE</b>: This rewrite method will hit <see cref="BooleanQuery.TooManyClauses" />
+ /// if the number of terms
+ /// exceeds <see cref="BooleanQuery.GetMaxClauseCount" />.
///
/// </summary>
- /// <seealso cref="setRewriteMethod">
+ /// <seealso cref="SetRewriteMethod">
/// </seealso>
public static readonly RewriteMethod SCORING_BOOLEAN_QUERY_REWRITE = new ScoringBooleanQueryRewrite();
@@ -196,17 +196,17 @@ namespace Lucene.Net.Search
}
}
- /// <summary>Like {@link #SCORING_BOOLEAN_QUERY_REWRITE} except
+ /// <summary>Like <see cref="SCORING_BOOLEAN_QUERY_REWRITE" /> except
/// scores are not computed. Instead, each matching
/// document receives a constant score equal to the
/// query's boost.
///
- /// <p/><b>NOTE</b>: This rewrite method will hit {@link
- /// BooleanQuery.TooManyClauses} if the number of terms
- /// exceeds {@link BooleanQuery#getMaxClauseCount}.
+ /// <p/><b>NOTE</b>: This rewrite method will hit <see cref="BooleanQuery.TooManyClauses" />
+ /// if the number of terms
+ /// exceeds <see cref="BooleanQuery.GetMaxClauseCount" />.
///
/// </summary>
- /// <seealso cref="setRewriteMethod">
+ /// <seealso cref="SetRewriteMethod">
/// </seealso>
public static readonly RewriteMethod CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE = new ConstantScoreBooleanQueryRewrite();
@@ -214,9 +214,9 @@ namespace Lucene.Net.Search
/// <summary>A rewrite method that tries to pick the best
/// constant-score rewrite method based on term and
/// document counts from the query. If both the number of
- /// terms and documents is small enough, then {@link
- /// #CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE} is used.
- /// Otherwise, {@link #CONSTANT_SCORE_FILTER_REWRITE} is
+ /// terms and documents is small enough, then <see cref="CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE" />
+ /// is used.
+ /// Otherwise, <see cref="CONSTANT_SCORE_FILTER_REWRITE" /> is
/// used.
/// </summary>
[Serializable]
@@ -245,15 +245,15 @@ namespace Lucene.Net.Search
private double docCountPercent;
/// <summary>If the number of terms in this query is equal to or
- /// larger than this setting then {@link
- /// #CONSTANT_SCORE_FILTER_REWRITE} is used.
+ /// larger than this setting then <see cref="CONSTANT_SCORE_FILTER_REWRITE" />
+ /// is used.
/// </summary>
public virtual void SetTermCountCutoff(int count)
{
termCountCutoff = count;
}
- /// <seealso cref="setTermCountCutoff">
+ /// <seealso cref="SetTermCountCutoff">
/// </seealso>
public virtual int GetTermCountCutoff()
{
@@ -262,8 +262,8 @@ namespace Lucene.Net.Search
/// <summary>If the number of documents to be visited in the
/// postings exceeds this specified percentage of the
- /// maxDoc() for the index, then {@link
- /// #CONSTANT_SCORE_FILTER_REWRITE} is used.
+ /// maxDoc() for the index, then <see cref="CONSTANT_SCORE_FILTER_REWRITE" />
+ /// is used.
/// </summary>
/// <param name="percent">0.0 to 100.0
/// </param>
@@ -272,7 +272,7 @@ namespace Lucene.Net.Search
docCountPercent = percent;
}
- /// <seealso cref="setDocCountPercent">
+ /// <seealso cref="SetDocCountPercent">
/// </seealso>
public virtual double GetDocCountPercent()
{
@@ -369,22 +369,22 @@ namespace Lucene.Net.Search
}
}
- /// <summary>Read-only default instance of {@link
- /// ConstantScoreAutoRewrite}, with {@link
- /// ConstantScoreAutoRewrite#setTermCountCutoff} set to
- /// {@link
- /// ConstantScoreAutoRewrite#DEFAULT_TERM_COUNT_CUTOFF}
- /// and {@link
- /// ConstantScoreAutoRewrite#setDocCountPercent} set to
- /// {@link
- /// ConstantScoreAutoRewrite#DEFAULT_DOC_COUNT_PERCENT}.
+ /// <summary>Read-only default instance of <see cref="ConstantScoreAutoRewrite" />
+ ///, with <see cref="ConstantScoreAutoRewrite.SetTermCountCutoff" />
+ /// set to
+ /// <see cref="ConstantScoreAutoRewrite.DEFAULT_TERM_COUNT_CUTOFF" />
+ ///
+ /// and <see cref="ConstantScoreAutoRewrite.SetDocCountPercent" />
+ /// set to
+ /// <see cref="ConstantScoreAutoRewrite.DEFAULT_DOC_COUNT_PERCENT" />
+ ///.
/// Note that you cannot alter the configuration of this
/// instance; you'll need to create a private instance
/// instead.
/// </summary>
public static readonly RewriteMethod CONSTANT_SCORE_AUTO_REWRITE_DEFAULT;
- /// <summary> Constructs a query for terms matching <code>term</code>.</summary>
+ /// <summary> Constructs a query for terms matching <c>term</c>.</summary>
/// <deprecated> check sub class for possible term access - the Term does not
/// make sense for all MultiTermQuerys and will be removed.
/// </deprecated>
@@ -420,14 +420,14 @@ namespace Lucene.Net.Search
/// <p/>This method is not thread safe, be sure to only call it when no query is running!
/// If you re-use the same query instance for another
/// search, be sure to first reset the term counter
- /// with {@link #clearTotalNumberOfTerms}.
+ /// with <see cref="ClearTotalNumberOfTerms" />.
/// <p/>On optimized indexes / no MultiReaders, you get the correct number of
/// unique terms for the whole index. Use this number to compare different queries.
/// For non-optimized indexes this number can also be achived in
/// non-constant-score mode. In constant-score mode you get the total number of
/// terms seeked for all segments / sub-readers.
/// </summary>
- /// <seealso cref="clearTotalNumberOfTerms">
+ /// <seealso cref="ClearTotalNumberOfTerms">
/// </seealso>
public virtual int GetTotalNumberOfTerms()
{
@@ -437,7 +437,7 @@ namespace Lucene.Net.Search
/// <summary> Expert: Resets the counting of unique terms.
/// Do this before executing the query/filter.
/// </summary>
- /// <seealso cref="getTotalNumberOfTerms">
+ /// <seealso cref="GetTotalNumberOfTerms">
/// </seealso>
public virtual void ClearTotalNumberOfTerms()
{
@@ -479,7 +479,7 @@ namespace Lucene.Net.Search
return buffer.ToString();
}
- /// <seealso cref="setRewriteMethod">
+ /// <seealso cref="SetRewriteMethod">
/// </seealso>
public virtual RewriteMethod GetRewriteMethod()
{
@@ -488,7 +488,7 @@ namespace Lucene.Net.Search
/// <summary> Sets the rewrite method to be used when executing the
/// query. You can use one of the four core methods, or
- /// implement your own subclass of {@link RewriteMethod}.
+ /// implement your own subclass of <see cref="RewriteMethod" />.
/// </summary>
public virtual void SetRewriteMethod(RewriteMethod method)
{
Modified: incubator/lucene.net/trunk/src/core/Search/MultiTermQueryWrapperFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/MultiTermQueryWrapperFilter.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/MultiTermQueryWrapperFilter.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/MultiTermQueryWrapperFilter.cs Sun Nov 6 05:24:26 2011
@@ -26,17 +26,17 @@ using OpenBitSet = Lucene.Net.Util.OpenB
namespace Lucene.Net.Search
{
- /// <summary> A wrapper for {@link MultiTermQuery}, that exposes its
- /// functionality as a {@link Filter}.
+ /// <summary> A wrapper for <see cref="MultiTermQuery" />, that exposes its
+ /// functionality as a <see cref="Filter" />.
/// <p/>
- /// <code>MultiTermQueryWrapperFilter</code> is not designed to
+ /// <c>MultiTermQueryWrapperFilter</c> is not designed to
/// be used by itself. Normally you subclass it to provide a Filter
- /// counterpart for a {@link MultiTermQuery} subclass.
+ /// counterpart for a <see cref="MultiTermQuery" /> subclass.
/// <p/>
- /// For example, {@link TermRangeFilter} and {@link PrefixFilter} extend
- /// <code>MultiTermQueryWrapperFilter</code>.
+ /// For example, <see cref="TermRangeFilter" /> and <see cref="PrefixFilter" /> extend
+ /// <c>MultiTermQueryWrapperFilter</c>.
/// This class also provides the functionality behind
- /// {@link MultiTermQuery#CONSTANT_SCORE_FILTER_REWRITE};
+ /// <see cref="MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE" />;
/// this is why it is not abstract.
/// </summary>
[Serializable]
@@ -98,7 +98,7 @@ namespace Lucene.Net.Search
protected internal MultiTermQuery query;
- /// <summary> Wrap a {@link MultiTermQuery} as a Filter.</summary>
+ /// <summary> Wrap a <see cref="MultiTermQuery" /> as a Filter.</summary>
protected internal MultiTermQueryWrapperFilter(MultiTermQuery query)
{
this.query = query;
@@ -137,9 +137,9 @@ namespace Lucene.Net.Search
/// <p/>This method is not thread safe, be sure to only call it when no filter is running!
/// If you re-use the same filter instance for another
/// search, be sure to first reset the term counter
- /// with {@link #clearTotalNumberOfTerms}.
+ /// with <see cref="ClearTotalNumberOfTerms" />.
/// </summary>
- /// <seealso cref="clearTotalNumberOfTerms">
+ /// <seealso cref="ClearTotalNumberOfTerms">
/// </seealso>
public virtual int GetTotalNumberOfTerms()
{
@@ -149,7 +149,7 @@ namespace Lucene.Net.Search
/// <summary> Expert: Resets the counting of unique terms.
/// Do this before executing the filter.
/// </summary>
- /// <seealso cref="getTotalNumberOfTerms">
+ /// <seealso cref="GetTotalNumberOfTerms">
/// </seealso>
public virtual void ClearTotalNumberOfTerms()
{
@@ -205,7 +205,7 @@ namespace Lucene.Net.Search
/// permitted in search results, and false for those that should
/// not.
/// </summary>
- /// <deprecated> Use {@link #GetDocIdSet(IndexReader)} instead.
+ /// <deprecated> Use <see cref="GetDocIdSet(IndexReader)" /> instead.
/// </deprecated>
//@Override
[Obsolete("Use GetDocIdSet(IndexReader) instead.")]
Modified: incubator/lucene.net/trunk/src/core/Search/NumericRangeFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/NumericRangeFilter.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/NumericRangeFilter.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/NumericRangeFilter.cs Sun Nov 6 05:24:26 2011
@@ -24,23 +24,23 @@ using NumericUtils = Lucene.Net.Util.Num
namespace Lucene.Net.Search
{
- /// <summary> A {@link Filter} that only accepts numeric values within
+ /// <summary> A <see cref="Filter" /> that only accepts numeric values within
/// a specified range. To use this, you must first index the
- /// numeric values using {@link NumericField} (expert: {@link
- /// NumericTokenStream}).
+ /// numeric values using <see cref="NumericField" /> (expert: <see cref="NumericTokenStream" />
+ ///).
///
/// <p/>You create a new NumericRangeFilter with the static
/// factory methods, eg:
///
- /// <pre>
+ /// <code>
/// Filter f = NumericRangeFilter.newFloatRange("weight",
- /// new Float(0.3f), new Float(0.10f),
- /// true, true);
- /// </pre>
+ /// new Float(0.3f), new Float(0.10f),
+ /// true, true);
+ /// </code>
///
/// accepts all documents whose float valued "weight" field
/// ranges from 0.3 to 0.10, inclusive.
- /// See {@link NumericRangeQuery} for details on how Lucene
+ /// See <see cref="NumericRangeQuery" /> for details on how Lucene
/// indexes and searches numeric valued fields.
///
/// <p/><font color="red"><b>NOTE:</b> This API is experimental and
@@ -59,10 +59,10 @@ namespace Lucene.Net.Search
{
}
- /// <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>.
+ /// <summary> Factory that creates a <c>NumericRangeFilter</c>, that filters a <c>long</c>
+ /// range using the given <a href="NumericRangeQuery.html#precisionStepDesc"><c>precisionStep</c></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 false, it will
/// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
/// </summary>
public static NumericRangeFilter NewLongRange(System.String field, int precisionStep, System.ValueType min, System.ValueType max, bool minInclusive, bool maxInclusive)
@@ -70,10 +70,10 @@ namespace Lucene.Net.Search
return new NumericRangeFilter(NumericRangeQuery.NewLongRange(field, precisionStep, min, max, minInclusive, maxInclusive));
}
- /// <summary> Factory that creates a <code>NumericRangeFilter</code>, that queries a <code>long</code>
- /// range using the default <code>precisionStep</code> {@link NumericUtils#PRECISION_STEP_DEFAULT} (4).
+ /// <summary> Factory that creates a <c>NumericRangeFilter</c>, that queries a <c>long</c>
+ /// range using the default <c>precisionStep</c> <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 false, it will
/// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
/// </summary>
public static NumericRangeFilter NewLongRange(System.String field, System.ValueType min, System.ValueType max, bool minInclusive, bool maxInclusive)
@@ -81,10 +81,10 @@ namespace Lucene.Net.Search
return new NumericRangeFilter(NumericRangeQuery.NewLongRange(field, min, max, minInclusive, maxInclusive));
}
- /// <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>.
+ /// <summary> Factory that creates a <c>NumericRangeFilter</c>, that filters a <c>int</c>
+ /// range using the given <a href="NumericRangeQuery.html#precisionStepDesc"><c>precisionStep</c></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 false, it will
/// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
/// </summary>
public static NumericRangeFilter NewIntRange(System.String field, int precisionStep, System.ValueType min, System.ValueType max, bool minInclusive, bool maxInclusive)
@@ -92,10 +92,10 @@ namespace Lucene.Net.Search
return new NumericRangeFilter(NumericRangeQuery.NewIntRange(field, precisionStep, min, max, minInclusive, maxInclusive));
}
- /// <summary> Factory that creates a <code>NumericRangeFilter</code>, that queries a <code>int</code>
- /// range using the default <code>precisionStep</code> {@link NumericUtils#PRECISION_STEP_DEFAULT} (4).
+ /// <summary> Factory that creates a <c>NumericRangeFilter</c>, that queries a <c>int</c>
+ /// range using the default <c>precisionStep</c> <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 false, it will
/// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
/// </summary>
public static NumericRangeFilter NewIntRange(System.String field, System.ValueType min, System.ValueType max, bool minInclusive, bool maxInclusive)
@@ -103,10 +103,10 @@ namespace Lucene.Net.Search
return new NumericRangeFilter(NumericRangeQuery.NewIntRange(field, min, max, minInclusive, maxInclusive));
}
- /// <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>.
+ /// <summary> Factory that creates a <c>NumericRangeFilter</c>, that filters a <c>double</c>
+ /// range using the given <a href="NumericRangeQuery.html#precisionStepDesc"><c>precisionStep</c></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 false, it will
/// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
/// </summary>
public static NumericRangeFilter NewDoubleRange(System.String field, int precisionStep, System.Double min, System.Double max, bool minInclusive, bool maxInclusive)
@@ -114,10 +114,10 @@ namespace Lucene.Net.Search
return new NumericRangeFilter(NumericRangeQuery.NewDoubleRange(field, precisionStep, min, max, minInclusive, maxInclusive));
}
- /// <summary> Factory that creates a <code>NumericRangeFilter</code>, that queries a <code>double</code>
- /// range using the default <code>precisionStep</code> {@link NumericUtils#PRECISION_STEP_DEFAULT} (4).
+ /// <summary> Factory that creates a <c>NumericRangeFilter</c>, that queries a <c>double</c>
+ /// range using the default <c>precisionStep</c> <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 false, it will
/// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
/// </summary>
public static NumericRangeFilter NewDoubleRange(System.String field, System.Double min, System.Double max, bool minInclusive, bool maxInclusive)
@@ -125,10 +125,10 @@ namespace Lucene.Net.Search
return new NumericRangeFilter(NumericRangeQuery.NewDoubleRange(field, min, max, minInclusive, maxInclusive));
}
- /// <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>.
+ /// <summary> Factory that creates a <c>NumericRangeFilter</c>, that filters a <c>float</c>
+ /// range using the given <a href="NumericRangeQuery.html#precisionStepDesc"><c>precisionStep</c></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 false, it will
/// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
/// </summary>
public static NumericRangeFilter NewFloatRange(System.String field, int precisionStep, System.Single min, System.Single max, bool minInclusive, bool maxInclusive)
@@ -136,10 +136,10 @@ namespace Lucene.Net.Search
return new NumericRangeFilter(NumericRangeQuery.NewFloatRange(field, precisionStep, min, max, minInclusive, maxInclusive));
}
- /// <summary> Factory that creates a <code>NumericRangeFilter</code>, that queries a <code>float</code>
- /// range using the default <code>precisionStep</code> {@link NumericUtils#PRECISION_STEP_DEFAULT} (4).
+ /// <summary> Factory that creates a <c>NumericRangeFilter</c>, that queries a <c>float</c>
+ /// range using the default <c>precisionStep</c> <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 false, it will
/// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
/// </summary>
public static NumericRangeFilter NewFloatRange(System.String field, System.Single min, System.Single max, bool minInclusive, bool maxInclusive)
@@ -153,13 +153,13 @@ namespace Lucene.Net.Search
return ((NumericRangeQuery) query).GetField();
}
- /// <summary>Returns <code>true</code> if the lower endpoint is inclusive </summary>
+ /// <summary>Returns <c>true</c> if the lower endpoint is inclusive </summary>
public bool IncludesMin()
{
return ((NumericRangeQuery) query).IncludesMin();
}
- /// <summary>Returns <code>true</code> if the upper endpoint is inclusive </summary>
+ /// <summary>Returns <c>true</c> if the upper endpoint is inclusive </summary>
public bool IncludesMax()
{
return ((NumericRangeQuery) query).IncludesMax();
Modified: incubator/lucene.net/trunk/src/core/Search/NumericRangeQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/NumericRangeQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/NumericRangeQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/NumericRangeQuery.cs Sun Nov 6 05:24:26 2011
@@ -28,48 +28,48 @@ using ToStringUtils = Lucene.Net.Util.To
namespace Lucene.Net.Search
{
- /// <summary> <p/>A {@link Query} that matches numeric values within a
+ /// <summary> <p/>A <see cref="Query" /> that matches numeric values within a
/// specified range. To use this, you must first index the
- /// numeric values using {@link NumericField} (expert: {@link
- /// NumericTokenStream}). If your terms are instead textual,
- /// you should use {@link TermRangeQuery}. {@link
- /// NumericRangeFilter} is the filter equivalent of this
+ /// numeric values using <see cref="NumericField" /> (expert: <see cref="NumericTokenStream" />
+ ///). If your terms are instead textual,
+ /// you should use <see cref="TermRangeQuery" />. <see cref="NumericRangeFilter" />
+ /// is the filter equivalent of this
/// query.<p/>
///
/// <p/>You create a new NumericRangeQuery with the static
/// factory methods, eg:
///
- /// <pre>
+ /// <code>
/// Query q = NumericRangeQuery.newFloatRange("weight",
/// new Float(0.3f), new Float(0.10f),
/// true, true);
- /// </pre>
+ /// </code>
///
/// matches all documents whose float valued "weight" field
/// ranges from 0.3 to 0.10, inclusive.
///
/// <p/>The performance of NumericRangeQuery is much better
- /// than the corresponding {@link TermRangeQuery} because the
+ /// 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/>
///
/// <p/>You can optionally specify a <a
- /// href="#precisionStepDesc"><code>precisionStep</code></a>
+ /// href="#precisionStepDesc"><c>precisionStep</c></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.
///
- /// <p/>This query defaults to {@linkplain
- /// MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} for
+ /// <p/>This query defaults to
+ /// <see cref="MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT"/> for
/// 32 bit (int/float) ranges with precisionStep <8 and 64
/// bit (long/double) ranges with precisionStep <6.
- /// Otherwise it uses {@linkplain
- /// MultiTermQuery#CONSTANT_SCORE_FILTER_REWRITE} as the
+ /// Otherwise it uses
+ /// <see cref="MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE"/> as the
/// number of terms is likely to be high. With precision
/// steps of <4, this query can be run with one of the
/// BooleanQuery rewrite methods without changing
@@ -81,7 +81,7 @@ namespace Lucene.Net.Search
/// <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>):
+ /// where this algorithm was described (referred to as <c>TrieRangeQuery</c>):
///
/// <blockquote><strong>Schindler, U, Diepenbroek, M</strong>, 2008.
/// <em>Generic XML-based Framework for Metadata Portals.</em>
@@ -97,52 +97,52 @@ namespace Lucene.Net.Search
/// (all numerical values like doubles, longs, floats, and ints are converted to
/// lexicographic sortable string representations and stored with different precisions
/// (for a more detailed description of how the values are stored,
- /// see {@link 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/>
///
/// <p/>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
+ /// <c>7*255*2 + 255 = 3825</c> 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/>
///
/// <a name="precisionStepDesc"/><h3>Precision Step</h3>
- /// <p/>You can choose any <code>precisionStep</code> when encoding values.
+ /// <p/>You can choose any <c>precisionStep</c> when encoding values.
/// Lower step values mean more precisions and so more terms in index (and index gets larger).
/// On the other hand, the maximum number of terms to match reduces, which optimized query speed.
/// The formula to calculate the maximum term count is:
- /// <pre>
+ /// <code>
/// n = [ (bitsPerValue/precisionStep - 1) * (2^precisionStep - 1 ) * 2 ] + (2^precisionStep - 1 )
- /// </pre>
- /// <p/><em>(this formula is only correct, when <code>bitsPerValue/precisionStep</code> is an integer;
+ /// </code>
+ /// <p/><em>(this formula is only correct, when <c>bitsPerValue/precisionStep</c> is an integer;
/// in other cases, the value must be rounded up and the last summand must contain the modulo of the division as
/// precision step)</em>.
- /// For longs stored using a precision step of 4, <code>n = 15*15*2 + 15 = 465</code>, and for a precision
- /// step of 2, <code>n = 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
+ /// For longs stored using a precision step of 4, <c>n = 15*15*2 + 15 = 465</c>, and for a precision
+ /// step of 2, <c>n = 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 <c>precisionStep</c> 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/>
///
- /// <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>
- /// <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>
- /// <li>Ideal value in most cases for <em>32 bit</em> data types <em>(int, float)</em> is <b>4</b>.</li>
- /// <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 {@link TermRangeQuery}. But it can be used
- /// to produce fields, that are solely used for sorting (in this case simply use {@link Integer#MAX_VALUE} as
- /// <code>precisionStep</code>). Using {@link NumericField NumericFields} for sorting
+ /// <p/>Good values for <c>precisionStep</c> are depending on usage and data type:
+ /// <list type="bullet">
+ /// <item>The default for all data types is <b>4</b>, which is used, when no <c>precisionStep</c> is given.</item>
+ /// <item>Ideal value in most cases for <em>64 bit</em> data types <em>(long, double)</em> is <b>6</b> or <b>8</b>.</item>
+ /// <item>Ideal value in most cases for <em>32 bit</em> data types <em>(int, float)</em> is <b>4</b>.</item>
+ /// <item>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
+ /// <c>precisionStep</c>). Using <see cref="NumericField">NumericFields</see> for sorting
/// is ideal, because building the field cache is much faster than with text-only numbers.
- /// Sorting is also possible with range query optimized fields using one of the above <code>precisionSteps</code>.</li>
- /// </ul>
+ /// Sorting is also possible with range query optimized fields using one of the above <c>precisionSteps</c>.</item>
+ /// </list>
///
/// <p/>Comparisons of the different types of RangeQueries on an index with about 500,000 docs showed
- /// that {@link TermRangeQuery} in boolean rewrite mode (with raised {@link BooleanQuery} clause count)
- /// took about 30-40 secs to complete, {@link TermRangeQuery} in constant score filter rewrite mode took 5 secs
+ /// 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/>
@@ -196,10 +196,10 @@ namespace Lucene.Net.Search
}
}
- /// <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>.
+ /// <summary> Factory that creates a <c>NumericRangeQuery</c>, that queries a <c>long</c>
+ /// range using the given <a href="#precisionStepDesc"><c>precisionStep</c></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 false, it will
/// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
/// </summary>
public static NumericRangeQuery NewLongRange(System.String field, int precisionStep, System.ValueType min, System.ValueType max, bool minInclusive, bool maxInclusive)
@@ -207,10 +207,10 @@ namespace Lucene.Net.Search
return new NumericRangeQuery(field, precisionStep, 64, min, max, minInclusive, maxInclusive);
}
- /// <summary> Factory that creates a <code>NumericRangeQuery</code>, that queries a <code>long</code>
- /// range using the default <code>precisionStep</code> {@link NumericUtils#PRECISION_STEP_DEFAULT} (4).
+ /// <summary> Factory that creates a <c>NumericRangeQuery</c>, that queries a <c>long</c>
+ /// range using the default <c>precisionStep</c> <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 false, it will
/// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
/// </summary>
public static NumericRangeQuery NewLongRange(System.String field, System.ValueType min, System.ValueType max, bool minInclusive, bool maxInclusive)
@@ -218,10 +218,10 @@ namespace Lucene.Net.Search
return new NumericRangeQuery(field, NumericUtils.PRECISION_STEP_DEFAULT, 64, min, max, minInclusive, maxInclusive);
}
- /// <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>.
+ /// <summary> Factory that creates a <c>NumericRangeQuery</c>, that queries a <c>int</c>
+ /// range using the given <a href="#precisionStepDesc"><c>precisionStep</c></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 false, it will
/// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
/// </summary>
public static NumericRangeQuery NewIntRange(System.String field, int precisionStep, System.ValueType min, System.ValueType max, bool minInclusive, bool maxInclusive)
@@ -229,10 +229,10 @@ namespace Lucene.Net.Search
return new NumericRangeQuery(field, precisionStep, 32, min, max, minInclusive, maxInclusive);
}
- /// <summary> Factory that creates a <code>NumericRangeQuery</code>, that queries a <code>int</code>
- /// range using the default <code>precisionStep</code> {@link NumericUtils#PRECISION_STEP_DEFAULT} (4).
+ /// <summary> Factory that creates a <c>NumericRangeQuery</c>, that queries a <c>int</c>
+ /// range using the default <c>precisionStep</c> <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 false, it will
/// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
/// </summary>
public static NumericRangeQuery NewIntRange(System.String field, System.ValueType min, System.ValueType max, bool minInclusive, bool maxInclusive)
@@ -240,10 +240,10 @@ namespace Lucene.Net.Search
return new NumericRangeQuery(field, NumericUtils.PRECISION_STEP_DEFAULT, 32, min, max, minInclusive, maxInclusive);
}
- /// <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>.
+ /// <summary> Factory that creates a <c>NumericRangeQuery</c>, that queries a <c>double</c>
+ /// range using the given <a href="#precisionStepDesc"><c>precisionStep</c></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 false, it will
/// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
/// </summary>
public static NumericRangeQuery NewDoubleRange(System.String field, int precisionStep, System.Double min, System.Double max, bool minInclusive, bool maxInclusive)
@@ -251,10 +251,10 @@ namespace Lucene.Net.Search
return new NumericRangeQuery(field, precisionStep, 64, min, max, minInclusive, maxInclusive);
}
- /// <summary> Factory that creates a <code>NumericRangeQuery</code>, that queries a <code>double</code>
- /// range using the default <code>precisionStep</code> {@link NumericUtils#PRECISION_STEP_DEFAULT} (4).
+ /// <summary> Factory that creates a <c>NumericRangeQuery</c>, that queries a <c>double</c>
+ /// range using the default <c>precisionStep</c> <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 false, it will
/// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
/// </summary>
public static NumericRangeQuery NewDoubleRange(System.String field, System.Double min, System.Double max, bool minInclusive, bool maxInclusive)
@@ -262,10 +262,10 @@ namespace Lucene.Net.Search
return new NumericRangeQuery(field, NumericUtils.PRECISION_STEP_DEFAULT, 64, min, max, minInclusive, maxInclusive);
}
- /// <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>.
+ /// <summary> Factory that creates a <c>NumericRangeQuery</c>, that queries a <c>float</c>
+ /// range using the given <a href="#precisionStepDesc"><c>precisionStep</c></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 false, it will
/// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
/// </summary>
public static NumericRangeQuery NewFloatRange(System.String field, int precisionStep, System.Single min, System.Single max, bool minInclusive, bool maxInclusive)
@@ -273,10 +273,10 @@ namespace Lucene.Net.Search
return new NumericRangeQuery(field, precisionStep, 32, min, max, minInclusive, maxInclusive);
}
- /// <summary> Factory that creates a <code>NumericRangeQuery</code>, that queries a <code>float</code>
- /// range using the default <code>precisionStep</code> {@link NumericUtils#PRECISION_STEP_DEFAULT} (4).
+ /// <summary> Factory that creates a <c>NumericRangeQuery</c>, that queries a <c>float</c>
+ /// range using the default <c>precisionStep</c> <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 false, it will
/// match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
/// </summary>
public static NumericRangeQuery NewFloatRange(System.String field, System.Single min, System.Single max, bool minInclusive, bool maxInclusive)
@@ -296,13 +296,13 @@ namespace Lucene.Net.Search
return field;
}
- /// <summary>Returns <code>true</code> if the lower endpoint is inclusive </summary>
+ /// <summary>Returns <c>true</c> if the lower endpoint is inclusive </summary>
public bool IncludesMin()
{
return minInclusive;
}
- /// <summary>Returns <code>true</code> if the upper endpoint is inclusive </summary>
+ /// <summary>Returns <c>true</c> if the upper endpoint is inclusive </summary>
public bool IncludesMax()
{
return maxInclusive;
@@ -383,10 +383,10 @@ namespace Lucene.Net.Search
/// sub-ranges for trie range queries.
/// <p/>
/// WARNING: This term enumeration is not guaranteed to be always ordered by
- /// {@link Term#compareTo}.
- /// The ordering depends on how {@link NumericUtils#splitLongRange} and
- /// {@link NumericUtils#splitIntRange} generates the sub-ranges. For
- /// {@link MultiTermQuery} ordering is not relevant.
+ /// <see cref="Term.CompareTo(Term)" />.
+ /// The ordering depends on how <see cref="NumericUtils.SplitLongRange" /> and
+ /// <see cref="NumericUtils.SplitIntRange" /> generates the sub-ranges. For
+ /// <see cref="MultiTermQuery" /> ordering is not relevant.
/// </summary>
private sealed class NumericRangeTermEnum:FilteredTermEnum
{
@@ -574,8 +574,8 @@ namespace Lucene.Net.Search
/// <summary> Compares if current upper bound is reached,
/// this also updates the term count for statistics.
- /// In contrast to {@link FilteredTermEnum}, a return value
- /// of <code>false</code> ends iterating the current enum
+ /// In contrast to <see cref="FilteredTermEnum" />, a return value
+ /// of <c>false</c> ends iterating the current enum
/// and forwards to the next sub-range.
/// </summary>
//@Override
Modified: incubator/lucene.net/trunk/src/core/Search/ParallelMultiSearcher.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/ParallelMultiSearcher.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/ParallelMultiSearcher.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/ParallelMultiSearcher.cs Sun Nov 6 05:24:26 2011
@@ -24,10 +24,10 @@ using PriorityQueue = Lucene.Net.Util.Pr
namespace Lucene.Net.Search
{
- /// <summary>Implements parallel search over a set of <code>Searchables</code>.
+ /// <summary>Implements parallel search over a set of <c>Searchables</c>.
///
- /// <p/>Applications usually need only call the inherited {@link #Search(Query)}
- /// or {@link #Search(Query,Filter)} methods.
+ /// <p/>Applications usually need only call the inherited <see cref="Searcher.Search(Query)" />
+ /// or <see cref="Searcher.Search(Query,Filter)" /> methods.
/// </summary>
public class ParallelMultiSearcher:MultiSearcher
{
@@ -196,11 +196,11 @@ namespace Lucene.Net.Search
/// <summary>Lower-level search API.
///
- /// <p/>{@link Collector#Collect(int)} is called for every matching document.
+ /// <p/><see cref="Collector.Collect(int)" /> is called for every matching document.
///
/// <p/>Applications should only use this if they need <i>all</i> of the
- /// matching documents. The high-level search API ({@link
- /// Searcher#Search(Query)}) is usually more efficient, as it skips
+ /// matching documents. The high-level search API (<see cref="Searcher.Search(Query)" />)
+ /// is usually more efficient, as it skips
/// non-high-scoring hits.
///
/// </summary>
@@ -225,10 +225,10 @@ namespace Lucene.Net.Search
}
}
- /*
- * TODO: this one could be parallelized too
- * @see Lucene.Net.Search.Searchable#rewrite(Lucene.Net.Search.Query)
- */
+ /// <summary>
+ /// <para>TODO: this one could be parallelized too</para>
+ /// <para><see cref="Lucene.Net.Search.Searchable.Rewrite(Lucene.Net.Search.Query)"/></para>
+ /// </summary>
public override Query Rewrite(Query original)
{
return base.Rewrite(original);
Modified: incubator/lucene.net/trunk/src/core/Search/Payloads/BoostingTermQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Payloads/BoostingTermQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Payloads/BoostingTermQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Payloads/BoostingTermQuery.cs Sun Nov 6 05:24:26 2011
@@ -27,11 +27,11 @@ using TermSpans = Lucene.Net.Search.Span
namespace Lucene.Net.Search.Payloads
{
- /// <summary> The BoostingTermQuery is very similar to the {@link Lucene.Net.Search.Spans.SpanTermQuery} except
+ /// <summary> The BoostingTermQuery is very similar to the <see cref="Lucene.Net.Search.Spans.SpanTermQuery" /> except
/// that it factors in the value of the payload located at each of the positions where the
- /// {@link Lucene.Net.Index.Term} occurs.
+ /// <see cref="Lucene.Net.Index.Term" /> occurs.
/// <p/>
- /// In order to take advantage of this, you must override {@link Lucene.Net.Search.Similarity#ScorePayload(String, byte[],int,int)}
+ /// In order to take advantage of this, you must override <see cref="Lucene.Net.Search.Similarity.ScorePayload(String, byte[],int,int)" />
/// which returns 1 by default.
/// <p/>
/// Payload scores are averaged across term occurrences in the document.
@@ -40,7 +40,7 @@ namespace Lucene.Net.Search.Payloads
/// <seealso cref="Lucene.Net.Search.Similarity.ScorePayload(String, byte[], int, int)">
///
/// </seealso>
- /// <deprecated> See {@link Lucene.Net.Search.Payloads.PayloadTermQuery}
+ /// <deprecated> See <see cref="Lucene.Net.Search.Payloads.PayloadTermQuery" />
/// </deprecated>
[Obsolete("See Lucene.Net.Search.Payloads.PayloadTermQuery")]
[Serializable]
Modified: incubator/lucene.net/trunk/src/core/Search/Payloads/PayloadNearQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Payloads/PayloadNearQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Payloads/PayloadNearQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Payloads/PayloadNearQuery.cs Sun Nov 6 05:24:26 2011
@@ -35,15 +35,15 @@ namespace Lucene.Net.Search.Payloads
{
/// <summary> This class is very similar to
- /// {@link Lucene.Net.Search.Spans.SpanNearQuery} except that it factors
+ /// <see cref="Lucene.Net.Search.Spans.SpanNearQuery" /> except that it factors
/// in the value of the payloads located at each of the positions where the
- /// {@link Lucene.Net.Search.Spans.TermSpans} occurs.
+ /// <see cref="Lucene.Net.Search.Spans.TermSpans" /> occurs.
/// <p/>
/// In order to take advantage of this, you must override
- /// {@link Lucene.Net.Search.Similarity#ScorePayload(String, byte[],int,int)}
+ /// <see cref="Lucene.Net.Search.Similarity.ScorePayload(String, byte[],int,int)" />
/// which returns 1 by default.
/// <p/>
- /// Payload scores are aggregated using a pluggable {@link PayloadFunction}.
+ /// Payload scores are aggregated using a pluggable <see cref="PayloadFunction" />.
///
/// </summary>
/// <seealso cref="Lucene.Net.Search.Similarity.ScorePayload(String, byte[], int,int)">
@@ -228,7 +228,7 @@ namespace Lucene.Net.Search.Payloads
}
}
- /// <summary> By default, uses the {@link PayloadFunction} to score the payloads, but
+ /// <summary> By default, uses the <see cref="PayloadFunction" /> to score the payloads, but
/// can be overridden to do other things.
///
/// </summary>
Modified: incubator/lucene.net/trunk/src/core/Search/Payloads/PayloadTermQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Payloads/PayloadTermQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Payloads/PayloadTermQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Payloads/PayloadTermQuery.cs Sun Nov 6 05:24:26 2011
@@ -35,15 +35,15 @@ namespace Lucene.Net.Search.Payloads
{
/// <summary> This class is very similar to
- /// {@link Lucene.Net.Search.Spans.SpanTermQuery} except that it factors
+ /// <see cref="Lucene.Net.Search.Spans.SpanTermQuery" /> except that it factors
/// in the value of the payload located at each of the positions where the
- /// {@link Lucene.Net.Index.Term} occurs.
+ /// <see cref="Lucene.Net.Index.Term" /> occurs.
/// <p/>
/// In order to take advantage of this, you must override
- /// {@link Lucene.Net.Search.Similarity#ScorePayload(String, byte[],int,int)}
+ /// <see cref="Lucene.Net.Search.Similarity.ScorePayload(String, byte[],int,int)" />
/// which returns 1 by default.
/// <p/>
- /// Payload scores are aggregated using a pluggable {@link PayloadFunction}.
+ /// Payload scores are aggregated using a pluggable <see cref="PayloadFunction" />.
///
/// </summary>
[Serializable]
@@ -160,7 +160,7 @@ namespace Lucene.Net.Search.Payloads
}
/// <summary> </summary>
- /// <returns> {@link #GetSpanScore()} * {@link #GetPayloadScore()}
+ /// <returns> <see cref="GetSpanScore()" /> * <see cref="GetPayloadScore()" />
/// </returns>
/// <throws> IOException </throws>
public override float Score()
@@ -190,7 +190,7 @@ namespace Lucene.Net.Search.Payloads
///
/// </summary>
/// <returns> The score, as calculated by
- /// {@link PayloadFunction#DocScore(int, String, int, float)}
+ /// <see cref="PayloadFunction.DocScore(int, String, int, float)" />
/// </returns>
protected internal virtual float GetPayloadScore()
{
Modified: incubator/lucene.net/trunk/src/core/Search/PhrasePositions.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/PhrasePositions.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/PhrasePositions.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/PhrasePositions.cs Sun Nov 6 05:24:26 2011
@@ -74,9 +74,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
+ /// <c>position</c> as <c>location - offset</c>, so that a
/// matching exact phrase is easily identified when all PhrasePositions
- /// have exactly the same <code>position</code>.
+ /// have exactly the same <c>position</c>.
/// </summary>
internal bool NextPosition()
{
Modified: incubator/lucene.net/trunk/src/core/Search/PhraseQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/PhraseQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/PhraseQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/PhraseQuery.cs Sun Nov 6 05:24:26 2011
@@ -27,9 +27,9 @@ namespace Lucene.Net.Search
{
/// <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 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 {@link BooleanQuery}.
+ /// <p/>This query may be combined with other terms or queries with a <see cref="BooleanQuery" />.
/// </summary>
[Serializable]
public class PhraseQuery:Query
@@ -47,7 +47,7 @@ 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.
+ /// 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
@@ -288,7 +288,7 @@ namespace Lucene.Net.Search
return new PhraseWeight(this, searcher);
}
- /// <seealso cref="Lucene.Net.Search.Query.ExtractTerms(java.util.Set)">
+ /// <seealso cref="Lucene.Net.Search.Query.ExtractTerms(System.Collections.Hashtable)">
/// </seealso>
public override void ExtractTerms(System.Collections.Hashtable queryTerms)
{
@@ -350,7 +350,7 @@ namespace Lucene.Net.Search
return buffer.ToString();
}
- /// <summary>Returns true iff <code>o</code> is equal to this. </summary>
+ /// <summary>Returns true iff <c>o</c> is equal to this. </summary>
public override bool Equals(System.Object o)
{
if (!(o is PhraseQuery))
Modified: incubator/lucene.net/trunk/src/core/Search/PhraseScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/PhraseScorer.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/PhraseScorer.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/PhraseScorer.cs Sun Nov 6 05:24:26 2011
@@ -27,7 +27,7 @@ namespace Lucene.Net.Search
/// at "valid" positons. What "valid positions" are
/// depends on the type of the phrase query: for an exact phrase query terms are required
/// to appear in adjacent locations, while for a sloppy phrase query some distance between
- /// the terms is allowed. The abstract method {@link #PhraseFreq()} of extending classes
+ /// the terms is allowed. The abstract method <see cref="PhraseFreq()" /> of extending classes
/// is invoked for each document containing all the phrase query terms, in order to
/// compute the frequency of the phrase query in that document. A non zero frequency
/// means a match.
@@ -75,7 +75,7 @@ namespace Lucene.Net.Search
first.doc = - 1;
}
- /// <deprecated> use {@link #DocID()} instead.
+ /// <deprecated> use <see cref="DocID()" /> instead.
/// </deprecated>
[Obsolete("use DocID() instead.")]
public override int Doc()
@@ -88,7 +88,7 @@ namespace Lucene.Net.Search
return first.doc;
}
- /// <deprecated> use {@link #NextDoc()} instead.
+ /// <deprecated> use <see cref="NextDoc()" /> instead.
/// </deprecated>
[Obsolete("use NextDoc() instead.")]
public override bool Next()
@@ -148,7 +148,7 @@ namespace Lucene.Net.Search
return norms == null?raw:raw * Similarity.DecodeNorm(norms[first.doc]); // normalize
}
- /// <deprecated> use {@link #Advance(int)} instead.
+ /// <deprecated> use <see cref="Advance(int)" /> instead.
/// </deprecated>
[Obsolete("use Advance(int) instead.")]
public override bool SkipTo(int target)
Modified: incubator/lucene.net/trunk/src/core/Search/PositiveScoresOnlyCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/PositiveScoresOnlyCollector.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/PositiveScoresOnlyCollector.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/PositiveScoresOnlyCollector.cs Sun Nov 6 05:24:26 2011
@@ -22,8 +22,8 @@ using IndexReader = Lucene.Net.Index.Ind
namespace Lucene.Net.Search
{
- /// <summary> A {@link Collector} implementation which wraps another
- /// {@link Collector} and makes sure only documents with
+ /// <summary> A <see cref="Collector" /> implementation which wraps another
+ /// <see cref="Collector" /> and makes sure only documents with
/// scores > 0 are collected.
/// </summary>
public class PositiveScoresOnlyCollector:Collector
Modified: incubator/lucene.net/trunk/src/core/Search/PrefixQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/PrefixQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/PrefixQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/PrefixQuery.cs Sun Nov 6 05:24:26 2011
@@ -25,10 +25,10 @@ namespace Lucene.Net.Search
{
/// <summary>A Query that matches documents containing terms with a specified prefix. A PrefixQuery
- /// is built by QueryParser for input like <code>app*</code>.
+ /// is built by QueryParser for input like <c>app*</c>.
///
- /// <p/>This query uses the {@link
- /// MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}
+ /// <p/>This query uses the
+ /// <see cref="MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT"/>
/// rewrite method.
/// </summary>
[Serializable]
@@ -36,7 +36,7 @@ namespace Lucene.Net.Search
{
private Term prefix;
- /// <summary>Constructs a query for terms starting with <code>prefix</code>. </summary>
+ /// <summary>Constructs a query for terms starting with <c>prefix</c>. </summary>
public PrefixQuery(Term prefix):base(prefix)
{ //will be removed in 3.0
this.prefix = prefix;
Modified: incubator/lucene.net/trunk/src/core/Search/Query.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Query.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Query.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Query.cs Sun Nov 6 05:24:26 2011
@@ -24,32 +24,32 @@ namespace Lucene.Net.Search
/// <summary>The abstract base class for queries.
/// <p/>Instantiable subclasses are:
- /// <ul>
- /// <li> {@link TermQuery} </li>
- /// <li> {@link MultiTermQuery} </li>
- /// <li> {@link BooleanQuery} </li>
- /// <li> {@link WildcardQuery} </li>
- /// <li> {@link PhraseQuery} </li>
- /// <li> {@link PrefixQuery} </li>
- /// <li> {@link MultiPhraseQuery} </li>
- /// <li> {@link FuzzyQuery} </li>
- /// <li> {@link TermRangeQuery} </li>
- /// <li> {@link NumericRangeQuery} </li>
- /// <li> {@link Lucene.Net.Search.Spans.SpanQuery} </li>
- /// </ul>
+ /// <list type="bullet">
+ /// <item> <see cref="TermQuery" /> </item>
+ /// <item> <see cref="MultiTermQuery" /> </item>
+ /// <item> <see cref="BooleanQuery" /> </item>
+ /// <item> <see cref="WildcardQuery" /> </item>
+ /// <item> <see cref="PhraseQuery" /> </item>
+ /// <item> <see cref="PrefixQuery" /> </item>
+ /// <item> <see cref="MultiPhraseQuery" /> </item>
+ /// <item> <see cref="FuzzyQuery" /> </item>
+ /// <item> <see cref="TermRangeQuery" /> </item>
+ /// <item> <see cref="NumericRangeQuery" /> </item>
+ /// <item> <see cref="Lucene.Net.Search.Spans.SpanQuery" /> </item>
+ /// </list>
/// <p/>A parser for queries is contained in:
- /// <ul>
- /// <li>{@link Lucene.Net.QueryParsers.QueryParser QueryParser} </li>
- /// </ul>
+ /// <list type="bullet">
+ /// <item><see cref="Lucene.Net.QueryParsers.QueryParser">QueryParser</see> </item>
+ /// </list>
/// </summary>
[Serializable]
public abstract class Query : System.ICloneable
{
private float boost = 1.0f; // query boost factor
- /// <summary>Sets the boost for this query clause to <code>b</code>. Documents
+ /// <summary>Sets the boost for this query clause to <c>b</c>. Documents
/// matching this clause will (in addition to the normal weightings) have
- /// their score multiplied by <code>b</code>.
+ /// their score multiplied by <c>b</c>.
/// </summary>
public virtual void SetBoost(float b)
{
@@ -58,26 +58,26 @@ namespace Lucene.Net.Search
/// <summary>Gets the boost for this clause. Documents matching
/// this clause will (in addition to the normal weightings) have their score
- /// multiplied by <code>b</code>. The boost is 1.0 by default.
+ /// multiplied by <c>b</c>. The boost is 1.0 by default.
/// </summary>
public virtual float GetBoost()
{
return boost;
}
- /// <summary>Prints a query to a string, with <code>field</code> assumed to be the
+ /// <summary>Prints a query to a string, with <c>field</c> assumed to be the
/// default field and omitted.
/// <p/>The representation used is one that is supposed to be readable
- /// by {@link Lucene.Net.QueryParsers.QueryParser QueryParser}. However,
+ /// by <see cref="Lucene.Net.QueryParsers.QueryParser">QueryParser</see>. However,
/// there are the following limitations:
- /// <ul>
- /// <li>If the query was created by the parser, the printed
+ /// <list type="bullet">
+ /// <item>If the query was created by the parser, the printed
/// representation may not be exactly what was parsed. For example,
/// characters that need to be escaped will be represented without
- /// the required backslash.</li>
- /// <li>Some of the more complicated queries (e.g. span queries)
- /// don't have a representation that can be parsed by QueryParser.</li>
- /// </ul>
+ /// the required backslash.</item>
+ /// <item>Some of the more complicated queries (e.g. span queries)
+ /// don't have a representation that can be parsed by QueryParser.</item>
+ /// </list>
/// </summary>
public abstract System.String ToString(System.String field);
@@ -181,7 +181,7 @@ namespace Lucene.Net.Search
/// <summary> Expert: adds all terms occuring in this query to the terms set. Only
- /// works if this query is in its {@link #rewrite rewritten} form.
+ /// works if this query is in its <see cref="Rewrite">rewritten</see> form.
///
/// </summary>
/// <throws> UnsupportedOperationException if this query is not yet rewritten </throws>
@@ -196,7 +196,7 @@ namespace Lucene.Net.Search
/// <summary>Expert: merges the clauses of a set of BooleanQuery's into a single
/// BooleanQuery.
///
- /// <p/>A utility for use by {@link #Combine(Query[])} implementations.
+ /// <p/>A utility for use by <see cref="Combine(Query[])" /> implementations.
/// </summary>
public static Query MergeBooleanQueries(BooleanQuery[] queries)
{
Modified: incubator/lucene.net/trunk/src/core/Search/QueryFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/QueryFilter.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/QueryFilter.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/QueryFilter.cs Sun Nov 6 05:24:26 2011
@@ -36,7 +36,7 @@ namespace Lucene.Net.Search
{
/// <summary>Constructs a filter which only matches documents matching
- /// <code>query</code>.
+ /// <c>query</c>.
/// </summary>
public QueryFilter(Query query):base(new QueryWrapperFilter(query))
{
Modified: incubator/lucene.net/trunk/src/core/Search/QueryWrapperFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/QueryWrapperFilter.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/QueryWrapperFilter.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/QueryWrapperFilter.cs Sun Nov 6 05:24:26 2011
@@ -25,7 +25,7 @@ namespace Lucene.Net.Search
/// <summary> Constrains search results to only match those which also match a provided
/// query.
///
- /// <p/> This could be used, for example, with a {@link TermRangeQuery} on a suitably
+ /// <p/> This could be used, for example, with a <see cref="TermRangeQuery" /> on a suitably
/// formatted date field to implement date filtering. One could re-use a single
/// QueryFilter that matches, e.g., only documents modified within the last
/// week. The QueryFilter and TermRangeQuery would only need to be reconstructed
@@ -115,14 +115,14 @@ namespace Lucene.Net.Search
private Query query;
/// <summary>Constructs a filter which only matches documents matching
- /// <code>query</code>.
+ /// <c>query</c>.
/// </summary>
public QueryWrapperFilter(Query query)
{
this.query = query;
}
- /// <deprecated> Use {@link #GetDocIdSet(IndexReader)} instead.
+ /// <deprecated> Use <see cref="GetDocIdSet(IndexReader)" /> instead.
/// </deprecated>
[Obsolete("Use GetDocIdSet(IndexReader) instead.")]
public override System.Collections.BitArray Bits(IndexReader reader)
Modified: incubator/lucene.net/trunk/src/core/Search/RangeFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/RangeFilter.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/RangeFilter.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/RangeFilter.cs Sun Nov 6 05:24:26 2011
@@ -24,15 +24,15 @@ namespace Lucene.Net.Search
/// field.
///
/// <p/>This filter matches the documents looking for terms that fall into the
- /// supplied range according to {@link String#compareTo(String)}. It is not intended
- /// for numerical ranges, use {@link NumericRangeFilter} instead.
+ /// supplied range according to <see cref="String.CompareTo(String)" />. It is not intended
+ /// for numerical ranges, use <see cref="NumericRangeFilter" /> instead.
///
/// <p/>If you construct a large number of range filters with different ranges but on the
- /// same field, {@link FieldCacheRangeFilter} may have significantly better performance.
+ /// same field, <see cref="FieldCacheRangeFilter" /> may have significantly better performance.
///
/// </summary>
- /// <deprecated> Use {@link TermRangeFilter} for term ranges or
- /// {@link NumericRangeFilter} for numeric ranges instead.
+ /// <deprecated> Use <see cref="TermRangeFilter" /> for term ranges or
+ /// <see cref="NumericRangeFilter" /> for numeric ranges instead.
/// This class will be removed in Lucene 3.0.
/// </deprecated>
[Obsolete("Use TermRangeFilter for term ranges or NumericRangeFilter for numeric ranges instead. This class will be removed in Lucene 3.0")]
@@ -57,43 +57,44 @@ namespace Lucene.Net.Search
public RangeFilter(System.String fieldName, System.String lowerTerm, System.String upperTerm, bool includeLower, bool includeUpper):base(new TermRangeQuery(fieldName, lowerTerm, upperTerm, includeLower, includeUpper))
{
}
-
- /// <summary> <strong>WARNING:</strong> Using this constructor and supplying a non-null
- /// value in the <code>collator</code> parameter will cause every single
- /// index Term in the Field referenced by lowerTerm and/or upperTerm to be
- /// examined. Depending on the number of index Terms in this Field, the
- /// operation could be very slow.
- ///
- /// </summary>
- /// <param name="lowerTerm">The lower bound on this range
- /// </param>
- /// <param name="upperTerm">The upper bound on this range
- /// </param>
- /// <param name="includeLower">Does this range include the lower bound?
- /// </param>
- /// <param name="includeUpper">Does this range include the upper bound?
- /// </param>
- /// <param name="collator">The collator to use when determining range inclusion; set
- /// to null to use Unicode code point ordering instead of collation.
- /// </param>
- /// <throws> IllegalArgumentException if both terms are null or if </throws>
- /// <summary> lowerTerm is null and includeLower is true (similar for upperTerm
- /// and includeUpper)
- /// </summary>
- public RangeFilter(System.String fieldName, System.String lowerTerm, System.String upperTerm, bool includeLower, bool includeUpper, System.Globalization.CompareInfo collator):base(new TermRangeQuery(fieldName, lowerTerm, upperTerm, includeLower, includeUpper, collator))
+
+ /// <summary> <strong>WARNING:</strong> Using this constructor and supplying a non-null
+ /// value in the <c>collator</c> parameter will cause every single
+ /// index Term in the Field referenced by lowerTerm and/or upperTerm to be
+ /// examined. Depending on the number of index Terms in this Field, the
+ /// operation could be very slow.
+ ///
+ /// </summary>
+ /// <param name="fieldName"></param>
+ /// <param name="lowerTerm">The lower bound on this range
+ /// </param>
+ /// <param name="upperTerm">The upper bound on this range
+ /// </param>
+ /// <param name="includeLower">Does this range include the lower bound?
+ /// </param>
+ /// <param name="includeUpper">Does this range include the upper bound?
+ /// </param>
+ /// <param name="collator">The collator to use when determining range inclusion; set
+ /// to null to use Unicode code point ordering instead of collation.
+ /// </param>
+ /// <throws> IllegalArgumentException if both terms are null or if </throws>
+ /// <summary> lowerTerm is null and includeLower is true (similar for upperTerm
+ /// and includeUpper)
+ /// </summary>
+ public RangeFilter(System.String fieldName, System.String lowerTerm, System.String upperTerm, bool includeLower, bool includeUpper, System.Globalization.CompareInfo collator):base(new TermRangeQuery(fieldName, lowerTerm, upperTerm, includeLower, includeUpper, collator))
{
}
- /// <summary> Constructs a filter for field <code>fieldName</code> matching
- /// less than or equal to <code>upperTerm</code>.
+ /// <summary> Constructs a filter for field <c>fieldName</c> matching
+ /// less than or equal to <c>upperTerm</c>.
/// </summary>
public static RangeFilter Less(System.String fieldName, System.String upperTerm)
{
return new RangeFilter(fieldName, null, upperTerm, false, true);
}
- /// <summary> Constructs a filter for field <code>fieldName</code> matching
- /// greater than or equal to <code>lowerTerm</code>.
+ /// <summary> Constructs a filter for field <c>fieldName</c> matching
+ /// greater than or equal to <c>lowerTerm</c>.
/// </summary>
public static RangeFilter More(System.String fieldName, System.String lowerTerm)
{
Modified: incubator/lucene.net/trunk/src/core/Search/RangeQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/RangeQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/RangeQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/RangeQuery.cs Sun Nov 6 05:24:26 2011
@@ -26,17 +26,17 @@ namespace Lucene.Net.Search
/// <summary> A Query that matches documents within an exclusive range of terms.
///
/// <p/>This query matches the documents looking for terms that fall into the
- /// supplied range according to {@link Term#CompareTo(Term)}. It is not intended
- /// for numerical ranges, use {@link NumericRangeQuery} instead.
+ /// supplied range according to <see cref="Term.CompareTo(Term)" />. It is not intended
+ /// for numerical ranges, use <see cref="NumericRangeQuery" /> instead.
///
- /// <p/>This query uses {@linkplain
- /// MultiTermQuery#SCORING_BOOLEAN_QUERY_REWRITE}. If you
- /// want to change this, use the new {@link TermRangeQuery}
+ /// <p/>This query uses
+ /// <see cref="MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE"/>. If you
+ /// want to change this, use the new <see cref="TermRangeQuery" />
/// instead.
///
/// </summary>
- /// <deprecated> Use {@link TermRangeQuery} for term ranges or
- /// {@link NumericRangeQuery} for numeric ranges instead.
+ /// <deprecated> Use <see cref="TermRangeQuery" /> for term ranges or
+ /// <see cref="NumericRangeQuery" /> for numeric ranges instead.
/// This class will be removed in Lucene 3.0.
/// </deprecated>
[Obsolete("Use TermRangeQuery for term ranges or NumericRangeQuery for numeric ranges instead. This class will be removed in Lucene 3.0")]
@@ -46,7 +46,7 @@ namespace Lucene.Net.Search
private TermRangeQuery delegate_Renamed;
/// <summary>Constructs a query selecting all terms greater than
- /// <code>lowerTerm</code> but less than <code>upperTerm</code>.
+ /// <c>lowerTerm</c> but less than <c>upperTerm</c>.
/// There must be at least one term and either term may be null,
/// in which case there is no bound on that side, but if there are
/// two terms, both terms <b>must</b> be for the same field.
@@ -56,25 +56,25 @@ namespace Lucene.Net.Search
/// </param>
/// <param name="upperTerm">The Term at the upper end of the range
/// </param>
- /// <param name="inclusive">If true, both <code>lowerTerm</code> and
- /// <code>upperTerm</code> will themselves be included in the range.
+ /// <param name="inclusive">If true, both <c>lowerTerm</c> and
+ /// <c>upperTerm</c> will themselves be included in the range.
/// </param>
public RangeQuery(Term lowerTerm, Term upperTerm, bool inclusive):this(lowerTerm, upperTerm, inclusive, null)
{
}
/// <summary>Constructs a query selecting all terms greater than
- /// <code>lowerTerm</code> but less than <code>upperTerm</code>.
+ /// <c>lowerTerm</c> but less than <c>upperTerm</c>.
/// There must be at least one term and either term may be null,
/// in which case there is no bound on that side, but if there are
/// two terms, both terms <b>must</b> be for the same field.
/// <p/>
- /// If <code>collator</code> is not null, it will be used to decide whether
+ /// If <c>collator</c> is not null, it will be used to decide whether
/// index terms are within the given range, rather than using the Unicode code
/// point order in which index terms are stored.
/// <p/>
/// <strong>WARNING:</strong> Using this constructor and supplying a non-null
- /// value in the <code>collator</code> parameter will cause every single
+ /// value in the <c>collator</c> parameter will cause every single
/// index Term in the Field referenced by lowerTerm and/or upperTerm to be
/// examined. Depending on the number of index Terms in this Field, the
/// operation could be very slow.
@@ -84,12 +84,12 @@ namespace Lucene.Net.Search
/// </param>
/// <param name="upperTerm">The Term at the upper end of the range
/// </param>
- /// <param name="inclusive">If true, both <code>lowerTerm</code> and
- /// <code>upperTerm</code> will themselves be included in the range.
+ /// <param name="inclusive">If true, both <c>lowerTerm</c> and
+ /// <c>upperTerm</c> will themselves be included in the range.
/// </param>
/// <param name="collator">The collator to use to collate index Terms, to determine
- /// their membership in the range bounded by <code>lowerTerm</code> and
- /// <code>upperTerm</code>.
+ /// their membership in the range bounded by <c>lowerTerm</c> and
+ /// <c>upperTerm</c>.
/// </param>
public RangeQuery(Term lowerTerm, Term upperTerm, bool inclusive, System.Globalization.CompareInfo collator)
{
@@ -133,7 +133,7 @@ namespace Lucene.Net.Search
return (term == null)?null:new Term(GetField(), term);
}
- /// <summary>Returns <code>true</code> if the range query is inclusive </summary>
+ /// <summary>Returns <c>true</c> if the range query is inclusive </summary>
public virtual bool IsInclusive()
{
return delegate_Renamed.IncludesLower() && delegate_Renamed.IncludesUpper();
@@ -151,7 +151,7 @@ namespace Lucene.Net.Search
return delegate_Renamed.ToString(field);
}
- /// <summary>Returns true iff <code>o</code> is equal to this. </summary>
+ /// <summary>Returns true iff <c>o</c> is equal to this. </summary>
public override bool Equals(System.Object o)
{
if (this == o)
Modified: incubator/lucene.net/trunk/src/core/Search/ReqExclScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/ReqExclScorer.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/ReqExclScorer.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/ReqExclScorer.cs Sun Nov 6 05:24:26 2011
@@ -24,7 +24,7 @@ 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 {@link Scorer#SkipTo(int)},
+ /// This <c>Scorer</c> implements <see cref="DocIdSetIterator.SkipTo(int)" />,
/// and it uses the skipTo() on the given scorers.
/// </summary>
class ReqExclScorer:Scorer
@@ -33,7 +33,7 @@ namespace Lucene.Net.Search
private DocIdSetIterator exclDisi;
private int doc = - 1;
- /// <summary>Construct a <code>ReqExclScorer</code>.</summary>
+ /// <summary>Construct a <c>ReqExclScorer</c>.</summary>
/// <param name="reqScorer">The scorer that must match, except where
/// </param>
/// <param name="exclDisi">indicates exclusion.
@@ -44,7 +44,7 @@ namespace Lucene.Net.Search
this.exclDisi = exclDisi;
}
- /// <deprecated> use {@link #NextDoc()} instead.
+ /// <deprecated> use <see cref="NextDoc()" /> instead.
/// </deprecated>
[Obsolete("use NextDoc() instead. ")]
public override bool Next()
@@ -73,12 +73,12 @@ namespace Lucene.Net.Search
/// <summary>Advance to non excluded doc.
/// <br/>On entry:
- /// <ul>
- /// <li>reqScorer != null, </li>
- /// <li>exclScorer != null, </li>
- /// <li>reqScorer was advanced once via next() or skipTo()
- /// and reqScorer.doc() may still be excluded.</li>
- /// </ul>
+ /// <list type="bullet">
+ /// <item>reqScorer != null, </item>
+ /// <item>exclScorer != null, </item>
+ /// <item>reqScorer was advanced once via next() or skipTo()
+ /// and reqScorer.doc() may still be excluded.</item>
+ /// </list>
/// Advances reqScorer a non excluded required doc, if any.
/// </summary>
/// <returns> true iff there is a non excluded required doc.
@@ -112,7 +112,7 @@ namespace Lucene.Net.Search
return NO_MORE_DOCS;
}
- /// <deprecated> use {@link #DocID()} instead.
+ /// <deprecated> use <see cref="DocID()" /> instead.
/// </deprecated>
[Obsolete("use DocID() instead.")]
public override int Doc()
@@ -126,7 +126,7 @@ namespace Lucene.Net.Search
}
/// <summary>Returns the score of the current document matching the query.
- /// Initially invalid, until {@link #Next()} is called the first time.
+ /// Initially invalid, until <see cref="Next()" /> is called the first time.
/// </summary>
/// <returns> The score of the required scorer.
/// </returns>
@@ -135,7 +135,7 @@ namespace Lucene.Net.Search
return reqScorer.Score(); // reqScorer may be null when next() or skipTo() already return false
}
- /// <deprecated> use {@link #Advance(int)} instead.
+ /// <deprecated> use <see cref="Advance(int)" /> instead.
/// </deprecated>
[Obsolete("use Advance(int) instead.")]
public override bool SkipTo(int target)
Modified: incubator/lucene.net/trunk/src/core/Search/ReqOptSumScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/ReqOptSumScorer.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/ReqOptSumScorer.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/ReqOptSumScorer.cs Sun Nov 6 05:24:26 2011
@@ -23,7 +23,7 @@ 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 {@link Scorer#SkipTo(int)}.
+ /// This <c>Scorer</c> implements <see cref="DocIdSetIterator.SkipTo(int)" />.
/// </summary>
class ReqOptSumScorer:Scorer
{
@@ -33,7 +33,7 @@ namespace Lucene.Net.Search
private Scorer reqScorer;
private Scorer optScorer;
- /// <summary>Construct a <code>ReqOptScorer</code>.</summary>
+ /// <summary>Construct a <c>ReqOptScorer</c>.</summary>
/// <param name="reqScorer">The required scorer. This must match.
/// </param>
/// <param name="optScorer">The optional scorer. This is used for scoring only.
@@ -44,7 +44,7 @@ namespace Lucene.Net.Search
this.optScorer = optScorer;
}
- /// <deprecated> use {@link #NextDoc()} instead.
+ /// <deprecated> use <see cref="NextDoc()" /> instead.
/// </deprecated>
[Obsolete("use NextDoc() instead.")]
public override bool Next()
@@ -57,7 +57,7 @@ namespace Lucene.Net.Search
return reqScorer.NextDoc();
}
- /// <deprecated> use {@link #Advance(int)} instead.
+ /// <deprecated> use <see cref="Advance(int)" /> instead.
/// </deprecated>
[Obsolete("use Advance(int) instead.")]
public override bool SkipTo(int target)
@@ -70,7 +70,7 @@ namespace Lucene.Net.Search
return reqScorer.Advance(target);
}
- /// <deprecated> use {@link #DocID()} instead.
+ /// <deprecated> use <see cref="DocID()" /> instead.
/// </deprecated>
[Obsolete("use DocID() instead.")]
public override int Doc()
@@ -84,7 +84,7 @@ namespace Lucene.Net.Search
}
/// <summary>Returns the score of the current document matching the query.
- /// Initially invalid, until {@link #Next()} is called the first time.
+ /// Initially invalid, until <see cref="Next()" /> 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.