lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From d...@apache.org
Subject svn commit: r890338 [3/4] - in /incubator/lucene.net/trunk/C#/src/Lucene.Net: Analysis/ Analysis/Standard/ Analysis/Tokenattributes/ Document/ Index/ QueryParser/ Search/ Search/Function/ Search/Payloads/ Search/Spans/ Store/ Util/
Date Mon, 14 Dec 2009 14:13:08 GMT
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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -72,13 +72,13 @@
 	/// Clause ::= ["+", "-"] [<TERM> ":"] ( <TERM> | "(" Query ")" )
 	/// </pre>
 	/// 
-	/// <p>
+	/// <p/>
 	/// 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.
 	/// <tt>date:[6/1/2005 TO 6/4/2005]</tt> produces a range query that searches
 	/// for "date" fields between 2005-06-01 and 2005-06-04. Note that the format
@@ -88,7 +88,7 @@
 	/// 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)}
 	/// or {@link #SetDateResolution(String, DateTools.Resolution)}. The former
@@ -96,7 +96,7 @@
 	/// 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
@@ -104,14 +104,14 @@
 	/// use a different method for date conversion.
 	/// </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
+	/// <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
+	/// <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>
@@ -311,12 +311,12 @@
 		
 		
 		/// <summary> Set to <code>true</code> to allow leading wildcard characters.
-		/// <p>
+		/// <p/>
 		/// When set, <code>*</code> or <code>?</code> are allowed as 
 		/// the first character of a PrefixQuery and WildcardQuery.
 		/// Note that this can produce very slow
 		/// queries on big indexes. 
-		/// <p>
+		/// <p/>
 		/// Default: false.
 		/// </summary>
 		public virtual void  SetAllowLeadingWildcard(bool allowLeadingWildcard)
@@ -332,12 +332,12 @@
 		}
 		
 		/// <summary> Set to <code>true</code> to enable position increments in result query.
-		/// <p>
+		/// <p/>
 		/// When set, result phrase and multi-phrase queries will
 		/// be aware of position increments.
 		/// Useful when e.g. a StopFilter increases the position increment of
 		/// the token that follows an omitted token.
-		/// <p>
+		/// <p/>
 		/// Default: false.
 		/// </summary>
 		public virtual void  SetEnablePositionIncrements(bool enable)
@@ -1140,12 +1140,12 @@
 		/// parses an input term token that contains one or more wildcard
 		/// characters (? and *), but is not a prefix term token (one
 		/// that has just a single * character at the end)
-		/// <p>
+		/// <p/>
 		/// Depending on settings, prefix term may be lower-cased
 		/// automatically. It will not go through the default Analyzer,
 		/// however, since normal Analyzers are unlikely to work properly
 		/// with wildcard templates.
-		/// <p>
+		/// <p/>
 		/// Can be overridden by extending classes, to provide custom handling for
 		/// wildcard queries, which may be necessary due to missing analyzer calls.
 		/// 
@@ -1183,12 +1183,12 @@
 		/// character as its last character. Since this is a special case
 		/// of generic wildcard term, and such a query can be optimized easily,
 		/// this usually results in a different query object.
-		/// <p>
+		/// <p/>
 		/// Depending on settings, a prefix term may be lower-cased
 		/// automatically. It will not go through the default Analyzer,
 		/// however, since normal Analyzers are unlikely to work properly
 		/// with wildcard templates.
-		/// <p>
+		/// <p/>
 		/// Can be overridden by extending classes, to provide custom handling for
 		/// wild card queries, which may be necessary due to missing analyzer calls.
 		/// 

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -150,17 +150,17 @@
 		/// <summary> Specifies a minimum number of the optional BooleanClauses
 		/// which must be satisfied.
 		/// 
-		/// <p>
+		/// <p/>
 		/// 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>
@@ -222,7 +222,7 @@
 		/// <summary> Expert: the Weight for BooleanQuery, used to
 		/// normalize, score and explain these queries.
 		/// 
-		/// <p>NOTE: this API and implementation is subject to
+		/// <p/>NOTE: this API and implementation is subject to
 		/// change suddenly in the next release.</p>
 		/// </summary>
 		[Serializable]
@@ -475,7 +475,7 @@
 		
 		/// <summary> Expert: Indicates whether hit docs may be collected out of docid order.
 		/// 
-		/// <p>
+		/// <p/>
 		/// Background: although the contract of the Scorer class requires that
 		/// documents be iterated in order of doc id, this was not true in early
 		/// versions of Lucene. Many pieces of functionality in the current Lucene code
@@ -485,7 +485,7 @@
 		/// queries.)
 		/// </p>
 		/// 
-		/// <p>
+		/// <p/>
 		/// Specifics: By setting this option to true, docid N might be scored for a
 		/// single segment before docid N-1. Across multiple segments, docs may be
 		/// scored out of order regardless of this setting - it only applies to scoring

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -22,18 +22,18 @@
 namespace Lucene.Net.Search
 {
 	
-	/// <summary> <p>Expert: Collectors are primarily meant to be used to
+	/// <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>
 	/// 
-	/// <p>As of 2.9, this class replaces the deprecated
+	/// <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>
 	/// 
-	/// <p>Lucene's core collectors are derived from Collector.
+	/// <p/>Lucene's core collectors are derived from Collector.
 	/// Likely your application can use one of these classes, or
 	/// subclass {@link TopDocsCollector}, instead of
 	/// implementing Collector directly:
@@ -69,7 +69,7 @@
 	/// 
 	/// </ul>
 	/// 
-	/// <p>Collector decouples the score from the collected doc:
+	/// <p/>Collector decouples the score from the collected doc:
 	/// the score computation is skipped entirely if it's not
 	/// needed.  Collectors that do need the score should
 	/// implement the {@link #setScorer} method, to hold onto the
@@ -79,7 +79,7 @@
 	/// score for a single hit multiple times, you should use
 	/// {@link ScoreCachingWrappingScorer}. </p>
 	/// 
-	/// <p><b>NOTE:</b> The doc that is passed to the collect
+	/// <p/><b>NOTE:</b> The doc that is passed to the collect
 	/// method is relative to the current reader. If your
 	/// collector needs to resolve this to the docID space of the
 	/// Multi*Reader, you must re-base it by recording the
@@ -112,11 +112,11 @@
 	/// });
 	/// </pre>
 	/// 
-	/// <p>Not all collectors will need to rebase the docID.  For
+	/// <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>
 	/// 
-	/// <p><b>NOTE:</b> Prior to 2.9, Lucene silently filtered
+	/// <p/><b>NOTE:</b> Prior to 2.9, Lucene silently filtered
 	/// out hits with score <= 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
@@ -124,7 +124,7 @@
 	/// you need that behavior, use {@link
 	/// PositiveScoresOnlyCollector}.</p>
 	/// 
-	/// <p><b>NOTE:</b> This API is experimental and might change
+	/// <p/><b>NOTE:</b> This API is experimental and might change
 	/// in incompatible ways in the next release.</p>
 	/// 
 	/// </summary>
@@ -143,7 +143,7 @@
 		/// <summary> Called once for every document matching a query, with the unbased document
 		/// number.
 		/// 
-		/// <p>
+		/// <p/>
 		/// Note: This is called in an inner search loop. For good search performance,
 		/// implementations of this method should not call {@link Searcher#Doc(int)} or
 		/// {@link Lucene.Net.Index.IndexReader#Document(int)} on every hit.
@@ -166,7 +166,7 @@
 		
 		/// <summary> Returns true iff this {@link Collector} can accept documents given to
 		/// {@link #Collect(int)} out of order.
-		/// <p>
+		/// <p/>
 		/// NOTE: some collectors can work in either mode, with a more efficient
 		/// implementation for in-order docs collection. If your collector can work in
 		/// either mode, it is recommended that you create two variants of it, since

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -56,7 +56,7 @@
 		}
 		/// <summary> Indicates whether or not this Explanation models a good match.
 		/// 
-		/// <p>
+		/// <p/>
 		/// If the match status is explicitly set (i.e.: not null) this method
 		/// uses it; otherwise it defers to the superclass.
 		/// </p>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ConstantScoreRangeQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/ConstantScoreRangeQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ConstantScoreRangeQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ConstantScoreRangeQuery.cs Mon Dec 14 14:13:03 2009
@@ -23,13 +23,13 @@
 	/// <summary> A range query that returns a constant score equal to its boost for
 	/// all documents in the exclusive range of terms.
 	/// 
-	/// <p>It does not have an upper bound on the number of clauses covered in the range.
+	/// <p/>It does not have an upper bound on the number of clauses covered in the range.
 	/// 
-	/// <p>This query matches the documents looking for terms that fall into the
+	/// <p/>This query matches the documents looking for terms that fall into the
 	/// supplied range according to {@link String#compareTo(String)}. It is not intended
 	/// for numerical ranges, use {@link NumericRangeQuery} instead.
 	/// 
-	/// <p>This query is hardwired to {@link MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}.
+	/// <p/>This query is hardwired to {@link MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}.
 	/// If you want to change this, use {@link TermRangeQuery} instead.
 	/// 
 	/// </summary>

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -34,7 +34,7 @@
 		/// FieldInvertState#GetLength()} - {@link
 		/// FieldInvertState#GetNumOverlap()}.
 		/// 
-		/// <p><b>WARNING</b>: This API is new and experimental, and may suddenly
+		/// <p/><b>WARNING</b>: This API is new and experimental, and may suddenly
 		/// change.</p> 
 		/// </summary>
 		public override float ComputeNorm(System.String field, FieldInvertState state)
@@ -91,7 +91,7 @@
 		/// norm.  By default this is false, meaning overlap
 		/// tokens are counted just like non-overlap tokens.
 		/// 
-		/// <p><b>WARNING</b>: This API is new and experimental, and may suddenly
+		/// <p/><b>WARNING</b>: This API is new and experimental, and may suddenly
 		/// change.</p>
 		/// 
 		/// </summary>

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -92,7 +92,7 @@
 		/// <summary> Expert: the Weight for DisjunctionMaxQuery, used to
 		/// normalize, score and explain these queries.
 		/// 
-		/// <p>NOTE: this API and implementation is subject to
+		/// <p/>NOTE: this API and implementation is subject to
 		/// change suddenly in the next release.</p>
 		/// </summary>
 		[Serializable]

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -43,7 +43,7 @@
 		/// <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>
+		/// <p/>
 		/// After each to call to next() or skipTo()
 		/// <code>currentSumScore</code> is the total score of the current matching doc,
 		/// <code>nrMatchers</code> is the number of matching scorers,

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -56,7 +56,7 @@
 		/// <li>{@link #NO_MORE_DOCS} if the iterator has exhausted.
 		/// <li>Otherwise it should return the doc ID it is currently on.
 		/// </ul>
-		/// <p>
+		/// <p/>
 		/// <b>NOTE:</b> in 3.0, this method will become abstract.
 		/// 
 		/// </summary>
@@ -118,7 +118,7 @@
 		/// <summary> Advances to the first beyond the current whose document number is greater
 		/// than or equal to <i>target</i>. Returns the current document number or
 		/// {@link #NO_MORE_DOCS} if there are no more docs in the set.
-		/// <p>
+		/// <p/>
 		/// Behaves as if written:
 		/// 
 		/// <pre>
@@ -131,18 +131,18 @@
 		/// </pre>
 		/// 
 		/// Some implementations are considerably more efficient than that.
-		/// <p>
+		/// <p/>
 		/// <b>NOTE:</b> certain implemenations may return a different value (each
 		/// time) if called several times in a row with the same target.
-		/// <p>
+		/// <p/>
 		/// <b>NOTE:</b> this method may be called with {@value #NO_MORE_DOCS} for
 		/// efficiency by some Scorers. If your implementation cannot efficiently
 		/// determine that it should exhaust, it is recommended that you check for that
 		/// value in each call to this method.
-		/// <p>
+		/// <p/>
 		/// <b>NOTE:</b> after the iterator has exhausted you should not call this
 		/// method, as it may result in unpredicted behavior.
-		/// <p>
+		/// <p/>
 		/// <b>NOTE:</b> in 3.0 this method will become abstract, following the removal
 		/// of {@link #SkipTo(int)}.
 		/// 

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -40,7 +40,7 @@
 		
 		/// <summary> Indicates whether or not this Explanation models a good match.
 		/// 
-		/// <p>
+		/// <p/>
 		/// By default, an Explanation represents a "match" if the value is positive.
 		/// </p>
 		/// </summary>

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -28,7 +28,7 @@
 	
 	/// <summary> Expert: Maintains caches of term values.
 	/// 
-	/// <p>Created: May 19, 2004 11:13:14 AM
+	/// <p/>Created: May 19, 2004 11:13:14 AM
 	/// 
 	/// </summary>
 	/// <since>   lucene 1.4
@@ -84,7 +84,7 @@
 	}
 	/// <summary> EXPERT: A unique Identifier/Description for each item in the FieldCache. 
 	/// Can be useful for logging/debugging.
-	/// <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 
@@ -633,13 +633,13 @@
 		
 		/// <summary> EXPERT: Generates an array of CacheEntry objects representing all items 
 		/// currently in the FieldCache.
-		/// <p>
+		/// <p/>
 		/// NOTE: These CacheEntry objects maintain a strong refrence to the 
 		/// 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 
@@ -648,7 +648,7 @@
 		/// </summary>
 		CacheEntry[] GetCacheEntries();
 		
-		/// <summary> <p>
+		/// <summary> <p/>
 		/// EXPERT: Instructs the FieldCache to forcibly expunge all entries 
 		/// from the underlying caches.  This is intended only to be used for 
 		/// test methods as a way to ensure a known base state of the Cache 
@@ -656,7 +656,7 @@
 		/// 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 

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCacheImpl.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FieldCacheImpl.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCacheImpl.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCacheImpl.cs Mon Dec 14 14:13:03 2009
@@ -31,7 +31,7 @@
 	/// <summary> Expert: The default cache implementation, storing all values in memory.
 	/// A WeakHashMap is used for storage.
 	/// 
-	/// <p>Created: May 19, 2004 4:40:36 PM
+	/// <p/>Created: May 19, 2004 4:40:36 PM
 	/// 
 	/// </summary>
 	/// <since>   lucene 1.4

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCacheRangeFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FieldCacheRangeFilter.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCacheRangeFilter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCacheRangeFilter.cs Mon Dec 14 14:13:03 2009
@@ -27,11 +27,11 @@
 	
 	/// <summary> A range filter built on top of a cached single term field (in {@link FieldCache}).
 	/// 
-	/// <p>FieldCacheRangeFilter builds a single cache for the field the first time it is used.
+	/// <p/>FieldCacheRangeFilter builds a single cache for the field the first time it is used.
 	/// Each subsequent FieldCacheRangeFilter on the same field then reuses this cache,
 	/// even if the range itself changes. 
 	/// 
-	/// <p>This means that FieldCacheRangeFilter is much faster (sometimes more than 100x as fast) 
+	/// <p/>This means that FieldCacheRangeFilter is much faster (sometimes more than 100x as fast) 
 	/// as building a {@link TermRangeFilter} (or {@link ConstantScoreRangeQuery} on a {@link TermRangeFilter})
 	/// for each query, if using a {@link #newStringRange}. However, if the range never changes it
 	/// is slower (around 2x as slow) than building a CachingWrapperFilter on top of a single TermRangeFilter.
@@ -40,16 +40,16 @@
 	/// Furthermore, it does not need the numeric values encoded by {@link NumericField}. But
 	/// it has the problem that it only works with exact one value/document (see below).
 	/// 
-	/// <p>As with all {@link FieldCache} based functionality, FieldCacheRangeFilter is only valid for 
+	/// <p/>As with all {@link FieldCache} based functionality, FieldCacheRangeFilter is only valid for 
 	/// fields which exact one term for each document (except for {@link #newStringRange}
 	/// where 0 terms are also allowed). Due to a restriction of {@link FieldCache}, for numeric ranges
 	/// all terms that do not have a numeric value, 0 is assumed.
 	/// 
-	/// <p>Thus it works on dates, prices and other single value fields but will not work on
+	/// <p/>Thus it works on dates, prices and other single value fields but will not work on
 	/// regular text fields. It is preferable to use a <code>NOT_ANALYZED</code> field to ensure that
 	/// there is only a single term. 
 	/// 
-	/// <p>This class does not have an constructor, use one of the static factory methods available,
+	/// <p/>This class does not have an constructor, use one of the static factory methods available,
 	/// that create a correct instance for different data types supported by {@link FieldCache}.
 	/// </summary>
 	

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -34,7 +34,7 @@
 	/// TopFieldCollector}.  The concrete public FieldComparator
 	/// classes here correspond to the SortField types.
 	/// 
-	/// <p>This API is designed to achieve high performance
+	/// <p/>This API is designed to achieve high performance
 	/// sorting, by exposing a tight interaction with {@link
 	/// FieldValueHitQueue} as it visits hits.  Whenever a hit is
 	/// competitive, it's enrolled into a virtual slot, which is
@@ -43,7 +43,7 @@
 	/// during searching in case any internal state it's tracking
 	/// 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>
 	/// 
@@ -1004,7 +1004,7 @@
 		/// #Compare(int,int)}} as if bottom were slot1 and the new
 		/// document were slot 2.
 		/// 
-		/// <p>For a search that hits many results, this method
+		/// <p/>For a search that hits many results, this method
 		/// will be the hotspot (invoked by far the most
 		/// frequently).</p>
 		/// 

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldDoc.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FieldDoc.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldDoc.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldDoc.cs Mon Dec 14 14:13:03 2009
@@ -32,7 +32,7 @@
 	/// Integer, Float or String depending on the type of values
 	/// in the terms of each field.
 	/// 
-	/// <p>Created: Feb 11, 2004 1:23:38 PM
+	/// <p/>Created: Feb 11, 2004 1:23:38 PM
 	/// 
 	/// </summary>
 	/// <since>   lucene 1.4

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldDocSortedHitQueue.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FieldDocSortedHitQueue.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldDocSortedHitQueue.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldDocSortedHitQueue.cs Mon Dec 14 14:13:03 2009
@@ -25,7 +25,7 @@
 	/// <summary> Expert: Collects sorted results from Searchable's and collates them.
 	/// The elements put into this queue must be of type FieldDoc.
 	/// 
-	/// <p>Created: Feb 11, 2004 2:04:21 PM
+	/// <p/>Created: Feb 11, 2004 2:04:21 PM
 	/// 
 	/// </summary>
 	/// <since>   lucene 1.4

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldSortedHitQueue.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FieldSortedHitQueue.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldSortedHitQueue.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldSortedHitQueue.cs Mon Dec 14 14:13:03 2009
@@ -26,7 +26,7 @@
 	/// <summary> Expert: A hit queue for sorting by hits by terms in more than one field.
 	/// Uses <code>FieldCache.DEFAULT</code> for maintaining internal term lookup tables.
 	/// 
-	/// <p>Created: Dec 8, 2003 12:56:03 PM
+	/// <p/>Created: Dec 8, 2003 12:56:03 PM
 	/// 
 	/// </summary>
 	/// <since>   lucene 1.4

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldValueHitQueue.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FieldValueHitQueue.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldValueHitQueue.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldValueHitQueue.cs Mon Dec 14 14:13:03 2009
@@ -184,7 +184,7 @@
 		
 		/// <summary> Creates a hit queue sorted by the given list of fields.
 		/// 
-		/// <p><b>NOTE</b>: The instances returned by this method
+		/// <p/><b>NOTE</b>: The instances returned by this method
 		/// pre-allocate a full array of length <code>numHits</code>.
 		/// 
 		/// </summary>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Filter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Filter.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Filter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Filter.cs Mon Dec 14 14:13:03 2009
@@ -25,7 +25,7 @@
 	
 	/// <summary>Abstract base class providing a mechanism to use a subset of an index
 	/// for restriction or permission of index search results.
-	/// <p>
+	/// <p/>
 	/// <b>Note:</b> In Lucene 3.0 {@link #Bits(IndexReader)} will be removed
 	/// and {@link #GetDocIdSet(IndexReader)} will be defined as abstract.
 	/// All implementing classes must therefore implement {@link #GetDocIdSet(IndexReader)}

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FilteredQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FilteredQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FilteredQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FilteredQuery.cs Mon Dec 14 14:13:03 2009
@@ -26,11 +26,11 @@
 	
 	/// <summary> A query that applies a filter to the results of another query.
 	/// 
-	/// <p>Note: the bits are retrieved from the filter each time this
+	/// <p/>Note: the bits are retrieved from the filter each time this
 	/// query is used in a search - use a CachingWrapperFilter to avoid
 	/// regenerating the bits every time.
 	/// 
-	/// <p>Created: Apr 20, 2004 8:58:29 AM
+	/// <p/>Created: Apr 20, 2004 8:58:29 AM
 	/// 
 	/// </summary>
 	/// <since>   1.4

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FilteredTermEnum.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FilteredTermEnum.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FilteredTermEnum.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FilteredTermEnum.cs Mon Dec 14 14:13:03 2009
@@ -24,7 +24,7 @@
 {
 	
 	/// <summary>Abstract class for enumerating a subset of all terms. 
-	/// <p>Term enumerations are always ordered by Term.compareTo().  Each term in
+	/// <p/>Term enumerations are always ordered by Term.compareTo().  Each term in
 	/// the enumeration is greater than all that precede it.  
 	/// </summary>
 	public abstract class FilteredTermEnum:TermEnum

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -28,7 +28,7 @@
 	/// using <code>getBytes()</code> and makes those values 
 	/// available as other numeric types, casting as needed.
 	/// 
-	/// <p><font color="#FF0000">
+	/// <p/><font color="#FF0000">
 	/// WARNING: The status of the <b>Search.Function</b> package is experimental. 
 	/// The APIs introduced here might change in the future and will not be 
 	/// supported anymore in such a case.</font>
@@ -37,7 +37,7 @@
 	/// <seealso cref="Lucene.Net.Search.Function.FieldCacheSource for requirements">
 	/// on the field. 
 	/// 
-	/// <p><b>NOTE</b>: with the switch in 2.9 to segment-based
+	/// <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
 	/// searching, if {@link #getValues} is invoked with a
 	/// composite (multi-segment) reader, this can easily cause
 	/// double RAM usage for the values in the FieldCache.  It's

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/CustomScoreQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/CustomScoreQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/CustomScoreQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/CustomScoreQuery.cs Mon Dec 14 14:13:03 2009
@@ -39,7 +39,7 @@
 	/// </ol>
 	/// Subclasses can modify the computation by overriding {@link #CustomScore(int, float, float)}.
 	/// 
-	/// <p><font color="#FF0000">
+	/// <p/><font color="#FF0000">
 	/// WARNING: The status of the <b>Search.Function</b> package is experimental. 
 	/// The APIs introduced here might change in the future and will not be 
 	/// supported anymore in such a case.</font>
@@ -172,16 +172,16 @@
 		
 		/// <summary> Compute a custom score by the subQuery score and a number of 
 		/// ValueSourceQuery scores.
-		/// <p> 
+		/// <p/> 
 		/// Subclasses can override this method to modify the custom score.  
-		/// <p>
+		/// <p/>
 		/// If your custom scoring is different than the default herein you 
 		/// should override at least one of the two customScore() methods.
 		/// If the number of ValueSourceQueries is always &lt; 2 it is 
 		/// sufficient to override the other 
 		/// {@link #CustomScore(int, float, float) customScore()} 
 		/// method, which is simpler. 
-		/// <p>
+		/// <p/>
 		/// The default computation herein is a multiplication of given scores:
 		/// <pre>
 		/// ModifiedScore = valSrcScore * valSrcScores[0] * valSrcScores[1] * ...
@@ -215,14 +215,14 @@
 		}
 		
 		/// <summary> Compute a custom score by the subQuery score and the ValueSourceQuery score.
-		/// <p> 
+		/// <p/> 
 		/// Subclasses can override this method to modify the custom score.
-		/// <p>
+		/// <p/>
 		/// If your custom scoring is different than the default herein you 
 		/// should override at least one of the two customScore() methods.
 		/// If the number of ValueSourceQueries is always &lt; 2 it is 
 		/// sufficient to override this customScore() method, which is simpler. 
-		/// <p>
+		/// <p/>
 		/// The default computation herein is a multiplication of the two scores:
 		/// <pre>
 		/// ModifiedScore = subQueryScore * valSrcScore
@@ -587,7 +587,7 @@
 		/// This may be useful when one wants full control over how scores are modified, and does 
 		/// not care about normalizing by the ValueSource part.
 		/// One particular case where this is useful if for testing this query.   
-		/// <P>
+		/// <p/>
 		/// Note: only has effect when the ValueSource part is not null.
 		/// </summary>
 		public virtual bool IsStrict()

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -27,7 +27,7 @@
 	/// {@link Lucene.Net.Search.Function.ValueSource ValueSuorce} 
 	/// for a particular field and reader.
 	/// 
-	/// <p><font color="#FF0000">
+	/// <p/><font color="#FF0000">
 	/// WARNING: The status of the <b>Search.Function</b> package is experimental. 
 	/// The APIs introduced here might change in the future and will not be 
 	/// supported anymore in such a case.</font>
@@ -46,14 +46,14 @@
 		*/
 		
 		/// <summary> Return doc value as a float. 
-		/// <P>Mandatory: every DocValues implementation must implement at least this method. 
+		/// <p/>Mandatory: every DocValues implementation must implement at least this method. 
 		/// </summary>
 		/// <param name="doc">document whose float value is requested. 
 		/// </param>
 		public abstract float FloatVal(int doc);
 		
 		/// <summary> Return doc value as an int. 
-		/// <P>Optional: DocValues implementation can (but don't have to) override this method. 
+		/// <p/>Optional: DocValues implementation can (but don't have to) override this method. 
 		/// </summary>
 		/// <param name="doc">document whose int value is requested.
 		/// </param>
@@ -63,7 +63,7 @@
 		}
 		
 		/// <summary> Return doc value as a long. 
-		/// <P>Optional: DocValues implementation can (but don't have to) override this method. 
+		/// <p/>Optional: DocValues implementation can (but don't have to) override this method. 
 		/// </summary>
 		/// <param name="doc">document whose long value is requested.
 		/// </param>
@@ -73,7 +73,7 @@
 		}
 		
 		/// <summary> Return doc value as a double. 
-		/// <P>Optional: DocValues implementation can (but don't have to) override this method. 
+		/// <p/>Optional: DocValues implementation can (but don't have to) override this method. 
 		/// </summary>
 		/// <param name="doc">document whose double value is requested.
 		/// </param>
@@ -83,7 +83,7 @@
 		}
 		
 		/// <summary> Return doc value as a string. 
-		/// <P>Optional: DocValues implementation can (but don't have to) override this method. 
+		/// <p/>Optional: DocValues implementation can (but don't have to) override this method. 
 		/// </summary>
 		/// <param name="doc">document whose string value is requested.
 		/// </param>
@@ -102,7 +102,7 @@
 		}
 		
 		/// <summary> Expert: for test purposes only, return the inner array of values, or null if not applicable.
-		/// <p>
+		/// <p/>
 		/// Allows tests to verify that loaded values are:
 		/// <ol>
 		/// <li>indeed cached/reused.</li>
@@ -154,7 +154,7 @@
 		
 		/// <summary> Returns the minimum of all values or <code>Float.NaN</code> if this
 		/// DocValues instance does not contain any value.
-		/// <p>
+		/// <p/>
 		/// This operation is optional
 		/// </p>
 		/// 
@@ -170,7 +170,7 @@
 		
 		/// <summary> Returns the maximum of all values or <code>Float.NaN</code> if this
 		/// DocValues instance does not contain any value.
-		/// <p>
+		/// <p/>
 		/// This operation is optional
 		/// </p>
 		/// 
@@ -186,7 +186,7 @@
 		
 		/// <summary> Returns the average of all values or <code>Float.NaN</code> if this
 		/// DocValues instance does not contain any value. *
-		/// <p>
+		/// <p/>
 		/// This operation is optional
 		/// </p>
 		/// 

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -25,21 +25,21 @@
 	
 	/// <summary> Expert: A base class for ValueSource implementations that retrieve values for
 	/// a single field from the {@link Lucene.Net.Search.FieldCache FieldCache}.
-	/// <p>
+	/// <p/>
 	/// Fields used herein nust be indexed (doesn't matter if these fields are stored or not).
-	/// <p> 
+	/// <p/> 
 	/// It is assumed that each such indexed field is untokenized, or at least has a single token in a document.
 	/// For documents with multiple tokens of the same field, behavior is undefined (It is likely that current 
 	/// code would use the value of one of these tokens, but this is not guaranteed).
-	/// <p>
+	/// <p/>
 	/// Document with no tokens in this field are assigned the <code>Zero</code> value.    
 	/// 
-	/// <p><font color="#FF0000">
+	/// <p/><font color="#FF0000">
 	/// WARNING: The status of the <b>Search.Function</b> package is experimental. 
 	/// The APIs introduced here might change in the future and will not be 
 	/// supported anymore in such a case.</font>
 	/// 
-	/// <p><b>NOTE</b>: with the switch in 2.9 to segment-based
+	/// <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
 	/// searching, if {@link #getValues} is invoked with a
 	/// composite (multi-segment) reader, this can easily cause
 	/// double RAM usage for the values in the FieldCache.  It's

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FieldScoreQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/FieldScoreQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FieldScoreQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FieldScoreQuery.cs Mon Dec 14 14:13:03 2009
@@ -21,10 +21,10 @@
 {
 	
 	/// <summary> A query that scores each document as the value of the numeric input field.
-	/// <p> 
+	/// <p/> 
 	/// The query matches all documents, and scores each document according to the numeric 
 	/// value of that field. 
-	/// <p>
+	/// <p/>
 	/// It is assumed, and expected, that:
 	/// <ul>
 	/// <li>The field used here is indexed, and has exactly 
@@ -32,12 +32,12 @@
 	/// <li>Best if this field is un_tokenized.</li>
 	/// <li>That token is parsable to the selected type.</li>
 	/// </ul>
-	/// <p>  
+	/// <p/>  
 	/// Combining this query in a FunctionQuery allows much freedom in affecting document scores.
 	/// Note, that with this freedom comes responsibility: it is more than likely that the
 	/// default Lucene scoring is superior in quality to scoring modified as explained here.
 	/// However, in some cases, and certainly for research experiments, this capability may turn useful.
-	/// <p>
+	/// <p/>
 	/// When contructing this query, select the appropriate type. That type should match the data stored in the
 	/// field. So in fact the "right" type should be selected before indexing. Type selection
 	/// has effect on the RAM usage: 
@@ -47,14 +47,14 @@
 	/// <li>{@link Type#INT} consumes 4 * maxDocs bytes.</li>
 	/// <li>{@link Type#FLOAT} consumes 8 * maxDocs bytes.</li>
 	/// </ul>
-	/// <p>
+	/// <p/>
 	/// <b>Caching:</b>
 	/// Values for the numeric field are loaded once and cached in memory for further use with the same IndexReader. 
 	/// To take advantage of this, it is extremely important to reuse index-readers or index-searchers, 
 	/// otherwise, for instance if for each query a new index reader is opened, large penalties would be 
 	/// paid for loading the field values into memory over and over again!
 	/// 
-	/// <p><font color="#FF0000">
+	/// <p/><font color="#FF0000">
 	/// WARNING: The status of the <b>Search.Function</b> package is experimental. 
 	/// The APIs introduced here might change in the future and will not be 
 	/// supported anymore in such a case.</font>
@@ -64,7 +64,7 @@
 	{
 		
 		/// <summary> Type of score field, indicating how field values are interpreted/parsed.  
-		/// <p>
+		/// <p/>
 		/// The type selected at search search time should match the data stored in the field. 
 		/// Different types have different RAM requirements: 
 		/// <ul>
@@ -102,7 +102,7 @@
 		}
 		
 		/// <summary> Create a FieldScoreQuery - a query that scores each document as the value of the numeric input field.
-		/// <p>
+		/// <p/>
 		/// The <code>type</code> param tells how to parse the field string values into a numeric score value.
 		/// </summary>
 		/// <param name="field">the numeric field to be used.

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -28,7 +28,7 @@
 	/// using <code>getFloats()</code> and makes those values 
 	/// available as other numeric types, casting as needed.
 	/// 
-	/// <p><font color="#FF0000">
+	/// <p/><font color="#FF0000">
 	/// WARNING: The status of the <b>Search.Function</b> package is experimental. 
 	/// The APIs introduced here might change in the future and will not be 
 	/// supported anymore in such a case.</font>
@@ -37,7 +37,7 @@
 	/// <seealso cref="Lucene.Net.Search.Function.FieldCacheSource for requirements">
 	/// on the field.
 	/// 
-	/// <p><b>NOTE</b>: with the switch in 2.9 to segment-based
+	/// <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
 	/// searching, if {@link #getValues} is invoked with a
 	/// composite (multi-segment) reader, this can easily cause
 	/// double RAM usage for the values in the FieldCache.  It's

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -28,7 +28,7 @@
 	/// using <code>getInts()</code> and makes those values 
 	/// available as other numeric types, casting as needed.
 	/// 
-	/// <p><font color="#FF0000">
+	/// <p/><font color="#FF0000">
 	/// WARNING: The status of the <b>Search.Function</b> package is experimental. 
 	/// The APIs introduced here might change in the future and will not be 
 	/// supported anymore in such a case.</font>
@@ -37,7 +37,7 @@
 	/// <seealso cref="Lucene.Net.Search.Function.FieldCacheSource for requirements">
 	/// on the field.
 	/// 
-	/// <p><b>NOTE</b>: with the switch in 2.9 to segment-based
+	/// <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
 	/// searching, if {@link #getValues} is invoked with a
 	/// composite (multi-segment) reader, this can easily cause
 	/// double RAM usage for the values in the FieldCache.  It's

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -28,7 +28,7 @@
 	/// against accidental double RAM usage in FieldCache when
 	/// a composite reader is passed to {@link #getValues}.
 	/// 
-	/// <p><b>NOTE</b>: this class adds a CPU penalty to every
+	/// <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>
 	/// 

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -25,26 +25,26 @@
 	
 	/// <summary> Expert: obtains the ordinal of the field value from the default Lucene 
 	/// {@link Lucene.Net.Search.FieldCache Fieldcache} using getStringIndex().
-	/// <p>
+	/// <p/>
 	/// 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.
-	/// <p>
+	/// <p/>
 	/// Example:
 	/// <br>If there were only three field values: "apple","banana","pear"
 	/// <br>then ord("apple")=1, ord("banana")=2, ord("pear")=3
-	/// <p>
+	/// <p/>
 	/// WARNING: 
 	/// ord() depends on the position in an index and can thus change 
 	/// when other documents are inserted or deleted,
 	/// or if a MultiSearcher is used. 
 	/// 
-	/// <p><font color="#FF0000">
+	/// <p/><font color="#FF0000">
 	/// WARNING: The status of the <b>Search.Function</b> package is experimental. 
 	/// The APIs introduced here might change in the future and will not be 
 	/// supported anymore in such a case.</font>
 	/// 
-	/// <p><b>NOTE</b>: with the switch in 2.9 to segment-based
+	/// <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
 	/// searching, if {@link #getValues} is invoked with a
 	/// composite (multi-segment) reader, this can easily cause
 	/// double RAM usage for the values in the FieldCache.  It's

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -26,26 +26,26 @@
 	/// <summary> Expert: obtains the ordinal of the field value from the default Lucene 
 	/// {@link Lucene.Net.Search.FieldCache FieldCache} using getStringIndex()
 	/// and reverses the order.
-	/// <p>
+	/// <p/>
 	/// The native lucene index order is used to assign an ordinal value for each field value.
-	/// <p>
+	/// <p/>
 	/// Field values (terms) are lexicographically ordered by unicode value, and numbered starting at 1.
 	/// <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
-	/// <p>
+	/// <p/>
 	/// WARNING: 
 	/// rord() depends on the position in an index and can thus change 
 	/// when other documents are inserted or deleted,
 	/// or if a MultiSearcher is used. 
 	/// 
-	/// <p><font color="#FF0000">
+	/// <p/><font color="#FF0000">
 	/// WARNING: The status of the <b>Search.Function</b> package is experimental. 
 	/// The APIs introduced here might change in the future and will not be 
 	/// supported anymore in such a case.</font>
 	/// 
-	/// <p><b>NOTE</b>: with the switch in 2.9 to segment-based
+	/// <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
 	/// searching, if {@link #getValues} is invoked with a
 	/// composite (multi-segment) reader, this can easily cause
 	/// double RAM usage for the values in the FieldCache.  It's

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -28,7 +28,7 @@
 	/// using <code>getShorts()</code> and makes those values 
 	/// available as other numeric types, casting as needed.
 	/// 
-	/// <p><font color="#FF0000">
+	/// <p/><font color="#FF0000">
 	/// WARNING: The status of the <b>Search.Function</b> package is experimental. 
 	/// The APIs introduced here might change in the future and will not be 
 	/// supported anymore in such a case.</font>
@@ -37,7 +37,7 @@
 	/// <seealso cref="Lucene.Net.Search.Function.FieldCacheSource for requirements">
 	/// on the field.
 	/// 
-	/// <p><b>NOTE</b>: with the switch in 2.9 to segment-based
+	/// <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
 	/// searching, if {@link #getValues} is invoked with a
 	/// composite (multi-segment) reader, this can easily cause
 	/// double RAM usage for the values in the FieldCache.  It's

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ValueSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/ValueSource.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ValueSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ValueSource.cs Mon Dec 14 14:13:03 2009
@@ -23,13 +23,13 @@
 {
 	
 	/// <summary> Expert: source of values for basic function queries.
-	/// <P>At its default/simplest form, values - one per doc - are used as the score of that doc.
-	/// <P>Values are instantiated as 
+	/// <p/>At its default/simplest form, values - one per doc - are used as the score of that doc.
+	/// <p/>Values are instantiated as 
 	/// {@link Lucene.Net.Search.Function.DocValues DocValues} for a particular reader.
-	/// <P>ValueSource implementations differ in RAM requirements: it would always be a factor
+	/// <p/>ValueSource implementations differ in RAM requirements: it would always be a factor
 	/// of the number of documents, but for each document the number of bytes can be 1, 2, 4, or 8. 
 	/// 
-	/// <p><font color="#FF0000">
+	/// <p/><font color="#FF0000">
 	/// WARNING: The status of the <b>Search.Function</b> package is experimental. 
 	/// The APIs introduced here might change in the future and will not be 
 	/// supported anymore in such a case.</font>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ValueSourceQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/ValueSourceQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ValueSourceQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ValueSourceQuery.cs Mon Dec 14 14:13:03 2009
@@ -27,15 +27,15 @@
 	
 	/// <summary> Expert: A Query that sets the scores of document to the
 	/// values obtained from a {@link Lucene.Net.Search.Function.ValueSource ValueSource}.
-	/// <p>
+	/// <p/>
 	/// This query provides a score for <em>each and every</em> undeleted document in the index.    
-	/// <p>
+	/// <p/>
 	/// The value source can be based on a (cached) value of an indexed field, but it
 	/// can also be based on an external source, e.g. values read from an external database. 
-	/// <p>
+	/// <p/>
 	/// Score is set as: Score(doc,query) = query.getBoost()<sup>2</sup> * valueSource(doc).  
 	/// 
-	/// <p><font color="#FF0000">
+	/// <p/><font color="#FF0000">
 	/// WARNING: The status of the <b>Search.Function</b> package is experimental. 
 	/// The APIs introduced here might change in the future and will not be 
 	/// supported anymore in such a case.</font>

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -26,7 +26,7 @@
 	/// <summary>Subclass of FilteredTermEnum for enumerating all terms that are similiar
 	/// to the specified filter term.
 	/// 
-	/// <p>Term enumerations are always ordered by Term.compareTo().  Each term in
+	/// <p/>Term enumerations are always ordered by Term.compareTo().  Each term in
 	/// the enumeration is greater than all that precede it.
 	/// </summary>
 	public sealed class FuzzyTermEnum:FilteredTermEnum
@@ -56,7 +56,7 @@
 		private int[] maxDistances = new int[TYPICAL_LONGEST_WORD_IN_INDEX];
 		
 		/// <summary> Creates a FuzzyTermEnum with an empty prefix and a minSimilarity of 0.5f.
-		/// <p>
+		/// <p/>
 		/// After calling the constructor the enumeration is already pointing to the first 
 		/// valid term if such a term exists. 
 		/// 
@@ -73,7 +73,7 @@
 		}
 		
 		/// <summary> Creates a FuzzyTermEnum with an empty prefix.
-		/// <p>
+		/// <p/>
 		/// After calling the constructor the enumeration is already pointing to the first 
 		/// valid term if such a term exists. 
 		/// 
@@ -94,7 +94,7 @@
 		/// <summary> Constructor for enumeration of all terms from specified <code>reader</code> which share a prefix of
 		/// length <code>prefixLength</code> with <code>term</code> and which have a fuzzy similarity &gt;
 		/// <code>minSimilarity</code>.
-		/// <p>
+		/// <p/>
 		/// After calling the constructor the enumeration is already pointing to the first 
 		/// valid term if such a term exists. 
 		/// 
@@ -184,7 +184,7 @@
 			return tmpArray;
 		}
 		
-		/// <summary> <p>Similarity returns a number that is 1.0f or less (including negative numbers)
+		/// <summary> <p/>Similarity returns a number that is 1.0f or less (including negative numbers)
 		/// based on how similar the Term is compared to a target term.  It returns
 		/// exactly 0.0f when
 		/// <pre>
@@ -196,12 +196,12 @@
 		/// prefix that are identical and editDistance is the Levenshtein distance for
 		/// the two words.</p>
 		/// 
-		/// <p>Embedded within this algorithm is a fail-fast Levenshtein distance
+		/// <p/>Embedded within this algorithm is a fail-fast Levenshtein distance
 		/// algorithm.  The fail-fast algorithm differs from the standard Levenshtein
 		/// distance algorithm in that it is aborted if it is discovered that the
 		/// mimimum distance between the words is greater than some threshold.
 		/// 
-		/// <p>To calculate the maximum distance threshold we use the following formula:
+		/// <p/>To calculate the maximum distance threshold we use the following formula:
 		/// <pre>
 		/// (1 - minimumSimilarity) * length</pre>
 		/// where length is the shortest term including any prefix that is not part of the
@@ -212,7 +212,7 @@
 		/// return (similarity > minimumSimilarity);</pre>
 		/// where distance is the Levenshtein distance for the two words.
 		/// </p>
-		/// <p>Levenshtein distance (also known as edit distance) is a measure of similiarity
+		/// <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
 		/// the other string.

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -38,7 +38,7 @@
 		/// <summary>Called once for every document matching a query, with the document
 		/// number and its raw score.
 		/// 
-		/// <P>If, for example, an application wished to collect all of the hits for a
+		/// <p/>If, for example, an application wished to collect all of the hits for a
 		/// query in a BitSet, then it might:<pre>
 		/// Searcher searcher = new IndexSearcher(indexReader);
 		/// final BitSet bits = new BitSet(indexReader.maxDoc());
@@ -49,13 +49,13 @@
 		/// });
 		/// </pre>
 		/// 
-		/// <p>Note: This is called in an inner search loop.  For good search
+		/// <p/>Note: This is called in an inner search loop.  For good search
 		/// performance, implementations of this method should not call
 		/// {@link Searcher#Doc(int)} or
 		/// {@link Lucene.Net.Index.IndexReader#Document(int)} on every
 		/// document number encountered.  Doing so can slow searches by an order
 		/// of magnitude or more.
-		/// <p>Note: The <code>score</code> passed to this method is a raw score.
+		/// <p/>Note: The <code>score</code> 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>

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -56,7 +56,7 @@
 		/// }
 		/// </pre>
 		/// 
-		/// <p><b>NOTE</b>: This class pre-allocate a full array of
+		/// <p/><b>NOTE</b>: This class pre-allocate a full array of
 		/// length <code>size</code>.
 		/// 
 		/// </summary>

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -24,13 +24,13 @@
 {
 	
 	/// <summary> A ranked list of documents, used to hold search results.
-	/// <p>
+	/// <p/>
 	/// <b>Caution:</b> Iterate only over the hits needed. Iterating over all 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 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
 	/// {@link #Length()}. In such case,
@@ -175,7 +175,7 @@
 		}
 		
 		/// <summary>Returns the stored fields of the n<sup>th</sup> document in this set.
-		/// <p>Documents are cached, so that repeated requests for the same element may
+		/// <p/>Documents are cached, so that repeated requests for the same element may
 		/// return the same Document object.
 		/// </summary>
 		/// <throws>  CorruptIndexException if the index is corrupt </throws>
@@ -220,7 +220,7 @@
 		
 		/// <summary> Returns a {@link HitIterator} to navigate the Hits.  Each item returned
 		/// from {@link Iterator#next()} is a {@link Hit}.
-		/// <p>
+		/// <p/>
 		/// <b>Caution:</b> Iterate only over the hits needed.  Iterating over all
 		/// hits is generally not desirable and may be the source of
 		/// performance issues. If you need to iterate over many or all hits, consider

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -30,14 +30,14 @@
 	
 	/// <summary>Implements search over a single IndexReader.
 	/// 
-	/// <p>Applications usually need only call the inherited {@link #Search(Query)}
+	/// <p/>Applications usually need only call the inherited {@link #Search(Query)}
 	/// or {@link #Search(Query,Filter)} methods. For performance reasons it is 
 	/// recommended to open only one IndexSearcher and use it for all of your searches.
 	/// 
-	/// <p>Note that you can only access Hits from an IndexSearcher as long as it is
+	/// <p/>Note that you can only access Hits from an IndexSearcher as long as it is
 	/// not yet closed, otherwise an IOException will be thrown. 
 	/// 
-	/// <a name="thread-safety"></a><p><b>NOTE</b>: {@link
+	/// <a name="thread-safety"></a><p/><b>NOTE</b>: {@link
 	/// <code>IndexSearcher</code>} instances are completely
 	/// thread safe, meaning multiple threads can call any of its
 	/// methods, concurrently.  If your application requires
@@ -200,7 +200,7 @@
 		/// whether or not the fields in the returned {@link FieldDoc} instances
 		/// should be set by specifying fillFields.<br>
 		/// 
-		/// <p>
+		/// <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

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiSearcher.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/MultiSearcher.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiSearcher.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiSearcher.cs Mon Dec 14 14:13:03 2009
@@ -29,7 +29,7 @@
 	
 	/// <summary>Implements search over a set of <code>Searchables</code>.
 	/// 
-	/// <p>Applications usually need only call the inherited {@link #Search(Query)}
+	/// <p/>Applications usually need only call the inherited {@link #Search(Query)}
 	/// or {@link #Search(Query,Filter)} methods.
 	/// </summary>
 	public class MultiSearcher:Searcher

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiTermQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/MultiTermQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiTermQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiTermQuery.cs Mon Dec 14 14:13:03 2009
@@ -30,12 +30,12 @@
 	/// containing a subset of terms provided by a {@link
 	/// FilteredTermEnum} enumeration.
 	/// 
-	/// <p>This query cannot be used directly; you must subclass
+	/// <p/>This query cannot be used directly; you must subclass
 	/// it and define {@link #getEnum} to provide a {@link
 	/// FilteredTermEnum} that iterates through the terms to be
 	/// matched.
 	/// 
-	/// <p><b>NOTE</b>: if {@link #setRewriteMethod} is either
+	/// <p/><b>NOTE</b>: if {@link #setRewriteMethod} is either
 	/// {@link #CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE} or {@link
 	/// #SCORING_BOOLEAN_QUERY_REWRITE}, you may encounter a
 	/// {@link BooleanQuery.TooManyClauses} exception during
@@ -45,7 +45,7 @@
 	/// #setRewriteMethod} to {@link #CONSTANT_SCORE_FILTER_REWRITE}
 	/// prevents this.
 	/// 
-	/// <p>The recommended rewrite method is {@link
+	/// <p/>The recommended rewrite method is {@link
 	/// #CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}: it doesn't spend CPU
 	/// computing unhelpful scores, and it tries to pick the most
 	/// performant rewrite method given the query.
@@ -111,7 +111,7 @@
 		/// for that term.  Matching documents are assigned a
 		/// constant score equal to the query's boost.
 		/// 
-		/// <p> This method is faster than the BooleanQuery
+		/// <p/> This method is faster than the BooleanQuery
 		/// rewrite methods when the number of matched terms or
 		/// matched documents is non-trivial. Also, it will never
 		/// hit an errant {@link BooleanQuery.TooManyClauses}
@@ -169,7 +169,7 @@
 		/// to compute, so it's almost always better to use {@link
 		/// #CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} instead.
 		/// 
-		/// <p><b>NOTE</b>: This rewrite method will hit {@link
+		/// <p/><b>NOTE</b>: This rewrite method will hit {@link
 		/// BooleanQuery.TooManyClauses} if the number of terms
 		/// exceeds {@link BooleanQuery#getMaxClauseCount}.
 		/// 
@@ -201,7 +201,7 @@
 		/// document receives a constant score equal to the
 		/// query's boost.
 		/// 
-		/// <p><b>NOTE</b>: This rewrite method will hit {@link
+		/// <p/><b>NOTE</b>: This rewrite method will hit {@link
 		/// BooleanQuery.TooManyClauses} if the number of terms
 		/// exceeds {@link BooleanQuery#getMaxClauseCount}.
 		/// 
@@ -417,11 +417,11 @@
 		/// <summary> Expert: Return the number of unique terms visited during execution of the query.
 		/// If there are many of them, you may consider using another query type
 		/// or optimize your total term count in index.
-		/// <p>This method is not thread safe, be sure to only call it when no query is running!
+		/// <p/>This method is not thread safe, be sure to only call it when no query is running!
 		/// If you re-use the same query instance for another
 		/// search, be sure to first reset the term counter
 		/// with {@link #clearTotalNumberOfTerms}.
-		/// <p>On optimized indexes / no MultiReaders, you get the correct number of
+		/// <p/>On optimized indexes / no MultiReaders, you get the correct number of
 		/// unique terms for the whole index. Use this number to compare different queries.
 		/// For non-optimized indexes this number can also be achived in
 		/// non-constant-score mode. In constant-score mode you get the total number of

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiTermQueryWrapperFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/MultiTermQueryWrapperFilter.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiTermQueryWrapperFilter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiTermQueryWrapperFilter.cs Mon Dec 14 14:13:03 2009
@@ -28,11 +28,11 @@
 	
 	/// <summary> A wrapper for {@link MultiTermQuery}, that exposes its
 	/// functionality as a {@link Filter}.
-	/// <P>
+	/// <p/>
 	/// <code>MultiTermQueryWrapperFilter</code> is not designed to
 	/// be used by itself. Normally you subclass it to provide a Filter
 	/// counterpart for a {@link MultiTermQuery} subclass.
-	/// <P>
+	/// <p/>
 	/// For example, {@link TermRangeFilter} and {@link PrefixFilter} extend
 	/// <code>MultiTermQueryWrapperFilter</code>.
 	/// This class also provides the functionality behind
@@ -134,7 +134,7 @@
 		/// <summary> Expert: Return the number of unique terms visited during execution of the filter.
 		/// If there are many of them, you may consider using another filter type
 		/// or optimize your total term count in index.
-		/// <p>This method is not thread safe, be sure to only call it when no filter is running!
+		/// <p/>This method is not thread safe, be sure to only call it when no filter is running!
 		/// If you re-use the same filter instance for another
 		/// search, be sure to first reset the term counter
 		/// with {@link #clearTotalNumberOfTerms}.

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/NumericRangeFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/NumericRangeFilter.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/NumericRangeFilter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/NumericRangeFilter.cs Mon Dec 14 14:13:03 2009
@@ -29,7 +29,7 @@
 	/// numeric values using {@link NumericField} (expert: {@link
 	/// NumericTokenStream}).
 	/// 
-	/// <p>You create a new NumericRangeFilter with the static
+	/// <p/>You create a new NumericRangeFilter with the static
 	/// factory methods, eg:
 	/// 
 	/// <pre>
@@ -43,7 +43,7 @@
 	/// See {@link NumericRangeQuery} for details on how Lucene
 	/// indexes and searches numeric valued fields.
 	/// 
-	/// <p><font color="red"><b>NOTE:</b> This API is experimental and
+	/// <p/><font color="red"><b>NOTE:</b> This API is experimental and
 	/// might change in incompatible ways in the next
 	/// release.</font>
 	/// 

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -28,7 +28,7 @@
 namespace Lucene.Net.Search
 {
 	
-	/// <summary> <p>A {@link Query} that matches numeric values within a
+	/// <summary> <p/>A {@link Query} that matches numeric values within a
 	/// specified range.  To use this, you must first index the
 	/// numeric values using {@link NumericField} (expert: {@link
 	/// NumericTokenStream}).  If your terms are instead textual,
@@ -36,7 +36,7 @@
 	/// NumericRangeFilter} is the filter equivalent of this
 	/// query.</p>
 	/// 
-	/// <p>You create a new NumericRangeQuery with the static
+	/// <p/>You create a new NumericRangeQuery with the static
 	/// factory methods, eg:
 	/// 
 	/// <pre>
@@ -48,12 +48,12 @@
 	/// matches all documents whose float valued "weight" field
 	/// ranges from 0.3 to 0.10, inclusive.
 	/// 
-	/// <p>The performance of NumericRangeQuery is much better
+	/// <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>
 	/// 
-	/// <p>You can optionally specify a <a
+	/// <p/>You can optionally specify a <a
 	/// href="#precisionStepDesc"><code>precisionStep</code></a>
 	/// when creating this query.  This is necessary if you've
 	/// changed this configuration from its default (4) during
@@ -64,7 +64,7 @@
 	/// classes.  See <a href="#precisionStepDesc">below</a> for
 	/// details.
 	/// 
-	/// <p>This query defaults to {@linkplain
+	/// <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.
@@ -75,12 +75,12 @@
 	/// BooleanQuery rewrite methods without changing
 	/// BooleanQuery's default max clause count.
 	/// 
-	/// <p><font color="red"><b>NOTE:</b> This API is experimental and
+	/// <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>
 	/// 
-	/// <p>See the publication about <a target="_blank" href="http://www.panfmp.org">panFMP</a>,
+	/// <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>):
 	/// 
 	/// <blockquote><strong>Schindler, U, Diepenbroek, M</strong>, 2008.
@@ -89,7 +89,7 @@
 	/// <a href="http://dx.doi.org/10.1016/j.cageo.2008.02.023"
 	/// target="_blank">doi:10.1016/j.cageo.2008.02.023</a></blockquote>
 	/// 
-	/// <p><em>A quote from this paper:</em> Because Apache Lucene is a full-text
+	/// <p/><em>A quote from this paper:</em> Because Apache Lucene is a full-text
 	/// search engine and not a conventional database, it cannot handle numerical ranges
 	/// (e.g., field value is inside user defined bounds, even dates are numerical values).
 	/// We have developed an extension to Apache Lucene that stores
@@ -101,7 +101,7 @@
 	/// The center of the range is searched only with the lowest possible precision in the <em>trie</em>,
 	/// while the boundaries are matched more exactly. This reduces the number of terms dramatically.</p>
 	/// 
-	/// <p>For the variant that stores long values in 8 different precisions (each reduced by 8 bits) that
+	/// <p/>For the variant that stores long values in 8 different precisions (each reduced by 8 bits) that
 	/// uses a lowest precision of 1 byte, the index contains only a maximum of 256 distinct values in the
 	/// lowest precision. Overall, a range could consist of a theoretical maximum of
 	/// <code>7*255*2 + 255 = 3825</code> distinct terms (when there is a term for every distinct value of an
@@ -111,14 +111,14 @@
 	/// and a uniform value distribution).</p>
 	/// 
 	/// <a name="precisionStepDesc"><h3>Precision Step</h3>
-	/// <p>You can choose any <code>precisionStep</code> when encoding values.
+	/// <p/>You can choose any <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.
 	/// The formula to calculate the maximum term count is:
 	/// <pre>
 	/// n = [ (bitsPerValue/precisionStep - 1) * (2^precisionStep - 1 ) * 2 ] + (2^precisionStep - 1 )
 	/// </pre>
-	/// <p><em>(this formula is only correct, when <code>bitsPerValue/precisionStep</code> is an integer;
+	/// <p/><em>(this formula is only correct, when <code>bitsPerValue/precisionStep</code> is an integer;
 	/// in other cases, the value must be rounded up and the last summand must contain the modulo of the division as
 	/// precision step)</em>.
 	/// For longs stored using a precision step of 4, <code>n = 15*15*2 + 15 = 465</code>, and for a precision
@@ -127,7 +127,7 @@
 	/// be found out by testing. <b>Important:</b> You can index with a lower precision step value and test search speed
 	/// using a multiple of the original step value.</p>
 	/// 
-	/// <p>Good values for <code>precisionStep</code> are depending on usage and data type:
+	/// <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>.
@@ -140,7 +140,7 @@
 	/// Sorting is also possible with range query optimized fields using one of the above <code>precisionSteps</code>.
 	/// </ul>
 	/// 
-	/// <p>Comparisons of the different types of RangeQueries on an index with about 500,000 docs showed
+	/// <p/>Comparisons of the different types of RangeQueries on an index with about 500,000 docs showed
 	/// that {@link TermRangeQuery} in boolean rewrite mode (with raised {@link BooleanQuery} clause count)
 	/// took about 30-40 secs to complete, {@link TermRangeQuery} in constant score filter rewrite mode took 5 secs
 	/// and executing this class took &lt;100ms to complete (on an Opteron64 machine, Java 1.5, 8 bit
@@ -367,7 +367,7 @@
 		
 		/// <summary> Subclass of FilteredTermEnum for enumerating all terms that match the
 		/// sub-ranges for trie range queries.
-		/// <p>
+		/// <p/>
 		/// WARNING: This term enumeration is not guaranteed to be always ordered by
 		/// {@link Term#compareTo}.
 		/// The ordering depends on how {@link NumericUtils#splitLongRange} and

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ParallelMultiSearcher.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/ParallelMultiSearcher.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ParallelMultiSearcher.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ParallelMultiSearcher.cs Mon Dec 14 14:13:03 2009
@@ -26,7 +26,7 @@
 	
 	/// <summary>Implements parallel search over a set of <code>Searchables</code>.
 	/// 
-	/// <p>Applications usually need only call the inherited {@link #Search(Query)}
+	/// <p/>Applications usually need only call the inherited {@link #Search(Query)}
 	/// or {@link #Search(Query,Filter)} methods.
 	/// </summary>
 	public class ParallelMultiSearcher:MultiSearcher
@@ -196,9 +196,9 @@
 		
 		/// <summary>Lower-level search API.
 		/// 
-		/// <p>{@link Collector#Collect(int)} is called for every matching document.
+		/// <p/>{@link Collector#Collect(int)} is called for every matching document.
 		/// 
-		/// <p>Applications should only use this if they need <i>all</i> of the
+		/// <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
 		/// non-high-scoring hits.

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Payloads/BoostingTermQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Payloads/BoostingTermQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Payloads/BoostingTermQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Payloads/BoostingTermQuery.cs Mon Dec 14 14:13:03 2009
@@ -30,10 +30,10 @@
 	/// <summary> The BoostingTermQuery is very similar to the {@link Lucene.Net.Search.Spans.SpanTermQuery} except
 	/// that it factors in the value of the payload located at each of the positions where the
 	/// {@link Lucene.Net.Index.Term} occurs.
-	/// <p>
+	/// <p/>
 	/// In order to take advantage of this, you must override {@link Lucene.Net.Search.Similarity#ScorePayload(String, byte[],int,int)}
 	/// which returns 1 by default.
-	/// <p>
+	/// <p/>
 	/// Payload scores are averaged across term occurrences in the document.  
 	/// 
 	/// </summary>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Payloads/PayloadTermQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Payloads/PayloadTermQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Payloads/PayloadTermQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Payloads/PayloadTermQuery.cs Mon Dec 14 14:13:03 2009
@@ -38,11 +38,11 @@
 	/// {@link Lucene.Net.Search.Spans.SpanTermQuery} except that it factors
 	/// in the value of the payload located at each of the positions where the
 	/// {@link Lucene.Net.Index.Term} occurs.
-	/// <p>
+	/// <p/>
 	/// In order to take advantage of this, you must override
 	/// {@link Lucene.Net.Search.Similarity#ScorePayload(String, byte[],int,int)}
 	/// which returns 1 by default.
-	/// <p>
+	/// <p/>
 	/// Payload scores are aggregated using a pluggable {@link PayloadFunction}.
 	/// 
 	/// </summary>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/PhraseQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/PhraseQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/PhraseQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/PhraseQuery.cs Mon Dec 14 14:13:03 2009
@@ -29,7 +29,7 @@
 	/// <summary>A Query that matches documents containing a particular sequence of terms.
 	/// A PhraseQuery is built by QueryParser for input like <code>"new york"</code>.
 	/// 
-	/// <p>This query may be combined with other terms or queries with a {@link BooleanQuery}.
+	/// <p/>This query may be combined with other terms or queries with a {@link BooleanQuery}.
 	/// </summary>
 	[Serializable]
 	public class PhraseQuery:Query
@@ -48,14 +48,14 @@
 		/// <summary>Sets the number of other words permitted between words in query phrase.
 		/// If zero, then this is an exact phrase search.  For larger values this works
 		/// like a <code>WITHIN</code> or <code>NEAR</code> operator.
-		/// <p>The slop is in fact an edit-distance, where the units correspond to
+		/// <p/>The slop is in fact an edit-distance, where the units correspond to
 		/// moves of terms in the query phrase out of position.  For example, to switch
 		/// the order of two words requires two moves (the first move places the words
 		/// atop one another), so to permit re-orderings of phrases, the slop must be
 		/// at least two.
-		/// <p>More exact matches are scored higher than sloppier matches, thus search
+		/// <p/>More exact matches are scored higher than sloppier matches, thus search
 		/// results are sorted by exactness.
-		/// <p>The slop is zero by default, requiring exact matches.
+		/// <p/>The slop is zero by default, requiring exact matches.
 		/// </summary>
 		public virtual void  SetSlop(int s)
 		{

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/PrefixQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/PrefixQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/PrefixQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/PrefixQuery.cs Mon Dec 14 14:13:03 2009
@@ -27,7 +27,7 @@
 	/// <summary>A Query that matches documents containing terms with a specified prefix. A PrefixQuery
 	/// is built by QueryParser for input like <code>app*</code>.
 	/// 
-	/// <p>This query uses the {@link
+	/// <p/>This query uses the {@link
 	/// MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}
 	/// rewrite method. 
 	/// </summary>



Mime
View raw message