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 [10/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/QueryParser/QueryParser.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/QueryParser/QueryParser.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/QueryParser/QueryParser.cs (original)
+++ incubator/lucene.net/trunk/src/core/QueryParser/QueryParser.cs Sun Nov  6 05:24:26 2011
@@ -46,31 +46,31 @@ namespace Lucene.Net.QueryParsers
 {
 	
 	/// <summary> This class is generated by JavaCC.  The most important method is
-	/// {@link #Parse(String)}.
+	/// <see cref="Parse(String)" />.
 	/// 
 	/// The syntax for query strings is as follows:
 	/// A Query is a series of clauses.
 	/// A clause may be prefixed by:
-	/// <ul>
-	/// <li> a plus (<code>+</code>) or a minus (<code>-</code>) sign, indicating
-	/// that the clause is required or prohibited respectively; or</li>
-	/// <li> a term followed by a colon, indicating the field to be searched.
-	/// This enables one to construct queries which search multiple fields.</li>
-	/// </ul>
+	/// <list type="bullet">
+	/// <item> a plus (<c>+</c>) or a minus (<c>-</c>) sign, indicating
+	/// that the clause is required or prohibited respectively; or</item>
+	/// <item> a term followed by a colon, indicating the field to be searched.
+	/// This enables one to construct queries which search multiple fields.</item>
+	/// </list>
 	/// 
 	/// A clause may be either:
-	/// <ul>
-	/// <li> a term, indicating all the documents that contain this term; or</li>
-	/// <li> a nested query, enclosed in parentheses.  Note that this may be used
-	/// with a <code>+</code>/<code>-</code> prefix to require any of a set of
-	/// terms.</li>
-	/// </ul>
+	/// <list type="bullet">
+	/// <item> a term, indicating all the documents that contain this term; or</item>
+	/// <item> a nested query, enclosed in parentheses.  Note that this may be used
+	/// with a <c>+</c>/<c>-</c> prefix to require any of a set of
+	/// terms.</item>
+	/// </list>
 	/// 
 	/// Thus, in BNF, the query grammar is:
-	/// <pre>
+    /// <code>
 	/// Query  ::= ( Clause )*
 	/// Clause ::= ["+", "-"] [&lt;TERM&gt; ":"] ( &lt;TERM&gt; | "(" Query ")" )
-	/// </pre>
+    /// </code>
 	/// 
 	/// <p/>
 	/// Examples of appropriately formatted queries can be found in the <a
@@ -79,28 +79,28 @@ namespace Lucene.Net.QueryParsers
 	/// <p/>
 	/// 
 	/// <p/>
-	/// In {@link TermRangeQuery}s, QueryParser tries to detect date values, e.g.
+	/// In <see cref="TermRangeQuery" />s, QueryParser tries to detect date values, e.g.
 	/// <tt>date:[6/1/2005 TO 6/4/2005]</tt> produces a range query that searches
 	/// for "date" fields between 2005-06-01 and 2005-06-04. Note that the format
-	/// of the accepted input depends on {@link #SetLocale(Locale) the locale}.
+	/// of the accepted input depends on <see cref="SetLocale(System.Globalization.CultureInfo)">the locale</see>.
 	/// By default a date is converted into a search term using the deprecated
-	/// {@link DateField} for compatibility reasons.
-	/// To use the new {@link DateTools} to convert dates, a
-	/// {@link Lucene.Net.Documents.DateTools.Resolution} has to be set.
+	/// <see cref="DateField" /> for compatibility reasons.
+	/// To use the new <see cref="DateTools" /> to convert dates, a
+	/// <see cref="Lucene.Net.Documents.DateTools.Resolution" /> has to be set.
 	/// <p/>
 	/// <p/>
 	/// The date resolution that shall be used for RangeQueries can be set
-	/// using {@link #SetDateResolution(DateTools.Resolution)}
-	/// or {@link #SetDateResolution(String, DateTools.Resolution)}. The former
+	/// using <see cref="SetDateResolution(DateTools.Resolution)" />
+	/// or <see cref="SetDateResolution(String, DateTools.Resolution)" />. The former
 	/// sets the default date resolution for all fields, whereas the latter can
 	/// be used to set field specific date resolutions. Field specific date
 	/// resolutions take, if set, precedence over the default date resolution.
 	/// <p/>
 	/// <p/>
-	/// If you use neither {@link DateField} nor {@link DateTools} in your
+	/// If you use neither <see cref="DateField" /> nor <see cref="DateTools" /> in your
 	/// index, you can create your own
 	/// query parser that inherits QueryParser and overwrites
-	/// {@link #GetRangeQuery(String, String, String, boolean)} to
+	/// <see cref="GetRangeQuery(String, String, String, bool)" /> to
 	/// use a different method for date conversion.
 	/// <p/>
 	/// 
@@ -113,11 +113,11 @@ namespace Lucene.Net.QueryParsers
 	/// <p/><b>NOTE</b>: there is a new QueryParser in contrib, which matches
 	/// the same syntax as this class, but is more modular,
 	/// enabling substantial customization to how a query is created.
-	/// <b>NOTE</b>: You must specify the required {@link Version} compatibility when
+	/// <b>NOTE</b>: You must specify the required <see cref="Version" /> compatibility when
 	/// creating QueryParser:
-	/// <ul>
-	/// <li>As of 2.9, {@link #SetEnablePositionIncrements} is true by default.</li>
-	/// </ul>
+	/// <list type="bullet">
+	/// <item>As of 2.9, <see cref="SetEnablePositionIncrements" /> is true by default.</item>
+	/// </list>
 	/// </summary>
 	public class QueryParser : QueryParserConstants
 	{
@@ -170,7 +170,7 @@ namespace Lucene.Net.QueryParsers
 		internal System.Globalization.CompareInfo rangeCollator = null;
 		
 		/// <summary>The default operator for parsing queries. 
-		/// Use {@link QueryParser#setDefaultOperator} to change it.
+		/// Use <see cref="QueryParser.SetDefaultOperator" /> to change it.
 		/// </summary>
 		[Serializable]
 		public sealed class Operator:Parameter
@@ -188,7 +188,7 @@ namespace Lucene.Net.QueryParsers
 		/// </param>
 		/// <param name="a">  used to find terms in the query text.
 		/// </param>
-		/// <deprecated> Use {@link #QueryParser(Version, String, Analyzer)} instead
+		/// <deprecated> Use <see cref="QueryParser(Version, String, Analyzer)" /> instead
 		/// </deprecated>
         [Obsolete("Use QueryParser(Version, String, Analyzer) instead")]
 		public QueryParser(System.String f, Analyzer a):this(Version.LUCENE_24, f, a)
@@ -218,7 +218,7 @@ namespace Lucene.Net.QueryParsers
 			}
 		}
 		
-		/// <summary>Parses a query string, returning a {@link Lucene.Net.Search.Query}.</summary>
+		/// <summary>Parses a query string, returning a <see cref="Lucene.Net.Search.Query" />.</summary>
 		/// <param name="query"> the query string to be parsed.
 		/// </param>
 		/// <throws>  ParseException if the parsing fails </throws>
@@ -308,9 +308,9 @@ namespace Lucene.Net.QueryParsers
 		}
 		
 		
-		/// <summary> Set to <code>true</code> to allow leading wildcard characters.
+		/// <summary> Set to <c>true</c> to allow leading wildcard characters.
 		/// <p/>
-		/// When set, <code>*</code> or <code>?</code> are allowed as 
+		/// When set, <c>*</c> or <c>?</c> are allowed as 
 		/// the first character of a PrefixQuery and WildcardQuery.
 		/// Note that this can produce very slow
 		/// queries on big indexes. 
@@ -321,15 +321,15 @@ namespace Lucene.Net.QueryParsers
 		{
 			this.allowLeadingWildcard = allowLeadingWildcard;
 		}
-		
-		/// <seealso cref="SetAllowLeadingWildcard(boolean)">
+
+        /// <seealso cref="SetAllowLeadingWildcard(bool)">
 		/// </seealso>
 		public virtual bool GetAllowLeadingWildcard()
 		{
 			return allowLeadingWildcard;
 		}
 		
-		/// <summary> Set to <code>true</code> to enable position increments in result query.
+		/// <summary> Set to <c>true</c> to enable position increments in result query.
 		/// <p/>
 		/// When set, result phrase and multi-phrase queries will
 		/// be aware of position increments.
@@ -342,8 +342,8 @@ namespace Lucene.Net.QueryParsers
 		{
 			this.enablePositionIncrements = enable;
 		}
-		
-		/// <seealso cref="SetEnablePositionIncrements(boolean)">
+
+        /// <seealso cref="SetEnablePositionIncrements(bool)">
 		/// </seealso>
 		public virtual bool GetEnablePositionIncrements()
 		{
@@ -351,11 +351,11 @@ namespace Lucene.Net.QueryParsers
 		}
 		
 		/// <summary> Sets the boolean operator of the QueryParser.
-		/// In default mode (<code>OR_OPERATOR</code>) terms without any modifiers
-		/// are considered optional: for example <code>capital of Hungary</code> is equal to
-		/// <code>capital OR of OR Hungary</code>.<br/>
-		/// In <code>AND_OPERATOR</code> mode terms are considered to be in conjunction: the
-		/// above mentioned query is parsed as <code>capital AND of AND Hungary</code>
+		/// In default mode (<c>OR_OPERATOR</c>) terms without any modifiers
+		/// are considered optional: for example <c>capital of Hungary</c> is equal to
+		/// <c>capital OR of OR Hungary</c>.<br/>
+		/// In <c>AND_OPERATOR</c> mode terms are considered to be in conjunction: the
+		/// above mentioned query is parsed as <c>capital AND of AND Hungary</c>
 		/// </summary>
 		public virtual void  SetDefaultOperator(Operator op)
 		{
@@ -373,7 +373,7 @@ namespace Lucene.Net.QueryParsers
 		
 		
 		/// <summary> Whether terms of wildcard, prefix, fuzzy and range queries are to be automatically
-		/// lower-cased or not.  Default is <code>true</code>.
+		/// lower-cased or not.  Default is <c>true</c>.
 		/// </summary>
 		public virtual void  SetLowercaseExpandedTerms(bool lowercaseExpandedTerms)
 		{
@@ -381,14 +381,14 @@ namespace Lucene.Net.QueryParsers
 		}
 		
 		
-		/// <seealso cref="SetLowercaseExpandedTerms(boolean)">
+		/// <seealso cref="SetLowercaseExpandedTerms(bool)">
 		/// </seealso>
 		public virtual bool GetLowercaseExpandedTerms()
 		{
 			return lowercaseExpandedTerms;
 		}
 		
-		/// <deprecated> Please use {@link #setMultiTermRewriteMethod} instead.
+		/// <deprecated> Please use <see cref="SetMultiTermRewriteMethod" /> instead.
 		/// </deprecated>
         [Obsolete("Please use SetMultiTermRewriteMethod instead.")]
 		public virtual void  SetUseOldRangeQuery(bool useOldRangeQuery)
@@ -404,7 +404,7 @@ namespace Lucene.Net.QueryParsers
 		}
 		
 		
-		/// <deprecated> Please use {@link #getMultiTermRewriteMethod} instead.
+		/// <deprecated> Please use <see cref="GetMultiTermRewriteMethod" /> instead.
 		/// </deprecated>
         [Obsolete("Please use GetMultiTermRewriteMethod} instead.")]
 		public virtual bool GetUseOldRangeQuery()
@@ -419,7 +419,7 @@ namespace Lucene.Net.QueryParsers
 			}
 		}
 		
-		/// <summary> By default QueryParser uses {@link MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}
+		/// <summary> By default QueryParser uses <see cref="MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT" />
 		/// when creating a PrefixQuery, WildcardQuery or RangeQuery. This implementation is generally preferable because it 
 		/// a) Runs faster b) Does not have the scarcity of terms unduly influence score 
 		/// c) avoids any "TooManyBooleanClauses" exception.
@@ -434,7 +434,7 @@ namespace Lucene.Net.QueryParsers
 		}
 		
 		
-		/// <seealso cref="setMultiTermRewriteMethod">
+		/// <seealso cref="SetMultiTermRewriteMethod">
 		/// </seealso>
 		public virtual MultiTermQuery.RewriteMethod GetMultiTermRewriteMethod()
 		{
@@ -455,7 +455,7 @@ namespace Lucene.Net.QueryParsers
 		
 		/// <summary> Sets the default date resolution used by RangeQueries for fields for which no
 		/// specific date resolutions has been set. Field specific resolutions can be set
-		/// with {@link #SetDateResolution(String, DateTools.Resolution)}.
+		/// with <see cref="SetDateResolution(String, DateTools.Resolution)" />.
 		/// 
 		/// </summary>
 		/// <param name="dateResolution">the default date resolution to set
@@ -541,7 +541,7 @@ namespace Lucene.Net.QueryParsers
 			return rangeCollator;
 		}
 		
-		/// <deprecated> use {@link #AddClause(List, int, int, Query)} instead.
+		/// <deprecated> use <see cref="AddClause(System.Collections.IList, int, int, Query)" /> instead.
 		/// </deprecated>
         [Obsolete("use AddClause(List, int, int, Query) instead.")]
 		protected internal virtual void  AddClause(System.Collections.ArrayList clauses, int conj, int mods, Query q)
@@ -549,7 +549,7 @@ namespace Lucene.Net.QueryParsers
 			AddClause((System.Collections.IList) clauses, conj, mods, q);
 		}
 		
-		protected internal virtual void  AddClause(System.Collections.IList clauses, int conj, int mods, Query q)
+		protected internal virtual void AddClause(System.Collections.IList clauses, int conj, int mods, Query q)
 		{
 			bool required, prohibited;
 			
@@ -833,7 +833,7 @@ namespace Lucene.Net.QueryParsers
 		
 		
 		
-		/// <summary> Base implementation delegates to {@link #GetFieldQuery(String,String)}.
+		/// <summary> Base implementation delegates to <see cref="GetFieldQuery(String,String)" />.
 		/// This method may be overridden, for example, to return
 		/// a SpanNearQuery instead of a PhraseQuery.
 		/// 
@@ -1042,15 +1042,15 @@ namespace Lucene.Net.QueryParsers
 		/// returned.
 		/// 
 		/// </summary>
-		/// <param name="clauses">List that contains {@link BooleanClause} instances
+		/// <param name="clauses">List that contains <see cref="BooleanClause" /> instances
 		/// to join.
 		/// 
 		/// </param>
-		/// <returns> Resulting {@link Query} object.
+		/// <returns> Resulting <see cref="Query" /> object.
 		/// </returns>
 		/// <exception cref="ParseException">throw in overridden method to disallow
 		/// </exception>
-		/// <deprecated> use {@link #GetBooleanQuery(List)} instead
+		/// <deprecated> use <see cref="GetBooleanQuery(System.Collections.IList)" /> instead
 		/// </deprecated>
         [Obsolete("use GetBooleanQuery(List) instead")]
 		protected internal virtual Query GetBooleanQuery(System.Collections.ArrayList clauses)
@@ -1065,11 +1065,11 @@ namespace Lucene.Net.QueryParsers
 		/// returned.
 		/// 
 		/// </summary>
-		/// <param name="clauses">List that contains {@link BooleanClause} instances
+		/// <param name="clauses">List that contains <see cref="BooleanClause" /> instances
 		/// to join.
 		/// 
 		/// </param>
-		/// <returns> Resulting {@link Query} object.
+		/// <returns> Resulting <see cref="Query" /> object.
 		/// </returns>
 		/// <exception cref="ParseException">throw in overridden method to disallow
 		/// </exception>
@@ -1085,17 +1085,17 @@ namespace Lucene.Net.QueryParsers
 		/// returned.
 		/// 
 		/// </summary>
-		/// <param name="clauses">List that contains {@link BooleanClause} instances
+		/// <param name="clauses">List that contains <see cref="BooleanClause" /> instances
 		/// to join.
 		/// </param>
 		/// <param name="disableCoord">true if coord scoring should be disabled.
 		/// 
 		/// </param>
-		/// <returns> Resulting {@link Query} object.
+		/// <returns> Resulting <see cref="Query" /> object.
 		/// </returns>
 		/// <exception cref="ParseException">throw in overridden method to disallow
 		/// </exception>
-		/// <deprecated> use {@link #GetBooleanQuery(List, boolean)} instead
+		/// <deprecated> use <see cref="GetBooleanQuery(System.Collections.IList, bool)" /> instead
 		/// </deprecated>
         [Obsolete("use GetBooleanQuery(List, bool) instead")]
 		protected internal virtual Query GetBooleanQuery(System.Collections.ArrayList clauses, bool disableCoord)
@@ -1110,13 +1110,13 @@ namespace Lucene.Net.QueryParsers
 		/// returned.
 		/// 
 		/// </summary>
-		/// <param name="clauses">List that contains {@link BooleanClause} instances
+		/// <param name="clauses">List that contains <see cref="BooleanClause" /> instances
 		/// to join.
 		/// </param>
 		/// <param name="disableCoord">true if coord scoring should be disabled.
 		/// 
 		/// </param>
-		/// <returns> Resulting {@link Query} object.
+		/// <returns> Resulting <see cref="Query" /> object.
 		/// </returns>
 		/// <exception cref="ParseException">throw in overridden method to disallow
 		/// </exception>
@@ -1154,7 +1154,7 @@ namespace Lucene.Net.QueryParsers
 		/// characters (? or *), but is not simple prefix term
 		/// 
 		/// </param>
-		/// <returns> Resulting {@link Query} built for the term
+		/// <returns> Resulting <see cref="Query" /> built for the term
 		/// </returns>
 		/// <exception cref="ParseException">throw in overridden method to disallow
 		/// </exception>
@@ -1176,7 +1176,7 @@ namespace Lucene.Net.QueryParsers
 		}
 		
 		/// <summary> Factory method for generating a query (similar to
-		/// {@link #getWildcardQuery}). Called when parser parses an input term
+		/// <see cref="GetWildcardQuery" />). Called when parser parses an input term
 		/// token that uses prefix notation; that is, contains a single '*' wildcard
 		/// character as its last character. Since this is a special case
 		/// of generic wildcard term, and such a query can be optimized easily,
@@ -1197,7 +1197,7 @@ namespace Lucene.Net.QueryParsers
 		/// (<b>without</b> trailing '*' character!)
 		/// 
 		/// </param>
-		/// <returns> Resulting {@link Query} built for the term
+		/// <returns> Resulting <see cref="Query" /> built for the term
 		/// </returns>
 		/// <exception cref="ParseException">throw in overridden method to disallow
 		/// </exception>
@@ -1214,7 +1214,7 @@ namespace Lucene.Net.QueryParsers
 		}
 		
 		/// <summary> Factory method for generating a query (similar to
-		/// {@link #getWildcardQuery}). Called when parser parses
+		/// <see cref="GetWildcardQuery" />). Called when parser parses
 		/// an input term token that has the fuzzy suffix (~) appended.
 		/// 
 		/// </summary>
@@ -1223,7 +1223,7 @@ namespace Lucene.Net.QueryParsers
 		/// <param name="termStr">Term token to use for building term for the query
 		/// 
 		/// </param>
-		/// <returns> Resulting {@link Query} built for the term
+		/// <returns> Resulting <see cref="Query" /> built for the term
 		/// </returns>
 		/// <exception cref="ParseException">throw in overridden method to disallow
 		/// </exception>
@@ -1241,7 +1241,7 @@ namespace Lucene.Net.QueryParsers
 		/// removed, or kept only once if there was a double escape.
 		/// 
 		/// Supports escaped unicode characters, e. g. translates
-		/// <code>\\u0041</code> to <code>A</code>.
+		/// <c>\\u0041</c> to <c>A</c>.
 		/// 
 		/// </summary>
 		private System.String DiscardEscapeChar(System.String input)
@@ -1342,7 +1342,7 @@ namespace Lucene.Net.QueryParsers
 		}
 		
 		/// <summary> Returns a String where those characters that QueryParser
-		/// expects to be escaped are escaped by a preceding <code>\</code>.
+		/// expects to be escaped are escaped by a preceding <c>\</c>.
 		/// </summary>
 		public static System.String Escape(System.String s)
 		{
@@ -1360,9 +1360,9 @@ namespace Lucene.Net.QueryParsers
 			return sb.ToString();
 		}
 		
-		/// <summary> Command line tool to test QueryParser, using {@link Lucene.Net.Analysis.SimpleAnalyzer}.
+		/// <summary> Command line tool to test QueryParser, using <see cref="Lucene.Net.Analysis.SimpleAnalyzer" />.
 		/// Usage:<br/>
-		/// <code>java Lucene.Net.QueryParsers.QueryParser &lt;input&gt;</code>
+		/// <c>java Lucene.Net.QueryParsers.QueryParser &lt;input&gt;</c>
 		/// </summary>
 		[STAThread]
 		public static void  Main(System.String[] args)

Modified: incubator/lucene.net/trunk/src/core/Search/BooleanClause.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/BooleanClause.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/BooleanClause.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/BooleanClause.cs Sun Nov  6 05:24:26 2011
@@ -48,16 +48,16 @@ namespace Lucene.Net.Search
 			/// <summary>Use this operator for clauses that <i>must</i> appear in the matching documents. </summary>
 			public static readonly Occur MUST = new Occur("MUST");
 			/// <summary>Use this operator for clauses that <i>should</i> appear in the 
-			/// matching documents. For a BooleanQuery with no <code>MUST</code> 
-			/// clauses one or more <code>SHOULD</code> clauses must match a document 
+			/// matching documents. For a BooleanQuery with no <c>MUST</c> 
+			/// clauses one or more <c>SHOULD</c> clauses must match a document 
 			/// for the BooleanQuery to match.
 			/// </summary>
-			/// <seealso cref="BooleanQuery.setMinimumNumberShouldMatch">
+			/// <seealso cref="BooleanQuery.SetMinimumNumberShouldMatch">
 			/// </seealso>
 			public static readonly Occur SHOULD = new Occur("SHOULD");
 			/// <summary>Use this operator for clauses that <i>must not</i> appear in the matching documents.
 			/// Note that it is not possible to search for queries that only consist
-			/// of a <code>MUST_NOT</code> clause. 
+			/// of a <c>MUST_NOT</c> clause. 
 			/// </summary>
 			public static readonly Occur MUST_NOT = new Occur("MUST_NOT");
 		}
@@ -107,7 +107,7 @@ namespace Lucene.Net.Search
 		
 		
 		
-		/// <summary>Returns true if <code>o</code> is equal to this. </summary>
+		/// <summary>Returns true if <c>o</c> is equal to this. </summary>
 		public  override bool Equals(System.Object o)
 		{
 			if (o == null || !(o is BooleanClause))

Modified: incubator/lucene.net/trunk/src/core/Search/BooleanQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/BooleanQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/BooleanQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/BooleanQuery.cs Sun Nov  6 05:24:26 2011
@@ -25,7 +25,7 @@ namespace Lucene.Net.Search
 {
 	
 	/// <summary>A Query that matches documents matching boolean combinations of other
-	/// queries, e.g. {@link TermQuery}s, {@link PhraseQuery}s or other
+	/// queries, e.g. <see cref="TermQuery" />s, <see cref="PhraseQuery" />s or other
 	/// BooleanQuerys.
 	/// </summary>
 	[Serializable]
@@ -59,8 +59,8 @@ namespace Lucene.Net.Search
 		
 		private static int maxClauseCount = 1024;
 		
-		/// <summary>Thrown when an attempt is made to add more than {@link
-		/// #GetMaxClauseCount()} clauses. This typically happens if
+		/// <summary>Thrown when an attempt is made to add more than <see cref="GetMaxClauseCount()" />
+		/// clauses. This typically happens if
 		/// a PrefixQuery, FuzzyQuery, WildcardQuery, or TermRangeQuery 
 		/// is expanded to many terms during search. 
 		/// </summary>
@@ -81,8 +81,8 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Return the maximum number of clauses permitted, 1024 by default.
-		/// Attempts to add more than the permitted number of clauses cause {@link
-		/// TooManyClauses} to be thrown.
+		/// Attempts to add more than the permitted number of clauses cause <see cref="TooManyClauses" />
+		/// to be thrown.
 		/// </summary>
 		/// <seealso cref="SetMaxClauseCount(int)">
 		/// </seealso>
@@ -111,23 +111,23 @@ namespace Lucene.Net.Search
 		
 		/// <summary>Constructs an empty boolean query.
 		/// 
-		/// {@link Similarity#Coord(int,int)} may be disabled in scoring, as
+		/// <see cref="Similarity.Coord(int,int)" /> may be disabled in scoring, as
 		/// appropriate. For example, this score factor does not make sense for most
-		/// automatically generated queries, like {@link WildcardQuery} and {@link
-		/// FuzzyQuery}.
+		/// automatically generated queries, like <see cref="WildcardQuery" /> and <see cref="FuzzyQuery" />
+		///.
 		/// 
 		/// </summary>
-		/// <param name="disableCoord">disables {@link Similarity#Coord(int,int)} in scoring.
+		/// <param name="disableCoord">disables <see cref="Similarity.Coord(int,int)" /> in scoring.
 		/// </param>
 		public BooleanQuery(bool disableCoord)
 		{
 			this.disableCoord = disableCoord;
 		}
 		
-		/// <summary>Returns true iff {@link Similarity#Coord(int,int)} is disabled in
+		/// <summary>Returns true iff <see cref="Similarity.Coord(int,int)" /> is disabled in
 		/// scoring for this query instance.
 		/// </summary>
-		/// <seealso cref="BooleanQuery(boolean)">
+		/// <seealso cref="BooleanQuery(bool)">
 		/// </seealso>
 		public virtual bool IsCoordDisabled()
 		{
@@ -168,7 +168,7 @@ namespace Lucene.Net.Search
 		/// </summary>
 		/// <param name="min">the number of optional clauses that must match
 		/// </param>
-		/// <seealso cref="setAllowDocsOutOfOrder">
+		/// <seealso cref="SetAllowDocsOutOfOrder">
 		/// </seealso>
 		public virtual void  SetMinimumNumberShouldMatch(int min)
 		{
@@ -468,7 +468,7 @@ namespace Lucene.Net.Search
 		/// 
 		/// </summary>
 		/// <deprecated> this will not be needed anymore, as
-		/// {@link Weight#ScoresDocsOutOfOrder()} is used.
+		/// <see cref="Weight.ScoresDocsOutOfOrder()" /> is used.
 		/// </deprecated>
         [Obsolete("this will not be needed anymore, as Weight.ScoresDocsOutOfOrder() is used.")]
 		private static bool allowDocsOutOfOrder = true;
@@ -496,7 +496,7 @@ namespace Lucene.Net.Search
 		/// 
 		/// </summary>
 		/// <deprecated> this is not needed anymore, as
-		/// {@link Weight#ScoresDocsOutOfOrder()} is used.
+		/// <see cref="Weight.ScoresDocsOutOfOrder()" /> is used.
 		/// </deprecated>
         [Obsolete("this is not needed anymore, as Weight.ScoresDocsOutOfOrder() is used.")]
 		public static void  SetAllowDocsOutOfOrder(bool allow)
@@ -507,18 +507,18 @@ namespace Lucene.Net.Search
 		/// <summary> Whether hit docs may be collected out of docid order.
 		/// 
 		/// </summary>
-		/// <seealso cref="SetAllowDocsOutOfOrder(boolean)">
+        /// <seealso cref="SetAllowDocsOutOfOrder(bool)">
 		/// </seealso>
 		/// <deprecated> this is not needed anymore, as
-		/// {@link Weight#ScoresDocsOutOfOrder()} is used.
+		/// <see cref="Weight.ScoresDocsOutOfOrder()" /> is used.
 		/// </deprecated>
         [Obsolete("this is not needed anymore, as Weight.ScoresDocsOutOfOrder() is used.")]
 		public static bool GetAllowDocsOutOfOrder()
 		{
 			return allowDocsOutOfOrder;
 		}
-		
-		/// <deprecated> Use {@link #SetAllowDocsOutOfOrder(boolean)} instead. 
+
+        /// <deprecated> Use <see cref="SetAllowDocsOutOfOrder(bool)" /> instead. 
 		/// </deprecated>
         [Obsolete("Use SetAllowDocsOutOfOrder(bool) instead.")]
 		public static void  SetUseScorer14(bool use14)
@@ -526,7 +526,7 @@ namespace Lucene.Net.Search
 			SetAllowDocsOutOfOrder(use14);
 		}
 		
-		/// <deprecated> Use {@link #GetAllowDocsOutOfOrder()} instead.
+		/// <deprecated> Use <see cref="GetAllowDocsOutOfOrder()" /> instead.
 		/// </deprecated>
         [Obsolete("Use GetAllowDocsOutOfOrder() instead.")]
 		public static bool GetUseScorer14()
@@ -663,7 +663,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 BooleanQuery))

Modified: incubator/lucene.net/trunk/src/core/Search/BooleanScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/BooleanScorer.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/BooleanScorer.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/BooleanScorer.cs Sun Nov  6 05:24:26 2011
@@ -136,7 +136,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()
@@ -154,7 +154,7 @@ namespace Lucene.Net.Search
 				return null;
 			}
 			
-			/// <deprecated> use {@link #NextDoc()} instead. 
+			/// <deprecated> use <see cref="NextDoc()" /> instead. 
 			/// </deprecated>
             [Obsolete("use NextDoc() instead. ")]
 			public override bool Next()
@@ -172,7 +172,7 @@ namespace Lucene.Net.Search
 				return score;
 			}
 			
-			/// <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)
@@ -359,7 +359,7 @@ namespace Lucene.Net.Search
 			return false;
 		}
 		
-		/// <deprecated> use {@link #Score(Collector, int, int)} instead. 
+		/// <deprecated> use <see cref="Score(Collector, int, int)" /> instead. 
 		/// </deprecated>
         [Obsolete("use Score(Collector, int, int) instead.")]
 		protected internal override bool Score(HitCollector hc, int max)
@@ -372,7 +372,7 @@ namespace Lucene.Net.Search
 			throw new System.NotSupportedException();
 		}
 		
-		/// <deprecated> use {@link #DocID()} instead. 
+		/// <deprecated> use <see cref="DocID()" /> instead. 
 		/// </deprecated>
         [Obsolete("use DocID() instead. ")]
 		public override int Doc()
@@ -390,7 +390,7 @@ namespace Lucene.Net.Search
 			throw new System.NotSupportedException();
 		}
 		
-		/// <deprecated> use {@link #NextDoc()} instead. 
+		/// <deprecated> use <see cref="NextDoc()" /> instead. 
 		/// </deprecated>
         [Obsolete("use NextDoc() instead. ")]
 		public override bool Next()
@@ -447,7 +447,7 @@ namespace Lucene.Net.Search
 			Score(collector, System.Int32.MaxValue, NextDoc());
 		}
 		
-		/// <deprecated> use {@link #Score(Collector)} instead. 
+		/// <deprecated> use <see cref="Score(Collector)" /> instead. 
 		/// </deprecated>
         [Obsolete("use Score(Collector) instead. ")]
 		public override void  Score(HitCollector hc)
@@ -455,7 +455,7 @@ namespace Lucene.Net.Search
 			Score(new HitCollectorWrapper(hc));
 		}
 		
-		/// <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/BooleanScorer2.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/BooleanScorer2.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/BooleanScorer2.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/BooleanScorer2.cs Sun Nov  6 05:24:26 2011
@@ -164,7 +164,7 @@ namespace Lucene.Net.Search
 		
 		private int doc = - 1;
 		
-		/// <summary> Creates a {@link Scorer} with the given similarity and lists of required,
+		/// <summary> Creates a <see cref="Scorer" /> with the given similarity and lists of required,
 		/// prohibited and optional scorers. In no required scorers are added, at least
 		/// one of the optional scorers will have to match during the search.
 		/// 
@@ -243,7 +243,7 @@ namespace Lucene.Net.Search
 				}
 				return lastDocScore;
 			}
-			/// <deprecated> use {@link #DocID()} instead. 
+			/// <deprecated> use <see cref="DocID()" /> instead. 
 			/// </deprecated>
             [Obsolete("use DocID() instead. ")]
 			public override int Doc()
@@ -254,7 +254,7 @@ namespace Lucene.Net.Search
 			{
 				return scorer.DocID();
 			}
-			/// <deprecated> use {@link #NextDoc()} instead. 
+			/// <deprecated> use <see cref="NextDoc()" /> instead. 
 			/// </deprecated>
             [Obsolete("use NextDoc() instead. ")]
 			public override bool Next()
@@ -265,7 +265,7 @@ namespace Lucene.Net.Search
 			{
 				return scorer.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 docNr)
@@ -370,10 +370,10 @@ namespace Lucene.Net.Search
 		
 		/// <summary>Scores and collects all matching documents.</summary>
 		/// <param name="hc">The collector to which all matching documents are passed through
-		/// {@link HitCollector#Collect(int, float)}.
-		/// <br/>When this method is used the {@link #Explain(int)} method should not be used.
+		/// <see cref="HitCollector.Collect(int, float)" />.
+		/// <br/>When this method is used the <see cref="Explain(int)" /> method should not be used.
 		/// </param>
-		/// <deprecated> use {@link #Score(Collector)} instead.
+		/// <deprecated> use <see cref="Score(Collector)" /> instead.
 		/// </deprecated>
         [Obsolete("use Score(Collector) instead.")]
 		public override void  Score(HitCollector hc)
@@ -383,7 +383,7 @@ namespace Lucene.Net.Search
 		
 		/// <summary>Scores and collects all matching documents.</summary>
 		/// <param name="collector">The collector to which all matching documents are passed through.
-		/// <br/>When this method is used the {@link #Explain(int)} method should not be used.
+		/// <br/>When this method is used the <see cref="Explain(int)" /> method should not be used.
 		/// </param>
 		public override void  Score(Collector collector)
 		{
@@ -395,17 +395,17 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Expert: Collects matching documents in a range.
-		/// <br/>Note that {@link #Next()} must be called once before this method is
+		/// <br/>Note that <see cref="Next()" /> must be called once before this method is
 		/// called for the first time.
 		/// </summary>
 		/// <param name="hc">The collector to which all matching documents are passed through
-		/// {@link HitCollector#Collect(int, float)}.
+		/// <see cref="HitCollector.Collect(int, float)" />.
 		/// </param>
 		/// <param name="max">Do not score documents past this.
 		/// </param>
 		/// <returns> true if more matching documents may remain.
 		/// </returns>
-		/// <deprecated> use {@link #Score(Collector, int, int)} instead.
+		/// <deprecated> use <see cref="Score(Collector, int, int)" /> instead.
 		/// </deprecated>
         [Obsolete("use Score(Collector, int, int) instead.")]
 		protected internal override bool Score(HitCollector hc, int max)
@@ -425,7 +425,7 @@ namespace Lucene.Net.Search
 			return doc != NO_MORE_DOCS;
 		}
 		
-		/// <deprecated> use {@link #DocID()} instead. 
+		/// <deprecated> use <see cref="DocID()" /> instead. 
 		/// </deprecated>
         [Obsolete("use DocID() instead. ")]
 		public override int Doc()
@@ -438,7 +438,7 @@ namespace Lucene.Net.Search
 			return doc;
 		}
 		
-		/// <deprecated> use {@link #NextDoc()} instead. 
+		/// <deprecated> use <see cref="NextDoc()" /> instead. 
 		/// </deprecated>
         [Obsolete("use NextDoc() instead. ")]
 		public override bool Next()
@@ -458,7 +458,7 @@ namespace Lucene.Net.Search
 			return sum * coordinator.coordFactors[coordinator.nrMatchers];
 		}
 		
-		/// <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/CachingSpanFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/CachingSpanFilter.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/CachingSpanFilter.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/CachingSpanFilter.cs Sun Nov  6 05:24:26 2011
@@ -37,7 +37,7 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// New deletions always result in a cache miss, by default
-        /// ({@link CachingWrapperFilter.DeletesMode#RECACHE}.
+        /// (<see cref="CachingWrapperFilter.DeletesMode.RECACHE" />.
         /// <param name="filter">Filter to cache results of
 		/// </param>
         /// </summary>
@@ -46,10 +46,9 @@ namespace Lucene.Net.Search
 			
 		}
 
-        /**
-        * @param filter Filter to cache results of
-        * @param deletesMode See {@link CachingWrapperFilter.DeletesMode}
-        */
+        /// <summary>New deletions always result in a cache miss, specify the <paramref name="deletesMode"/></summary>
+        /// <param name="filter">Filter to cache results of</param>
+        /// <param name="deletesMode">See <see cref="CachingWrapperFilter.DeletesMode" /></param>
         public CachingSpanFilter(SpanFilter filter, CachingWrapperFilter.DeletesMode deletesMode)
         {
             this.filter = filter;
@@ -72,7 +71,7 @@ namespace Lucene.Net.Search
             }
         }
 
-		/// <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/CachingWrapperFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/CachingWrapperFilter.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/CachingWrapperFilter.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/CachingWrapperFilter.cs Sun Nov  6 05:24:26 2011
@@ -34,28 +34,28 @@ namespace Lucene.Net.Search
 	public class CachingWrapperFilter:Filter
 	{
 		protected internal Filter filter;
-		
-	    /**
-       * Expert: Specifies how new deletions against a reopened
-       * reader should be handled.
-       *
-       * <p>The default is IGNORE, which means the cache entry
-       * will be re-used for a given segment, even when that
-       * segment has been reopened due to changes in deletions.
-       * This is a big performance gain, especially with
-       * near-real-timer readers, since you don't hit a cache
-       * miss on every reopened reader for prior segments.</p>
-       *
-       * <p>However, in some cases this can cause invalid query
-       * results, allowing deleted documents to be returned.
-       * This only happens if the main query does not rule out
-       * deleted documents on its own, such as a toplevel
-       * ConstantScoreQuery.  To fix this, use RECACHE to
-       * re-create the cached filter (at a higher per-reopen
-       * cost, but at faster subsequent search performance), or
-       * use DYNAMIC to dynamically intersect deleted docs (fast
-       * reopen time but some hit to search performance).</p>
-       */
+
+        ///
+        /// Expert: Specifies how new deletions against a reopened
+        /// reader should be handled.
+        ///
+        /// <para>The default is IGNORE, which means the cache entry
+        /// will be re-used for a given segment, even when that
+        /// segment has been reopened due to changes in deletions.
+        /// This is a big performance gain, especially with
+        /// near-real-timer readers, since you don't hit a cache
+        /// miss on every reopened reader for prior segments.</para>
+        ///
+        /// <para>However, in some cases this can cause invalid query
+        /// results, allowing deleted documents to be returned.
+        /// This only happens if the main query does not rule out
+        /// deleted documents on its own, such as a toplevel
+        /// ConstantScoreQuery.  To fix this, use RECACHE to
+        /// re-create the cached filter (at a higher per-reopen
+        /// cost, but at faster subsequent search performance), or
+        /// use DYNAMIC to dynamically intersect deleted docs (fast
+        /// reopen time but some hit to search performance).</para>
+        ///
         [Serializable]
         public class DeletesMode : Parameter
         {
@@ -151,28 +151,29 @@ namespace Lucene.Net.Search
             }
         }
 
-        /**
-          * New deletes are ignored by default, which gives higher
-          * cache hit rate on reopened readers.  Most of the time
-          * this is safe, because the filter will be AND'd with a
-          * Query that fully enforces deletions.  If instead you
-          * need this filter to always enforce deletions, pass
-          * either {@link DeletesMode#RECACHE} or {@link
-          * DeletesMode#DYNAMIC}.
-          * @param filter Filter to cache results of
-          */
+        /// <summary>
+        /// New deletes are ignored by default, which gives higher
+        /// cache hit rate on reopened readers.  Most of the time
+        /// this is safe, because the filter will be AND'd with a
+        /// Query that fully enforces deletions.  If instead you
+        /// need this filter to always enforce deletions, pass
+        /// either <see cref="DeletesMode.RECACHE" /> or
+        /// <see cref="DeletesMode.DYNAMIC"/>.
+        /// </summary>
+        /// <param name="filter">Filter to cache results of</param>
+        ///
         public CachingWrapperFilter(Filter filter) : this(filter, DeletesMode.IGNORE)
 		{
 		}
 
-         /**
-   * Expert: by default, the cached filter will be shared
-   * across reopened segments that only had changes to their
-   * deletions.  
-   *
-   * @param filter Filter to cache results of
-   * @param deletesMode See {@link DeletesMode}
-   */
+        /// <summary>
+        /// Expert: by default, the cached filter will be shared
+        /// across reopened segments that only had changes to their
+        /// deletions.  
+        /// </summary>
+        /// <param name="filter">Filter to cache results of</param>
+        /// <param name="deletesMode">See <see cref="DeletesMode" /></param>
+        ///
         public CachingWrapperFilter(Filter filter, DeletesMode deletesMode)
         {
             this.filter = filter;
@@ -215,7 +216,7 @@ namespace Lucene.Net.Search
             }
         }
 
-		/// <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/Collector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Collector.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Collector.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Collector.cs Sun Nov  6 05:24:26 2011
@@ -28,56 +28,56 @@ namespace Lucene.Net.Search
 	/// 
 	/// <p/>As of 2.9, this class replaces the deprecated
 	/// HitCollector, and offers an API for efficient collection
-	/// of hits across sequential {@link IndexReader}s. {@link
-	/// IndexSearcher} advances the collector through each of the
+	/// of hits across sequential <see cref="IndexReader" />s. <see cref="IndexSearcher" />
+	/// advances the collector through each of the
 	/// sub readers, in an arbitrary order. This results in a
 	/// higher performance means of collection.<p/>
 	/// 
 	/// <p/>Lucene's core collectors are derived from Collector.
 	/// Likely your application can use one of these classes, or
-	/// subclass {@link TopDocsCollector}, instead of
+	/// subclass <see cref="TopDocsCollector" />, instead of
 	/// implementing Collector directly:
 	/// 
-	/// <ul>
+	/// <list type="bullet">
 	/// 
-	/// <li>{@link TopDocsCollector} is an abstract base class
+	/// <item><see cref="TopDocsCollector" /> is an abstract base class
 	/// that assumes you will retrieve the top N docs,
 	/// according to some criteria, after collection is
-	/// done.  </li>
+	/// done.  </item>
 	/// 
-	/// <li>{@link TopScoreDocCollector} is a concrete subclass
-	/// {@link TopDocsCollector} and sorts according to score +
-	/// docID.  This is used internally by the {@link
-	/// IndexSearcher} search methods that do not take an
-	/// explicit {@link Sort}. It is likely the most frequently
-	/// used collector.</li>
-	/// 
-	/// <li>{@link TopFieldCollector} subclasses {@link
-	/// TopDocsCollector} and sorts according to a specified
-	/// {@link Sort} object (sort by field).  This is used
-	/// internally by the {@link IndexSearcher} search methods
-	/// that take an explicit {@link Sort}.</li>
+	/// <item><see cref="TopScoreDocCollector" /> is a concrete subclass
+	/// <see cref="TopDocsCollector" /> and sorts according to score +
+	/// docID.  This is used internally by the <see cref="IndexSearcher" />
+	/// search methods that do not take an
+	/// explicit <see cref="Sort" />. It is likely the most frequently
+	/// used collector.</item>
+	/// 
+	/// <item><see cref="TopFieldCollector" /> subclasses <see cref="TopDocsCollector" />
+	/// and sorts according to a specified
+	/// <see cref="Sort" /> object (sort by field).  This is used
+	/// internally by the <see cref="IndexSearcher" /> search methods
+	/// that take an explicit <see cref="Sort" />.</item>
 	/// 
-	/// <li>{@link TimeLimitingCollector}, which wraps any other
+	/// <item><see cref="TimeLimitingCollector" />, which wraps any other
 	/// Collector and aborts the search if it's taken too much
 	/// time, will subclass Collector in 3.0 (presently it
-	/// subclasses the deprecated HitCollector).</li>
+	/// subclasses the deprecated HitCollector).</item>
 	/// 
-	/// <li>{@link PositiveScoresOnlyCollector} wraps any other
+	/// <item><see cref="PositiveScoresOnlyCollector" /> wraps any other
 	/// Collector and prevents collection of hits whose score
-	/// is &lt;= 0.0</li>
+	/// is &lt;= 0.0</item>
 	/// 
-	/// </ul>
+	/// </list>
 	/// 
 	/// <p/>Collector decouples the score from the collected doc:
 	/// the score computation is skipped entirely if it's not
 	/// needed.  Collectors that do need the score should
-	/// implement the {@link #setScorer} method, to hold onto the
-	/// passed {@link Scorer} instance, and call {@link
-	/// Scorer#Score()} within the collect method to compute the
+	/// implement the <see cref="SetScorer" /> method, to hold onto the
+	/// passed <see cref="Scorer" /> instance, and call <see cref="Scorer.Score()" />
+	/// within the collect method to compute the
 	/// current hit's score.  If your collector may request the
 	/// score for a single hit multiple times, you should use
-	/// {@link ScoreCachingWrappingScorer}. <p/>
+	/// <see cref="ScoreCachingWrappingScorer" />. <p/>
 	/// 
 	/// <p/><b>NOTE:</b> The doc that is passed to the collect
 	/// method is relative to the current reader. If your
@@ -87,7 +87,7 @@ namespace Lucene.Net.Search
 	/// a simple example showing how to collect docIDs into a
 	/// BitSet:<p/>
 	/// 
-	/// <pre>
+    /// <code>
 	/// Searcher searcher = new IndexSearcher(indexReader);
 	/// final BitSet bits = new BitSet(indexReader.maxDoc());
 	/// searcher.search(query, new Collector() {
@@ -110,7 +110,7 @@ namespace Lucene.Net.Search
 	/// this.docBase = docBase;
 	/// }
 	/// });
-	/// </pre>
+    /// </code>
 	/// 
 	/// <p/>Not all collectors will need to rebase the docID.  For
 	/// example, a collector that simply counts the total number
@@ -121,8 +121,8 @@ namespace Lucene.Net.Search
 	/// no longer do that.  It's very unusual to have such hits
 	/// (a negative query boost, or function query returning
 	/// negative custom scores, could cause it to happen).  If
-	/// you need that behavior, use {@link
-	/// PositiveScoresOnlyCollector}.<p/>
+	/// you need that behavior, use <see cref="PositiveScoresOnlyCollector" />
+	///.<p/>
 	/// 
 	/// <p/><b>NOTE:</b> This API is experimental and might change
 	/// in incompatible ways in the next release.<p/>
@@ -133,9 +133,9 @@ namespace Lucene.Net.Search
 	public abstract class Collector
 	{
 		
-		/// <summary> Called before successive calls to {@link #Collect(int)}. Implementations
+		/// <summary> Called before successive calls to <see cref="Collect(int)" />. Implementations
 		/// that need the score of the current document (passed-in to
-		/// {@link #Collect(int)}), should save the passed-in Scorer and call
+		/// <see cref="Collect(int)" />), should save the passed-in Scorer and call
 		/// scorer.score() when needed.
 		/// </summary>
 		public abstract void  SetScorer(Scorer scorer);
@@ -145,17 +145,17 @@ namespace Lucene.Net.Search
 		/// 
 		/// <p/>
 		/// Note: This is called in an inner search loop. For good search performance,
-		/// implementations of this method should not call {@link Searcher#Doc(int)} or
-		/// {@link Lucene.Net.Index.IndexReader#Document(int)} on every hit.
+		/// implementations of this method should not call <see cref="Searcher.Doc(int)" /> or
+		/// <see cref="Lucene.Net.Index.IndexReader.Document(int)" /> on every hit.
 		/// Doing so can slow searches by an order of magnitude or more.
 		/// </summary>
 		public abstract void  Collect(int doc);
 		
 		/// <summary> Called before collecting from each IndexReader. All doc ids in
-		/// {@link #Collect(int)} will correspond to reader.
+		/// <see cref="Collect(int)" /> will correspond to reader.
 		/// 
 		/// Add docBase to the current IndexReaders internal document id to re-base ids
-		/// in {@link #Collect(int)}.
+		/// in <see cref="Collect(int)" />.
 		/// 
 		/// </summary>
 		/// <param name="reader">next IndexReader
@@ -165,21 +165,18 @@ namespace Lucene.Net.Search
 		public abstract void  SetNextReader(IndexReader reader, int docBase);
 		
 		/// <summary>
-		///  * Return <code>true</code> if this collector does not
-		///  * require the matching docIDs to be delivered in int sort
-        ///  * order (smallest to largest) to {@link #collect}.
-        ///  *
-        ///  * <p/> Most Lucene Query implementations will visit
-        ///  * matching docIDs in order.  However, some queries
-        ///  * (currently limited to certain cases of {@link
-        ///  * BooleanQuery}) can achieve faster searching if the
-        ///  * <code>Collector</code> allows them to deliver the
-        ///  * docIDs out of order.
-        ///  *
-        ///  * <p/> Many collectors don't mind getting docIDs out of
-        ///  * order, so it's important to return <code>true</code>
-        ///  * here.
-        ///  *
+		/// Return <c>true</c> if this collector does not
+		/// require the matching docIDs to be delivered in int sort
+        /// order (smallest to largest) to <see cref="Collect" />.
+        /// <p/> Most Lucene Query implementations will visit
+        /// matching docIDs in order.  However, some queries
+        /// (currently limited to certain cases of <see cref="BooleanQuery" />)
+        /// can achieve faster searching if the
+        /// <c>Collector</c> allows them to deliver the
+        /// docIDs out of order.
+        /// <p/> Many collectors don't mind getting docIDs out of
+        /// order, so it's important to return <c>true</c>
+        /// here. 
 		/// </summary>
 		/// <returns></returns>
 		public abstract bool AcceptsDocsOutOfOrder();

Modified: incubator/lucene.net/trunk/src/core/Search/ComplexExplanation.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/ComplexExplanation.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/ComplexExplanation.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/ComplexExplanation.cs Sun Nov  6 05:24:26 2011
@@ -61,7 +61,7 @@ namespace Lucene.Net.Search
 		/// uses it; otherwise it defers to the superclass.
 		/// <p/>
 		/// </summary>
-		/// <seealso cref="getMatch">
+		/// <seealso cref="GetMatch">
 		/// </seealso>
 		public override bool IsMatch()
 		{

Modified: incubator/lucene.net/trunk/src/core/Search/ConjunctionScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/ConjunctionScorer.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/ConjunctionScorer.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/ConjunctionScorer.cs Sun Nov  6 05:24:26 2011
@@ -139,7 +139,7 @@ namespace Lucene.Net.Search
 			return lastDoc = DoNext();
 		}
 		
-		/// <deprecated> use {@link #DocID()} instead. 
+		/// <deprecated> use <see cref="DocID()" /> instead. 
 		/// </deprecated>
         [Obsolete("use DocID() instead.")]
 		public override int Doc()
@@ -157,7 +157,7 @@ namespace Lucene.Net.Search
 			throw new System.NotSupportedException();
 		}
 		
-		/// <deprecated> use {@link #NextDoc()} instead. 
+		/// <deprecated> use <see cref="NextDoc()" /> instead. 
 		/// </deprecated>
         [Obsolete("use NextDoc() instead.")]
 		public override bool Next()
@@ -189,7 +189,7 @@ namespace Lucene.Net.Search
 			return sum * coord;
 		}
 		
-		/// <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/ConstantScoreQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/ConstantScoreQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/ConstantScoreQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/ConstantScoreQuery.cs Sun Nov  6 05:24:26 2011
@@ -179,7 +179,7 @@ namespace Lucene.Net.Search
 				}
 			}
 			
-			/// <deprecated> use {@link #NextDoc()} instead. 
+			/// <deprecated> use <see cref="NextDoc()" /> instead. 
 			/// </deprecated>
             [Obsolete("use NextDoc() instead.")]
 			public override bool Next()
@@ -192,7 +192,7 @@ namespace Lucene.Net.Search
 				return docIdSetIterator.NextDoc();
 			}
 			
-			/// <deprecated> use {@link #DocID()} instead. 
+			/// <deprecated> use <see cref="DocID()" /> instead. 
 			/// </deprecated>
             [Obsolete("use DocID() instead. ")]
 			public override int Doc()
@@ -210,7 +210,7 @@ namespace Lucene.Net.Search
 				return theScore;
 			}
 			
-			/// <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)
@@ -240,7 +240,7 @@ namespace Lucene.Net.Search
 			return "ConstantScore(" + filter.ToString() + (GetBoost() == 1.0?")":"^" + GetBoost());
 		}
 		
-		/// <summary>Returns true if <code>o</code> is equal to this. </summary>
+		/// <summary>Returns true if <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/ConstantScoreRangeQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/ConstantScoreRangeQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/ConstantScoreRangeQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/ConstantScoreRangeQuery.cs Sun Nov  6 05:24:26 2011
@@ -26,15 +26,15 @@ namespace Lucene.Net.Search
 	/// <p/>It does not have an upper bound on the number of clauses covered in the range.
 	/// 
 	/// <p/>This query 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 NumericRangeQuery} instead.
+	/// supplied range according to <see cref="String.CompareTo(String)" />. It is not intended
+	/// for numerical ranges, use <see cref="NumericRangeQuery" /> instead.
 	/// 
-	/// <p/>This query is hardwired to {@link MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}.
-	/// If you want to change this, use {@link TermRangeQuery} instead.
+	/// <p/>This query is hardwired to <see cref="MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT" />.
+	/// If you want to change this, use <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>
 	/// <version>  $Id: ConstantScoreRangeQuery.java 797694 2009-07-25 00:03:33Z mikemccand $

Modified: incubator/lucene.net/trunk/src/core/Search/DefaultSimilarity.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/DefaultSimilarity.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/DefaultSimilarity.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/DefaultSimilarity.cs Sun Nov  6 05:24:26 2011
@@ -28,11 +28,11 @@ namespace Lucene.Net.Search
 	{
 		
 		/// <summary>Implemented as
-		/// <code>state.getBoost()*lengthNorm(numTerms)</code>, where
-		/// <code>numTerms</code> is {@link FieldInvertState#GetLength()} if {@link
-		/// #setDiscountOverlaps} is false, else it's {@link
-		/// FieldInvertState#GetLength()} - {@link
-		/// FieldInvertState#GetNumOverlap()}.
+		/// <c>state.getBoost()*lengthNorm(numTerms)</c>, where
+		/// <c>numTerms</c> is <see cref="FieldInvertState.GetLength()" /> if <see cref="SetDiscountOverlaps" />
+		/// is false, else it's <see cref="FieldInvertState.GetLength()" />
+		/// - <see cref="FieldInvertState.GetNumOverlap()" />
+		///.
 		/// 
 		/// <p/><b>WARNING</b>: This API is new and experimental, and may suddenly
 		/// change.<p/> 
@@ -47,37 +47,37 @@ namespace Lucene.Net.Search
 			return (float) (state.GetBoost() * LengthNorm(field, numTerms));
 		}
 		
-		/// <summary>Implemented as <code>1/sqrt(numTerms)</code>. </summary>
+		/// <summary>Implemented as <c>1/sqrt(numTerms)</c>. </summary>
 		public override float LengthNorm(System.String fieldName, int numTerms)
 		{
 			return (float) (1.0 / System.Math.Sqrt(numTerms));
 		}
 		
-		/// <summary>Implemented as <code>1/sqrt(sumOfSquaredWeights)</code>. </summary>
+		/// <summary>Implemented as <c>1/sqrt(sumOfSquaredWeights)</c>. </summary>
 		public override float QueryNorm(float sumOfSquaredWeights)
 		{
 			return (float) (1.0 / System.Math.Sqrt(sumOfSquaredWeights));
 		}
 		
-		/// <summary>Implemented as <code>sqrt(freq)</code>. </summary>
+		/// <summary>Implemented as <c>sqrt(freq)</c>. </summary>
 		public override float Tf(float freq)
 		{
 			return (float) System.Math.Sqrt(freq);
 		}
 		
-		/// <summary>Implemented as <code>1 / (distance + 1)</code>. </summary>
+		/// <summary>Implemented as <c>1 / (distance + 1)</c>. </summary>
 		public override float SloppyFreq(int distance)
 		{
 			return 1.0f / (distance + 1);
 		}
 		
-		/// <summary>Implemented as <code>log(numDocs/(docFreq+1)) + 1</code>. </summary>
+		/// <summary>Implemented as <c>log(numDocs/(docFreq+1)) + 1</c>. </summary>
 		public override float Idf(int docFreq, int numDocs)
 		{
 			return (float) (System.Math.Log(numDocs / (double) (docFreq + 1)) + 1.0);
 		}
 		
-		/// <summary>Implemented as <code>overlap / maxOverlap</code>. </summary>
+		/// <summary>Implemented as <c>overlap / maxOverlap</c>. </summary>
 		public override float Coord(int overlap, int maxOverlap)
 		{
 			return overlap / (float) maxOverlap;
@@ -95,14 +95,14 @@ namespace Lucene.Net.Search
 		/// change.<p/>
 		/// 
 		/// </summary>
-		/// <seealso cref="computeNorm">
+		/// <seealso cref="ComputeNorm">
 		/// </seealso>
 		public virtual void  SetDiscountOverlaps(bool v)
 		{
 			discountOverlaps = v;
 		}
 		
-		/// <seealso cref="setDiscountOverlaps">
+		/// <seealso cref="SetDiscountOverlaps">
 		/// </seealso>
 		public virtual bool GetDiscountOverlaps()
 		{

Modified: incubator/lucene.net/trunk/src/core/Search/DisjunctionMaxScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/DisjunctionMaxScorer.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/DisjunctionMaxScorer.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/DisjunctionMaxScorer.cs Sun Nov  6 05:24:26 2011
@@ -67,7 +67,7 @@ namespace Lucene.Net.Search
 		/// </summary>
 		/// <returns> true iff there is a next document
 		/// </returns>
-		/// <deprecated> use {@link #NextDoc()} instead.
+		/// <deprecated> use <see cref="NextDoc()" /> instead.
 		/// </deprecated>
         [Obsolete("use NextDoc() instead.")]
 		public override bool Next()
@@ -98,7 +98,7 @@ namespace Lucene.Net.Search
 			return doc = subScorers[0].DocID();
 		}
 		
-		/// <deprecated> use {@link #DocID()} instead. 
+		/// <deprecated> use <see cref="DocID()" /> instead. 
 		/// </deprecated>
         [Obsolete("use DocID() instead. ")]
 		public override int Doc()
@@ -111,7 +111,7 @@ namespace Lucene.Net.Search
 			return doc;
 		}
 		
-		/// <summary>Determine the current document score.  Initially invalid, until {@link #Next()} is called the first time.</summary>
+		/// <summary>Determine the current document score.  Initially invalid, until <see cref="Next()" /> is called the first time.</summary>
 		/// <returns> the score of the current generated document
 		/// </returns>
 		public override float Score()
@@ -146,7 +146,7 @@ namespace Lucene.Net.Search
 		/// <returns> true iff there is a document to be generated whose number is at
 		/// least target
 		/// </returns>
-		/// <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/DisjunctionSumScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/DisjunctionSumScorer.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/DisjunctionSumScorer.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/DisjunctionSumScorer.cs Sun Nov  6 05:24:26 2011
@@ -22,8 +22,8 @@ using ScorerDocQueue = Lucene.Net.Util.S
 namespace Lucene.Net.Search
 {
 	
-	/// <summary>A Scorer for OR like queries, counterpart of <code>ConjunctionScorer</code>.
-	/// This Scorer implements {@link Scorer#SkipTo(int)} and uses skipTo() on the given Scorers. 
+	/// <summary>A Scorer for OR like queries, counterpart of <c>ConjunctionScorer</c>.
+	/// This Scorer implements <see cref="DocIdSetIterator.SkipTo(int)" /> and uses skipTo() on the given Scorers. 
 	/// TODO: Implement score(HitCollector, int).
 	/// </summary>
 	class DisjunctionSumScorer:Scorer
@@ -45,8 +45,8 @@ namespace Lucene.Net.Search
 		/// remain in the scorerDocQueue next() and skipTo() return false.
 		/// <p/>
 		/// After each to call to next() or skipTo()
-		/// <code>currentSumScore</code> is the total score of the current matching doc,
-		/// <code>nrMatchers</code> is the number of matching scorers,
+		/// <c>currentSumScore</c> is the total score of the current matching doc,
+		/// <c>nrMatchers</c> is the number of matching scorers,
 		/// and all scorers are after the matching doc, or are exhausted.
 		/// </summary>
 		private ScorerDocQueue scorerDocQueue;
@@ -59,16 +59,16 @@ namespace Lucene.Net.Search
 		
 		private float currentScore = System.Single.NaN;
 		
-		/// <summary>Construct a <code>DisjunctionScorer</code>.</summary>
+		/// <summary>Construct a <c>DisjunctionScorer</c>.</summary>
 		/// <param name="subScorers">A collection of at least two subscorers.
 		/// </param>
 		/// <param name="minimumNrMatchers">The positive minimum number of subscorers that should
 		/// match to match this query.
-		/// <br/>When <code>minimumNrMatchers</code> is bigger than
-		/// the number of <code>subScorers</code>,
+		/// <br/>When <c>minimumNrMatchers</c> is bigger than
+		/// the number of <c>subScorers</c>,
 		/// no matches will be produced.
 		/// <br/>When minimumNrMatchers equals the number of subScorers,
-		/// it more efficient to use <code>ConjunctionScorer</code>.
+		/// it more efficient to use <c>ConjunctionScorer</c>.
 		/// </param>
 		public DisjunctionSumScorer(System.Collections.IList subScorers, int minimumNrMatchers):base(null)
 		{
@@ -90,7 +90,7 @@ namespace Lucene.Net.Search
 			InitScorerDocQueue();
 		}
 		
-		/// <summary>Construct a <code>DisjunctionScorer</code>, using one as the minimum number
+		/// <summary>Construct a <c>DisjunctionScorer</c>, using one as the minimum number
 		/// of matching subscorers.
 		/// </summary>
 		public DisjunctionSumScorer(System.Collections.IList subScorers):this(subScorers, 1)
@@ -98,7 +98,7 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Called the first time next() or skipTo() is called to
-		/// initialize <code>scorerDocQueue</code>.
+		/// initialize <c>scorerDocQueue</c>.
 		/// </summary>
 		private void  InitScorerDocQueue()
 		{
@@ -117,10 +117,10 @@ namespace Lucene.Net.Search
 		
 		/// <summary>Scores and collects all matching documents.</summary>
 		/// <param name="hc">The collector to which all matching documents are passed through
-		/// {@link HitCollector#Collect(int, float)}.
-		/// <br/>When this method is used the {@link #Explain(int)} method should not be used.
+		/// <see cref="HitCollector.Collect(int, float)" />.
+		/// <br/>When this method is used the <see cref="Explain(int)" /> method should not be used.
 		/// </param>
-		/// <deprecated> use {@link #Score(Collector)} instead.
+		/// <deprecated> use <see cref="Score(Collector)" /> instead.
 		/// </deprecated>
         [Obsolete("use Score(Collector) instead.")]
 		public override void  Score(HitCollector hc)
@@ -130,7 +130,7 @@ namespace Lucene.Net.Search
 		
 		/// <summary>Scores and collects all matching documents.</summary>
 		/// <param name="collector">The collector to which all matching documents are passed through.
-		/// <br/>When this method is used the {@link #Explain(int)} method should not be used.
+		/// <br/>When this method is used the <see cref="Explain(int)" /> method should not be used.
 		/// </param>
 		public override void  Score(Collector collector)
 		{
@@ -142,35 +142,36 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Expert: Collects matching documents in a range.  Hook for optimization.
-		/// Note that {@link #Next()} must be called once before this method is called
+		/// Note that <see cref="Next()" /> must be called once before this method is called
 		/// for the first time.
 		/// </summary>
 		/// <param name="hc">The collector to which all matching documents are passed through
-		/// {@link HitCollector#Collect(int, float)}.
+		/// <see cref="HitCollector.Collect(int, float)" />.
 		/// </param>
 		/// <param name="max">Do not score documents past this.
 		/// </param>
 		/// <returns> true if more matching documents may remain.
 		/// </returns>
-		/// <deprecated> use {@link #Score(Collector, int, int)} instead.
+		/// <deprecated> use <see cref="Score(Collector, int, int)" /> instead.
 		/// </deprecated>
         [Obsolete("use Score(Collector, int, int) instead.")]
 		protected internal override bool Score(HitCollector hc, int max)
 		{
 			return Score(new HitCollectorWrapper(hc), max, DocID());
 		}
-		
-		/// <summary>Expert: Collects matching documents in a range.  Hook for optimization.
-		/// Note that {@link #Next()} must be called once before this method is called
-		/// for the first time.
-		/// </summary>
-		/// <param name="collector">The collector to which all matching documents are passed through.
-		/// </param>
-		/// <param name="max">Do not score documents past this.
-		/// </param>
-		/// <returns> true if more matching documents may remain.
-		/// </returns>
-		public /*protected internal*/ override bool Score(Collector collector, int max, int firstDocID)
+
+	    /// <summary>Expert: Collects matching documents in a range.  Hook for optimization.
+	    /// Note that <see cref="Next()" /> must be called once before this method is called
+	    /// for the first time.
+	    /// </summary>
+	    /// <param name="collector">The collector to which all matching documents are passed through.
+	    /// </param>
+	    /// <param name="max">Do not score documents past this.
+	    /// </param>
+	    /// <param name="firstDocID"></param>
+	    /// <returns> true if more matching documents may remain.
+	    /// </returns>
+	    public /*protected internal*/ override bool Score(Collector collector, int max, int firstDocID)
 		{
 			// firstDocID is ignored since nextDoc() sets 'currentDoc'
 			collector.SetScorer(this);
@@ -185,7 +186,7 @@ namespace Lucene.Net.Search
 			return true;
 		}
 		
-		/// <deprecated> use {@link #NextDoc()} instead. 
+		/// <deprecated> use <see cref="NextDoc()" /> instead. 
 		/// </deprecated>
         [Obsolete("use NextDoc() instead. ")]
 		public override bool Next()
@@ -203,15 +204,15 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Advance all subscorers after the current document determined by the
-		/// top of the <code>scorerDocQueue</code>.
+		/// top of the <c>scorerDocQueue</c>.
 		/// Repeat until at least the minimum number of subscorers match on the same
 		/// document and all subscorers are after that document or are exhausted.
-		/// <br/>On entry the <code>scorerDocQueue</code> has at least <code>minimumNrMatchers</code>
+		/// <br/>On entry the <c>scorerDocQueue</c> has at least <c>minimumNrMatchers</c>
 		/// available. At least the scorer with the minimum document number will be advanced.
 		/// </summary>
 		/// <returns> true iff there is a match.
-		/// <br/>In case there is a match, <code>currentDoc</code>, <code>currentSumScore</code>,
-		/// and <code>nrMatchers</code> describe the match.
+		/// <br/>In case there is a match, <c>currentDoc</c>, <c>currentSumScore</c>,
+		/// and <c>nrMatchers</c> describe the match.
 		/// 
 		/// TODO: Investigate whether it is possible to use skipTo() when
 		/// the minimum number of matchers is bigger than one, ie. try and use the
@@ -261,14 +262,14 @@ 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>
 		public override float Score()
 		{
 			return currentScore;
 		}
 		
-		/// <deprecated> use {@link #DocID()} instead. 
+		/// <deprecated> use <see cref="DocID()" /> instead. 
 		/// </deprecated>
         [Obsolete("use DocID() instead. ")]
 		public override int Doc()
@@ -282,7 +283,7 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Returns the number of subscorers matching the current document.
-		/// Initially invalid, until {@link #Next()} is called the first time.
+		/// Initially invalid, until <see cref="Next()" /> is called the first time.
 		/// </summary>
 		public virtual int NrMatchers()
 		{
@@ -291,7 +292,7 @@ namespace Lucene.Net.Search
 		
 		/// <summary> Skips to the first match beyond the current whose document number is
 		/// greater than or equal to a given target. <br/>
-		/// When this method is used the {@link #Explain(int)} method should not be
+		/// When this method is used the <see cref="Explain(int)" /> method should not be
 		/// used. <br/>
 		/// The implementation uses the skipTo() method on the subscorers.
 		/// 
@@ -300,7 +301,7 @@ namespace Lucene.Net.Search
 		/// </param>
 		/// <returns> true iff there is such a match.
 		/// </returns>
-		/// <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)
@@ -310,7 +311,7 @@ namespace Lucene.Net.Search
 		
 		/// <summary> Advances to the first match beyond the current whose document number is
 		/// greater than or equal to a given target. <br/>
-		/// When this method is used the {@link #Explain(int)} method should not be
+		/// When this method is used the <see cref="Explain(int)" /> method should not be
 		/// used. <br/>
 		/// The implementation uses the skipTo() method on the subscorers.
 		/// 

Modified: incubator/lucene.net/trunk/src/core/Search/DocIdSet.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/DocIdSet.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/DocIdSet.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/DocIdSet.cs Sun Nov  6 05:24:26 2011
@@ -21,7 +21,7 @@ namespace Lucene.Net.Search
 {
 	
 	/// <summary> A DocIdSet contains a set of doc ids. Implementing classes must
-	/// only implement {@link #iterator} to provide access to the set. 
+	/// only implement <see cref="Iterator" /> to provide access to the set. 
 	/// </summary>
 	[Serializable]
 	public abstract class DocIdSet
@@ -81,21 +81,21 @@ namespace Lucene.Net.Search
 				return true;
 			}
 		}
-		
-		/// <summary>An empty {@code DocIdSet} instance for easy use, e.g. in Filters that hit no documents. </summary>
+
+        /// <summary>An empty <see cref="DocIdSet"/> instance for easy use, e.g. in Filters that hit no documents. </summary>
 		[NonSerialized]
 		public static readonly DocIdSet EMPTY_DOCIDSET;
 		
-		/// <summary>Provides a {@link DocIdSetIterator} to access the set.
-		/// This implementation can return <code>null</code> or
-		/// <code>{@linkplain #EMPTY_DOCIDSET}.iterator()</code> if there
+		/// <summary>Provides a <see cref="DocIdSetIterator" /> to access the set.
+		/// This implementation can return <c>null</c> or
+		/// <c>EMPTY_DOCIDSET.Iterator()</c> if there
 		/// are no docs that match. 
 		/// </summary>
 		public abstract DocIdSetIterator Iterator();
 
-		/// <summary>This method is a hint for {@link CachingWrapperFilter}, if this <code>DocIdSet</code>
+		/// <summary>This method is a hint for <see cref="CachingWrapperFilter" />, if this <c>DocIdSet</c>
 		/// should be cached without copying it into a BitSet. The default is to return
-		/// <code>false</code>. If you have an own <code>DocIdSet</code> implementation
+		/// <c>false</c>. If you have an own <c>DocIdSet</c> implementation
 		/// that does its iteration very effective and fast without doing disk I/O,
 		/// override this method and return true.
 		/// </summary>

Modified: incubator/lucene.net/trunk/src/core/Search/DocIdSetIterator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/DocIdSetIterator.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/DocIdSetIterator.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/DocIdSetIterator.cs Sun Nov  6 05:24:26 2011
@@ -22,9 +22,9 @@ namespace Lucene.Net.Search
 	
 	/// <summary> This abstract class defines methods to iterate over a set of non-decreasing
 	/// doc ids. Note that this class assumes it iterates on doc Ids, and therefore
-	/// {@link #NO_MORE_DOCS} is set to {@value #NO_MORE_DOCS} in order to be used as
+	/// <see cref="NO_MORE_DOCS" /> is set to Int32.MaxValue in order to be used as
 	/// a sentinel object. Implementations of this class are expected to consider
-	/// {@link Integer#MAX_VALUE} as an invalid value.
+	/// <see cref="int.MaxValue" /> as an invalid value.
 	/// </summary>
 	public abstract class DocIdSetIterator
 	{
@@ -32,16 +32,16 @@ namespace Lucene.Net.Search
 		// TODO (3.0): review the javadocs and remove any references to '3.0'.
 		private int doc = - 1;
 		
-		/// <summary> When returned by {@link #NextDoc()}, {@link #Advance(int)} and
-		/// {@link #Doc()} it means there are no more docs in the iterator.
+		/// <summary> When returned by <see cref="NextDoc()" />, <see cref="Advance(int)" /> and
+		/// <see cref="Doc()" /> it means there are no more docs in the iterator.
 		/// </summary>
 		public static readonly int NO_MORE_DOCS = System.Int32.MaxValue;
 		
-		/// <summary> Unsupported anymore. Call {@link #DocID()} instead. This method throws
-		/// {@link UnsupportedOperationException} if called.
+		/// <summary> Unsupported anymore. Call <see cref="DocID()" /> instead. This method throws
+		/// <see cref="NotSupportedException" /> if called.
 		/// 
 		/// </summary>
-		/// <deprecated> use {@link #DocID()} instead.
+		/// <deprecated> use <see cref="DocID()" /> instead.
 		/// </deprecated>
         [Obsolete("use DocID() instead.")]
 		public virtual int Doc()
@@ -50,12 +50,12 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary> Returns the following:
-		/// <ul>
-		/// <li>-1 or {@link #NO_MORE_DOCS} if {@link #NextDoc()} or
-		/// {@link #Advance(int)} were not called yet.</li>
-		/// <li>{@link #NO_MORE_DOCS} if the iterator has exhausted.</li>
-		/// <li>Otherwise it should return the doc ID it is currently on.</li>
-		/// </ul>
+		/// <list type="bullet">
+		/// <item>-1 or <see cref="NO_MORE_DOCS" /> if <see cref="NextDoc()" /> or
+		/// <see cref="Advance(int)" /> were not called yet.</item>
+		/// <item><see cref="NO_MORE_DOCS" /> if the iterator has exhausted.</item>
+		/// <item>Otherwise it should return the doc ID it is currently on.</item>
+		/// </list>
 		/// <p/>
 		/// <b>NOTE:</b> in 3.0, this method will become abstract.
 		/// 
@@ -67,11 +67,11 @@ namespace Lucene.Net.Search
 			return doc;
 		}
 		
-		/// <summary> Unsupported anymore. Call {@link #NextDoc()} instead. This method throws
-		/// {@link UnsupportedOperationException} if called.
+		/// <summary> Unsupported anymore. Call <see cref="NextDoc()" /> instead. This method throws
+		/// <see cref="NotSupportedException" /> if called.
 		/// 
 		/// </summary>
-		/// <deprecated> use {@link #NextDoc()} instead. This will be removed in 3.0
+		/// <deprecated> use <see cref="NextDoc()" /> instead. This will be removed in 3.0
 		/// </deprecated>
         [Obsolete("use NextDoc() instead. This will be removed in 3.0")]
 		public virtual bool Next()
@@ -79,11 +79,11 @@ namespace Lucene.Net.Search
 			throw new System.NotSupportedException("Call nextDoc() instead.");
 		}
 		
-		/// <summary> Unsupported anymore. Call {@link #Advance(int)} instead. This method throws
-		/// {@link UnsupportedOperationException} if called.
+		/// <summary> Unsupported anymore. Call <see cref="Advance(int)" /> instead. This method throws
+        /// <see cref="NotSupportedException" /> if called.
 		/// 
 		/// </summary>
-		/// <deprecated> use {@link #Advance(int)} instead. This will be removed in 3.0
+		/// <deprecated> use <see cref="Advance(int)" /> instead. This will be removed in 3.0
 		/// </deprecated>
         [Obsolete("use Advance(int) instead. This will be removed in 3.0")]
 		public virtual bool SkipTo(int target)
@@ -92,17 +92,17 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary> Advances to the next document in the set and returns the doc it is
-		/// currently on, or {@link #NO_MORE_DOCS} if there are no more docs in the
+		/// currently on, or <see cref="NO_MORE_DOCS" /> if there are no more docs in the
 		/// set.<br/>
 		/// 
 		/// <b>NOTE:</b> in 3.0 this method will become abstract, following the removal
-		/// of {@link #Next()}. For backward compatibility it is implemented as:
+		/// of <see cref="Next()" />. For backward compatibility it is implemented as:
 		/// 
-		/// <pre>
+        /// <code>
 		/// public int nextDoc() throws IOException {
-		/// return next() ? doc() : NO_MORE_DOCS;
+		///     return next() ? doc() : NO_MORE_DOCS;
 		/// }
-		/// </pre>
+        /// </code>
 		/// 
 		/// <b>NOTE:</b> after the iterator has exhausted you should not call this
 		/// method, as it may result in unpredicted behavior.
@@ -117,25 +117,25 @@ namespace Lucene.Net.Search
 		
 		/// <summary> Advances to the first beyond the current whose document number is greater
 		/// than or equal to <i>target</i>. Returns the current document number or
-		/// {@link #NO_MORE_DOCS} if there are no more docs in the set.
+		/// <see cref="NO_MORE_DOCS" /> if there are no more docs in the set.
 		/// <p/>
 		/// Behaves as if written:
 		/// 
-		/// <pre>
+        /// <code>
 		/// int advance(int target) {
-		/// int doc;
-		/// while ((doc = nextDoc()) &lt; target) {
+		///     int doc;
+		///     while ((doc = nextDoc()) &lt; target) {
+		///     }
+		///     return doc;
 		/// }
-		/// return doc;
-		/// }
-		/// </pre>
+        /// </code>
 		/// 
 		/// Some implementations are considerably more efficient than that.
 		/// <p/>
 		/// <b>NOTE:</b> certain implemenations may return a different value (each
 		/// time) if called several times in a row with the same target.
 		/// <p/>
-		/// <b>NOTE:</b> this method may be called with {@value #NO_MORE_DOCS} for
+        /// <b>NOTE:</b> this method may be called with <see cref="NO_MORE_DOCS"/> for
 		/// efficiency by some Scorers. If your implementation cannot efficiently
 		/// determine that it should exhaust, it is recommended that you check for that
 		/// value in each call to this method.
@@ -144,7 +144,7 @@ namespace Lucene.Net.Search
 		/// method, as it may result in unpredicted behavior.
 		/// <p/>
 		/// <b>NOTE:</b> in 3.0 this method will become abstract, following the removal
-		/// of {@link #SkipTo(int)}.
+		/// of <see cref="SkipTo(int)" />.
 		/// 
 		/// </summary>
 		/// <since> 2.9

Modified: incubator/lucene.net/trunk/src/core/Search/Explanation.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Explanation.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Explanation.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Explanation.cs Sun Nov  6 05:24:26 2011
@@ -44,7 +44,7 @@ namespace Lucene.Net.Search
 		/// By default, an Explanation represents a "match" if the value is positive.
 		/// <p/>
 		/// </summary>
-		/// <seealso cref="getValue">
+		/// <seealso cref="GetValue">
 		/// </seealso>
 		public virtual bool IsMatch()
 		{
@@ -131,9 +131,9 @@ namespace Lucene.Net.Search
 		public virtual System.String ToHtml()
 		{
 			System.Text.StringBuilder buffer = new System.Text.StringBuilder();
-			buffer.Append("<ul>\n");
+			buffer.Append("<list>\n");
 			
-			buffer.Append("<li>");
+			buffer.Append("<item>");
 			buffer.Append(GetSummary());
 			buffer.Append("<br />\n");
 			
@@ -146,8 +146,8 @@ namespace Lucene.Net.Search
 				}
 			}
 			
-			buffer.Append("</li>\n");
-			buffer.Append("</ul>\n");
+			buffer.Append("</item>\n");
+			buffer.Append("</list>\n");
 			
 			return buffer.ToString();
 		}
@@ -155,7 +155,7 @@ namespace Lucene.Net.Search
 		/// <summary> Small Util class used to pass both an idf factor as well as an
 		/// explanation for that factor.
 		/// 
-		/// This class will likely be held on a {@link Weight}, so be aware 
+		/// This class will likely be held on a <see cref="Weight" />, so be aware 
 		/// before storing any large or un-serializable fields.
 		/// 
 		/// </summary>

Modified: incubator/lucene.net/trunk/src/core/Search/ExtendedFieldCache.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/ExtendedFieldCache.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/ExtendedFieldCache.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/ExtendedFieldCache.cs Sun Nov  6 05:24:26 2011
@@ -22,15 +22,15 @@ using IndexReader = Lucene.Net.Index.Ind
 namespace Lucene.Net.Search.ExtendedFieldCache_old
 {
 	
-	/// <summary> This interface is obsolete, use {@link FieldCache} instead.
+	/// <summary> This interface is obsolete, use <see cref="FieldCache" /> instead.
 	/// 
 	/// </summary>
-	/// <deprecated> Use {@link FieldCache}, this will be removed in Lucene 3.0
+	/// <deprecated> Use <see cref="FieldCache" />, this will be removed in Lucene 3.0
 	/// 
 	/// </deprecated>
     [Obsolete("Use FieldCache, this will be removed in Lucene 3.0")]
 	public struct ExtendedFieldCache_Fields{
-		/// <deprecated> Use {@link FieldCache#DEFAULT}; this will be removed in Lucene 3.0 
+        /// <deprecated> Use <see cref="FieldCache_Fields.DEFAULT" />; this will be removed in Lucene 3.0 
 		/// </deprecated>
         [Obsolete("Use FieldCache.DEFAULT; this will be removed in Lucene 3.0 ")]
 		public readonly static ExtendedFieldCache EXT_DEFAULT;
@@ -46,21 +46,20 @@ namespace Lucene.Net.Search.ExtendedFiel
 		/// </deprecated>
         [Obsolete("Will be removed in 3.0, this is for binary compatibility only ")]
 		new long[] GetLongs(IndexReader reader, System.String field, Lucene.Net.Search.LongParser parser);
-		
 		/// <deprecated> Will be removed in 3.0, this is for binary compatibility only 
 		/// </deprecated>
         [Obsolete("Will be removed in 3.0, this is for binary compatibility only ")]
 		new double[] GetDoubles(IndexReader reader, System.String field, Lucene.Net.Search.DoubleParser parser);
 	}
 
-	/// <deprecated> Use {@link FieldCache.LongParser}, this will be removed in Lucene 3.0 
+	/// <deprecated> Use <see cref="LongParser" />, this will be removed in Lucene 3.0 
 	/// </deprecated>
     [Obsolete("Use FieldCache.LongParser, this will be removed in Lucene 3.0 ")]
 	public interface LongParser:Lucene.Net.Search.LongParser
 	{
 	}
 
-	/// <deprecated> Use {@link FieldCache.DoubleParser}, this will be removed in Lucene 3.0 
+	/// <deprecated> Use <see cref="DoubleParser" />, this will be removed in Lucene 3.0 
 	/// </deprecated>
     [Obsolete("Use FieldCache.DoubleParser, this will be removed in Lucene 3.0 ")]
 	public interface DoubleParser:Lucene.Net.Search.DoubleParser



Mime
View raw message