Mailing-List: contact lucene-net-commits-help@incubator.apache.org;
 run by ezmlm
Precedence: bulk
Reply-To: lucene-net-dev@incubator.apache.org
Content-Type: text/plain; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
Subject: svn commit: r890443 [2/3] - in /incubator/lucene.net/trunk/C#/src:
 Lucene.Net/Analysis/ Lucene.Net/Analysis/Standard/
 Lucene.Net/Analysis/Tokenattributes/ Lucene.Net/Document/ Lucene.Net/Index/
 Lucene.Net/QueryParser/ Lucene.Net/Search/ Lucene.Net/Sear...
Date: Mon, 14 Dec 2009 19:06:28 -0000
To: lucene-net-commits@incubator.apache.org
From: digy@apache.org
Message-Id: <20091214190800.C49B523888D1@eris.apache.org>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/SegmentInfos.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Index/SegmentInfos.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/SegmentInfos.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/SegmentInfos.cs Mon Dec 14 19:05:31 2009
@@ -31,7 +31,7 @@
 	/// those segments in relation to the file system.
 	/// 
 	/// <p/><b>NOTE:</b> This API is new and still experimental
-	/// (subject to change suddenly in the next release)</p>
+	/// (subject to change suddenly in the next release)<p/>
 	/// </summary>
 	[Serializable]
 	public sealed class SegmentInfos:System.Collections.ArrayList

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/SegmentReader.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Index/SegmentReader.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/SegmentReader.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/SegmentReader.cs Mon Dec 14 19:05:31 2009
@@ -33,7 +33,7 @@
 	/// <version>  $Id 
 	/// </version>
 	/// <summary> <p/><b>NOTE:</b> This API is new and still experimental
-	/// (subject to change suddenly in the next release)</p>
+	/// (subject to change suddenly in the next release)<p/>
 	/// </summary>
 	public class SegmentReader:IndexReader, System.ICloneable
 	{

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/SnapshotDeletionPolicy.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Index/SnapshotDeletionPolicy.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/SnapshotDeletionPolicy.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/SnapshotDeletionPolicy.cs Mon Dec 14 19:05:31 2009
@@ -38,7 +38,7 @@
 	/// when the next writer is opened.
 	/// 
 	/// <p/><b>WARNING</b>: This API is a new and experimental and
-	/// may suddenly change.</p> 
+	/// may suddenly change.<p/> 
 	/// </summary>
 	
 	public class SnapshotDeletionPolicy : IndexDeletionPolicy

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/TermPositions.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Index/TermPositions.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/TermPositions.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/TermPositions.cs Mon Dec 14 19:05:31 2009
@@ -41,7 +41,7 @@
 		
 		/// <summary> Returns the length of the payload at the current term position.
 		/// This is invalid until {@link #NextPosition()} is called for
-		/// the first time.<br>
+		/// the first time.<br/>
 		/// </summary>
 		/// <returns> length of the current payload in number of bytes
 		/// </returns>
@@ -53,7 +53,7 @@
 		/// This method must not be called more than once after each call
 		/// of {@link #NextPosition()}. However, payloads are loaded lazily,
 		/// so if the payload data for the current position is not needed,
-		/// this method may not be called at all for performance reasons.<br>
+		/// this method may not be called at all for performance reasons.<br/>
 		/// 
 		/// </summary>
 		/// <param name="data">the array into which the data of this payload is to be

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/QueryParser/MultiFieldQueryParser.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/QueryParser/MultiFieldQueryParser.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/QueryParser/MultiFieldQueryParser.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/QueryParser/MultiFieldQueryParser.cs Mon Dec 14 19:05:31 2009
@@ -45,7 +45,7 @@
 		/// It will, when parse(String query) is called, construct a query like this
 		/// (assuming the query consists of two terms and you specify the two fields
 		/// <code>title</code> and <code>body</code>):
-		/// </p>
+		/// <p/>
 		/// 
 		/// <code>
 		/// (title:term1 body:term1) (title:term2 body:term2)
@@ -53,7 +53,7 @@
 		/// 
 		/// <p/>
 		/// When setDefaultOperator(AND_OPERATOR) is set, the result will be:
-		/// </p>
+		/// <p/>
 		/// 
 		/// <code>
 		/// +(title:term1 body:term1) +(title:term2 body:term2)
@@ -61,7 +61,7 @@
 		/// 
 		/// <p/>
 		/// When you pass a boost (title=>5 body=>10) you can get
-		/// </p>
+		/// <p/>
 		/// 
 		/// <code>
 		/// +(title:term1^5.0 body:term1^10.0) +(title:term2^5.0 body:term2^10.0)
@@ -70,7 +70,7 @@
 		/// <p/>
 		/// In other words, all the query's terms must appear, but it doesn't matter
 		/// in what fields they appear.
-		/// </p>
+		/// <p/>
 		/// 
 		/// </summary>
 		/// <deprecated> Please use
@@ -90,7 +90,7 @@
 		/// It will, when parse(String query) is called, construct a query like this
 		/// (assuming the query consists of two terms and you specify the two fields
 		/// <code>title</code> and <code>body</code>):
-		/// </p>
+		/// <p/>
 		/// 
 		/// <code>
 		/// (title:term1 body:term1) (title:term2 body:term2)
@@ -98,7 +98,7 @@
 		/// 
 		/// <p/>
 		/// When setDefaultOperator(AND_OPERATOR) is set, the result will be:
-		/// </p>
+		/// <p/>
 		/// 
 		/// <code>
 		/// +(title:term1 body:term1) +(title:term2 body:term2)
@@ -106,7 +106,7 @@
 		/// 
 		/// <p/>
 		/// When you pass a boost (title=>5 body=>10) you can get
-		/// </p>
+		/// <p/>
 		/// 
 		/// <code>
 		/// +(title:term1^5.0 body:term1^10.0) +(title:term2^5.0 body:term2^10.0)
@@ -115,7 +115,7 @@
 		/// <p/>
 		/// In other words, all the query's terms must appear, but it doesn't matter
 		/// in what fields they appear.
-		/// </p>
+		/// <p/>
 		/// </summary>
 		public MultiFieldQueryParser(Version matchVersion, System.String[] fields, Analyzer analyzer, System.Collections.IDictionary boosts):this(matchVersion, fields, analyzer)
 		{
@@ -128,7 +128,7 @@
 		/// It will, when parse(String query) is called, construct a query like this
 		/// (assuming the query consists of two terms and you specify the two fields
 		/// <code>title</code> and <code>body</code>):
-		/// </p>
+		/// <p/>
 		/// 
 		/// <code>
 		/// (title:term1 body:term1) (title:term2 body:term2)
@@ -136,7 +136,7 @@
 		/// 
 		/// <p/>
 		/// When setDefaultOperator(AND_OPERATOR) is set, the result will be:
-		/// </p>
+		/// <p/>
 		/// 
 		/// <code>
 		/// +(title:term1 body:term1) +(title:term2 body:term2)
@@ -145,7 +145,7 @@
 		/// <p/>
 		/// In other words, all the query's terms must appear, but it doesn't matter
 		/// in what fields they appear.
-		/// </p>
+		/// <p/>
 		/// 
 		/// </summary>
 		/// <deprecated> Please use
@@ -163,7 +163,7 @@
 		/// It will, when parse(String query) is called, construct a query like this
 		/// (assuming the query consists of two terms and you specify the two fields
 		/// <code>title</code> and <code>body</code>):
-		/// </p>
+		/// <p/>
 		/// 
 		/// <code>
 		/// (title:term1 body:term1) (title:term2 body:term2)
@@ -171,7 +171,7 @@
 		/// 
 		/// <p/>
 		/// When setDefaultOperator(AND_OPERATOR) is set, the result will be:
-		/// </p>
+		/// <p/>
 		/// 
 		/// <code>
 		/// +(title:term1 body:term1) +(title:term2 body:term2)
@@ -180,7 +180,7 @@
 		/// <p/>
 		/// In other words, all the query's terms must appear, but it doesn't matter
 		/// in what fields they appear.
-		/// </p>
+		/// <p/>
 		/// </summary>
 		public MultiFieldQueryParser(Version matchVersion, System.String[] fields, Analyzer analyzer):base(matchVersion, null, analyzer)
 		{

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/QueryParser/QueryParser.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/QueryParser/QueryParser.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/QueryParser/QueryParser.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/QueryParser/QueryParser.cs Mon Dec 14 19:05:31 2009
@@ -53,17 +53,17 @@
 	/// 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
+	/// 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.
+	/// This enables one to construct queries which search multiple fields.</li>
 	/// </ul>
 	/// 
 	/// A clause may be either:
 	/// <ul>
-	/// <li> a term, indicating all the documents that contain this term; or
+	/// <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.
+	/// terms.</li>
 	/// </ul>
 	/// 
 	/// Thus, in BNF, the query grammar is:
@@ -76,7 +76,7 @@
 	/// Examples of appropriately formatted queries can be found in the <a
 	/// href="../../../../../../queryparsersyntax.html">query syntax
 	/// documentation</a>.
-	/// </p>
+	/// <p/>
 	/// 
 	/// <p/>
 	/// In {@link TermRangeQuery}s, QueryParser tries to detect date values, e.g.
@@ -87,7 +87,7 @@
 	/// {@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.
-	/// </p>
+	/// <p/>
 	/// <p/>
 	/// The date resolution that shall be used for RangeQueries can be set
 	/// using {@link #SetDateResolution(DateTools.Resolution)}
@@ -95,30 +95,28 @@
 	/// 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/>
 	/// <p/>
 	/// If you use neither {@link DateField} nor {@link DateTools} in your
 	/// index, you can create your own
 	/// query parser that inherits QueryParser and overwrites
 	/// {@link #GetRangeQuery(String, String, String, boolean)} to
 	/// use a different method for date conversion.
-	/// </p>
+	/// <p/>
 	/// 
-	/// <p/>Note that QueryParser is <em>not</em> thread-safe.</p> 
+	/// <p/>Note that QueryParser is <em>not</em> thread-safe.<p/> 
 	/// 
 	/// <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.
-	/// </summary>
 	/// 
 	/// <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.
-	/// </summary>
 	/// <b>NOTE</b>: You must specify the required {@link Version} compatibility when
 	/// creating QueryParser:
 	/// <ul>
-	/// <li>As of 2.9, {@link #SetEnablePositionIncrements} is true by default.
+	/// <li>As of 2.9, {@link #SetEnablePositionIncrements} is true by default.</li>
 	/// </ul>
 	/// </summary>
 	public class QueryParser : QueryParserConstants
@@ -1363,7 +1361,7 @@
 		}
 		
 		/// <summary> Command line tool to test QueryParser, using {@link Lucene.Net.Analysis.SimpleAnalyzer}.
-		/// Usage:<br>
+		/// Usage:<br/>
 		/// <code>java Lucene.Net.QueryParsers.QueryParser &lt;input&gt;</code>
 		/// </summary>
 		[STAThread]

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/BooleanQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/BooleanQuery.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/BooleanQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/BooleanQuery.cs Mon Dec 14 19:05:31 2009
@@ -154,16 +154,16 @@
 		/// By default no optional clauses are necessary for a match
 		/// (unless there are no required clauses).  If this method is used,
 		/// then the specified number of clauses is required.
-		/// </p>
+		/// <p/>
 		/// <p/>
 		/// Use of this method is totally independent of specifying that
 		/// any specific clauses are required (or prohibited).  This number will
 		/// only be compared against the number of matching optional clauses.
-		/// </p>
+		/// <p/>
 		/// <p/>
 		/// EXPERT NOTE: Using this method may force collecting docs in order,
 		/// regardless of whether setAllowDocsOutOfOrder(true) has been called.
-		/// </p>
+		/// <p/>
 		/// 
 		/// </summary>
 		/// <param name="min">the number of optional clauses that must match
@@ -223,7 +223,7 @@
 		/// normalize, score and explain these queries.
 		/// 
 		/// <p/>NOTE: this API and implementation is subject to
-		/// change suddenly in the next release.</p>
+		/// change suddenly in the next release.<p/>
 		/// </summary>
 		[Serializable]
 		protected internal class BooleanWeight:Weight
@@ -483,7 +483,7 @@
 		/// specific simple cases may be faster. (For example: disjunction queries with
 		/// less than 32 prohibited clauses; This setting has no effect for other
 		/// queries.)
-		/// </p>
+		/// <p/>
 		/// 
 		/// <p/>
 		/// Specifics: By setting this option to true, docid N might be scored for a
@@ -492,7 +492,7 @@
 		/// a single segment.
 		/// 
 		/// Being static, this setting is system wide.
-		/// </p>
+		/// <p/>
 		/// 
 		/// </summary>
 		/// <deprecated> this is not needed anymore, as

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/BooleanScorer2.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/BooleanScorer2.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/BooleanScorer2.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/BooleanScorer2.cs Mon Dec 14 19:05:31 2009
@@ -25,8 +25,8 @@
 	
 	/// <summary>An alternative to BooleanScorer that also allows a minimum number
 	/// of optional scorers that should match.
-	/// <br>Implements skipTo(), and has no limitations on the numbers of added scorers.
-	/// <br>Uses ConjunctionScorer, DisjunctionScorer, ReqOptScorer and ReqExclScorer.
+	/// <br/>Implements skipTo(), and has no limitations on the numbers of added scorers.
+	/// <br/>Uses ConjunctionScorer, DisjunctionScorer, ReqOptScorer and ReqExclScorer.
 	/// </summary>
 	class BooleanScorer2:Scorer
 	{
@@ -371,7 +371,7 @@
 		/// <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.
+		/// <br/>When this method is used the {@link #Explain(int)} method should not be used.
 		/// </param>
 		/// <deprecated> use {@link #Score(Collector)} instead.
 		/// </deprecated>
@@ -383,7 +383,7 @@
 		
 		/// <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 {@link #Explain(int)} method should not be used.
 		/// </param>
 		public override void  Score(Collector collector)
 		{
@@ -395,7 +395,7 @@
 		}
 		
 		/// <summary>Expert: Collects matching documents in a range.
-		/// <br>Note that {@link #Next()} must be called once before this method is
+		/// <br/>Note that {@link #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

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Collector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Collector.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Collector.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Collector.cs Mon Dec 14 19:05:31 2009
@@ -24,14 +24,14 @@
 	
 	/// <summary> <p/>Expert: Collectors are primarily meant to be used to
 	/// gather raw results from a search, and implement sorting
-	/// or custom result filtering, collation, etc. </p>
+	/// or custom result filtering, collation, etc. <p/>
 	/// 
 	/// <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
 	/// sub readers, in an arbitrary order. This results in a
-	/// higher performance means of collection.</p>
+	/// 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
@@ -56,7 +56,7 @@
 	/// 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}.
+	/// that take an explicit {@link Sort}.</li>
 	/// 
 	/// <li>{@link TimeLimitingCollector}, which wraps any other
 	/// Collector and aborts the search if it's taken too much
@@ -77,7 +77,7 @@
 	/// 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>
+	/// {@link ScoreCachingWrappingScorer}. <p/>
 	/// 
 	/// <p/><b>NOTE:</b> The doc that is passed to the collect
 	/// method is relative to the current reader. If your
@@ -85,7 +85,7 @@
 	/// Multi*Reader, you must re-base it by recording the
 	/// docBase from the most recent setNextReader call.  Here's
 	/// a simple example showing how to collect docIDs into a
-	/// BitSet:</p>
+	/// BitSet:<p/>
 	/// 
 	/// <pre>
 	/// Searcher searcher = new IndexSearcher(indexReader);
@@ -114,18 +114,18 @@
 	/// 
 	/// <p/>Not all collectors will need to rebase the docID.  For
 	/// example, a collector that simply counts the total number
-	/// of hits would skip it.</p>
+	/// of hits would skip it.<p/>
 	/// 
 	/// <p/><b>NOTE:</b> Prior to 2.9, Lucene silently filtered
-	/// out hits with score <= 0.  As of 2.9, the core Collectors
+	/// out hits with score &lt;= 0.  As of 2.9, the core Collectors
 	/// 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>
+	/// PositiveScoresOnlyCollector}.<p/>
 	/// 
 	/// <p/><b>NOTE:</b> This API is experimental and might change
-	/// in incompatible ways in the next release.</p>
+	/// in incompatible ways in the next release.<p/>
 	/// 
 	/// </summary>
 	/// <since> 2.9

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ComplexExplanation.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/ComplexExplanation.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ComplexExplanation.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ComplexExplanation.cs Mon Dec 14 19:05:31 2009
@@ -59,7 +59,7 @@
 		/// <p/>
 		/// If the match status is explicitly set (i.e.: not null) this method
 		/// uses it; otherwise it defers to the superclass.
-		/// </p>
+		/// <p/>
 		/// </summary>
 		/// <seealso cref="getMatch">
 		/// </seealso>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DefaultSimilarity.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/DefaultSimilarity.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DefaultSimilarity.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DefaultSimilarity.cs Mon Dec 14 19:05:31 2009
@@ -35,7 +35,7 @@
 		/// FieldInvertState#GetNumOverlap()}.
 		/// 
 		/// <p/><b>WARNING</b>: This API is new and experimental, and may suddenly
-		/// change.</p> 
+		/// change.<p/> 
 		/// </summary>
 		public override float ComputeNorm(System.String field, FieldInvertState state)
 		{
@@ -92,7 +92,7 @@
 		/// tokens are counted just like non-overlap tokens.
 		/// 
 		/// <p/><b>WARNING</b>: This API is new and experimental, and may suddenly
-		/// change.</p>
+		/// change.<p/>
 		/// 
 		/// </summary>
 		/// <seealso cref="computeNorm">

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DisjunctionMaxQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/DisjunctionMaxQuery.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DisjunctionMaxQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DisjunctionMaxQuery.cs Mon Dec 14 19:05:31 2009
@@ -93,7 +93,7 @@
 		/// normalize, score and explain these queries.
 		/// 
 		/// <p/>NOTE: this API and implementation is subject to
-		/// change suddenly in the next release.</p>
+		/// change suddenly in the next release.<p/>
 		/// </summary>
 		[Serializable]
 		protected internal class DisjunctionMaxWeight:Weight

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DisjunctionSumScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/DisjunctionSumScorer.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DisjunctionSumScorer.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DisjunctionSumScorer.cs Mon Dec 14 19:05:31 2009
@@ -39,9 +39,9 @@
 		
 		/// <summary>The scorerDocQueue contains all subscorers ordered by their current doc(),
 		/// with the minimum at the top.
-		/// <br>The scorerDocQueue is initialized the first time next() or skipTo() is called.
-		/// <br>An exhausted scorer is immediately removed from the scorerDocQueue.
-		/// <br>If less than the minimumNrMatchers scorers
+		/// <br/>The scorerDocQueue is initialized the first time next() or skipTo() is called.
+		/// <br/>An exhausted scorer is immediately removed from the scorerDocQueue.
+		/// <br/>If less than the minimumNrMatchers scorers
 		/// remain in the scorerDocQueue next() and skipTo() return false.
 		/// <p/>
 		/// After each to call to next() or skipTo()
@@ -64,10 +64,10 @@
 		/// </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
+		/// <br/>When <code>minimumNrMatchers</code> is bigger than
 		/// the number of <code>subScorers</code>,
 		/// no matches will be produced.
-		/// <br>When minimumNrMatchers equals the number of subScorers,
+		/// <br/>When minimumNrMatchers equals the number of subScorers,
 		/// it more efficient to use <code>ConjunctionScorer</code>.
 		/// </param>
 		public DisjunctionSumScorer(System.Collections.IList subScorers, int minimumNrMatchers):base(null)
@@ -118,7 +118,7 @@
 		/// <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.
+		/// <br/>When this method is used the {@link #Explain(int)} method should not be used.
 		/// </param>
 		/// <deprecated> use {@link #Score(Collector)} instead.
 		/// </deprecated>
@@ -130,7 +130,7 @@
 		
 		/// <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 {@link #Explain(int)} method should not be used.
 		/// </param>
 		public override void  Score(Collector collector)
 		{
@@ -206,11 +206,11 @@
 		/// top of the <code>scorerDocQueue</code>.
 		/// 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 <code>scorerDocQueue</code> has at least <code>minimumNrMatchers</code>
 		/// 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>,
+		/// <br/>In case there is a match, </code>currentDoc</code>, </code>currentSumScore</code>,
 		/// and </code>nrMatchers</code> describe the match.
 		/// 
 		/// TODO: Investigate whether it is possible to use skipTo() when
@@ -218,7 +218,7 @@
 		/// character of ConjunctionScorer for the minimum number of matchers.
 		/// Also delay calling score() on the sub scorers until the minimum number of
 		/// matchers is reached.
-		/// <br>For this, a Scorer array with minimumNrMatchers elements might
+		/// <br/>For this, a Scorer array with minimumNrMatchers elements might
 		/// hold Scorers at currentDoc that are temporarily popped from scorerQueue.
 		/// </returns>
 		protected internal virtual bool AdvanceAfterCurrent()
@@ -290,9 +290,9 @@
 		}
 		
 		/// <summary> Skips to the first match beyond the current whose document number is
-		/// greater than or equal to a given target. <br>
+		/// greater than or equal to a given target. <br/>
 		/// When this method is used the {@link #Explain(int)} method should not be
-		/// used. <br>
+		/// used. <br/>
 		/// The implementation uses the skipTo() method on the subscorers.
 		/// 
 		/// </summary>
@@ -309,9 +309,9 @@
 		}
 		
 		/// <summary> Advances to the first match beyond the current whose document number is
-		/// greater than or equal to a given target. <br>
+		/// greater than or equal to a given target. <br/>
 		/// When this method is used the {@link #Explain(int)} method should not be
-		/// used. <br>
+		/// used. <br/>
 		/// The implementation uses the skipTo() method on the subscorers.
 		/// 
 		/// </summary>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DocIdSetIterator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/DocIdSetIterator.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DocIdSetIterator.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DocIdSetIterator.cs Mon Dec 14 19:05:31 2009
@@ -52,9 +52,9 @@
 		/// <summary> Returns the following:
 		/// <ul>
 		/// <li>-1 or {@link #NO_MORE_DOCS} if {@link #NextDoc()} or
-		/// {@link #Advance(int)} were not called yet.
-		/// <li>{@link #NO_MORE_DOCS} if the iterator has exhausted.
-		/// <li>Otherwise it should return the doc ID it is currently on.
+		/// {@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>
 		/// <p/>
 		/// <b>NOTE:</b> in 3.0, this method will become abstract.
@@ -93,7 +93,7 @@
 		
 		/// <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
-		/// set.<br>
+		/// 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:

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Explanation.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Explanation.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Explanation.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Explanation.cs Mon Dec 14 19:05:31 2009
@@ -42,7 +42,7 @@
 		/// 
 		/// <p/>
 		/// By default, an Explanation represents a "match" if the value is positive.
-		/// </p>
+		/// <p/>
 		/// </summary>
 		/// <seealso cref="getValue">
 		/// </seealso>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCache.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FieldCache.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCache.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCache.cs Mon Dec 14 19:05:31 2009
@@ -89,7 +89,7 @@
 	/// and experimental.  It may be removed or altered w/o warning in future 
 	/// releases 
 	/// of Lucene.
-	/// </p>
+	/// <p/>
 	/// </summary>
 	public abstract class CacheEntry
 	{
@@ -638,13 +638,13 @@
 		/// Cached Values.  Maintaining refrences to a CacheEntry the IndexReader 
 		/// associated with it has garbage collected will prevent the Value itself
 		/// from being garbage collected when the Cache drops the WeakRefrence.
-		/// </p>
+		/// <p/>
 		/// <p/>
 		/// <b>EXPERIMENTAL API:</b> This API is considered extremely advanced 
 		/// and experimental.  It may be removed or altered w/o warning in future 
 		/// releases 
 		/// of Lucene.
-		/// </p>
+		/// <p/>
 		/// </summary>
 		CacheEntry[] GetCacheEntries();
 		
@@ -655,13 +655,13 @@
 		/// (with out needing to rely on GC to free WeakReferences).  
 		/// It should not be relied on for "Cache maintenance" in general 
 		/// application code.
-		/// </p>
+		/// <p/>
 		/// <p/>
 		/// <b>EXPERIMENTAL API:</b> This API is considered extremely advanced 
 		/// and experimental.  It may be removed or altered w/o warning in future 
 		/// releases 
 		/// of Lucene.
-		/// </p>
+		/// <p/>
 		/// </summary>
 		void  PurgeAllCaches();
 		

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldComparator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FieldComparator.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldComparator.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldComparator.cs Mon Dec 14 19:05:31 2009
@@ -41,14 +41,14 @@
 	/// an int ranging from 0 to numHits-1.  The {@link
 	/// FieldComparator} is made aware of segment transitions
 	/// during searching in case any internal state it's tracking
-	/// needs to be recomputed during these transitions.</p>
+	/// needs to be recomputed during these transitions.<p/>
 	/// 
-	/// <p/>A comparator must define these functions:</p>
+	/// <p/>A comparator must define these functions:<p/>
 	/// 
 	/// <ul>
 	/// 
 	/// <li> {@link #compare} Compare a hit at 'slot a'
-	/// with hit 'slot b'.
+	/// with hit 'slot b'.</li>
 	/// 
 	/// <li> {@link #setBottom} This method is called by
 	/// {@link FieldValueHitQueue} to notify the
@@ -56,25 +56,25 @@
 	/// slot.  Note that this slot may not hold the weakest
 	/// value according to your comparator, in cases where
 	/// your comparator is not the primary one (ie, is only
-	/// used to break ties from the comparators before it).
+	/// used to break ties from the comparators before it).</li>
 	/// 
 	/// <li> {@link #compareBottom} Compare a new hit (docID)
-	/// against the "weakest" (bottom) entry in the queue.
+	/// against the "weakest" (bottom) entry in the queue.</li>
 	/// 
 	/// <li> {@link #copy} Installs a new hit into the
 	/// priority queue.  The {@link FieldValueHitQueue}
-	/// calls this method when a new hit is competitive.
+	/// calls this method when a new hit is competitive.</li>
 	/// 
 	/// <li> {@link #setNextReader} Invoked
 	/// when the search is switching to the next segment.
 	/// You may need to update internal state of the
 	/// comparator, for example retrieving new values from
-	/// the {@link FieldCache}.
+	/// the {@link FieldCache}.</li>
 	/// 
 	/// <li> {@link #value} Return the sort value stored in
 	/// the specified slot.  This is only called at the end
 	/// of the search, in order to populate {@link
-	/// FieldDoc#fields} when returning the top results.
+	/// FieldDoc#fields} when returning the top results.</li>
 	/// </ul>
 	/// 
 	/// <b>NOTE:</b> This API is experimental and might change in
@@ -1006,7 +1006,7 @@
 		/// 
 		/// <p/>For a search that hits many results, this method
 		/// will be the hotspot (invoked by far the most
-		/// frequently).</p>
+		/// frequently).<p/>
 		/// 
 		/// </summary>
 		/// <param name="doc">that was hit

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ByteFieldSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/ByteFieldSource.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ByteFieldSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ByteFieldSource.cs Mon Dec 14 19:05:31 2009
@@ -45,7 +45,7 @@
 	/// (single segment) readers to this API.  Alternatively, for
 	/// a short-term fix, you could wrap your ValueSource using
 	/// {@link MultiValueSource}, which costs more CPU per lookup
-	/// but will not consume double the FieldCache RAM.</p>
+	/// but will not consume double the FieldCache RAM.<p/>
 	/// </seealso>
 	[Serializable]
 	public class ByteFieldSource:FieldCacheSource

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/DocValues.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/DocValues.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/DocValues.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/DocValues.cs Mon Dec 14 19:05:31 2009
@@ -156,7 +156,7 @@
 		/// DocValues instance does not contain any value.
 		/// <p/>
 		/// This operation is optional
-		/// </p>
+		/// <p/>
 		/// 
 		/// </summary>
 		/// <returns> the minimum of all values or <code>Float.NaN</code> if this
@@ -172,7 +172,7 @@
 		/// DocValues instance does not contain any value.
 		/// <p/>
 		/// This operation is optional
-		/// </p>
+		/// <p/>
 		/// 
 		/// </summary>
 		/// <returns> the maximum of all values or <code>Float.NaN</code> if this
@@ -188,7 +188,7 @@
 		/// DocValues instance does not contain any value. *
 		/// <p/>
 		/// This operation is optional
-		/// </p>
+		/// <p/>
 		/// 
 		/// </summary>
 		/// <returns> the average of all values or <code>Float.NaN</code> if this

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FieldCacheSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/FieldCacheSource.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FieldCacheSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FieldCacheSource.cs Mon Dec 14 19:05:31 2009
@@ -47,7 +47,7 @@
 	/// (single segment) readers to this API.  Alternatively, for
 	/// a short-term fix, you could wrap your ValueSource using
 	/// {@link MultiValueSource}, which costs more CPU per lookup
-	/// but will not consume double the FieldCache RAM.</p>
+	/// but will not consume double the FieldCache RAM.<p/>
 	/// </summary>
 	[Serializable]
 	public abstract class FieldCacheSource:ValueSource

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FloatFieldSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/FloatFieldSource.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FloatFieldSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FloatFieldSource.cs Mon Dec 14 19:05:31 2009
@@ -45,7 +45,7 @@
 	/// (single segment) readers to this API.  Alternatively, for
 	/// a short-term fix, you could wrap your ValueSource using
 	/// {@link MultiValueSource}, which costs more CPU per lookup
-	/// but will not consume double the FieldCache RAM.</p>
+	/// but will not consume double the FieldCache RAM.<p/>
 	/// </seealso>
 	[Serializable]
 	public class FloatFieldSource:FieldCacheSource

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/IntFieldSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/IntFieldSource.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/IntFieldSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/IntFieldSource.cs Mon Dec 14 19:05:31 2009
@@ -45,7 +45,7 @@
 	/// (single segment) readers to this API.  Alternatively, for
 	/// a short-term fix, you could wrap your ValueSource using
 	/// {@link MultiValueSource}, which costs more CPU per lookup
-	/// but will not consume double the FieldCache RAM.</p>
+	/// but will not consume double the FieldCache RAM.<p/>
 	/// </seealso>
 	[Serializable]
 	public class IntFieldSource:FieldCacheSource

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/MultiValueSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/MultiValueSource.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/MultiValueSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/MultiValueSource.cs Mon Dec 14 19:05:31 2009
@@ -30,7 +30,7 @@
 	/// 
 	/// <p/><b>NOTE</b>: this class adds a CPU penalty to every
 	/// lookup, as it must resolve the incoming document to the
-	/// right sub-reader using a binary search.</p>
+	/// right sub-reader using a binary search.<p/>
 	/// 
 	/// </summary>
 	/// <deprecated> This class is temporary, to ease the

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/OrdFieldSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/OrdFieldSource.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/OrdFieldSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/OrdFieldSource.cs Mon Dec 14 19:05:31 2009
@@ -31,8 +31,8 @@
 	/// Field values (terms) are lexicographically ordered by unicode value, and numbered starting at 1.
 	/// <p/>
 	/// Example:
-	/// <br>If there were only three field values: "apple","banana","pear"
-	/// <br>then ord("apple")=1, ord("banana")=2, ord("pear")=3
+	/// <br/>If there were only three field values: "apple","banana","pear"
+	/// <br/>then ord("apple")=1, ord("banana")=2, ord("pear")=3
 	/// <p/>
 	/// WARNING: 
 	/// ord() depends on the position in an index and can thus change 
@@ -52,7 +52,7 @@
 	/// (single segment) readers to this API.  Alternatively, for
 	/// a short-term fix, you could wrap your ValueSource using
 	/// {@link MultiValueSource}, which costs more CPU per lookup
-	/// but will not consume double the FieldCache RAM.</p>
+	/// but will not consume double the FieldCache RAM.<p/>
 	/// </summary>
 	
 	[Serializable]

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ReverseOrdFieldSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/ReverseOrdFieldSource.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ReverseOrdFieldSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ReverseOrdFieldSource.cs Mon Dec 14 19:05:31 2009
@@ -30,10 +30,10 @@
 	/// The native lucene index order is used to assign an ordinal value for each field value.
 	/// <p/>
 	/// Field values (terms) are lexicographically ordered by unicode value, and numbered starting at 1.
-	/// <br>
+	/// <br/>
 	/// Example of reverse ordinal (rord):
-	/// <br>If there were only three field values: "apple","banana","pear"
-	/// <br>then rord("apple")=3, rord("banana")=2, ord("pear")=1
+	/// <br/>If there were only three field values: "apple","banana","pear"
+	/// <br/>then rord("apple")=3, rord("banana")=2, ord("pear")=1
 	/// <p/>
 	/// WARNING: 
 	/// rord() depends on the position in an index and can thus change 
@@ -53,7 +53,7 @@
 	/// (single segment) readers to this API.  Alternatively, for
 	/// a short-term fix, you could wrap your ValueSource using
 	/// {@link MultiValueSource}, which costs more CPU per lookup
-	/// but will not consume double the FieldCache RAM.</p>
+	/// but will not consume double the FieldCache RAM.<p/>
 	/// </summary>
 	
 	[Serializable]

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ShortFieldSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/ShortFieldSource.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ShortFieldSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ShortFieldSource.cs Mon Dec 14 19:05:31 2009
@@ -45,7 +45,7 @@
 	/// (single segment) readers to this API.  Alternatively, for
 	/// a short-term fix, you could wrap your ValueSource using
 	/// {@link MultiValueSource}, which costs more CPU per lookup
-	/// but will not consume double the FieldCache RAM.</p>
+	/// but will not consume double the FieldCache RAM.<p/>
 	/// </seealso>
 	[Serializable]
 	public class ShortFieldSource:FieldCacheSource

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FuzzyTermEnum.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FuzzyTermEnum.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FuzzyTermEnum.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FuzzyTermEnum.cs Mon Dec 14 19:05:31 2009
@@ -194,7 +194,7 @@
 		/// 1 - (editDistance / length)</pre>
 		/// where length is the length of the shortest term (text or target) including a
 		/// prefix that are identical and editDistance is the Levenshtein distance for
-		/// the two words.</p>
+		/// the two words.<p/>
 		/// 
 		/// <p/>Embedded within this algorithm is a fail-fast Levenshtein distance
 		/// algorithm.  The fail-fast algorithm differs from the standard Levenshtein
@@ -211,7 +211,7 @@
 		/// similarity = 1 - ((float)distance / (float) (prefixLength + Math.min(textlen, targetlen)));
 		/// return (similarity > minimumSimilarity);</pre>
 		/// where distance is the Levenshtein distance for the two words.
-		/// </p>
+		/// <p/>
 		/// <p/>Levenshtein distance (also known as edit distance) is a measure of similiarity
 		/// between two strings where the distance is measured as the number of character
 		/// deletions, insertions or substitutions required to transform one string to

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/HitCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/HitCollector.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/HitCollector.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/HitCollector.cs Mon Dec 14 19:05:31 2009
@@ -20,7 +20,7 @@
 namespace Lucene.Net.Search
 {
 	
-	/// <summary> Lower-level search API. <br>
+	/// <summary> Lower-level search API. <br/>
 	/// HitCollectors are primarily meant to be used to implement queries, sorting
 	/// and filtering. See {@link Collector} for a lower level and higher performance
 	/// (on a multi-segment index) API.

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/HitQueue.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/HitQueue.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/HitQueue.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/HitQueue.cs Mon Dec 14 19:05:31 2009
@@ -31,7 +31,7 @@
 		/// <code>prePopulate</code> is set to true, the queue will pre-populate itself
 		/// with sentinel objects and set its {@link #Size()} to <code>size</code>. In
 		/// that case, you should not rely on {@link #Size()} to get the number of
-		/// actual elements that were added to the queue, but keep track yourself.<br>
+		/// actual elements that were added to the queue, but keep track yourself.<br/>
 		/// <b>NOTE:</b> in case <code>prePopulate</code> is true, you should pop
 		/// elements from the queue using the following code example:
 		/// 

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Hits.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Hits.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Hits.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Hits.cs Mon Dec 14 19:05:31 2009
@@ -29,7 +29,7 @@
 	/// generally not desirable and may be the source of performance issues. If you
 	/// need to iterate over many or all hits, consider using the search method that
 	/// takes a {@link HitCollector}.
-	/// </p>
+	/// <p/>
 	/// <p/>
 	/// <b>Note:</b> Deleting matching documents concurrently with traversing the
 	/// hits, might, when deleting hits that were not yet retrieved, decrease
@@ -42,7 +42,7 @@
 	/// </summary>
 	/// <deprecated> see {@link Searcher#Search(Query, int)},
 	/// {@link Searcher#Search(Query, Filter, int)} and
-	/// {@link Searcher#Search(Query, Filter, int, Sort)}:<br>
+	/// {@link Searcher#Search(Query, Filter, int, Sort)}:<br/>
 	/// 
 	/// <pre>
 	/// TopDocs topDocs = searcher.Search(query, numHits);
@@ -225,7 +225,7 @@
 		/// hits is generally not desirable and may be the source of
 		/// performance issues. If you need to iterate over many or all hits, consider
 		/// using a search method that takes a {@link HitCollector}.
-		/// </p>
+		/// <p/>
 		/// </summary>
 		public System.Collections.IEnumerator Iterator()
 		{

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/IndexSearcher.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/IndexSearcher.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/IndexSearcher.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/IndexSearcher.cs Mon Dec 14 19:05:31 2009
@@ -43,7 +43,7 @@
 	/// methods, concurrently.  If your application requires
 	/// external synchronization, you should <b>not</b>
 	/// synchronize on the <code>IndexSearcher</code> instance;
-	/// use your own (non-Lucene) objects instead.</p>
+	/// use your own (non-Lucene) objects instead.<p/>
 	/// </summary>
 	public class IndexSearcher:Searcher
 	{
@@ -198,14 +198,14 @@
 		
 		/// <summary> Just like {@link #Search(Weight, Filter, int, Sort)}, but you choose
 		/// whether or not the fields in the returned {@link FieldDoc} instances
-		/// should be set by specifying fillFields.<br>
+		/// should be set by specifying fillFields.<br/>
 		/// 
 		/// <p/>
 		/// NOTE: this does not compute scores by default. If you need scores, create
 		/// a {@link TopFieldCollector} instance by calling
 		/// {@link TopFieldCollector#create} and then pass that to
 		/// {@link #Search(Weight, Filter, Collector)}.
-		/// </p>
+		/// <p/>
 		/// </summary>
 		public virtual TopFieldDocs Search(Weight weight, Filter filter, int nDocs, Sort sort, bool fillFields)
 		{

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/NumericRangeQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/NumericRangeQuery.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/NumericRangeQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/NumericRangeQuery.cs Mon Dec 14 19:05:31 2009
@@ -34,7 +34,7 @@
 	/// NumericTokenStream}).  If your terms are instead textual,
 	/// you should use {@link TermRangeQuery}.  {@link
 	/// NumericRangeFilter} is the filter equivalent of this
-	/// query.</p>
+	/// query.<p/>
 	/// 
 	/// <p/>You create a new NumericRangeQuery with the static
 	/// factory methods, eg:
@@ -51,7 +51,7 @@
 	/// <p/>The performance of NumericRangeQuery is much better
 	/// than the corresponding {@link TermRangeQuery} because the
 	/// number of terms that must be searched is usually far
-	/// fewer, thanks to trie indexing, described below.</p>
+	/// fewer, thanks to trie indexing, described below.<p/>
 	/// 
 	/// <p/>You can optionally specify a <a
 	/// href="#precisionStepDesc"><code>precisionStep</code></a>
@@ -66,19 +66,19 @@
 	/// 
 	/// <p/>This query defaults to {@linkplain
 	/// MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} for
-	/// 32 bit (int/float) ranges with precisionStep &le;8 and 64
-	/// bit (long/double) ranges with precisionStep &le;6.
+	/// 32 bit (int/float) ranges with precisionStep &lt;8 and 64
+	/// bit (long/double) ranges with precisionStep &lt;6.
 	/// Otherwise it uses {@linkplain
 	/// MultiTermQuery#CONSTANT_SCORE_FILTER_REWRITE} as the
 	/// number of terms is likely to be high.  With precision
-	/// steps of &le;4, this query can be run with one of the
+	/// steps of &lt;4, this query can be run with one of the
 	/// BooleanQuery rewrite methods without changing
 	/// BooleanQuery's default max clause count.
 	/// 
 	/// <p/><font color="red"><b>NOTE:</b> This API is experimental and
 	/// might change in incompatible ways in the next release.</font>
 	/// 
-	/// <br><h3>How it works</h3>
+	/// <br/><h3>How it works</h3>
 	/// 
 	/// <p/>See the publication about <a target="_blank" href="http://www.panfmp.org">panFMP</a>,
 	/// where this algorithm was described (referred to as <code>TrieRangeQuery</code>):
@@ -99,7 +99,7 @@
 	/// (for a more detailed description of how the values are stored,
 	/// see {@link NumericUtils}). A range is then divided recursively into multiple intervals for searching:
 	/// The center of the range is searched only with the lowest possible precision in the <em>trie</em>,
-	/// while the boundaries are matched more exactly. This reduces the number of terms dramatically.</p>
+	/// while the boundaries are matched more exactly. This reduces the number of terms dramatically.<p/>
 	/// 
 	/// <p/>For the variant that stores long values in 8 different precisions (each reduced by 8 bits) that
 	/// uses a lowest precision of 1 byte, the index contains only a maximum of 256 distinct values in the
@@ -108,9 +108,9 @@
 	/// 8-byte-number in the index and the range covers almost all of them; a maximum of 255 distinct values is used
 	/// because it would always be possible to reduce the full 256 values to one term with degraded precision).
 	/// In practice, we have seen up to 300 terms in most cases (index with 500,000 metadata records
-	/// and a uniform value distribution).</p>
+	/// and a uniform value distribution).<p/>
 	/// 
-	/// <a name="precisionStepDesc"><h3>Precision Step</h3>
+	/// <a name="precisionStepDesc"/><h3>Precision Step</h3>
 	/// <p/>You can choose any <code>precisionStep</code> when encoding values.
 	/// Lower step values mean more precisions and so more terms in index (and index gets larger).
 	/// On the other hand, the maximum number of terms to match reduces, which optimized query speed.
@@ -125,19 +125,19 @@
 	/// step of 2, <code>n = 31*3*2 + 3 = 189</code>. But the faster search speed is reduced by more seeking
 	/// in the term enum of the index. Because of this, the ideal <code>precisionStep</code> value can only
 	/// be found out by testing. <b>Important:</b> You can index with a lower precision step value and test search speed
-	/// using a multiple of the original step value.</p>
+	/// using a multiple of the original step value.<p/>
 	/// 
 	/// <p/>Good values for <code>precisionStep</code> are depending on usage and data type:
 	/// <ul>
-	/// <li>The default for all data types is <b>4</b>, which is used, when no <code>precisionStep</code> is given.
-	/// <li>Ideal value in most cases for <em>64 bit</em> data types <em>(long, double)</em> is <b>6</b> or <b>8</b>.
-	/// <li>Ideal value in most cases for <em>32 bit</em> data types <em>(int, float)</em> is <b>4</b>.
-	/// <li>Steps <b>&ge;64</b> for <em>long/double</em> and <b>&ge;32</b> for <em>int/float</em> produces one token
+	/// <li>The default for all data types is <b>4</b>, which is used, when no <code>precisionStep</code> is given.</li>
+	/// <li>Ideal value in most cases for <em>64 bit</em> data types <em>(long, double)</em> is <b>6</b> or <b>8</b>.</li>
+	/// <li>Ideal value in most cases for <em>32 bit</em> data types <em>(int, float)</em> is <b>4</b>.</li>
+	/// <li>Steps <b>&gt;64</b> for <em>long/double</em> and <b>&gt;32</b> for <em>int/float</em> produces one token
 	/// per value in the index and querying is as slow as a conventional {@link TermRangeQuery}. But it can be used
 	/// to produce fields, that are solely used for sorting (in this case simply use {@link Integer#MAX_VALUE} as
 	/// <code>precisionStep</code>). Using {@link NumericField NumericFields} for sorting
 	/// is ideal, because building the field cache is much faster than with text-only numbers.
-	/// Sorting is also possible with range query optimized fields using one of the above <code>precisionSteps</code>.
+	/// Sorting is also possible with range query optimized fields using one of the above <code>precisionSteps</code>.</li>
 	/// </ul>
 	/// 
 	/// <p/>Comparisons of the different types of RangeQueries on an index with about 500,000 docs showed
@@ -145,7 +145,7 @@
 	/// took about 30-40 secs to complete, {@link TermRangeQuery} in constant score filter rewrite mode took 5 secs
 	/// and executing this class took &lt;100ms to complete (on an Opteron64 machine, Java 1.5, 8 bit
 	/// precision step). This query type was developed for a geographic portal, where the performance for
-	/// e.g. bounding boxes or exact date/time stamps is important.</p>
+	/// e.g. bounding boxes or exact date/time stamps is important.<p/>
 	/// 
 	/// </summary>
 	/// <since> 2.9

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/PhraseScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/PhraseScorer.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/PhraseScorer.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/PhraseScorer.cs Mon Dec 14 19:05:31 2009
@@ -23,7 +23,7 @@
 {
 	
 	/// <summary>Expert: Scoring functionality for phrase queries.
-	/// <br>A document is considered matching if it contains the phrase-query terms  
+	/// <br/>A document is considered matching if it contains the phrase-query terms  
 	/// at "valid" positons. What "valid positions" are
 	/// depends on the type of the phrase query: for an exact phrase query terms are required 
 	/// to appear in adjacent locations, while for a sloppy phrase query some distance between 
@@ -177,7 +177,7 @@
 		/// <summary> For a document containing all the phrase query terms, compute the
 		/// frequency of the phrase in that document. 
 		/// A non zero frequency means a match.
-		/// <br>Note, that containing all phrase terms does not guarantee a match - they have to be found in matching locations.  
+		/// <br/>Note, that containing all phrase terms does not guarantee a match - they have to be found in matching locations.  
 		/// </summary>
 		/// <returns> frequency of the phrase in current doc, 0 if not found. 
 		/// </returns>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Query.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Query.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Query.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Query.cs Mon Dec 14 19:05:31 2009
@@ -25,21 +25,21 @@
 	/// <summary>The abstract base class for queries.
 	/// <p/>Instantiable subclasses are:
 	/// <ul>
-	/// <li> {@link TermQuery}
-	/// <li> {@link MultiTermQuery}
-	/// <li> {@link BooleanQuery}
-	/// <li> {@link WildcardQuery}
-	/// <li> {@link PhraseQuery}
-	/// <li> {@link PrefixQuery}
-	/// <li> {@link MultiPhraseQuery}
-	/// <li> {@link FuzzyQuery}
-	/// <li> {@link TermRangeQuery}
-	/// <li> {@link NumericRangeQuery}
-	/// <li> {@link Lucene.Net.Search.Spans.SpanQuery}
+	/// <li> {@link TermQuery} </li>
+    /// <li> {@link MultiTermQuery} </li>
+    /// <li> {@link BooleanQuery} </li>
+    /// <li> {@link WildcardQuery} </li>
+    /// <li> {@link PhraseQuery} </li>
+    /// <li> {@link PrefixQuery} </li>
+    /// <li> {@link MultiPhraseQuery} </li>
+    /// <li> {@link FuzzyQuery} </li>
+    /// <li> {@link TermRangeQuery} </li>
+    /// <li> {@link NumericRangeQuery} </li>
+    /// <li> {@link Lucene.Net.Search.Spans.SpanQuery} </li>
 	/// </ul>
 	/// <p/>A parser for queries is contained in:
 	/// <ul>
-	/// <li>{@link Lucene.Net.QueryParsers.QueryParser QueryParser}
+    /// <li>{@link Lucene.Net.QueryParsers.QueryParser QueryParser} </li>
 	/// </ul>
 	/// </summary>
 	[Serializable]

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ReqExclScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/ReqExclScorer.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ReqExclScorer.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ReqExclScorer.cs Mon Dec 14 19:05:31 2009
@@ -23,7 +23,7 @@
 	
 	/// <summary>A Scorer for queries with a required subscorer
 	/// and an excluding (prohibited) sub DocIdSetIterator.
-	/// <br>
+	/// <br/>
 	/// This <code>Scorer</code> implements {@link Scorer#SkipTo(int)},
 	/// and it uses the skipTo() on the given scorers.
 	/// </summary>
@@ -72,12 +72,12 @@
 		}
 		
 		/// <summary>Advance to non excluded doc.
-		/// <br>On entry:
+		/// <br/>On entry:
 		/// <ul>
-		/// <li>reqScorer != null,
-		/// <li>exclScorer != null,
-		/// <li>reqScorer was advanced once via next() or skipTo()
-		/// and reqScorer.doc() may still be excluded.
+		/// <li>reqScorer != null, </li>
+		/// <li>exclScorer != null, </li>
+		/// <li>reqScorer was advanced once via next() or skipTo() 
+        /// and reqScorer.doc() may still be excluded.</li>
 		/// </ul>
 		/// Advances reqScorer a non excluded required doc, if any.
 		/// </summary>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ReqOptSumScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/ReqOptSumScorer.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ReqOptSumScorer.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ReqOptSumScorer.cs Mon Dec 14 19:05:31 2009
@@ -22,7 +22,7 @@
 	
 	/// <summary>A Scorer for queries with a required part and an optional part.
 	/// Delays skipTo() on the optional part until a score() is needed.
-	/// <br>
+	/// <br/>
 	/// This <code>Scorer</code> implements {@link Scorer#SkipTo(int)}.
 	/// </summary>
 	class ReqOptSumScorer:Scorer

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ScoreCachingWrappingScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/ScoreCachingWrappingScorer.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ScoreCachingWrappingScorer.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ScoreCachingWrappingScorer.cs Mon Dec 14 19:05:31 2009
@@ -23,7 +23,7 @@
 	/// <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
 	/// result and will not invoke the wrapped Scorer's score() method, unless the
-	/// current document has changed.<br>
+	/// current document has changed.<br/>
 	/// This class might be useful due to the changes done to the {@link 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

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ScoreDocComparator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/ScoreDocComparator.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ScoreDocComparator.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ScoreDocComparator.cs Mon Dec 14 19:05:31 2009
@@ -91,8 +91,8 @@
 		/// </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>
+		/// <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>
 		/// <seealso cref="java.util.Comparator">

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Scorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Scorer.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Scorer.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Scorer.cs Mon Dec 14 19:05:31 2009
@@ -25,11 +25,11 @@
 	/// <p/>
 	/// A <code>Scorer</code> iterates over documents matching a
 	/// query in increasing order of doc Id.
-	/// </p>
+	/// <p/>
 	/// <p/>
 	/// Document scores are computed using a given <code>Similarity</code>
 	/// implementation.
-	/// </p>
+	/// <p/>
 	/// 
 	/// <p/><b>NOTE</b>: The values Float.Nan,
 	/// Float.NEGATIVE_INFINITY and Float.POSITIVE_INFINITY are
@@ -61,7 +61,7 @@
 		/// <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.
+		/// <br/>When this method is used the {@link #Explain(int)} method should not be used.
 		/// </param>
 		/// <deprecated> use {@link #Score(Collector)} instead.
 		/// </deprecated>
@@ -73,7 +73,7 @@
 		
 		/// <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 {@link #Explain(int)} method should not be used.
 		/// </param>
 		public virtual void  Score(Collector collector)
 		{
@@ -139,7 +139,7 @@
 		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
+		/// <br/>When this method is used, the {@link #Next()}, {@link #SkipTo(int)} and
 		/// {@link #Score(HitCollector)} methods should not be used.
 		/// </summary>
 		/// <param name="doc">The document number for the explanation.

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Searchable.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Searchable.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Searchable.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Searchable.cs Mon Dec 14 19:05:31 2009
@@ -48,7 +48,7 @@
 		/// 
 		/// <p/>{@link HitCollector#Collect(int,float)} is called for every non-zero
 		/// scoring document.
-		/// <br>HitCollector-based access to remote indexes is discouraged.
+		/// <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
@@ -71,7 +71,7 @@
 		/// <summary> Lower-level search API.
 		/// 
 		/// <p/>
-		/// {@link Collector#Collect(int)} is called for every document. <br>
+		/// {@link Collector#Collect(int)} is called for every document. <br/>
 		/// Collector-based access to remote indexes is discouraged.
 		/// 
 		/// <p/>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Searcher.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Searcher.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Searcher.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Searcher.cs Mon Dec 14 19:05:31 2009
@@ -150,7 +150,7 @@
 		/// 
 		/// <p/>{@link HitCollector#Collect(int,float)} is called for every matching
 		/// document.
-		/// <br>HitCollector-based access to remote indexes is discouraged.
+		/// <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
@@ -177,7 +177,7 @@
 		/// 
 		/// <p/>{@link Collector#Collect(int)} is called for every matching
 		/// document.
-		/// <br>Collector-based access to remote indexes is discouraged.
+		/// <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

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Similarity.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Similarity.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Similarity.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Similarity.cs Mon Dec 14 19:05:31 2009
@@ -78,7 +78,7 @@
 	/// The default computation for <i>tf(t in d)</i> in
 	/// {@link Lucene.Net.Search.DefaultSimilarity#Tf(float) DefaultSimilarity} is:
 	/// 
-	/// <br>&nbsp;<br>
+	/// <br/>&nbsp;<br/>
 	/// <table cellpadding="2" cellspacing="2" border="0" align="center">
 	/// <tr>
 	/// <td valign="middle" align="right" rowspan="1">
@@ -89,7 +89,7 @@
 	/// </td>
 	/// </tr>
 	/// </table>
-	/// <br>&nbsp;<br>
+	/// <br/>&nbsp;<br/>
 	/// </li>
 	/// 
 	/// <li>
@@ -101,7 +101,7 @@
 	/// The default computation for <i>idf(t)</i> in
 	/// {@link Lucene.Net.Search.DefaultSimilarity#Idf(int, int) DefaultSimilarity} is:
 	/// 
-	/// <br>&nbsp;<br>
+	/// <br/>&nbsp;<br/>
 	/// <table cellpadding="2" cellspacing="2" border="0" align="center">
 	/// <tr>
 	/// <td valign="middle" align="right">
@@ -122,7 +122,7 @@
 	/// </td>
 	/// </tr>
 	/// </table>
-	/// <br>&nbsp;<br>
+	/// <br/>&nbsp;<br/>
 	/// </li>
 	/// 
 	/// <li>
@@ -134,7 +134,7 @@
 	/// This is a search time factor computed in
 	/// {@link #Coord(int, int) coord(q,d)}
 	/// by the Similarity in effect at search time.
-	/// <br>&nbsp;<br>
+	/// <br/>&nbsp;<br/>
 	/// </li>
 	/// 
 	/// <li><b>
@@ -149,7 +149,7 @@
 	/// The default computation in
 	/// {@link Lucene.Net.Search.DefaultSimilarity#QueryNorm(float) DefaultSimilarity}
 	/// is:
-	/// <br>&nbsp;<br>
+	/// <br/>&nbsp;<br/>
 	/// <table cellpadding="1" cellspacing="0" border="0" align="center">
 	/// <tr>
 	/// <td valign="middle" align="right" rowspan="1">
@@ -168,14 +168,14 @@
 	/// </td>
 	/// </tr>
 	/// </table>
-	/// <br>&nbsp;<br>
+	/// <br/>&nbsp;<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}
 	/// computes this value as:
 	/// 
-	/// <br>&nbsp;<br>
+	/// <br/>&nbsp;<br/>
 	/// <table cellpadding="1" cellspacing="0" border="0"n align="center">
 	/// <tr>
 	/// <td valign="middle" align="right" rowspan="1">
@@ -199,7 +199,7 @@
 	/// <td></td>
 	/// </tr>
 	/// </table>
-	/// <br>&nbsp;<br>
+	/// <br/>&nbsp;<br/>
 	/// 
 	/// </li>
 	/// 
@@ -216,7 +216,7 @@
 	/// {@link Lucene.Net.Search.TermQuery TermQuery} 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()}.
-	/// <br>&nbsp;<br>
+	/// <br/>&nbsp;<br/>
 	/// </li>
 	/// 
 	/// <li>
@@ -243,7 +243,7 @@
 	/// When a document is added to the index, all the above factors are multiplied.
 	/// If the document has multiple fields with the same name, all their boosts are multiplied together:
 	/// 
-	/// <br>&nbsp;<br>
+	/// <br/>&nbsp;<br/>
 	/// <table cellpadding="1" cellspacing="0" border="0"n align="center">
 	/// <tr>
 	/// <td valign="middle" align="right" rowspan="1">
@@ -266,7 +266,7 @@
 	/// <td></td>
 	/// </tr>
 	/// </table>
-	/// <br>&nbsp;<br>
+	/// <br/>&nbsp;<br/>
 	/// However the resulted <i>norm</i> value is {@link #EncodeNorm(float) encoded} as a single byte
 	/// before being stored.
 	/// At search time, the norm byte value is read from the index
@@ -277,7 +277,7 @@
 	/// 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.
-	/// <br>&nbsp;<br>
+	/// <br/>&nbsp;<br/>
 	/// </li>
 	/// </ol>
 	/// 
@@ -496,10 +496,10 @@
 		/// <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>
+		/// then multiplies this value by {@link FieldInvertState#GetBoost()}.<p/>
 		/// 
 		/// <p/><b>WARNING</b>: This API is new and experimental and may
-		/// suddenly change.</p>
+		/// suddenly change.<p/>
 		/// 
 		/// </summary>
 		/// <param name="field">field name

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/SloppyPhraseScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/SloppyPhraseScorer.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/SloppyPhraseScorer.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/SloppyPhraseScorer.cs Mon Dec 14 19:05:31 2009
@@ -36,12 +36,12 @@
 		
 		/// <summary> Score a candidate doc for all slop-valid position-combinations (matches) 
 		/// encountered while traversing/hopping the PhrasePositions.
-		/// <br> The score contribution of a match depends on the distance: 
-		/// <br> - highest score for distance=0 (exact match).
-		/// <br> - score gets lower as distance gets higher.
-		/// <br>Example: for query "a b"~2, a document "x a b a y" can be scored twice: 
+		/// <br/> The score contribution of a match depends on the distance: 
+		/// <br/> - highest score for distance=0 (exact match).
+		/// <br/> - score gets lower as distance gets higher.
+		/// <br/>Example: for query "a b"~2, a document "x a b a y" can be scored twice: 
 		/// once for "a b" (distance=0), and once for "b a" (distance=2).
-		/// <br>Possibly not all valid combinations are encountered, because for efficiency  
+		/// <br/>Possibly not all valid combinations are encountered, because for efficiency  
 		/// we always propagate the least PhrasePosition. This allows to base on 
 		/// PriorityQueue and move forward faster. 
 		/// As result, for example, document "a b c b a"
@@ -117,14 +117,14 @@
 		
 		/// <summary> Init PhrasePositions in place.
 		/// There is a one time initialization for this scorer:
-		/// <br>- Put in repeats[] each pp that has another pp with same position in the doc.
-		/// <br>- Also mark each such pp by pp.repeats = true.
-		/// <br>Later can consult with repeats[] in termPositionsDiffer(pp), making that check efficient.
+		/// <br/>- Put in repeats[] each pp that has another pp with same position in the doc.
+		/// <br/>- Also mark each such pp by pp.repeats = true.
+		/// <br/>Later can consult with repeats[] in termPositionsDiffer(pp), making that check efficient.
 		/// In particular, this allows to score queries with no repetitions with no overhead due to this computation.
-		/// <br>- Example 1 - query with no repetitions: "ho my"~2
-		/// <br>- Example 2 - query with repetitions: "ho my my"~2
-		/// <br>- Example 3 - query with repetitions: "my ho my"~2
-		/// <br>Init per doc w/repeats in query, includes propagating some repeating pp's to avoid false phrase detection.  
+		/// <br/>- Example 1 - query with no repetitions: "ho my"~2
+		/// <br/>- Example 2 - query with repetitions: "ho my my"~2
+		/// <br/>- Example 3 - query with repetitions: "my ho my"~2
+		/// <br/>Init per doc w/repeats in query, includes propagating some repeating pp's to avoid false phrase detection.  
 		/// </summary>
 		/// <returns> end (max position), or -1 if any term ran out (i.e. done) 
 		/// </returns>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Sort.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Sort.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Sort.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Sort.cs Mon Dec 14 19:05:31 2009
@@ -30,7 +30,7 @@
 	/// 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/><code>document.add (new Field ("byNumber", Integer.toString(x), Field.Store.NO, Field.Index.NOT_ANALYZED));</code><p/>
 	/// 
 	/// 
 	/// <p/><h3>Valid Types of Values</h3>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Spans/FieldMaskingSpanQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Spans/FieldMaskingSpanQuery.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Spans/FieldMaskingSpanQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Spans/FieldMaskingSpanQuery.cs Mon Dec 14 19:05:31 2009
@@ -31,14 +31,14 @@
 	/// 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 
-	/// in this class's constructor.</p>
+	/// 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 
-	/// permitted.</p>
+	/// permitted.<p/>
 	/// 
 	/// <p/>This can be useful for denormalized relational data: for example, when 
-	/// indexing a document with conceptually many 'children': </p>
+	/// indexing a document with conceptually many 'children': <p/>
 	/// 
 	/// <pre>
 	/// teacherid: 1
@@ -62,11 +62,11 @@
 	/// </pre>
 	/// 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>
+	/// and 'jones' in position 1). <p/>
 	/// 
 	/// <p/>Note: as {@link #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>
+	/// scoring behaviour.<p/>
 	/// </summary>
 	[Serializable]
 	public class FieldMaskingSpanQuery:SpanQuery

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Spans/NearSpansOrdered.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Spans/NearSpansOrdered.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Spans/NearSpansOrdered.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Spans/NearSpansOrdered.cs Mon Dec 14 19:05:31 2009
@@ -25,9 +25,9 @@
 	/// <summary>A Spans that is formed from the ordered subspans of a SpanNearQuery
 	/// where the subspans do not overlap and have a maximum slop between them.
 	/// <p/>
-	/// The formed spans only contains minimum slop matches.<br>
+	/// The formed spans only contains minimum slop matches.<br/>
 	/// The matching slop is computed from the distance(s) between
-	/// the non overlapping matching Spans.<br>
+	/// the non overlapping matching Spans.<br/>
 	/// Successive matches are always formed from the successive Spans
 	/// of the SpanNearQuery.
 	/// <p/>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Spans/Spans.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Spans/Spans.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Spans/Spans.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Spans/Spans.cs Mon Dec 14 19:05:31 2009
@@ -63,14 +63,14 @@
 		/// this method may not be called at all for performance reasons. An ordered
 		/// SpanQuery does not lazy load, so if you have payloads in your index and
 		/// you do not want ordered SpanNearQuerys to collect payloads, you can
-		/// disable collection with a constructor option.<br>
+		/// disable collection with a constructor option.<br/>
 		/// 
 		/// Note that the return type is a collection, thus the ordering should not be relied upon.
 		/// </br>
 		/// <p/><font color="#FF0000">
 		/// WARNING: The status of the <b>Payloads</b> feature is experimental.
 		/// The APIs introduced here might change in the future and will not be
-		/// supported anymore in such a case.</font></p>
+		/// supported anymore in such a case.</font><p/>
 		/// 
 		/// </summary>
 		/// <returns> a List of byte arrays containing the data of this payload, otherwise null if isPayloadAvailable is false

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TermScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/TermScorer.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TermScorer.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TermScorer.cs Mon Dec 14 19:05:31 2009
@@ -127,7 +127,7 @@
 			return doc;
 		}
 		
-		/// <summary> Advances to the next document matching the query. <br>
+		/// <summary> Advances to the next document matching the query. <br/>
 		/// The iterator over the matching documents is buffered using
 		/// {@link TermDocs#Read(int[],int[])}.
 		/// 
@@ -142,7 +142,7 @@
 			return NextDoc() != NO_MORE_DOCS;
 		}
 		
-		/// <summary> Advances to the next document matching the query. <br>
+		/// <summary> Advances to the next document matching the query. <br/>
 		/// The iterator over the matching documents is buffered using
 		/// {@link TermDocs#Read(int[],int[])}.
 		/// 
@@ -179,7 +179,7 @@
 		}
 		
 		/// <summary> Skips to the first match beyond the current whose document number is
-		/// greater than or equal to a given target. <br>
+		/// greater than or equal to a given target. <br/>
 		/// The implementation uses {@link TermDocs#SkipTo(int)}.
 		/// 
 		/// </summary>
@@ -196,7 +196,7 @@
 		}
 		
 		/// <summary> Advances to the first match beyond the current whose document number is
-		/// greater than or equal to a given target. <br>
+		/// greater than or equal to a given target. <br/>
 		/// The implementation uses {@link TermDocs#SkipTo(int)}.
 		/// 
 		/// </summary>
@@ -232,7 +232,7 @@
 		}
 		
 		/// <summary>Returns an explanation of the score for a document.
-		/// <br>When this method is used, the {@link #Next()} method
+		/// <br/>When this method is used, the {@link #Next()} method
 		/// and the {@link #Score(HitCollector)} method should not be used.
 		/// </summary>
 		/// <param name="doc">The document number for the explanation.

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TimeLimitedCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/TimeLimitedCollector.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TimeLimitedCollector.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TimeLimitedCollector.cs Mon Dec 14 19:05:31 2009
@@ -24,7 +24,7 @@
 	/// The TimeLimitedCollector is used to timeout search requests that take longer
 	/// than the maximum allowed search time limit. After this time is exceeded, the
 	/// search thread is stopped by throwing a TimeExceeded Exception.
-	/// </p>
+	/// <p/>
 	/// 
 	/// </summary>
 	/// <deprecated> Use {@link TimeLimitingCollector} instead, which extends the new
@@ -187,7 +187,7 @@
 		/// The default timer resolution is 20 milliseconds. 
 		/// This means that a search required to take no longer than 
 		/// 800 milliseconds may be stopped after 780 to 820 milliseconds.
-		/// <br>Note that: 
+		/// <br/>Note that: 
 		/// <ul>
 		/// <li>Finer (smaller) resolution is more accurate but less efficient.</li>
 		/// <li>Setting resolution to less than 5 milliseconds will be silently modified to 5 milliseconds.</li>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TimeLimitingCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/TimeLimitingCollector.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TimeLimitingCollector.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TimeLimitingCollector.cs Mon Dec 14 19:05:31 2009
@@ -162,7 +162,7 @@
 		/// The default timer resolution is 20 milliseconds. 
 		/// This means that a search required to take no longer than 
 		/// 800 milliseconds may be stopped after 780 to 820 milliseconds.
-		/// <br>Note that: 
+		/// <br/>Note that: 
 		/// <ul>
 		/// <li>Finer (smaller) resolution is more accurate but less efficient.</li>
 		/// <li>Setting resolution to less than 5 milliseconds will be silently modified to 5 milliseconds.</li>