lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ccurr...@apache.org
Subject [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...
Date Sun, 06 Nov 2011 05:24:44 GMT
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 &lt;/&#8804; or &gt;/&#8805; 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 &lt;/&#8804; or &gt;/&#8805; 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 &lt;/&#8804; or &gt;/&#8805; 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 &lt;/&#8804; or &gt;/&#8805; 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 &lt;/&#8804; or &gt;/&#8805; 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 &lt;/&#8804; or &gt;/&#8805; 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 &lt;/&#8804; or &gt;/&#8805; 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 &lt;/&#8804; or &gt;/&#8805; 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 &lt;8 and 64
 	/// bit (long/double) ranges with precisionStep &lt;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 &lt;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>&gt;64</b> for <em>long/double</em> and <b>&gt;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>&gt;64</b> for <em>long/double</em> and <b>&gt;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 &lt;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 &lt;/&#8804; or &gt;/&#8805; 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 &lt;/&#8804; or &gt;/&#8805; 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 &lt;/&#8804; or &gt;/&#8805; 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 &lt;/&#8804; or &gt;/&#8805; 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 &lt;/&#8804; or &gt;/&#8805; 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 &lt;/&#8804; or &gt;/&#8805; 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 &lt;/&#8804; or &gt;/&#8805; 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 &lt;/&#8804; or &gt;/&#8805; 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 &gt; 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.



Mime
View raw message