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 [14/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/ScoreCachingWrappingScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/ScoreCachingWrappingScorer.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/ScoreCachingWrappingScorer.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/ScoreCachingWrappingScorer.cs Sun Nov  6 05:24:26 2011
@@ -20,14 +20,14 @@ using System;
 namespace Lucene.Net.Search
 {
 	
-	/// <summary> A {@link Scorer} which wraps another scorer and caches the score of the
-	/// current document. Successive calls to {@link #Score()} will return the same
+	/// <summary> A <see cref="Scorer" /> which wraps another scorer and caches the score of the
+	/// current document. Successive calls to <see cref="Score()" /> will return the same
 	/// result and will not invoke the wrapped Scorer's score() method, unless the
 	/// current document has changed.<br/>
-	/// This class might be useful due to the changes done to the {@link Collector}
+	/// This class might be useful due to the changes done to the <see cref="Collector" />
 	/// interface, in which the score is not computed for a document by default, only
 	/// if the collector requests it. Some collectors may need to use the score in
-	/// several places, however all they have in hand is a {@link Scorer} object, and
+	/// several places, however all they have in hand is a <see cref="Scorer" /> object, and
 	/// might end up computing the score of a document more than once.
 	/// </summary>
 	public class ScoreCachingWrappingScorer:Scorer
@@ -70,7 +70,7 @@ namespace Lucene.Net.Search
 			return curScore;
 		}
 		
-		/// <deprecated> use {@link #DocID()} instead. 
+		/// <deprecated> use <see cref="DocID()" /> instead. 
 		/// </deprecated>
         [Obsolete("use DocID() instead.")]
 		public override int Doc()
@@ -83,7 +83,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()
@@ -101,7 +101,7 @@ namespace Lucene.Net.Search
 			scorer.Score(collector);
 		}
 		
-		/// <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/ScoreDocComparator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/ScoreDocComparator.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/ScoreDocComparator.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/ScoreDocComparator.cs Sun Nov  6 05:24:26 2011
@@ -29,7 +29,7 @@ namespace Lucene.Net.Search
 	/// </since>
 	/// <version>  $Id: ScoreDocComparator.java 738219 2009-01-27 20:15:21Z mikemccand $
 	/// </version>
-	/// <deprecated> use {@link FieldComparator}
+	/// <deprecated> use <see cref="FieldComparator" />
 	/// </deprecated>
     [Obsolete("use FieldComparator")]
 	public struct ScoreDocComparator_Fields{
@@ -91,11 +91,11 @@ namespace Lucene.Net.Search
 		/// </param>
 		/// <param name="j">Second ScoreDoc
 		/// </param>
-		/// <returns> a negative integer if <code>i</code> should come before <code>j</code><br/>
-		/// a positive integer if <code>i</code> should come after <code>j</code><br/>
-		/// <code>0</code> if they are equal
+		/// <returns> a negative integer if <c>i</c> should come before <c>j</c><br/>
+		/// a positive integer if <c>i</c> should come after <c>j</c><br/>
+		/// <c>0</c> if they are equal
 		/// </returns>
-		/// <seealso cref="java.util.Comparator">
+		/// <seealso cref="IComparable">
 		/// </seealso>
 		int Compare(ScoreDoc i, ScoreDoc j);
 		
@@ -112,11 +112,11 @@ namespace Lucene.Net.Search
 		/// </returns>
 		System.IComparable SortValue(ScoreDoc i);
 		
-		/// <summary> Returns the type of sort.  Should return <code>SortField.SCORE</code>,
-		/// <code>SortField.DOC</code>, <code>SortField.STRING</code>,
-		/// <code>SortField.INTEGER</code>, <code>SortField.FLOAT</code> or
-		/// <code>SortField.CUSTOM</code>.  It is not valid to return
-		/// <code>SortField.AUTO</code>.
+		/// <summary> Returns the type of sort.  Should return <c>SortField.SCORE</c>,
+		/// <c>SortField.DOC</c>, <c>SortField.STRING</c>,
+		/// <c>SortField.INTEGER</c>, <c>SortField.FLOAT</c> or
+		/// <c>SortField.CUSTOM</c>.  It is not valid to return
+		/// <c>SortField.AUTO</c>.
 		/// This is used by multisearchers to determine how to collate results
 		/// from their searchers.
 		/// </summary>

Modified: incubator/lucene.net/trunk/src/core/Search/Scorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Scorer.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Scorer.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Scorer.cs Sun Nov  6 05:24:26 2011
@@ -16,6 +16,7 @@
  */
 
 using System;
+using Lucene.Net.Index;
 
 namespace Lucene.Net.Search
 {
@@ -23,29 +24,29 @@ namespace Lucene.Net.Search
 	/// <summary> Expert: Common scoring functionality for different types of queries.
 	/// 
 	/// <p/>
-	/// A <code>Scorer</code> iterates over documents matching a
+	/// A <c>Scorer</c> iterates over documents matching a
 	/// query in increasing order of doc Id.
 	/// <p/>
 	/// <p/>
-	/// Document scores are computed using a given <code>Similarity</code>
+	/// Document scores are computed using a given <c>Similarity</c>
 	/// implementation.
 	/// <p/>
 	/// 
 	/// <p/><b>NOTE</b>: The values Float.Nan,
 	/// Float.NEGATIVE_INFINITY and Float.POSITIVE_INFINITY are
-	/// not valid scores.  Certain collectors (eg {@link
-	/// TopScoreDocCollector}) will not properly collect hits
+	/// not valid scores.  Certain collectors (eg <see cref="TopScoreDocCollector" />
+	///) will not properly collect hits
 	/// with these scores.
 	/// 
 	/// </summary>
-	/// <seealso cref="BooleanQuery.setAllowDocsOutOfOrder">
+	/// <seealso cref="BooleanQuery.SetAllowDocsOutOfOrder">
 	/// </seealso>
 	public abstract class Scorer:DocIdSetIterator
 	{
 		private Similarity similarity;
 		
 		/// <summary>Constructs a Scorer.</summary>
-		/// <param name="similarity">The <code>Similarity</code> implementation used by this scorer.
+		/// <param name="similarity">The <c>Similarity</c> implementation used by this scorer.
 		/// </param>
 		protected internal Scorer(Similarity similarity)
 		{
@@ -60,10 +61,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 virtual void  Score(HitCollector hc)
@@ -73,7 +74,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.
-		/// <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 virtual void  Score(Collector collector)
 		{
@@ -86,17 +87,17 @@ 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="DocIdSetIterator.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 virtual bool Score(HitCollector hc, int max)
@@ -105,7 +106,7 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary> Expert: Collects matching documents in a range. Hook for optimization.
-		/// Note, <code>firstDocID</code> is added to ensure that {@link #NextDoc()}
+		/// Note, <paramref name="firstDocID" /> is added to ensure that <see cref="DocIdSetIterator.NextDoc()" />
 		/// was called before this method.
 		/// 
 		/// </summary>
@@ -114,7 +115,7 @@ namespace Lucene.Net.Search
 		/// <param name="max">Do not score documents past this.
 		/// </param>
 		/// <param name="firstDocID">
-		/// The first document ID (ensures {@link #NextDoc()} is called before
+        /// The first document ID (ensures <see cref="DocIdSetIterator.NextDoc()" /> is called before
 		/// this method.
 		/// </param>
 		/// <returns> true if more matching documents may remain.
@@ -132,21 +133,21 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Returns the score of the current document matching the query.
-		/// Initially invalid, until {@link #Next()} or {@link #SkipTo(int)}
+        /// Initially invalid, until <see cref="DocIdSetIterator.Next()" /> or <see cref="DocIdSetIterator.SkipTo(int)" />
 		/// is called the first time, or when called from within
-		/// {@link Collector#collect}.
+		/// <see cref="Collector.Collect(int)" />.
 		/// </summary>
 		public abstract float Score();
 		
 		/// <summary>Returns an explanation of the score for a document.
-		/// <br/>When this method is used, the {@link #Next()}, {@link #SkipTo(int)} and
-		/// {@link #Score(HitCollector)} methods should not be used.
+        /// <br/>When this method is used, the <see cref="DocIdSetIterator.Next()" />, <see cref="DocIdSetIterator.SkipTo(int)" /> and
+		/// <see cref="Score(HitCollector)" /> methods should not be used.
 		/// </summary>
 		/// <param name="doc">The document number for the explanation.
 		/// 
 		/// </param>
-		/// <deprecated> Please use {@link IndexSearcher#explain}
-		/// or {@link Weight#explain} instead.
+		/// <deprecated> Please use <see cref="IndexSearcher.Explain(Lucene.Net.Search.Weight,int)" />
+		/// or <see cref="Weight.Explain(IndexReader, int)" /> instead.
 		/// </deprecated>
 		public virtual Explanation Explain(int doc)
 		{

Modified: incubator/lucene.net/trunk/src/core/Search/Searchable.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Searchable.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Searchable.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Searchable.cs Sun Nov  6 05:24:26 2011
@@ -46,13 +46,13 @@ namespace Lucene.Net.Search
 		
 		/// <summary>Lower-level search API.
 		/// 
-		/// <p/>{@link HitCollector#Collect(int,float)} is called for every non-zero
+		/// <p/><see cref="HitCollector.Collect(int,float)" /> is called for every non-zero
 		/// scoring document.
 		/// <br/>HitCollector-based access to remote indexes is discouraged.
 		/// 
 		/// <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>
@@ -63,7 +63,7 @@ namespace Lucene.Net.Search
 		/// <param name="results">to receive hits
 		/// </param>
 		/// <throws>  BooleanQuery.TooManyClauses </throws>
-		/// <deprecated> use {@link #Search(Weight, Filter, Collector)} instead.
+		/// <deprecated> use <see cref="Search(Weight, Filter, Collector)" /> instead.
 		/// </deprecated>
         [Obsolete("use Search(Weight, Filter, Collector) instead.")]
 		void  Search(Weight weight, Filter filter, HitCollector results);
@@ -71,12 +71,12 @@ namespace Lucene.Net.Search
 		/// <summary> Lower-level search API.
 		/// 
 		/// <p/>
-		/// {@link Collector#Collect(int)} is called for every document. <br/>
+		/// <see cref="Collector.Collect(int)" /> is called for every document. <br/>
 		/// Collector-based access to remote indexes is discouraged.
 		/// 
 		/// <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
+		/// documents. The high-level search API (<see cref="Searcher.Search(Query)" />) is
 		/// usually more efficient, as it skips non-high-scoring hits.
 		/// 
 		/// </summary>
@@ -91,11 +91,11 @@ namespace Lucene.Net.Search
 		
 		/// <summary>Frees resources associated with this Searcher.
 		/// Be careful not to call this method while you are still using objects
-		/// like {@link Hits}.
+		/// like <see cref="Hits" />.
 		/// </summary>
 		void  Close();
 		
-		/// <summary>Expert: Returns the number of documents containing <code>term</code>.
+		/// <summary>Expert: Returns the number of documents containing <c>term</c>.
 		/// Called by search code to compute term weights.
 		/// </summary>
 		/// <seealso cref="Lucene.Net.Index.IndexReader.DocFreq(Term)">
@@ -103,7 +103,7 @@ namespace Lucene.Net.Search
 		int DocFreq(Term term);
 		
 		/// <summary>Expert: For each term in the terms array, calculates the number of
-		/// documents containing <code>term</code>. Returns an array with these
+		/// documents containing <c>term</c>. Returns an array with these
 		/// document frequencies. Used to minimize number of remote calls.
 		/// </summary>
 		int[] DocFreqs(Term[] terms);
@@ -115,40 +115,40 @@ namespace Lucene.Net.Search
 		/// </seealso>
 		int MaxDoc();
 		
-		/// <summary>Expert: Low-level search implementation.  Finds the top <code>n</code>
-		/// hits for <code>query</code>, applying <code>filter</code> if non-null.
+		/// <summary>Expert: Low-level search implementation.  Finds the top <c>n</c>
+		/// hits for <c>query</c>, applying <c>filter</c> if non-null.
 		/// 
-		/// <p/>Called by {@link Hits}.
+		/// <p/>Called by <see cref="Hits" />.
 		/// 
-		/// <p/>Applications should usually call {@link Searcher#Search(Query)} or
-		/// {@link Searcher#Search(Query,Filter)} instead.
+		/// <p/>Applications should usually call <see cref="Searcher.Search(Query)" /> or
+		/// <see cref="Searcher.Search(Query,Filter)" /> instead.
 		/// </summary>
 		/// <throws>  BooleanQuery.TooManyClauses </throws>
 		TopDocs Search(Weight weight, Filter filter, int n);
 		
-		/// <summary>Expert: Returns the stored fields of document <code>i</code>.
-		/// Called by {@link HitCollector} implementations.
+		/// <summary>Expert: Returns the stored fields of document <c>i</c>.
+		/// Called by <see cref="HitCollector" /> implementations.
 		/// </summary>
 		/// <seealso cref="Lucene.Net.Index.IndexReader.Document(int)">
 		/// </seealso>
 		/// <throws>  CorruptIndexException if the index is corrupt </throws>
 		/// <throws>  IOException if there is a low-level IO error </throws>
 		Document Doc(int i);
-		
-		/// <summary> Get the {@link Lucene.Net.Documents.Document} at the <code>n</code><sup>th</sup> position. The {@link Lucene.Net.Documents.FieldSelector}
-		/// may be used to determine what {@link Lucene.Net.Documents.Field}s to load and how they should be loaded.
+
+        /// <summary> Get the <see cref="Lucene.Net.Documents.Document" />at the <c>n</c><sup>th</sup> position. The <see cref="Lucene.Net.Documents.FieldSelector"/>
+		/// may be used to determine what <see cref="Lucene.Net.Documents.Field" />s to load and how they should be loaded.
 		/// 
-		/// <b>NOTE:</b> If the underlying Reader (more specifically, the underlying <code>FieldsReader</code>) is closed before the lazy {@link Lucene.Net.Documents.Field} is
-		/// loaded an exception may be thrown.  If you want the value of a lazy {@link Lucene.Net.Documents.Field} to be available after closing you must
+		/// <b>NOTE:</b> If the underlying Reader (more specifically, the underlying <c>FieldsReader</c>) is closed before the lazy <see cref="Lucene.Net.Documents.Field" /> is
+		/// loaded an exception may be thrown.  If you want the value of a lazy <see cref="Lucene.Net.Documents.Field" /> to be available after closing you must
 		/// explicitly load it or fetch the Document again with a new loader.
 		/// 
 		/// 
 		/// </summary>
-		/// <param name="n">Get the document at the <code>n</code><sup>th</sup> position
+		/// <param name="n">Get the document at the <c>n</c><sup>th</sup> position
 		/// </param>
-		/// <param name="fieldSelector">The {@link Lucene.Net.Documents.FieldSelector} to use to determine what Fields should be loaded on the Document.  May be null, in which case all Fields will be loaded.
+		/// <param name="fieldSelector">The <see cref="Lucene.Net.Documents.FieldSelector" /> to use to determine what Fields should be loaded on the Document.  May be null, in which case all Fields will be loaded.
 		/// </param>
-		/// <returns> The stored fields of the {@link Lucene.Net.Documents.Document} at the nth position
+		/// <returns> The stored fields of the <see cref="Lucene.Net.Documents.Document" /> at the nth position
 		/// </returns>
 		/// <throws>  CorruptIndexException if the index is corrupt </throws>
 		/// <throws>  IOException if there is a low-level IO error </throws>
@@ -171,25 +171,25 @@ namespace Lucene.Net.Search
 		Query Rewrite(Query query);
 		
 		/// <summary>Expert: low-level implementation method
-		/// Returns an Explanation that describes how <code>doc</code> scored against
-		/// <code>weight</code>.
+		/// Returns an Explanation that describes how <c>doc</c> scored against
+		/// <c>weight</c>.
 		/// 
 		/// <p/>This is intended to be used in developing Similarity implementations,
 		/// and, for good performance, should not be displayed with every hit.
 		/// Computing an explanation is as expensive as executing the query over the
 		/// entire index.
-		/// <p/>Applications should call {@link Searcher#Explain(Query, int)}.
+		/// <p/>Applications should call <see cref="Searcher.Explain(Query, int)" />.
 		/// </summary>
 		/// <throws>  BooleanQuery.TooManyClauses </throws>
 		Explanation Explain(Weight weight, int doc);
 		
 		/// <summary>Expert: Low-level search implementation with arbitrary sorting.  Finds
-		/// the top <code>n</code> hits for <code>query</code>, applying
-		/// <code>filter</code> if non-null, and sorting the hits by the criteria in
-		/// <code>sort</code>.
+		/// the top <c>n</c> hits for <c>query</c>, applying
+		/// <c>filter</c> if non-null, and sorting the hits by the criteria in
+		/// <c>sort</c>.
 		/// 
 		/// <p/>Applications should usually call
-		/// {@link Searcher#Search(Query,Filter,int,Sort)} instead.
+		/// <see cref="Searcher.Search(Query,Filter,int,Sort)" /> instead.
 		/// 
 		/// </summary>
 		/// <throws>  BooleanQuery.TooManyClauses </throws>

Modified: incubator/lucene.net/trunk/src/core/Search/Searcher.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Searcher.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Searcher.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Searcher.cs Sun Nov  6 05:24:26 2011
@@ -42,10 +42,10 @@ namespace Lucene.Net.Search
 			similarity = Similarity.GetDefault();
 		}
 		
-		/// <summary>Returns the documents matching <code>query</code>. </summary>
+		/// <summary>Returns the documents matching <c>query</c>. </summary>
 		/// <throws>  BooleanQuery.TooManyClauses </throws>
 		/// <deprecated> Hits will be removed in Lucene 3.0. Use
-		/// {@link #Search(Query, Filter, int)} instead.
+		/// <see cref="Search(Query, Filter, int)" /> instead.
 		/// </deprecated>
         [Obsolete("Hits will be removed in Lucene 3.0. Use Search(Query, Filter, int) instead")]
 		public Hits Search(Query query)
@@ -53,12 +53,12 @@ namespace Lucene.Net.Search
 			return Search(query, (Filter) null);
 		}
 		
-		/// <summary>Returns the documents matching <code>query</code> and
-		/// <code>filter</code>.
+		/// <summary>Returns the documents matching <c>query</c> and
+		/// <c>filter</c>.
 		/// </summary>
 		/// <throws>  BooleanQuery.TooManyClauses </throws>
 		/// <deprecated> Hits will be removed in Lucene 3.0. Use
-		/// {@link #Search(Query, Filter, int)} instead.
+		/// <see cref="Search(Query, Filter, int)" /> instead.
 		/// </deprecated>
         [Obsolete("Hits will be removed in Lucene 3.0. Use Search(Query, Filter, int) instead")]
 		public virtual Hits Search(Query query, Filter filter)
@@ -66,12 +66,12 @@ namespace Lucene.Net.Search
 			return new Hits(this, query, filter);
 		}
 		
-		/// <summary>Returns documents matching <code>query</code> sorted by
-		/// <code>sort</code>.
+		/// <summary>Returns documents matching <c>query</c> sorted by
+		/// <c>sort</c>.
 		/// </summary>
 		/// <throws>  BooleanQuery.TooManyClauses </throws>
 		/// <deprecated> Hits will be removed in Lucene 3.0. Use 
-		/// {@link #Search(Query, Filter, int, Sort)} instead.
+		/// <see cref="Search(Query, Filter, int, Sort)" /> instead.
 		/// </deprecated>
         [Obsolete("Hits will be removed in Lucene 3.0. Use Search(Query, Filter, int, Sort) instead")]
 		public virtual Hits Search(Query query, Sort sort)
@@ -79,12 +79,12 @@ namespace Lucene.Net.Search
 			return new Hits(this, query, null, sort);
 		}
 		
-		/// <summary>Returns documents matching <code>query</code> and <code>filter</code>,
-		/// sorted by <code>sort</code>.
+		/// <summary>Returns documents matching <c>query</c> and <c>filter</c>,
+		/// sorted by <c>sort</c>.
 		/// </summary>
 		/// <throws>  BooleanQuery.TooManyClauses </throws>
 		/// <deprecated> Hits will be removed in Lucene 3.0. Use 
-		/// {@link #Search(Query, Filter, int, Sort)} instead.
+		/// <see cref="Search(Query, Filter, int, Sort)" /> instead.
 		/// </deprecated>
         [Obsolete("Hits will be removed in Lucene 3.0. Use Search(Query, Filter, int, Sort) instead")]
 		public virtual Hits Search(Query query, Filter filter, Sort sort)
@@ -93,12 +93,12 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Search implementation with arbitrary sorting.  Finds
-		/// the top <code>n</code> hits for <code>query</code>, applying
-		/// <code>filter</code> if non-null, and sorting the hits by the criteria in
-		/// <code>sort</code>.
+		/// the top <c>n</c> hits for <c>query</c>, applying
+		/// <c>filter</c> if non-null, and sorting the hits by the criteria in
+		/// <c>sort</c>.
 		/// 
 		/// <p/>NOTE: this does not compute scores by default; use
-		/// {@link IndexSearcher#setDefaultFieldSortScoring} to enable scoring.
+		/// <see cref="IndexSearcher.SetDefaultFieldSortScoring(bool,bool)" /> to enable scoring.
 		/// 
 		/// </summary>
 		/// <throws>  BooleanQuery.TooManyClauses </throws>
@@ -109,19 +109,19 @@ namespace Lucene.Net.Search
 		
 		/// <summary>Lower-level search API.
 		/// 
-		/// <p/>{@link HitCollector#Collect(int,float)} is called for every matching
+		/// <p/><see cref="HitCollector.Collect(int,float)" /> 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.
-		/// <p/>Note: The <code>score</code> passed to this method is a raw score.
+		/// <p/>Note: The <c>score</c> passed to this method is a raw score.
 		/// In other words, the score will not necessarily be a float whose value is
 		/// between 0 and 1.
 		/// </summary>
 		/// <throws>  BooleanQuery.TooManyClauses </throws>
-		/// <deprecated> use {@link #Search(Query, Collector)} instead.
+		/// <deprecated> use <see cref="Search(Query, Collector)" /> instead.
 		/// </deprecated>
         [Obsolete("use Search(Query, Collector) instead.")]
 		public virtual void  Search(Query query, HitCollector results)
@@ -131,12 +131,12 @@ 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, int)}
+		/// documents. The high-level search API (<see cref="Searcher.Search(Query, int)" />
 		/// ) is usually more efficient, as it skips non-high-scoring hits.
-		/// <p/>Note: The <code>score</code> passed to this method is a raw score.
+		/// <p/>Note: The <c>score</c> passed to this method is a raw score.
 		/// In other words, the score will not necessarily be a float whose value is
 		/// between 0 and 1.
 		/// </summary>
@@ -148,13 +148,13 @@ namespace Lucene.Net.Search
 		
 		/// <summary>Lower-level search API.
 		/// 
-		/// <p/>{@link HitCollector#Collect(int,float)} is called for every matching
+		/// <p/><see cref="HitCollector.Collect(int,float)" /> is called for every matching
 		/// document.
 		/// <br/>HitCollector-based access to remote indexes is discouraged.
 		/// 
 		/// <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, Filter, int)}) is usually more efficient, as it skips
+		/// matching documents.  The high-level search API (<see cref="Searcher.Search(Query, Filter, int)" />)
+		/// is usually more efficient, as it skips
 		/// non-high-scoring hits.
 		/// 
 		/// </summary>
@@ -165,7 +165,7 @@ namespace Lucene.Net.Search
 		/// <param name="results">to receive hits
 		/// </param>
 		/// <throws>  BooleanQuery.TooManyClauses </throws>
-		/// <deprecated> use {@link #Search(Query, Filter, Collector)} instead.
+		/// <deprecated> use <see cref="Search(Query, Filter, Collector)" /> instead.
 		/// </deprecated>
         [Obsolete("use Search(Query, Filter, Collector) instead.")]
 		public virtual void  Search(Query query, Filter filter, HitCollector results)
@@ -175,13 +175,13 @@ namespace Lucene.Net.Search
 		
 		/// <summary>Lower-level search API.
 		/// 
-		/// <p/>{@link Collector#Collect(int)} is called for every matching
+		/// <p/><see cref="Collector.Collect(int)" /> is called for every matching
 		/// document.
 		/// <br/>Collector-based access to remote indexes is discouraged.
 		/// 
 		/// <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, Filter, int)}) is usually more efficient, as it skips
+		/// matching documents.  The high-level search API (<see cref="Searcher.Search(Query, Filter, int)" />)
+		/// is usually more efficient, as it skips
 		/// non-high-scoring hits.
 		/// 
 		/// </summary>
@@ -197,8 +197,8 @@ namespace Lucene.Net.Search
 			Search(CreateWeight(query), filter, results);
 		}
 		
-		/// <summary>Finds the top <code>n</code>
-		/// hits for <code>query</code>, applying <code>filter</code> if non-null.
+		/// <summary>Finds the top <c>n</c>
+		/// hits for <c>query</c>, applying <c>filter</c> if non-null.
 		/// 
 		/// </summary>
 		/// <throws>  BooleanQuery.TooManyClauses </throws>
@@ -207,8 +207,8 @@ namespace Lucene.Net.Search
 			return Search(CreateWeight(query), filter, n);
 		}
 		
-		/// <summary>Finds the top <code>n</code>
-		/// hits for <code>query</code>.
+		/// <summary>Finds the top <c>n</c>
+		/// hits for <c>query</c>.
 		/// 
 		/// </summary>
 		/// <throws>  BooleanQuery.TooManyClauses </throws>
@@ -217,8 +217,8 @@ namespace Lucene.Net.Search
 			return Search(query, null, n);
 		}
 		
-		/// <summary>Returns an Explanation that describes how <code>doc</code> scored against
-		/// <code>query</code>.
+		/// <summary>Returns an Explanation that describes how <c>doc</c> scored against
+		/// <c>query</c>.
 		/// 
 		/// <p/>This is intended to be used in developing Similarity implementations,
 		/// and, for good performance, should not be displayed with every hit.
@@ -245,14 +245,14 @@ namespace Lucene.Net.Search
 		
 		/// <summary>Expert: Return the Similarity implementation used by this Searcher.
 		/// 
-		/// <p/>This defaults to the current value of {@link Similarity#GetDefault()}.
+		/// <p/>This defaults to the current value of <see cref="Similarity.GetDefault()" />.
 		/// </summary>
 		public virtual Similarity GetSimilarity()
 		{
 			return this.similarity;
 		}
 		
-		/// <summary> creates a weight for <code>query</code></summary>
+		/// <summary> creates a weight for <c>query</c></summary>
 		/// <returns> new weight
 		/// </returns>
 		public /*protected internal*/ virtual Weight CreateWeight(Query query)
@@ -274,7 +274,7 @@ namespace Lucene.Net.Search
 		/* The following abstract methods were added as a workaround for GCJ bug #15411.
 		* http://gcc.gnu.org/bugzilla/show_bug.cgi?id=15411
 		*/
-		/// <deprecated> use {@link #Search(Weight, Filter, Collector)} instead.
+		/// <deprecated> use <see cref="Search(Weight, Filter, Collector)" /> instead.
 		/// </deprecated>
         [Obsolete("use Search(Weight, Filter, Collector) instead.")]
 		public virtual void  Search(Weight weight, Filter filter, HitCollector results)

Modified: incubator/lucene.net/trunk/src/core/Search/Similarity.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Similarity.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Similarity.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Similarity.cs Sun Nov  6 05:24:26 2011
@@ -28,7 +28,7 @@ namespace Lucene.Net.Search
 	/// <summary>Expert: Scoring API.
 	/// <p/>Subclasses implement search scoring.
 	/// 
-	/// <p/>The score of query <code>q</code> for document <code>d</code> correlates to the
+	/// <p/>The score of query <c>q</c> for document <c>d</c> correlates to the
 	/// cosine-distance or dot-product between document and query vectors in a
 	/// <a href="http://en.wikipedia.org/wiki/Vector_Space_Model">
 	/// Vector Space Model (VSM) of Information Retrieval</a>.
@@ -68,21 +68,21 @@ namespace Lucene.Net.Search
 	/// </table>
 	/// 
 	/// <p/> where
-	/// <ol>
-	/// <li>
+	/// <list type="bullet">
+	/// <item>
 	/// <A NAME="formula_tf"></A>
 	/// <b>tf(t in d)</b>
 	/// correlates to the term's <i>frequency</i>,
 	/// defined as the number of times term <i>t</i> appears in the currently scored document <i>d</i>.
 	/// Documents that have more occurrences of a given term receive a higher score.
 	/// The default computation for <i>tf(t in d)</i> in
-	/// {@link Lucene.Net.Search.DefaultSimilarity#Tf(float) DefaultSimilarity} is:
+    /// <see cref="Lucene.Net.Search.DefaultSimilarity.Tf(float)">DefaultSimilarity</see> is:
 	/// 
 	/// <br/>&#160;<br/>
 	/// <table cellpadding="2" cellspacing="2" border="0" align="center">
 	/// <tr>
 	/// <td valign="middle" align="right" rowspan="1">
-	/// {@link Lucene.Net.Search.DefaultSimilarity#Tf(float) tf(t in d)} &#160; = &#160;
+    /// <see cref="Lucene.Net.Search.DefaultSimilarity.Tf(float)">tf(t in d)</see> &#160; = &#160;
 	/// </td>
 	/// <td valign="top" align="center" rowspan="1">
 	/// frequency<sup><big>&#189;</big></sup>
@@ -90,22 +90,22 @@ namespace Lucene.Net.Search
 	/// </tr>
 	/// </table>
 	/// <br/>&#160;<br/>
-	/// </li>
+	/// </item>
 	/// 
-	/// <li>
+	/// <item>
 	/// <A NAME="formula_idf"></A>
 	/// <b>idf(t)</b> stands for Inverse Document Frequency. This value
 	/// correlates to the inverse of <i>docFreq</i>
 	/// (the number of documents in which the term <i>t</i> appears).
 	/// This means rarer terms give higher contribution to the total score.
-	/// The default computation for <i>idf(t)</i> in
-	/// {@link Lucene.Net.Search.DefaultSimilarity#Idf(int, int) DefaultSimilarity} is:
+	/// The default computation for <i>idf(t)</i> in 
+    /// <see cref="Lucene.Net.Search.DefaultSimilarity.Idf(int, int)">DefaultSimilarity</see> is:
 	/// 
 	/// <br/>&#160;<br/>
 	/// <table cellpadding="2" cellspacing="2" border="0" align="center">
 	/// <tr>
 	/// <td valign="middle" align="right">
-	/// {@link Lucene.Net.Search.DefaultSimilarity#Idf(int, int) idf(t)}&#160; = &#160;
+    /// <see cref="Lucene.Net.Search.DefaultSimilarity.Idf(int, int)">idf(t)</see>&#160; = &#160;
 	/// </td>
 	/// <td valign="middle" align="center">
 	/// 1 + log <big>(</big>
@@ -123,21 +123,21 @@ namespace Lucene.Net.Search
 	/// </tr>
 	/// </table>
 	/// <br/>&#160;<br/>
-	/// </li>
+	/// </item>
 	/// 
-	/// <li>
+	/// <item>
 	/// <A NAME="formula_coord"></A>
 	/// <b>coord(q,d)</b>
 	/// is a score factor based on how many of the query terms are found in the specified document.
 	/// Typically, a document that contains more of the query's terms will receive a higher score
 	/// than another document with fewer query terms.
-	/// This is a search time factor computed in
-	/// {@link #Coord(int, int) coord(q,d)}
+	/// This is a search time factor computed in 
+    /// <see cref="Coord(int, int)">coord(q,d)</see>
 	/// by the Similarity in effect at search time.
 	/// <br/>&#160;<br/>
-	/// </li>
+	/// </item>
 	/// 
-	/// <li><b>
+	/// <item><b>
 	/// <A NAME="formula_queryNorm"></A>
 	/// queryNorm(q)
 	/// </b>
@@ -147,14 +147,14 @@ namespace Lucene.Net.Search
 	/// This is a search time factor computed by the Similarity in effect at search time.
 	/// 
 	/// The default computation in
-	/// {@link Lucene.Net.Search.DefaultSimilarity#QueryNorm(float) DefaultSimilarity}
+    /// <see cref="Lucene.Net.Search.DefaultSimilarity.QueryNorm(float)">DefaultSimilarity</see>
 	/// is:
 	/// <br/>&#160;<br/>
 	/// <table cellpadding="1" cellspacing="0" border="0" align="center">
 	/// <tr>
 	/// <td valign="middle" align="right" rowspan="1">
 	/// queryNorm(q)  &#160; = &#160;
-	/// {@link Lucene.Net.Search.DefaultSimilarity#QueryNorm(float) queryNorm(sumOfSquaredWeights)}
+    /// <see cref="Lucene.Net.Search.DefaultSimilarity.QueryNorm(float)">queryNorm(sumOfSquaredWeights)</see>
 	/// &#160; = &#160;
 	/// </td>
 	/// <td valign="middle" align="center" rowspan="1">
@@ -171,16 +171,16 @@ namespace Lucene.Net.Search
 	/// <br/>&#160;<br/>
 	/// 
 	/// The sum of squared weights (of the query terms) is
-	/// computed by the query {@link Lucene.Net.Search.Weight} object.
-	/// For example, a {@link Lucene.Net.Search.BooleanQuery boolean query}
+	/// computed by the query <see cref="Lucene.Net.Search.Weight" /> object.
+	/// For example, a <see cref="Lucene.Net.Search.BooleanQuery">boolean query</see>
 	/// computes this value as:
 	/// 
 	/// <br/>&#160;<br/>
 	/// <table cellpadding="1" cellspacing="0" border="0" align="center">
 	/// <tr>
 	/// <td valign="middle" align="right" rowspan="1">
-	/// {@link Lucene.Net.Search.Weight#SumOfSquaredWeights() sumOfSquaredWeights} &#160; = &#160;
-	/// {@link Lucene.Net.Search.Query#GetBoost() q.getBoost()} <sup><big>2</big></sup>
+    /// <see cref="Lucene.Net.Search.Weight.SumOfSquaredWeights()">sumOfSquaredWeights</see> &#160; = &#160;
+    /// <see cref="Lucene.Net.Search.Query.GetBoost()">q.getBoost()</see> <sup><big>2</big></sup>
 	/// &#160;&#183;&#160;
 	/// </td>
 	/// <td valign="bottom" align="center" rowspan="1">
@@ -201,43 +201,43 @@ namespace Lucene.Net.Search
 	/// </table>
 	/// <br/>&#160;<br/>
 	/// 
-	/// </li>
+	/// </item>
 	/// 
-	/// <li>
+	/// <item>
 	/// <A NAME="formula_termBoost"></A>
 	/// <b>t.getBoost()</b>
 	/// is a search time boost of term <i>t</i> in the query <i>q</i> as
 	/// specified in the query text
 	/// (see <A HREF="../../../../../../queryparsersyntax.html#Boosting a Term">query syntax</A>),
 	/// or as set by application calls to
-	/// {@link Lucene.Net.Search.Query#SetBoost(float) setBoost()}.
+	/// <see cref="Lucene.Net.Search.Query.SetBoost(float)" />.
 	/// Notice that there is really no direct API for accessing a boost of one term in a multi term query,
 	/// but rather multi terms are represented in a query as multi
-	/// {@link Lucene.Net.Search.TermQuery TermQuery} objects,
+	/// <see cref="Lucene.Net.Search.TermQuery">TermQuery</see> objects,
 	/// and so the boost of a term in the query is accessible by calling the sub-query
-	/// {@link Lucene.Net.Search.Query#GetBoost() getBoost()}.
+    /// <see cref="Lucene.Net.Search.Query.GetBoost()" />.
 	/// <br/>&#160;<br/>
-	/// </li>
+	/// </item>
 	/// 
-	/// <li>
+	/// <item>
 	/// <A NAME="formula_norm"></A>
 	/// <b>norm(t,d)</b> encapsulates a few (indexing time) boost and length factors:
 	/// 
-	/// <ul>
-	/// <li><b>Document boost</b> - set by calling
-	/// {@link Lucene.Net.Documents.Document#SetBoost(float) doc.setBoost()}
+	/// <list type="bullet">
+	/// <item><b>Document boost</b> - set by calling 
+    /// <see cref="Lucene.Net.Documents.Document.SetBoost(float)">doc.setBoost()</see>
 	/// before adding the document to the index.
-	/// </li>
-	/// <li><b>Field boost</b> - set by calling
-	/// {@link Lucene.Net.Documents.Fieldable#SetBoost(float) field.setBoost()}
+	/// </item>
+	/// <item><b>Field boost</b> - set by calling 
+    /// <see cref="Lucene.Net.Documents.Fieldable.SetBoost(float)">field.SetBoost()</see>
 	/// before adding the field to a document.
-	/// </li>
-	/// <li>{@link #LengthNorm(String, int) <b>lengthNorm</b>(field)} - computed
+	/// </item>
+	/// <item><see cref="LengthNorm(String, int)">LengthNorm(field)</see> - computed
 	/// when the document is added to the index in accordance with the number of tokens
 	/// of this field in the document, so that shorter fields contribute more to the score.
 	/// LengthNorm is computed by the Similarity class in effect at indexing.
-	/// </li>
-	/// </ul>
+	/// </item>
+	/// </list>
 	/// 
 	/// <p/>
 	/// When a document is added to the index, all the above factors are multiplied.
@@ -248,16 +248,16 @@ namespace Lucene.Net.Search
 	/// <tr>
 	/// <td valign="middle" align="right" rowspan="1">
 	/// norm(t,d) &#160; = &#160;
-	/// {@link Lucene.Net.Documents.Document#GetBoost() doc.getBoost()}
+    /// <see cref="Lucene.Net.Documents.Document.GetBoost()">doc.GetBoost()</see>
 	/// &#160;&#183;&#160;
-	/// {@link #LengthNorm(String, int) lengthNorm(field)}
+    /// <see cref="LengthNorm(String, int)">LengthNorm(field)</see>
 	/// &#160;&#183;&#160;
 	/// </td>
 	/// <td valign="bottom" align="center" rowspan="1">
     /// <big><big><big>&#8719;</big></big></big>
 	/// </td>
 	/// <td valign="middle" align="right" rowspan="1">
-	/// {@link Lucene.Net.Documents.Fieldable#GetBoost() f.getBoost}()
+	/// <see cref="Lucene.Net.Documents.Fieldable.GetBoost()">field.GetBoost()</see>
 	/// </td>
 	/// </tr>
 	/// <tr valigh="top">
@@ -267,19 +267,19 @@ namespace Lucene.Net.Search
 	/// </tr>
 	/// </table>
 	/// <br/>&#160;<br/>
-	/// However the resulted <i>norm</i> value is {@link #EncodeNorm(float) encoded} as a single byte
+	/// However the resulted <i>norm</i> value is <see cref="EncodeNorm(float)">encoded</see> as a single byte
 	/// before being stored.
 	/// At search time, the norm byte value is read from the index
-	/// {@link Lucene.Net.Store.Directory directory} and
-	/// {@link #DecodeNorm(byte) decoded} back to a float <i>norm</i> value.
+	/// <see cref="Lucene.Net.Store.Directory">directory</see> and
+    /// <see cref="DecodeNorm(byte)">decoded</see> back to a float <i>norm</i> value.
 	/// This encoding/decoding, while reducing index size, comes with the price of
 	/// precision loss - it is not guaranteed that decode(encode(x)) = x.
 	/// For instance, decode(encode(0.89)) = 0.75.
 	/// Also notice that search time is too late to modify this <i>norm</i> part of scoring, e.g. by
-	/// using a different {@link Similarity} for search.
+	/// using a different <see cref="Similarity" /> for search.
 	/// <br/>&#160;<br/>
-	/// </li>
-	/// </ol>
+	/// </item>
+	/// </list>
 	/// 
 	/// </summary>
 	/// <seealso cref="SetDefault(Similarity)">
@@ -456,7 +456,7 @@ namespace Lucene.Net.Search
 		/// <summary>Return the default Similarity implementation used by indexing and search
 		/// code.
 		/// 
-		/// <p/>This is initially an instance of {@link DefaultSimilarity}.
+		/// <p/>This is initially an instance of <see cref="DefaultSimilarity" />.
 		/// 
 		/// </summary>
 		/// <seealso cref="Searcher.SetSimilarity(Similarity)">
@@ -488,15 +488,15 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary> Compute the normalization value for a field, given the accumulated
-		/// state of term processing for this field (see {@link FieldInvertState}).
+		/// state of term processing for this field (see <see cref="FieldInvertState" />).
 		/// 
 		/// <p/>Implementations should calculate a float value based on the field
 		/// state and then return that value.
 		/// 
 		/// <p/>For backward compatibility this method by default calls
-		/// {@link #LengthNorm(String, int)} passing
-		/// {@link FieldInvertState#GetLength()} as the second argument, and
-		/// then multiplies this value by {@link FieldInvertState#GetBoost()}.<p/>
+		/// <see cref="LengthNorm(String, int)" /> passing
+		/// <see cref="FieldInvertState.GetLength()" /> as the second argument, and
+		/// then multiplies this value by <see cref="FieldInvertState.GetBoost()" />.<p/>
 		/// 
 		/// <p/><b>WARNING</b>: This API is new and experimental and may
 		/// suddenly change.<p/>
@@ -519,13 +519,13 @@ namespace Lucene.Net.Search
 		/// search code.
 		/// 
 		/// <p/>Matches in longer fields are less precise, so implementations of this
-		/// method usually return smaller values when <code>numTokens</code> is large,
-		/// and larger values when <code>numTokens</code> is small.
+		/// method usually return smaller values when <c>numTokens</c> is large,
+		/// and larger values when <c>numTokens</c> is small.
 		/// 
 		/// <p/>Note that the return values are computed under 
-		/// {@link Lucene.Net.Index.IndexWriter#AddDocument(Lucene.Net.Documents.Document)} 
+		/// <see cref="Lucene.Net.Index.IndexWriter.AddDocument(Lucene.Net.Documents.Document)" /> 
 		/// and then stored using
-		/// {@link #EncodeNorm(float)}.  
+		/// <see cref="EncodeNorm(float)" />.  
 		/// Thus they have limited precision, and documents
 		/// must be re-indexed if this method is altered.
 		/// 
@@ -538,7 +538,7 @@ namespace Lucene.Net.Search
 		/// <returns> a normalization factor for hits on this field of this document
 		/// 
 		/// </returns>
-		/// <seealso cref="Lucene.Net.Documents.Field.SetBoost(float)">
+		/// <seealso cref="Lucene.Net.Documents.AbstractField.SetBoost(float)">
 		/// </seealso>
 		public abstract float LengthNorm(System.String fieldName, int numTokens);
 		
@@ -568,7 +568,7 @@ namespace Lucene.Net.Search
 		/// value.
 		/// 
 		/// </summary>
-		/// <seealso cref="Lucene.Net.Documents.Field.SetBoost(float)">
+		/// <seealso cref="Lucene.Net.Documents.AbstractField.SetBoost(float)">
 		/// </seealso>
 		/// <seealso cref="Lucene.Net.Util.SmallFloat">
 		/// </seealso>
@@ -579,16 +579,16 @@ namespace Lucene.Net.Search
 		
 		
 		/// <summary>Computes a score factor based on a term or phrase's frequency in a
-		/// document.  This value is multiplied by the {@link #Idf(Term, Searcher)}
+		/// document.  This value is multiplied by the <see cref="Idf(Term, Searcher)" />
 		/// factor for each term in the query and these products are then summed to
 		/// form the initial score for a document.
 		/// 
 		/// <p/>Terms and phrases repeated in a document indicate the topic of the
 		/// document, so implementations of this method usually return larger values
-		/// when <code>freq</code> is large, and smaller values when <code>freq</code>
+		/// when <c>freq</c> is large, and smaller values when <c>freq</c>
 		/// is small.
 		/// 
-		/// <p/>The default implementation calls {@link #Tf(float)}.
+		/// <p/>The default implementation calls <see cref="Tf(float)" />.
 		/// 
 		/// </summary>
 		/// <param name="freq">the frequency of a term within a document
@@ -602,7 +602,7 @@ namespace Lucene.Net.Search
 		
 		/// <summary>Computes the amount of a sloppy phrase match, based on an edit distance.
 		/// This value is summed for each sloppy phrase match in a document to form
-		/// the frequency that is passed to {@link #Tf(float)}.
+		/// the frequency that is passed to <see cref="Tf(float)" />.
 		/// 
 		/// <p/>A phrase match with a small edit distance to a document passage more
 		/// closely matches the document, so implementations of this method usually
@@ -619,13 +619,13 @@ namespace Lucene.Net.Search
 		public abstract float SloppyFreq(int distance);
 		
 		/// <summary>Computes a score factor based on a term or phrase's frequency in a
-		/// document.  This value is multiplied by the {@link #Idf(Term, Searcher)}
+		/// document.  This value is multiplied by the <see cref="Idf(Term, Searcher)" />
 		/// factor for each term in the query and these products are then summed to
 		/// form the initial score for a document.
 		/// 
 		/// <p/>Terms and phrases repeated in a document indicate the topic of the
 		/// document, so implementations of this method usually return larger values
-		/// when <code>freq</code> is large, and smaller values when <code>freq</code>
+		/// when <c>freq</c> is large, and smaller values when <c>freq</c>
 		/// is small.
 		/// 
 		/// </summary>
@@ -637,13 +637,13 @@ namespace Lucene.Net.Search
 		
 		/// <summary>Computes a score factor for a simple term.
 		/// 
-		/// <p/>The default implementation is:<pre>
+		/// <p/>The default implementation is: <c>
 		/// return idf(searcher.docFreq(term), searcher.maxDoc());
-		/// </pre>
+		/// </c>
 		/// 
-		/// Note that {@link Searcher#MaxDoc()} is used instead of
-		/// {@link Lucene.Net.Index.IndexReader#NumDocs()} because it is proportional to
-		/// {@link Searcher#DocFreq(Term)} , i.e., when one is inaccurate,
+		/// Note that <see cref="Searcher.MaxDoc()" /> is used instead of
+		/// <see cref="Lucene.Net.Index.IndexReader.NumDocs()" /> because it is proportional to
+		/// <see cref="Searcher.DocFreq(Term)" /> , i.e., when one is inaccurate,
 		/// so is the other, and in the same direction.
 		/// 
 		/// </summary>
@@ -653,7 +653,7 @@ namespace Lucene.Net.Search
 		/// </param>
 		/// <returns> a score factor for the term
 		/// </returns>
-		/// <deprecated> see {@link #IdfExplain(Term, Searcher)}
+		/// <deprecated> see <see cref="IdfExplain(Term, Searcher)" />
 		/// </deprecated>
         [Obsolete("see IdfExplain(Term, Searcher)")]
 		public virtual float Idf(Term term, Searcher searcher)
@@ -667,13 +667,13 @@ namespace Lucene.Net.Search
 		/// <p/>
 		/// The default implementation uses:
 		/// 
-		/// <pre>
+        /// <code>
 		/// idf(searcher.docFreq(term), searcher.maxDoc());
-		/// </pre>
+        /// </code>
 		/// 
-		/// Note that {@link Searcher#MaxDoc()} is used instead of
-		/// {@link Lucene.Net.Index.IndexReader#NumDocs()} because it is
-		/// proportional to {@link Searcher#DocFreq(Term)} , i.e., when one is
+		/// Note that <see cref="Searcher.MaxDoc()" /> is used instead of
+		/// <see cref="Lucene.Net.Index.IndexReader.NumDocs()" /> because it is
+		/// proportional to <see cref="Searcher.DocFreq(Term)" /> , i.e., when one is
 		/// inaccurate, so is the other, and in the same direction.
 		/// 
 		/// </summary>
@@ -700,7 +700,7 @@ namespace Lucene.Net.Search
 		
 		/// <summary>Computes a score factor for a phrase.
 		/// 
-		/// <p/>The default implementation sums the {@link #Idf(Term,Searcher)} factor
+		/// <p/>The default implementation sums the <see cref="Idf(Term,Searcher)" /> factor
 		/// for each term in the phrase.
 		/// 
 		/// </summary>
@@ -710,7 +710,7 @@ namespace Lucene.Net.Search
 		/// </param>
 		/// <returns> idf score factor
 		/// </returns>
-		/// <deprecated> see {@link #idfExplain(Collection, Searcher)}
+		/// <deprecated> see <see cref="idfExplain(System.Collections.ICollection, Searcher)" />
 		/// </deprecated>
         [Obsolete("see IdfExplain(Collection, Searcher)")]
 		public virtual float Idf(System.Collections.ICollection terms, Searcher searcher)
@@ -765,7 +765,7 @@ namespace Lucene.Net.Search
 		
 		/// <summary>Computes a score factor based on a term's document frequency (the number
 		/// of documents which contain the term).  This value is multiplied by the
-		/// {@link #Tf(int)} factor for each term in the query and these products are
+		/// <see cref="Tf(int)" /> factor for each term in the query and these products are
 		/// then summed to form the initial score for a document.
 		/// 
 		/// <p/>Terms that occur in fewer documents are better indicators of topic, so
@@ -819,7 +819,7 @@ namespace Lucene.Net.Search
 		/// <returns> An implementation dependent float to be used as a scoring factor
 		/// 
 		/// </returns>
-		/// <deprecated> See {@link #ScorePayload(int, String, int, int, byte[], int, int)}
+		/// <deprecated> See <see cref="ScorePayload(int, String, int, int, byte[], int, int)" />
 		/// </deprecated>
 		//TODO: When removing this, set the default value below to return 1.
         [Obsolete("See ScorePayload(int, String, int, int, byte[], int, int)")]
@@ -836,7 +836,7 @@ namespace Lucene.Net.Search
 		/// The default implementation returns 1.
 		/// 
 		/// </summary>
-		/// <param name="docId">The docId currently being scored.  If this value is {@link #NO_DOC_ID_PROVIDED}, then it should be assumed that the PayloadQuery implementation does not provide document information
+		/// <param name="docId">The docId currently being scored.  If this value is <see cref="NO_DOC_ID_PROVIDED" />, then it should be assumed that the PayloadQuery implementation does not provide document information
 		/// </param>
 		/// <param name="fieldName">The fieldName of the term this payload belongs to
 		/// </param>

Modified: incubator/lucene.net/trunk/src/core/Search/SimilarityDelegator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/SimilarityDelegator.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/SimilarityDelegator.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/SimilarityDelegator.cs Sun Nov  6 05:24:26 2011
@@ -22,8 +22,8 @@ using FieldInvertState = Lucene.Net.Inde
 namespace Lucene.Net.Search
 {
 	
-	/// <summary>Expert: Delegating scoring implementation.  Useful in {@link
-	/// Query#GetSimilarity(Searcher)} implementations, to override only certain
+	/// <summary>Expert: Delegating scoring implementation.  Useful in <see cref="Query.GetSimilarity(Searcher)" />
+	/// implementations, to override only certain
 	/// methods of a Searcher's Similiarty implementation.. 
 	/// </summary>
 	[Serializable]
@@ -32,7 +32,7 @@ namespace Lucene.Net.Search
 		
 		private Similarity delegee;
 		
-		/// <summary>Construct a {@link Similarity} that delegates all methods to another.
+		/// <summary>Construct a <see cref="Similarity" /> that delegates all methods to another.
 		/// 
 		/// </summary>
 		/// <param name="delegee">the Similarity implementation to delegate to

Modified: incubator/lucene.net/trunk/src/core/Search/Sort.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Sort.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Sort.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Sort.cs Sun Nov  6 05:24:26 2011
@@ -30,39 +30,39 @@ namespace Lucene.Net.Search
 	/// and does not need to be stored (unless you happen to want it back with the
 	/// rest of your document data).  In other words:
 	/// 
-	/// <p/><code>document.add (new Field ("byNumber", Integer.toString(x), Field.Store.NO, Field.Index.NOT_ANALYZED));</code><p/>
+	/// <p/><c>document.add (new Field ("byNumber", Integer.toString(x), Field.Store.NO, Field.Index.NOT_ANALYZED));</c><p/>
 	/// 
 	/// 
 	/// <p/><h3>Valid Types of Values</h3>
 	/// 
 	/// <p/>There are four possible kinds of term values which may be put into
 	/// sorting fields: Integers, Longs, Floats, or Strings.  Unless
-	/// {@link SortField SortField} objects are specified, the type of value
+	/// <see cref="SortField">SortField</see> objects are specified, the type of value
 	/// in the field is determined by parsing the first term in the field.
 	/// 
 	/// <p/>Integer term values should contain only digits and an optional
 	/// preceding negative sign.  Values must be base 10 and in the range
-	/// <code>Integer.MIN_VALUE</code> and <code>Integer.MAX_VALUE</code> inclusive.
+	/// <c>Integer.MIN_VALUE</c> and <c>Integer.MAX_VALUE</c> inclusive.
 	/// Documents which should appear first in the sort
 	/// should have low value integers, later documents high values
-	/// (i.e. the documents should be numbered <code>1..n</code> where
-	/// <code>1</code> is the first and <code>n</code> the last).
+	/// (i.e. the documents should be numbered <c>1..n</c> where
+	/// <c>1</c> is the first and <c>n</c> the last).
 	/// 
 	/// <p/>Long term values should contain only digits and an optional
 	/// preceding negative sign.  Values must be base 10 and in the range
-	/// <code>Long.MIN_VALUE</code> and <code>Long.MAX_VALUE</code> inclusive.
+	/// <c>Long.MIN_VALUE</c> and <c>Long.MAX_VALUE</c> inclusive.
 	/// Documents which should appear first in the sort
 	/// should have low value integers, later documents high values.
 	/// 
 	/// <p/>Float term values should conform to values accepted by
-	/// {@link Float Float.valueOf(String)} (except that <code>NaN</code>
-	/// and <code>Infinity</code> are not supported).
+	/// <see cref="float.Parse(string)" /> (except that <c>NaN</c>
+	/// and <c>Infinity</c> are not supported).
 	/// Documents which should appear first in the sort
 	/// should have low values, later documents high values.
 	/// 
 	/// <p/>String term values can contain any valid String, but should
 	/// not be tokenized.  The values are sorted according to their
-	/// {@link Comparable natural order}.  Note that using this type
+	/// <see cref="IComparable">natural order</see>.  Note that using this type
 	/// of term value has higher memory requirements than the other
 	/// two types.
 	/// 
@@ -77,11 +77,11 @@ namespace Lucene.Net.Search
 	/// 
 	/// <p/>Sorting uses of caches of term values maintained by the
 	/// internal HitQueue(s).  The cache is static and contains an integer
-	/// or float array of length <code>IndexReader.maxDoc()</code> for each field
+	/// or float array of length <c>IndexReader.maxDoc()</c> for each field
 	/// name for which a sort is performed.  In other words, the size of the
 	/// cache in bytes is:
 	/// 
-	/// <p/><code>4 * IndexReader.maxDoc() * (# of different fields actually used to sort)</code>
+	/// <p/><c>4 * IndexReader.maxDoc() * (# of different fields actually used to sort)</c>
 	/// 
 	/// <p/>For String fields, the cache is larger: in addition to the
 	/// above array, the value of every term in the field is kept in memory.
@@ -105,7 +105,7 @@ namespace Lucene.Net.Search
 		
 		/// <summary> Represents sorting by computed relevance. Using this sort criteria returns
 		/// the same results as calling
-		/// {@link Searcher#Search(Query) Searcher#search()}without a sort criteria,
+		/// <see cref="Searcher.Search(Query)" />Searcher#search()without a sort criteria,
 		/// only with slightly more overhead.
 		/// </summary>
 		public static readonly Sort RELEVANCE = new Sort();
@@ -117,23 +117,23 @@ namespace Lucene.Net.Search
 		internal SortField[] fields;
 		
 		/// <summary> Sorts by computed relevance. This is the same sort criteria as calling
-		/// {@link Searcher#Search(Query) Searcher#search()}without a sort criteria,
+		/// <see cref="Searcher.Search(Query)" />without a sort criteria,
 		/// only with slightly more overhead.
 		/// </summary>
 		public Sort():this(SortField.FIELD_SCORE)
 		{
 		}
 		
-		/// <summary> Sorts by the terms in <code>field</code> then by index order (document
-		/// number). The type of value in <code>field</code> is determined
+		/// <summary> Sorts by the terms in <c>field</c> then by index order (document
+		/// number). The type of value in <c>field</c> is determined
 		/// automatically.
 		/// 
 		/// </summary>
 		/// <seealso cref="SortField.AUTO">
 		/// </seealso>
 		/// <deprecated> Please specify the type explicitly by
-		/// first creating a {@link SortField} and then use {@link
-		/// #Sort(SortField)}
+		/// first creating a <see cref="SortField" /> and then use <see cref="Sort(SortField)" />
+		///
 		/// </deprecated>
         [Obsolete("Please specify the type explicitly by first creating a SortField and then use Sort(SortField)")]
 		public Sort(System.String field)
@@ -141,16 +141,16 @@ namespace Lucene.Net.Search
 			SetSort(field, false);
 		}
 		
-		/// <summary> Sorts possibly in reverse by the terms in <code>field</code> then by
-		/// index order (document number). The type of value in <code>field</code> is
+		/// <summary> Sorts possibly in reverse by the terms in <c>field</c> then by
+		/// index order (document number). The type of value in <c>field</c> is
 		/// determined automatically.
 		/// 
 		/// </summary>
 		/// <seealso cref="SortField.AUTO">
 		/// </seealso>
 		/// <deprecated> Please specify the type explicitly by
-		/// first creating a {@link SortField} and then use {@link
-		/// #Sort(SortField)}
+		/// first creating a <see cref="SortField" /> and then use <see cref="Sort(SortField)" />
+		///
 		/// </deprecated>
         [Obsolete("Please specify the type explicitly by first creating a SortField and then use Sort(SortField)")]
 		public Sort(System.String field, bool reverse)
@@ -159,14 +159,14 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary> Sorts in succession by the terms in each field. The type of value in
-		/// <code>field</code> is determined automatically.
+		/// <c>field</c> is determined automatically.
 		/// 
 		/// </summary>
 		/// <seealso cref="SortField.AUTO">
 		/// </seealso>
 		/// <deprecated> Please specify the type explicitly by
-		/// first creating {@link SortField}s and then use {@link
-		/// #Sort(SortField[])}
+		/// first creating <see cref="SortField" />s and then use <see cref="Sort(SortField[])" />
+		///
 		/// </deprecated>
         [Obsolete("Please specify the type explicitly by first creating SortFields and then use Sort(SortField[])")]
 		public Sort(System.String[] fields)
@@ -186,12 +186,12 @@ namespace Lucene.Net.Search
 			SetSort(fields);
 		}
 		
-		/// <summary> Sets the sort to the terms in <code>field</code> then by index order
+		/// <summary> Sets the sort to the terms in <c>field</c> then by index order
 		/// (document number).
 		/// </summary>
 		/// <deprecated> Please specify the type explicitly by
-		/// first creating a {@link SortField} and then use {@link
-		/// #SetSort(SortField)}
+		/// first creating a <see cref="SortField" /> and then use <see cref="SetSort(SortField)" />
+		///
 		/// </deprecated>
         [Obsolete("Please specify the type explicitly by first creating a SortField and then use SetSort(SortField)")]
 		public void  SetSort(System.String field)
@@ -199,12 +199,12 @@ namespace Lucene.Net.Search
 			SetSort(field, false);
 		}
 		
-		/// <summary> Sets the sort to the terms in <code>field</code> possibly in reverse,
+		/// <summary> Sets the sort to the terms in <c>field</c> possibly in reverse,
 		/// then by index order (document number).
 		/// </summary>
 		/// <deprecated> Please specify the type explicitly by
-		/// first creating a {@link SortField} and then use {@link
-		/// #SetSort(SortField)}
+		/// first creating a <see cref="SortField" /> and then use <see cref="SetSort(SortField)" />
+		///
 		/// </deprecated>
         [Obsolete("Please specify the type explicitly by first creating a SortField and then use SetSort(SortField)")]
 		public virtual void  SetSort(System.String field, bool reverse)
@@ -214,8 +214,8 @@ namespace Lucene.Net.Search
 		
 		/// <summary>Sets the sort to the terms in each field in succession.</summary>
 		/// <deprecated> Please specify the type explicitly by
-		/// first creating {@link SortField}s and then use {@link
-		/// #SetSort(SortField[])} 
+		/// first creating <see cref="SortField" />s and then use <see cref="SetSort(SortField[])" />
+		/// 
 		/// </deprecated>
         [Obsolete("Please specify the type explicitly by first creating a SortFields and then use SetSort(SortField[])")]
 		public virtual void  SetSort(System.String[] fieldnames)
@@ -263,7 +263,7 @@ namespace Lucene.Net.Search
 			return buffer.ToString();
 		}
 		
-		/// <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/SortComparator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/SortComparator.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/SortComparator.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/SortComparator.cs Sun Nov  6 05:24:26 2011
@@ -49,7 +49,7 @@ namespace Lucene.Net.Search
 	/// </version>
 	/// <since> 1.4
 	/// </since>
-	/// <deprecated> Please use {@link FieldComparatorSource} instead.
+	/// <deprecated> Please use <see cref="FieldComparatorSource" /> instead.
 	/// </deprecated>
     [Obsolete("Please use FieldComparatorSource instead.")]
 	[Serializable]
@@ -105,16 +105,16 @@ namespace Lucene.Net.Search
 		/// <summary> Returns an object which, when sorted according to natural order,
 		/// will order the Term values in the correct order.
 		/// <p/>For example, if the Terms contained integer values, this method
-		/// would return <code>new Integer(termtext)</code>.  Note that this
+		/// would return <c>new Integer(termtext)</c>.  Note that this
 		/// might not always be the most efficient implementation - for this
 		/// particular example, a better implementation might be to make a
 		/// ScoreDocLookupComparator that uses an internal lookup table of int.
 		/// </summary>
 		/// <param name="termtext">The textual value of the term.
 		/// </param>
-		/// <returns> An object representing <code>termtext</code> that sorts according to the natural order of <code>termtext</code>.
+		/// <returns> An object representing <c>termtext</c> that sorts according to the natural order of <c>termtext</c>.
 		/// </returns>
-		/// <seealso cref="Comparable">
+		/// <seealso cref="IComparable">
 		/// </seealso>
 		/// <seealso cref="ScoreDocComparator">
 		/// </seealso>

Modified: incubator/lucene.net/trunk/src/core/Search/SortComparatorSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/SortComparatorSource.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/SortComparatorSource.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/SortComparatorSource.cs Sun Nov  6 05:24:26 2011
@@ -40,7 +40,7 @@ namespace Lucene.Net.Search
 	/// </version>
 	/// <since> 1.4
 	/// </since>
-	/// <deprecated> Please use {@link FieldComparatorSource} instead.
+	/// <deprecated> Please use <see cref="FieldComparatorSource" /> instead.
 	/// </deprecated>
     [Obsolete("Please use FieldComparatorSource instead.")]
 	public interface SortComparatorSource

Modified: incubator/lucene.net/trunk/src/core/Search/SortField.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/SortField.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/SortField.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/SortField.cs Sun Nov  6 05:24:26 2011
@@ -59,7 +59,7 @@ namespace Lucene.Net.Search
 		/// </summary>
 		/// <deprecated> Please specify the exact type, instead.
 		/// Especially, guessing does <b>not</b> work with the new
-		/// {@link NumericField} type.
+		/// <see cref="NumericField" /> type.
 		/// </deprecated>
         [Obsolete("Please specify the exact type, instead. Especially, guessing does not work with the new NumericField type.")]
 		public const int AUTO = 2;
@@ -106,7 +106,7 @@ namespace Lucene.Net.Search
 		
 		/// <summary>Sort using term values as Strings, but comparing by
 		/// value (using String.compareTo) for all comparisons.
-		/// This is typically slower than {@link #STRING}, which
+		/// This is typically slower than <see cref="STRING" />, which
 		/// uses ordinals to do the sorting. 
 		/// </summary>
 		public const int STRING_VAL = 11;
@@ -134,10 +134,10 @@ namespace Lucene.Net.Search
 		private bool useLegacy = false; // remove in Lucene 3.0
 		
 		/// <summary>Creates a sort by terms in the given field where the type of term value
-		/// is determined dynamically ({@link #AUTO AUTO}).
+		/// is determined dynamically (<see cref="AUTO" />).
 		/// </summary>
 		/// <param name="field">Name of field to sort by, cannot be
-		/// <code>null</code>.
+		/// <c>null</c>.
 		/// </param>
 		/// <deprecated> Please specify the exact type instead.
 		/// </deprecated>
@@ -148,9 +148,9 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Creates a sort, possibly in reverse, by terms in the given field where
-		/// the type of term value is determined dynamically ({@link #AUTO AUTO}).
+		/// the type of term value is determined dynamically (<see cref="AUTO" />).
 		/// </summary>
-		/// <param name="field">Name of field to sort by, cannot be <code>null</code>.
+		/// <param name="field">Name of field to sort by, cannot be <c>null</c>.
 		/// </param>
 		/// <param name="reverse">True if natural order should be reversed.
 		/// </param>
@@ -166,8 +166,8 @@ namespace Lucene.Net.Search
 		/// <summary>Creates a sort by terms in the given field with the type of term
 		/// values explicitly given.
 		/// </summary>
-		/// <param name="field"> Name of field to sort by.  Can be <code>null</code> if
-		/// <code>type</code> is SCORE or DOC.
+		/// <param name="field"> Name of field to sort by.  Can be <c>null</c> if
+		/// <c>type</c> is SCORE or DOC.
 		/// </param>
 		/// <param name="type">  Type of values in the terms.
 		/// </param>
@@ -179,8 +179,8 @@ namespace Lucene.Net.Search
 		/// <summary>Creates a sort, possibly in reverse, by terms in the given field with the
 		/// type of term values explicitly given.
 		/// </summary>
-		/// <param name="field"> Name of field to sort by.  Can be <code>null</code> if
-		/// <code>type</code> is SCORE or DOC.
+		/// <param name="field"> Name of field to sort by.  Can be <c>null</c> if
+		/// <c>type</c> is SCORE or DOC.
 		/// </param>
 		/// <param name="type">  Type of values in the terms.
 		/// </param>
@@ -193,13 +193,13 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Creates a sort by terms in the given field, parsed
-		/// to numeric values using a custom {@link FieldCache.Parser}.
+        /// to numeric values using a custom <see cref="Parser" />.
 		/// </summary>
 		/// <param name="field"> Name of field to sort by.  Must not be null.
 		/// </param>
-		/// <param name="parser">Instance of a {@link FieldCache.Parser},
+        /// <param name="parser">Instance of a <see cref="Parser" />,
 		/// which must subclass one of the existing numeric
-		/// parsers from {@link FieldCache}. Sort type is inferred
+		/// parsers from <see cref="FieldCache" />. Sort type is inferred
 		/// by testing which numeric parser the parser subclasses.
 		/// </param>
 		/// <throws>  IllegalArgumentException if the parser fails to </throws>
@@ -210,13 +210,13 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Creates a sort, possibly in reverse, by terms in the given field, parsed
-		/// to numeric values using a custom {@link FieldCache.Parser}.
+        /// to numeric values using a custom <see cref="Parser" />.
 		/// </summary>
 		/// <param name="field"> Name of field to sort by.  Must not be null.
 		/// </param>
-		/// <param name="parser">Instance of a {@link FieldCache.Parser},
+		/// <param name="parser">Instance of a <see cref="Parser" />,
 		/// which must subclass one of the existing numeric
-		/// parsers from {@link FieldCache}. Sort type is inferred
+		/// parsers from <see cref="FieldCache" />. Sort type is inferred
 		/// by testing which numeric parser the parser subclasses.
 		/// </param>
 		/// <param name="reverse">True if natural order should be reversed.
@@ -250,7 +250,7 @@ namespace Lucene.Net.Search
 		/// <summary>Creates a sort by terms in the given field sorted
 		/// according to the given locale.
 		/// </summary>
-		/// <param name="field"> Name of field to sort by, cannot be <code>null</code>.
+		/// <param name="field"> Name of field to sort by, cannot be <c>null</c>.
 		/// </param>
 		/// <param name="locale">Locale of values in the field.
 		/// </param>
@@ -263,7 +263,7 @@ namespace Lucene.Net.Search
 		/// <summary>Creates a sort, possibly in reverse, by terms in the given field sorted
 		/// according to the given locale.
 		/// </summary>
-		/// <param name="field"> Name of field to sort by, cannot be <code>null</code>.
+		/// <param name="field"> Name of field to sort by, cannot be <c>null</c>.
 		/// </param>
 		/// <param name="locale">Locale of values in the field.
 		/// </param>
@@ -275,7 +275,7 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Creates a sort with a custom comparison function.</summary>
-		/// <param name="field">Name of field to sort by; cannot be <code>null</code>.
+		/// <param name="field">Name of field to sort by; cannot be <c>null</c>.
 		/// </param>
 		/// <param name="comparator">Returns a comparator for sorting hits.
 		/// </param>
@@ -290,7 +290,7 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Creates a sort with a custom comparison function.</summary>
-		/// <param name="field">Name of field to sort by; cannot be <code>null</code>.
+		/// <param name="field">Name of field to sort by; cannot be <c>null</c>.
 		/// </param>
 		/// <param name="comparator">Returns a comparator for sorting hits.
 		/// </param>
@@ -301,7 +301,7 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Creates a sort, possibly in reverse, with a custom comparison function.</summary>
-		/// <param name="field">Name of field to sort by; cannot be <code>null</code>.
+		/// <param name="field">Name of field to sort by; cannot be <c>null</c>.
 		/// </param>
 		/// <param name="comparator">Returns a comparator for sorting hits.
 		/// </param>
@@ -319,7 +319,7 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Creates a sort, possibly in reverse, with a custom comparison function.</summary>
-		/// <param name="field">Name of field to sort by; cannot be <code>null</code>.
+		/// <param name="field">Name of field to sort by; cannot be <c>null</c>.
 		/// </param>
 		/// <param name="comparator">Returns a comparator for sorting hits.
 		/// </param>
@@ -348,10 +348,10 @@ namespace Lucene.Net.Search
 			}
 		}
 		
-		/// <summary>Returns the name of the field.  Could return <code>null</code>
+		/// <summary>Returns the name of the field.  Could return <c>null</c>
 		/// if the sort is by SCORE or DOC.
 		/// </summary>
-		/// <returns> Name of field, possibly <code>null</code>.
+		/// <returns> Name of field, possibly <c>null</c>.
 		/// </returns>
 		public virtual System.String GetField()
 		{
@@ -367,19 +367,19 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Returns the Locale by which term values are interpreted.
-		/// May return <code>null</code> if no Locale was specified.
+		/// May return <c>null</c> if no Locale was specified.
 		/// </summary>
-		/// <returns> Locale, or <code>null</code>.
+		/// <returns> Locale, or <c>null</c>.
 		/// </returns>
 		public virtual System.Globalization.CultureInfo GetLocale()
 		{
 			return locale;
 		}
 		
-		/// <summary>Returns the instance of a {@link FieldCache} parser that fits to the given sort type.
-		/// May return <code>null</code> if no parser was specified. Sorting is using the default parser then.
+		/// <summary>Returns the instance of a <see cref="FieldCache" /> parser that fits to the given sort type.
+		/// May return <c>null</c> if no parser was specified. Sorting is using the default parser then.
 		/// </summary>
-		/// <returns> An instance of a {@link FieldCache} parser, or <code>null</code>.
+		/// <returns> An instance of a <see cref="FieldCache" /> parser, or <c>null</c>.
 		/// </returns>
 		public virtual Lucene.Net.Search.Parser GetParser()
 		{
@@ -394,7 +394,7 @@ namespace Lucene.Net.Search
 			return reverse;
 		}
 		
-		/// <deprecated> use {@link #GetComparatorSource()}
+		/// <deprecated> use <see cref="GetComparatorSource()" />
 		/// </deprecated>
         [Obsolete("use GetComparatorSource()")]
 		public virtual SortComparatorSource GetFactory()
@@ -514,9 +514,9 @@ namespace Lucene.Net.Search
 			return buffer.ToString();
 		}
 		
-		/// <summary>Returns true if <code>o</code> is equal to this.  If a
-		/// {@link SortComparatorSource} (deprecated) or {@link
-		/// FieldCache.Parser} was provided, it must properly
+		/// <summary>Returns true if <c>o</c> is equal to this.  If a
+		/// <see cref="SortComparatorSource" /> (deprecated) or <see cref="Parser" />
+		/// was provided, it must properly
 		/// implement equals (unless a singleton is always used). 
 		/// </summary>
 		public  override bool Equals(System.Object o)
@@ -529,9 +529,9 @@ namespace Lucene.Net.Search
 			return ((System.Object) other.field == (System.Object) this.field && other.type == this.type && other.reverse == this.reverse && (other.locale == null?this.locale == null:other.locale.Equals(this.locale)) && (other.factory == null?this.factory == null:other.factory.Equals(this.factory)) && (other.comparatorSource == null?this.comparatorSource == null:other.comparatorSource.Equals(this.comparatorSource)) && (other.parser == null?this.parser == null:other.parser.Equals(this.parser)));
 		}
 		
-		/// <summary>Returns true if <code>o</code> is equal to this.  If a
-		/// {@link SortComparatorSource} (deprecated) or {@link
-		/// FieldCache.Parser} was provided, it must properly
+		/// <summary>Returns true if <c>o</c> is equal to this.  If a
+		/// <see cref="SortComparatorSource" /> (deprecated) or <see cref="Parser" />
+		/// was provided, it must properly
 		/// implement hashCode (unless a singleton is always
 		/// used). 
 		/// </summary>
@@ -567,7 +567,7 @@ namespace Lucene.Net.Search
             field = StringHelper.Intern(field);
         }
 		
-		/// <summary>Returns the {@link FieldComparator} to use for
+		/// <summary>Returns the <see cref="FieldComparator" /> to use for
 		/// sorting.
 		/// 
 		/// <b>NOTE:</b> This API is experimental and might change in
@@ -576,12 +576,12 @@ namespace Lucene.Net.Search
 		/// </summary>
 		/// <param name="numHits">number of top hits the queue will store
 		/// </param>
-		/// <param name="sortPos">position of this SortField within {@link
-		/// Sort}.  The comparator is primary if sortPos==0,
+		/// <param name="sortPos">position of this SortField within <see cref="Sort" />
+		///.  The comparator is primary if sortPos==0,
 		/// secondary if sortPos==1, etc.  Some comparators can
 		/// optimize themselves when they are the primary sort.
 		/// </param>
-		/// <returns> {@link FieldComparator} to use when sorting
+		/// <returns> <see cref="FieldComparator" /> to use when sorting
 		/// </returns>
 		public virtual FieldComparator GetComparator(int numHits, int sortPos)
 		{

Modified: incubator/lucene.net/trunk/src/core/Search/SpanFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/SpanFilter.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/SpanFilter.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/SpanFilter.cs Sun Nov  6 05:24:26 2011
@@ -35,9 +35,9 @@ namespace Lucene.Net.Search
 		/// <summary>Returns a SpanFilterResult with true for documents which should be permitted in
 		/// search results, and false for those that should not and Spans for where the true docs match.
 		/// </summary>
-		/// <param name="reader">The {@link Lucene.Net.Index.IndexReader} to load position and DocIdSet information from
+		/// <param name="reader">The <see cref="Lucene.Net.Index.IndexReader" /> to load position and DocIdSet information from
 		/// </param>
-		/// <returns> A {@link SpanFilterResult}
+		/// <returns> A <see cref="SpanFilterResult" />
 		/// </returns>
 		/// <throws>  java.io.IOException if there was an issue accessing the necessary information </throws>
 		/// <summary> 

Modified: incubator/lucene.net/trunk/src/core/Search/SpanFilterResult.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/SpanFilterResult.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/SpanFilterResult.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/SpanFilterResult.cs Sun Nov  6 05:24:26 2011
@@ -41,9 +41,9 @@ namespace Lucene.Net.Search
 		/// <summary> </summary>
 		/// <param name="bits">The bits for the Filter
 		/// </param>
-		/// <param name="positions">A List of {@link Lucene.Net.Search.SpanFilterResult.PositionInfo} objects
+		/// <param name="positions">A List of <see cref="Lucene.Net.Search.SpanFilterResult.PositionInfo" /> objects
 		/// </param>
-		/// <deprecated> Use {@link #SpanFilterResult(DocIdSet, List)} instead
+        /// <deprecated> Use <see cref="SpanFilterResult(DocIdSet, System.Collections.IList)" /> instead
 		/// </deprecated>
         [Obsolete("Use SpanFilterResult(DocIdSet, List) instead")]
 		public SpanFilterResult(System.Collections.BitArray bits, System.Collections.IList positions)
@@ -55,7 +55,7 @@ namespace Lucene.Net.Search
 		/// <summary> </summary>
 		/// <param name="docIdSet">The DocIdSet for the Filter
 		/// </param>
-		/// <param name="positions">A List of {@link Lucene.Net.Search.SpanFilterResult.PositionInfo} objects
+		/// <param name="positions">A List of <see cref="Lucene.Net.Search.SpanFilterResult.PositionInfo" /> objects
 		/// </param>
 		public SpanFilterResult(DocIdSet docIdSet, System.Collections.IList positions)
 		{
@@ -73,7 +73,7 @@ namespace Lucene.Net.Search
 			return positions;
 		}
 		
-		/// <deprecated> Use {@link #GetDocIdSet()}
+		/// <deprecated> Use <see cref="GetDocIdSet()" />
 		/// </deprecated>
         [Obsolete("Use GetDocIdSet()")]
 		public virtual System.Collections.BitArray GetBits()
@@ -110,7 +110,7 @@ namespace Lucene.Net.Search
 			}
 			
 			/// <summary> </summary>
-			/// <returns> A List of {@link Lucene.Net.Search.SpanFilterResult.StartEnd} objects
+			/// <returns> A List of <see cref="Lucene.Net.Search.SpanFilterResult.StartEnd" /> objects
 			/// </returns>
 			public virtual System.Collections.IList GetPositions()
 			{

Modified: incubator/lucene.net/trunk/src/core/Search/SpanQueryFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/SpanQueryFilter.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/SpanQueryFilter.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/SpanQueryFilter.cs Sun Nov  6 05:24:26 2011
@@ -27,10 +27,10 @@ namespace Lucene.Net.Search
 	/// <summary> Constrains search results to only match those which also match a provided
 	/// query. Also provides position information about where each document matches
 	/// at the cost of extra space compared with the QueryWrapperFilter.
-	/// There is an added cost to this above what is stored in a {@link QueryWrapperFilter}.  Namely,
+	/// There is an added cost to this above what is stored in a <see cref="QueryWrapperFilter" />.  Namely,
 	/// the position information for each matching document is stored.
 	/// <p/>
-	/// This filter does not cache.  See the {@link Lucene.Net.Search.CachingSpanFilter} for a wrapper that
+	/// This filter does not cache.  See the <see cref="Lucene.Net.Search.CachingSpanFilter" /> for a wrapper that
 	/// caches.
 	/// 
 	/// 
@@ -47,9 +47,9 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Constructs a filter which only matches documents matching
-		/// <code>query</code>.
+		/// <c>query</c>.
 		/// </summary>
-		/// <param name="query">The {@link Lucene.Net.Search.Spans.SpanQuery} to use as the basis for the Filter.
+		/// <param name="query">The <see cref="Lucene.Net.Search.Spans.SpanQuery" /> to use as the basis for the Filter.
 		/// </param>
 		public SpanQueryFilter(SpanQuery query)
 		{

Modified: incubator/lucene.net/trunk/src/core/Search/Spans/FieldMaskingSpanQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Spans/FieldMaskingSpanQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Spans/FieldMaskingSpanQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Spans/FieldMaskingSpanQuery.cs Sun Nov  6 05:24:26 2011
@@ -27,14 +27,14 @@ using Weight = Lucene.Net.Search.Weight;
 namespace Lucene.Net.Search.Spans
 {
 	
-	/// <summary> <p/>Wrapper to allow {@link SpanQuery} objects participate in composite 
+	/// <summary> <p/>Wrapper to allow <see cref="SpanQuery" /> objects participate in composite 
 	/// single-field SpanQueries by 'lying' about their search field. That is, 
 	/// the masked SpanQuery will function as normal, 
-	/// but {@link SpanQuery#GetField()} simply hands back the value supplied 
+	/// but <see cref="SpanQuery.GetField()" /> simply hands back the value supplied 
 	/// in this class's constructor.<p/>
 	/// 
-	/// <p/>This can be used to support Queries like {@link SpanNearQuery} or 
-	/// {@link SpanOrQuery} across different fields, which is not ordinarily 
+	/// <p/>This can be used to support Queries like <see cref="SpanNearQuery" /> or 
+	/// <see cref="SpanOrQuery" /> across different fields, which is not ordinarily 
 	/// permitted.<p/>
 	/// 
 	/// <p/>This can be useful for denormalized relational data: for example, when 
@@ -53,18 +53,18 @@ namespace Lucene.Net.Search.Spans
 	/// </pre>
 	/// 
 	/// <p/>a SpanNearQuery with a slop of 0 can be applied across two 
-	/// {@link SpanTermQuery} objects as follows:
-	/// <pre>
+	/// <see cref="SpanTermQuery" /> objects as follows:
+    /// <code>
 	/// SpanQuery q1  = new SpanTermQuery(new Term("studentfirstname", "james"));
 	/// SpanQuery q2  = new SpanTermQuery(new Term("studentsurname", "jones"));
 	/// SpanQuery q2m new FieldMaskingSpanQuery(q2, "studentfirstname");
 	/// Query q = new SpanNearQuery(new SpanQuery[]{q1, q2m}, -1, false);
-	/// </pre>
+    /// </code>
 	/// to search for 'studentfirstname:james studentsurname:jones' and find 
 	/// teacherid 1 without matching teacherid 2 (which has a 'james' in position 0 
 	/// and 'jones' in position 1). <p/>
 	/// 
-	/// <p/>Note: as {@link #GetField()} returns the masked field, scoring will be 
+	/// <p/>Note: as <see cref="GetField()" /> returns the masked field, scoring will be 
 	/// done using the norms of the field name supplied. This may lead to unexpected
 	/// scoring behaviour.<p/>
 	/// </summary>
@@ -98,7 +98,7 @@ namespace Lucene.Net.Search.Spans
 			return maskedQuery.GetSpans(reader);
 		}
 		
-		/// <deprecated> use {@link #ExtractTerms(Set)} instead. 
+		/// <deprecated> use <see cref="ExtractTerms(System.Collections.Hashtable)" /> instead. 
 		/// </deprecated>
         [Obsolete("use ExtractTerms(Hashtable) instead.")]
 		public override System.Collections.ICollection GetTerms()

Modified: incubator/lucene.net/trunk/src/core/Search/Spans/NearSpansOrdered.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Spans/NearSpansOrdered.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Spans/NearSpansOrdered.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Spans/NearSpansOrdered.cs Sun Nov  6 05:24:26 2011
@@ -33,12 +33,12 @@ namespace Lucene.Net.Search.Spans
 	/// <p/>
 	/// The formed spans may contain overlaps when the slop is at least 1.
 	/// For example, when querying using
-	/// <pre>t1 t2 t3</pre>
+	/// <c>t1 t2 t3</c>
 	/// with slop at least 1, the fragment:
-	/// <pre>t1 t2 t1 t3 t2 t3</pre>
+	/// <c>t1 t2 t1 t3 t2 t3</c>
 	/// matches twice:
-	/// <pre>t1 t2 .. t3      </pre>
-	/// <pre>      t1 .. t2 t3</pre>
+	/// <c>t1 t2 .. t3      </c>
+	/// <c>      t1 .. t2 t3</c>
 	/// 
 	/// 
 	/// Expert:
@@ -281,7 +281,7 @@ namespace Lucene.Net.Search.Spans
 			return (start1 == start2)?(spans1.End() < spans2.End()):(start1 < start2);
 		}
 		
-		/// <summary>Like {@link #DocSpansOrdered(Spans,Spans)}, but use the spans
+		/// <summary>Like <see cref="DocSpansOrdered(Spans,Spans)" />, but use the spans
 		/// starts and ends as parameters.
 		/// </summary>
 		private static bool DocSpansOrdered(int start1, int end1, int start2, int end2)



Mime
View raw message