lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From d...@apache.org
Subject svn commit: r890338 [4/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/Search/PrefixTermEnum.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/PrefixTermEnum.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/PrefixTermEnum.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/PrefixTermEnum.cs Mon Dec 14 14:13:03 2009
@@ -25,7 +25,7 @@
 	
 	/// <summary> Subclass of FilteredTermEnum for enumerating all terms that match the
 	/// specified prefix filter term.
-	/// <p>
+	/// <p/>
 	/// Term enumerations are always ordered by Term.compareTo().  Each term in
 	/// the enumeration is greater than all that precede it.
 	/// 

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -23,7 +23,7 @@
 {
 	
 	/// <summary>The abstract base class for queries.
-	/// <p>Instantiable subclasses are:
+	/// <p/>Instantiable subclasses are:
 	/// <ul>
 	/// <li> {@link TermQuery}
 	/// <li> {@link MultiTermQuery}
@@ -37,7 +37,7 @@
 	/// <li> {@link NumericRangeQuery}
 	/// <li> {@link Lucene.Net.Search.Spans.SpanQuery}
 	/// </ul>
-	/// <p>A parser for queries is contained in:
+	/// <p/>A parser for queries is contained in:
 	/// <ul>
 	/// <li>{@link Lucene.Net.QueryParsers.QueryParser QueryParser}
 	/// </ul>
@@ -67,7 +67,7 @@
 		
 		/// <summary>Prints a query to a string, with <code>field</code> assumed to be the 
 		/// default field and omitted.
-		/// <p>The representation used is one that is supposed to be readable
+		/// <p/>The representation used is one that is supposed to be readable
 		/// by {@link Lucene.Net.QueryParsers.QueryParser QueryParser}. However,
 		/// there are the following limitations:
 		/// <ul>
@@ -89,7 +89,7 @@
 		
 		/// <summary> Expert: Constructs an appropriate Weight implementation for this query.
 		/// 
-		/// <p>
+		/// <p/>
 		/// Only implemented by primitive queries, which re-write to themselves.
 		/// </summary>
 		public virtual Weight CreateWeight(Searcher searcher)
@@ -194,7 +194,7 @@
 		/// <summary>Expert: merges the clauses of a set of BooleanQuery's into a single
 		/// BooleanQuery.
 		/// 
-		/// <p>A utility for use by {@link #Combine(Query[])} implementations.
+		/// <p/>A utility for use by {@link #Combine(Query[])} implementations.
 		/// </summary>
 		public static Query MergeBooleanQueries(BooleanQuery[] queries)
 		{

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/QueryWrapperFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/QueryWrapperFilter.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/QueryWrapperFilter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/QueryWrapperFilter.cs Mon Dec 14 14:13:03 2009
@@ -25,7 +25,7 @@
 	/// <summary> Constrains search results to only match those which also match a provided
 	/// query.  
 	/// 
-	/// <p> This could be used, for example, with a {@link TermRangeQuery} on a suitably
+	/// <p/> This could be used, for example, with a {@link TermRangeQuery} on a suitably
 	/// formatted date field to implement date filtering.  One could re-use a single
 	/// QueryFilter that matches, e.g., only documents modified within the last
 	/// week.  The QueryFilter and TermRangeQuery would only need to be reconstructed

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/RangeFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/RangeFilter.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/RangeFilter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/RangeFilter.cs Mon Dec 14 14:13:03 2009
@@ -23,11 +23,11 @@
 	/// <summary> A Filter that restricts search results to a range of values in a given
 	/// field.
 	/// 
-	/// <p>This filter matches the documents looking for terms that fall into the
+	/// <p/>This filter matches the documents looking for terms that fall into the
 	/// supplied range according to {@link String#compareTo(String)}. It is not intended
 	/// for numerical ranges, use {@link NumericRangeFilter} instead.
 	/// 
-	/// <p>If you construct a large number of range filters with different ranges but on the 
+	/// <p/>If you construct a large number of range filters with different ranges but on the 
 	/// same field, {@link FieldCacheRangeFilter} may have significantly better performance. 
 	/// 
 	/// </summary>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/RangeQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/RangeQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/RangeQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/RangeQuery.cs Mon Dec 14 14:13:03 2009
@@ -25,11 +25,11 @@
 	
 	/// <summary> A Query that matches documents within an exclusive range of terms.
 	/// 
-	/// <p>This query matches the documents looking for terms that fall into the
+	/// <p/>This query matches the documents looking for terms that fall into the
 	/// supplied range according to {@link Term#CompareTo(Term)}. It is not intended
 	/// for numerical ranges, use {@link NumericRangeQuery} instead.
 	/// 
-	/// <p>This query uses {@linkplain
+	/// <p/>This query uses {@linkplain
 	/// MultiTermQuery#SCORING_BOOLEAN_QUERY_REWRITE}.  If you
 	/// want to change this, use the new {@link TermRangeQuery}
 	/// instead.
@@ -68,11 +68,11 @@
 		/// There must be at least one term and either term may be null,
 		/// in which case there is no bound on that side, but if there are
 		/// two terms, both terms <b>must</b> be for the same field.
-		/// <p>
+		/// <p/>
 		/// If <code>collator</code> is not null, it will be used to decide whether
 		/// index terms are within the given range, rather than using the Unicode code
 		/// point order in which index terms are stored.
-		/// <p>
+		/// <p/>
 		/// <strong>WARNING:</strong> Using this constructor and supplying a non-null
 		/// value in the <code>collator</code> parameter will cause every single 
 		/// index Term in the Field referenced by lowerTerm and/or upperTerm to be

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -22,7 +22,7 @@
 	
 	/// <summary> Expert: Compares two ScoreDoc objects for sorting.
 	/// 
-	/// <p>Created: Feb 3, 2004 9:00:16 AM 
+	/// <p/>Created: Feb 3, 2004 9:00:16 AM 
 	/// 
 	/// </summary>
 	/// <since>   lucene 1.4

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -22,16 +22,16 @@
 	
 	/// <summary> Expert: Common scoring functionality for different types of queries.
 	/// 
-	/// <p>
+	/// <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><b>NOTE</b>: The values Float.Nan,
+	/// <p/><b>NOTE</b>: The values Float.Nan,
 	/// Float.NEGATIVE_INFINITY and Float.POSITIVE_INFINITY are
 	/// not valid scores.  Certain collectors (eg {@link
 	/// TopScoreDocCollector}) will not properly collect hits

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -27,12 +27,12 @@
 	
 	/// <summary> The interface for search implementations.
 	/// 
-	/// <p>
+	/// <p/>
 	/// Searchable is the abstract network protocol for searching. Implementations
 	/// provide search over a single index, over multiple indices, and over indices
 	/// on remote servers.
 	/// 
-	/// <p>
+	/// <p/>
 	/// Queries, filters and sort criteria are designed to be compact so that they
 	/// may be efficiently passed to a remote index, with only the top-scoring hits
 	/// being returned, rather than every matching hit.
@@ -46,11 +46,11 @@
 		
 		/// <summary>Lower-level search API.
 		/// 
-		/// <p>{@link HitCollector#Collect(int,float)} is called for every non-zero
+		/// <p/>{@link HitCollector#Collect(int,float)} is called for every non-zero
 		/// scoring document.
 		/// <br>HitCollector-based access to remote indexes is discouraged.
 		/// 
-		/// <p>Applications should only use this if they need <i>all</i> of the
+		/// <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.
@@ -70,11 +70,11 @@
 		
 		/// <summary> Lower-level search API.
 		/// 
-		/// <p>
+		/// <p/>
 		/// {@link Collector#Collect(int)} is called for every document. <br>
 		/// Collector-based access to remote indexes is discouraged.
 		/// 
-		/// <p>
+		/// <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.
@@ -118,9 +118,9 @@
 		/// <summary>Expert: Low-level search implementation.  Finds the top <code>n</code>
 		/// hits for <code>query</code>, applying <code>filter</code> if non-null.
 		/// 
-		/// <p>Called by {@link Hits}.
+		/// <p/>Called by {@link Hits}.
 		/// 
-		/// <p>Applications should usually call {@link Searcher#Search(Query)} or
+		/// <p/>Applications should usually call {@link Searcher#Search(Query)} or
 		/// {@link Searcher#Search(Query,Filter)} instead.
 		/// </summary>
 		/// <throws>  BooleanQuery.TooManyClauses </throws>
@@ -174,11 +174,11 @@
 		/// Returns an Explanation that describes how <code>doc</code> scored against
 		/// <code>weight</code>.
 		/// 
-		/// <p>This is intended to be used in developing Similarity implementations,
+		/// <p/>This is intended to be used in developing Similarity implementations,
 		/// and, for good performance, should not be displayed with every hit.
 		/// Computing an explanation is as expensive as executing the query over the
 		/// entire index.
-		/// <p>Applications should call {@link Searcher#Explain(Query, int)}.
+		/// <p/>Applications should call {@link Searcher#Explain(Query, int)}.
 		/// </summary>
 		/// <throws>  BooleanQuery.TooManyClauses </throws>
 		Explanation Explain(Weight weight, int doc);
@@ -188,7 +188,7 @@
 		/// <code>filter</code> if non-null, and sorting the hits by the criteria in
 		/// <code>sort</code>.
 		/// 
-		/// <p>Applications should usually call
+		/// <p/>Applications should usually call
 		/// {@link Searcher#Search(Query,Filter,int,Sort)} instead.
 		/// 
 		/// </summary>

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -27,7 +27,7 @@
 	/// <summary> An abstract base class for search implementations. Implements the main search
 	/// methods.
 	/// 
-	/// <p>
+	/// <p/>
 	/// Note that you can only access hits from a Searcher as long as it is not yet
 	/// closed, otherwise an IOException will be thrown.
 	/// </summary>
@@ -97,7 +97,7 @@
 		/// <code>filter</code> if non-null, and sorting the hits by the criteria in
 		/// <code>sort</code>.
 		/// 
-		/// <p>NOTE: this does not compute scores by default; use
+		/// <p/>NOTE: this does not compute scores by default; use
 		/// {@link IndexSearcher#setDefaultFieldSortScoring} to enable scoring.
 		/// 
 		/// </summary>
@@ -109,14 +109,14 @@
 		
 		/// <summary>Lower-level search API.
 		/// 
-		/// <p>{@link HitCollector#Collect(int,float)} is called for every matching
+		/// <p/>{@link HitCollector#Collect(int,float)} 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.
-		/// <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>
@@ -131,12 +131,12 @@
 		
 		/// <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 matching
+		/// <p/>Applications should only use this if they need <i>all</i> of the matching
 		/// documents. The high-level search API ({@link Searcher#Search(Query, int)}
 		/// ) is usually more efficient, as it skips non-high-scoring hits.
-		/// <p>Note: The <code>score</code> passed to this method is a raw score.
+		/// <p/>Note: The <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>
@@ -148,11 +148,11 @@
 		
 		/// <summary>Lower-level search API.
 		/// 
-		/// <p>{@link HitCollector#Collect(int,float)} is called for every matching
+		/// <p/>{@link HitCollector#Collect(int,float)} is called for every matching
 		/// document.
 		/// <br>HitCollector-based access to remote indexes is discouraged.
 		/// 
-		/// <p>Applications should only use this if they need <i>all</i> of the
+		/// <p/>Applications should only use this if they need <i>all</i> of the
 		/// matching documents.  The high-level search API ({@link
 		/// Searcher#Search(Query, Filter, int)}) is usually more efficient, as it skips
 		/// non-high-scoring hits.
@@ -175,11 +175,11 @@
 		
 		/// <summary>Lower-level search API.
 		/// 
-		/// <p>{@link Collector#Collect(int)} is called for every matching
+		/// <p/>{@link Collector#Collect(int)} is called for every matching
 		/// document.
 		/// <br>Collector-based access to remote indexes is discouraged.
 		/// 
-		/// <p>Applications should only use this if they need <i>all</i> of the
+		/// <p/>Applications should only use this if they need <i>all</i> of the
 		/// matching documents.  The high-level search API ({@link
 		/// Searcher#Search(Query, Filter, int)}) is usually more efficient, as it skips
 		/// non-high-scoring hits.
@@ -220,7 +220,7 @@
 		/// <summary>Returns an Explanation that describes how <code>doc</code> scored against
 		/// <code>query</code>.
 		/// 
-		/// <p>This is intended to be used in developing Similarity implementations,
+		/// <p/>This is intended to be used in developing Similarity implementations,
 		/// and, for good performance, should not be displayed with every hit.
 		/// Computing an explanation is as expensive as executing the query over the
 		/// entire index.
@@ -245,7 +245,7 @@
 		
 		/// <summary>Expert: Return the Similarity implementation used by this Searcher.
 		/// 
-		/// <p>This defaults to the current value of {@link Similarity#GetDefault()}.
+		/// <p/>This defaults to the current value of {@link Similarity#GetDefault()}.
 		/// </summary>
 		public virtual Similarity GetSimilarity()
 		{

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -26,9 +26,9 @@
 {
 	
 	/// <summary>Expert: Scoring API.
-	/// <p>Subclasses implement search scoring.
+	/// <p/>Subclasses implement search scoring.
 	/// 
-	/// <p>The score of query <code>q</code> for document <code>d</code> correlates to the
+	/// <p/>The score of query <code>q</code> for document <code>d</code> correlates to the
 	/// cosine-distance or dot-product between document and query vectors in a
 	/// <a href="http://en.wikipedia.org/wiki/Vector_Space_Model">
 	/// Vector Space Model (VSM) of Information Retrieval</a>.
@@ -36,7 +36,7 @@
 	/// 
 	/// The score is computed as follows:
 	/// 
-	/// <P>
+	/// <p/>
 	/// <table cellpadding="1" cellspacing="0" border="1" align="center">
 	/// <tr><td>
 	/// <table cellpadding="1" cellspacing="0" border="0" align="center">
@@ -67,7 +67,7 @@
 	/// </td></tr>
 	/// </table>
 	/// 
-	/// <p> where
+	/// <p/> where
 	/// <ol>
 	/// <li>
 	/// <A NAME="formula_tf"></A>
@@ -239,7 +239,7 @@
 	/// </li>
 	/// </ul>
 	/// 
-	/// <p>
+	/// <p/>
 	/// 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:
 	/// 
@@ -456,7 +456,7 @@
 		/// <summary>Return the default Similarity implementation used by indexing and search
 		/// code.
 		/// 
-		/// <p>This is initially an instance of {@link DefaultSimilarity}.
+		/// <p/>This is initially an instance of {@link DefaultSimilarity}.
 		/// 
 		/// </summary>
 		/// <seealso cref="Searcher.SetSimilarity(Similarity)">
@@ -490,15 +490,15 @@
 		/// <summary> Compute the normalization value for a field, given the accumulated
 		/// state of term processing for this field (see {@link FieldInvertState}).
 		/// 
-		/// <p>Implementations should calculate a float value based on the field
+		/// <p/>Implementations should calculate a float value based on the field
 		/// state and then return that value.
 		/// 
-		/// <p>For backward compatibility this method by default calls
+		/// <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>
 		/// 
-		/// <p><b>WARNING</b>: This API is new and experimental and may
+		/// <p/><b>WARNING</b>: This API is new and experimental and may
 		/// suddenly change.</p>
 		/// 
 		/// </summary>
@@ -518,11 +518,11 @@
 		/// stored in an index and multipled into scores for hits on each field by the
 		/// search code.
 		/// 
-		/// <p>Matches in longer fields are less precise, so implementations of this
+		/// <p/>Matches in longer fields are less precise, so implementations of this
 		/// method usually return smaller values when <code>numTokens</code> is large,
 		/// and larger values when <code>numTokens</code> is small.
 		/// 
-		/// <p>Note that the return values are computed under 
+		/// <p/>Note that the return values are computed under 
 		/// {@link Lucene.Net.Index.IndexWriter#AddDocument(Lucene.Net.Documents.Document)} 
 		/// and then stored using
 		/// {@link #EncodeNorm(float)}.  
@@ -546,7 +546,7 @@
 		/// weights of each of the query terms.  This value is then multipled into the
 		/// weight of each query term.
 		/// 
-		/// <p>This does not affect ranking, but rather just attempts to make scores
+		/// <p/>This does not affect ranking, but rather just attempts to make scores
 		/// from different queries comparable.
 		/// 
 		/// </summary>
@@ -558,7 +558,7 @@
 		
 		/// <summary>Encodes a normalization factor for storage in an index.
 		/// 
-		/// <p>The encoding uses a three-bit mantissa, a five-bit exponent, and
+		/// <p/>The encoding uses a three-bit mantissa, a five-bit exponent, and
 		/// the zero-exponent point at 15, thus
 		/// representing values from around 7x10^9 to 2x10^-9 with about one
 		/// significant decimal digit of accuracy.  Zero is also represented.
@@ -583,12 +583,12 @@
 		/// factor for each term in the query and these products are then summed to
 		/// form the initial score for a document.
 		/// 
-		/// <p>Terms and phrases repeated in a document indicate the topic of the
+		/// <p/>Terms and phrases repeated in a document indicate the topic of the
 		/// document, so implementations of this method usually return larger values
 		/// when <code>freq</code> is large, and smaller values when <code>freq</code>
 		/// is small.
 		/// 
-		/// <p>The default implementation calls {@link #Tf(float)}.
+		/// <p/>The default implementation calls {@link #Tf(float)}.
 		/// 
 		/// </summary>
 		/// <param name="freq">the frequency of a term within a document
@@ -604,7 +604,7 @@
 		/// This value is summed for each sloppy phrase match in a document to form
 		/// the frequency that is passed to {@link #Tf(float)}.
 		/// 
-		/// <p>A phrase match with a small edit distance to a document passage more
+		/// <p/>A phrase match with a small edit distance to a document passage more
 		/// closely matches the document, so implementations of this method usually
 		/// return larger values when the edit distance is small and smaller values
 		/// when it is large.
@@ -623,7 +623,7 @@
 		/// factor for each term in the query and these products are then summed to
 		/// form the initial score for a document.
 		/// 
-		/// <p>Terms and phrases repeated in a document indicate the topic of the
+		/// <p/>Terms and phrases repeated in a document indicate the topic of the
 		/// document, so implementations of this method usually return larger values
 		/// when <code>freq</code> is large, and smaller values when <code>freq</code>
 		/// is small.
@@ -637,7 +637,7 @@
 		
 		/// <summary>Computes a score factor for a simple term.
 		/// 
-		/// <p>The default implementation is:<pre>
+		/// <p/>The default implementation is:<pre>
 		/// return idf(searcher.docFreq(term), searcher.maxDoc());
 		/// </pre>
 		/// 
@@ -664,7 +664,7 @@
 		/// <summary> Computes a score factor for a simple term and returns an explanation
 		/// for that score factor.
 		/// 
-		/// <p>
+		/// <p/>
 		/// The default implementation uses:
 		/// 
 		/// <pre>
@@ -700,7 +700,7 @@
 		
 		/// <summary>Computes a score factor for a phrase.
 		/// 
-		/// <p>The default implementation sums the {@link #Idf(Term,Searcher)} factor
+		/// <p/>The default implementation sums the {@link #Idf(Term,Searcher)} factor
 		/// for each term in the phrase.
 		/// 
 		/// </summary>
@@ -726,7 +726,7 @@
 		
 		/// <summary> Computes a score factor for a phrase.
 		/// 
-		/// <p>
+		/// <p/>
 		/// The default implementation sums the idf factor for
 		/// each term in the phrase.
 		/// 
@@ -768,7 +768,7 @@
 		/// {@link #Tf(int)} factor for each term in the query and these products are
 		/// then summed to form the initial score for a document.
 		/// 
-		/// <p>Terms that occur in fewer documents are better indicators of topic, so
+		/// <p/>Terms that occur in fewer documents are better indicators of topic, so
 		/// implementations of this method usually return larger values for rare terms,
 		/// and smaller values for common terms.
 		/// 
@@ -784,7 +784,7 @@
 		/// <summary>Computes a score factor based on the fraction of all query terms that a
 		/// document contains.  This value is multiplied into scores.
 		/// 
-		/// <p>The presence of a large portion of the query terms indicates a better
+		/// <p/>The presence of a large portion of the query terms indicates a better
 		/// match with the query, so implementations of this method usually return
 		/// larger values when the ratio between these parameters is large and smaller
 		/// values when the ratio between them is small.
@@ -804,7 +804,7 @@
 		/// <summary> Calculate a scoring factor based on the data in the payload.  Overriding implementations
 		/// are responsible for interpreting what is in the payload.  Lucene makes no assumptions about
 		/// what is in the byte array.
-		/// <p>
+		/// <p/>
 		/// The default implementation returns 1.
 		/// 
 		/// </summary>
@@ -832,7 +832,7 @@
 		/// <summary> Calculate a scoring factor based on the data in the payload.  Overriding implementations
 		/// are responsible for interpreting what is in the payload.  Lucene makes no assumptions about
 		/// what is in the byte array.
-		/// <p>
+		/// <p/>
 		/// The default implementation returns 1.
 		/// 
 		/// </summary>

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -23,24 +23,24 @@
 	
 	/// <summary> Encapsulates sort criteria for returned hits.
 	/// 
-	/// <p>The fields used to determine sort order must be carefully chosen.
+	/// <p/>The fields used to determine sort order must be carefully chosen.
 	/// Documents must contain a single term in such a field,
 	/// and the value of the term should indicate the document's relative position in
 	/// a given sort order.  The field must be indexed, but should not be tokenized,
 	/// 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>
+	/// <p/><h3>Valid Types of Values</h3>
 	/// 
-	/// <p>There are four possible kinds of term values which may be put into
+	/// <p/>There are four possible kinds of term values which may be put into
 	/// sorting fields: Integers, Longs, Floats, or Strings.  Unless
 	/// {@link SortField SortField} objects are specified, the type of value
 	/// in the field is determined by parsing the first term in the field.
 	/// 
-	/// <p>Integer term values should contain only digits and an optional
+	/// <p/>Integer term values should contain only digits and an optional
 	/// preceding negative sign.  Values must be base 10 and in the range
 	/// <code>Integer.MIN_VALUE</code> and <code>Integer.MAX_VALUE</code> inclusive.
 	/// Documents which should appear first in the sort
@@ -48,51 +48,51 @@
 	/// (i.e. the documents should be numbered <code>1..n</code> where
 	/// <code>1</code> is the first and <code>n</code> the last).
 	/// 
-	/// <p>Long term values should contain only digits and an optional
+	/// <p/>Long term values should contain only digits and an optional
 	/// preceding negative sign.  Values must be base 10 and in the range
 	/// <code>Long.MIN_VALUE</code> and <code>Long.MAX_VALUE</code> inclusive.
 	/// Documents which should appear first in the sort
 	/// should have low value integers, later documents high values.
 	/// 
-	/// <p>Float term values should conform to values accepted by
+	/// <p/>Float term values should conform to values accepted by
 	/// {@link Float Float.valueOf(String)} (except that <code>NaN</code>
 	/// and <code>Infinity</code> are not supported).
 	/// Documents which should appear first in the sort
 	/// should have low values, later documents high values.
 	/// 
-	/// <p>String term values can contain any valid String, but should
+	/// <p/>String term values can contain any valid String, but should
 	/// not be tokenized.  The values are sorted according to their
 	/// {@link Comparable natural order}.  Note that using this type
 	/// of term value has higher memory requirements than the other
 	/// two types.
 	/// 
-	/// <p><h3>Object Reuse</h3>
+	/// <p/><h3>Object Reuse</h3>
 	/// 
-	/// <p>One of these objects can be
+	/// <p/>One of these objects can be
 	/// used multiple times and the sort order changed between usages.
 	/// 
-	/// <p>This class is thread safe.
+	/// <p/>This class is thread safe.
 	/// 
-	/// <p><h3>Memory Usage</h3>
+	/// <p/><h3>Memory Usage</h3>
 	/// 
-	/// <p>Sorting uses of caches of term values maintained by the
+	/// <p/>Sorting uses of caches of term values maintained by the
 	/// internal HitQueue(s).  The cache is static and contains an integer
 	/// or float array of length <code>IndexReader.maxDoc()</code> for each field
 	/// name for which a sort is performed.  In other words, the size of the
 	/// cache in bytes is:
 	/// 
-	/// <p><code>4 * IndexReader.maxDoc() * (# of different fields actually used to sort)</code>
+	/// <p/><code>4 * IndexReader.maxDoc() * (# of different fields actually used to sort)</code>
 	/// 
-	/// <p>For String fields, the cache is larger: in addition to the
+	/// <p/>For String fields, the cache is larger: in addition to the
 	/// above array, the value of every term in the field is kept in memory.
 	/// If there are many unique terms in the field, this could
 	/// be quite large.
 	/// 
-	/// <p>Note that the size of the cache is not affected by how many
+	/// <p/>Note that the size of the cache is not affected by how many
 	/// fields are in the index and <i>might</i> be used to sort - only by
 	/// the ones actually used to sort a result set.
 	/// 
-	/// <p>Created: Feb 12, 2004 10:53:57 AM
+	/// <p/>Created: Feb 12, 2004 10:53:57 AM
 	/// 
 	/// </summary>
 	/// <since>   lucene 1.4

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/SortComparator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/SortComparator.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/SortComparator.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/SortComparator.cs Mon Dec 14 14:13:03 2009
@@ -24,7 +24,7 @@
 	
 	/// <summary> Abstract base class for sorting hits returned by a Query.
 	/// 
-	/// <p>
+	/// <p/>
 	/// This class should only be used if the other SortField types (SCORE, DOC,
 	/// STRING, INT, FLOAT) do not provide an adequate sorting. It maintains an
 	/// internal cache of values which could be quite large. The cache is an array of
@@ -40,7 +40,7 @@
 	/// instance on every call to the server, so hashCode/equals is very important in
 	/// that situation.
 	/// 
-	/// <p>
+	/// <p/>
 	/// Created: Apr 21, 2004 5:08:38 PM
 	/// 
 	/// 
@@ -104,7 +104,7 @@
 		
 		/// <summary> Returns an object which, when sorted according to natural order,
 		/// will order the Term values in the correct order.
-		/// <p>For example, if the Terms contained integer values, this method
+		/// <p/>For example, if the Terms contained integer values, this method
 		/// would return <code>new Integer(termtext)</code>.  Note that this
 		/// might not always be the most efficient implementation - for this
 		/// particular example, a better implementation might be to make a

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/SortComparatorSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/SortComparatorSource.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/SortComparatorSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/SortComparatorSource.cs Mon Dec 14 14:13:03 2009
@@ -24,7 +24,7 @@
 	
 	/// <summary> Expert: returns a comparator for sorting ScoreDocs.
 	/// 
-	/// <p>
+	/// <p/>
 	/// Created: Apr 21, 2004 3:49:28 PM
 	/// 
 	/// This class will be used as part of a key to a FieldCache value. You must

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/SortField.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/SortField.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/SortField.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/SortField.cs Mon Dec 14 14:13:03 2009
@@ -29,7 +29,7 @@
 	/// <summary> Stores information about how to sort documents by terms in an individual
 	/// field.  Fields must be indexed in order to sort by them.
 	/// 
-	/// <p>Created: Feb 11, 2004 1:25:29 PM
+	/// <p/>Created: Feb 11, 2004 1:25:29 PM
 	/// 
 	/// </summary>
 	/// <since>   lucene 1.4

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -27,17 +27,17 @@
 namespace Lucene.Net.Search.Spans
 {
 	
-	/// <summary> <p>Wrapper to allow {@link SpanQuery} objects participate in composite 
+	/// <summary> <p/>Wrapper to allow {@link SpanQuery} objects participate in composite 
 	/// single-field SpanQueries by 'lying' about their search field. That is, 
 	/// the masked SpanQuery will function as normal, 
 	/// but {@link SpanQuery#GetField()} simply hands back the value supplied 
 	/// in this class's constructor.</p>
 	/// 
-	/// <p>This can be used to support Queries like {@link SpanNearQuery} or 
+	/// <p/>This can be used to support Queries like {@link SpanNearQuery} or 
 	/// {@link SpanOrQuery} across different fields, which is not ordinarily 
 	/// permitted.</p>
 	/// 
-	/// <p>This can be useful for denormalized relational data: for example, when 
+	/// <p/>This can be useful for denormalized relational data: for example, when 
 	/// indexing a document with conceptually many 'children': </p>
 	/// 
 	/// <pre>
@@ -52,7 +52,7 @@
 	/// studentsurname: jones
 	/// </pre>
 	/// 
-	/// <p>a SpanNearQuery with a slop of 0 can be applied across two 
+	/// <p/>a SpanNearQuery with a slop of 0 can be applied across two 
 	/// {@link SpanTermQuery} objects as follows:
 	/// <pre>
 	/// SpanQuery q1  = new SpanTermQuery(new Term("studentfirstname", "james"));
@@ -64,7 +64,7 @@
 	/// teacherid 1 without matching teacherid 2 (which has a 'james' in position 0 
 	/// and 'jones' in position 1). </p>
 	/// 
-	/// <p>Note: as {@link #GetField()} returns the masked field, scoring will be 
+	/// <p/>Note: as {@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>
 	/// </summary>

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -24,13 +24,13 @@
 	
 	/// <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>
+	/// <p/>
 	/// 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>
 	/// Successive matches are always formed from the successive Spans
 	/// of the SpanNearQuery.
-	/// <p>
+	/// <p/>
 	/// The formed spans may contain overlaps when the slop is at least 1.
 	/// For example, when querying using
 	/// <pre>t1 t2 t3</pre>

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -31,8 +31,8 @@
 		public abstract bool Next();
 		
 		/// <summary>Skips to the first match beyond the current, whose document number is
-		/// greater than or equal to <i>target</i>. <p>Returns true iff there is such
-		/// a match.  <p>Behaves as if written: <pre>
+		/// greater than or equal to <i>target</i>. <p/>Returns true iff there is such
+		/// a match.  <p/>Behaves as if written: <pre>
 		/// boolean skipTo(int target) {
 		/// do {
 		/// if (!next())
@@ -67,7 +67,7 @@
 		/// 
 		/// Note that the return type is a collection, thus the ordering should not be relied upon.
 		/// </br>
-		/// <p><font color="#FF0000">
+		/// <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>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TermRangeFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/TermRangeFilter.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TermRangeFilter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TermRangeFilter.cs Mon Dec 14 14:13:03 2009
@@ -23,11 +23,11 @@
 	/// <summary> A Filter that restricts search results to a range of values in a given
 	/// field.
 	/// 
-	/// <p>This filter matches the documents looking for terms that fall into the
+	/// <p/>This filter matches the documents looking for terms that fall into the
 	/// supplied range according to {@link String#compareTo(String)}. It is not intended
 	/// for numerical ranges, use {@link NumericRangeFilter} instead.
 	/// 
-	/// <p>If you construct a large number of range filters with different ranges but on the 
+	/// <p/>If you construct a large number of range filters with different ranges but on the 
 	/// same field, {@link FieldCacheRangeFilter} may have significantly better performance. 
 	/// </summary>
 	/// <since> 2.9

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TermRangeQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/TermRangeQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TermRangeQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TermRangeQuery.cs Mon Dec 14 14:13:03 2009
@@ -25,11 +25,11 @@
 	
 	/// <summary> A Query that matches documents within an exclusive range of terms.
 	/// 
-	/// <p>This query matches the documents looking for terms that fall into the
+	/// <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 uses the {@link
+	/// <p/>This query uses the {@link
 	/// MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}
 	/// rewrite method.
 	/// </summary>
@@ -50,7 +50,7 @@
 		/// <summary> Constructs a query selecting all terms greater/equal than <code>lowerTerm</code>
 		/// but less/equal than <code>upperTerm</code>. 
 		/// 
-		/// <p>
+		/// <p/>
 		/// If an endpoint is null, it is said 
 		/// to be "open". Either or both endpoints may be open.  Open endpoints may not 
 		/// be exclusive (you can't select all but the first or last term without 
@@ -75,16 +75,16 @@
 		
 		/// <summary>Constructs a query selecting all terms greater/equal than
 		/// <code>lowerTerm</code> but less/equal than <code>upperTerm</code>.
-		/// <p>
+		/// <p/>
 		/// If an endpoint is null, it is said 
 		/// to be "open". Either or both endpoints may be open.  Open endpoints may not 
 		/// be exclusive (you can't select all but the first or last term without 
 		/// explicitly specifying the term to exclude.)
-		/// <p>
+		/// <p/>
 		/// If <code>collator</code> is not null, it will be used to decide whether
 		/// index terms are within the given range, rather than using the Unicode code
 		/// point order in which index terms are stored.
-		/// <p>
+		/// <p/>
 		/// <strong>WARNING:</strong> Using this constructor and supplying a non-null
 		/// value in the <code>collator</code> parameter will cause every single 
 		/// index Term in the Field referenced by lowerTerm and/or upperTerm to be

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

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=890338&r1=890337&r2=890338&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 14:13:03 2009
@@ -20,7 +20,7 @@
 namespace Lucene.Net.Search
 {
 	
-	/// <summary> <p>
+	/// <summary> <p/>
 	/// 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.

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TopDocCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/TopDocCollector.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TopDocCollector.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TopDocCollector.cs Mon Dec 14 14:13:03 2009
@@ -26,7 +26,7 @@
 	/// documents, returning them as a {@link TopDocs}.  This is used by {@link
 	/// IndexSearcher} to implement {@link TopDocs}-based search.
 	/// 
-	/// <p>This may be extended, overriding the collect method to, e.g.,
+	/// <p/>This may be extended, overriding the collect method to, e.g.,
 	/// conditionally invoke <code>super()</code> in order to filter which
 	/// documents are collected.
 	/// 

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TopFieldCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/TopFieldCollector.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TopFieldCollector.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TopFieldCollector.cs Mon Dec 14 14:13:03 2009
@@ -30,7 +30,7 @@
 	/// See the {@link #create(Lucene.Net.Search.Sort, int, boolean, boolean, boolean, boolean)} method
 	/// for instantiating a TopFieldCollector.
 	/// 
-	/// <p><b>NOTE:</b> This API is experimental and might change in
+	/// <p/><b>NOTE:</b> This API is experimental and might change in
 	/// incompatible ways in the next release.</p>
 	/// </summary>
 	public abstract class TopFieldCollector:TopDocsCollector
@@ -979,7 +979,7 @@
 		/// <summary> Creates a new {@link TopFieldCollector} from the given
 		/// arguments.
 		/// 
-		/// <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>.
 		/// 

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TopFieldDocCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/TopFieldDocCollector.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TopFieldDocCollector.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TopFieldDocCollector.cs Mon Dec 14 14:13:03 2009
@@ -26,7 +26,7 @@
 	/// documents, returning them as a {@link TopFieldDocs}.  This is used by {@link
 	/// IndexSearcher} to implement {@link TopFieldDocs}-based search.
 	/// 
-	/// <p>This may be extended, overriding the collect method to, e.g.,
+	/// <p/>This may be extended, overriding the collect method to, e.g.,
 	/// conditionally invoke <code>super()</code> in order to filter which
 	/// documents are collected.
 	/// 

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TopFieldDocs.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/TopFieldDocs.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TopFieldDocs.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TopFieldDocs.cs Mon Dec 14 14:13:03 2009
@@ -22,7 +22,7 @@
 	
 	/// <summary> Expert: Returned by low-level sorted search implementations.
 	/// 
-	/// <p>Created: Feb 12, 2004 8:58:46 AM 
+	/// <p/>Created: Feb 12, 2004 8:58:46 AM 
 	/// 
 	/// </summary>
 	/// <since>   lucene 1.4

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TopScoreDocCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/TopScoreDocCollector.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TopScoreDocCollector.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TopScoreDocCollector.cs Mon Dec 14 14:13:03 2009
@@ -29,7 +29,7 @@
 	/// instance of this collector you should know in advance whether documents are
 	/// going to be collected in doc Id order or not.
 	/// 
-	/// <p><b>NOTE</b>: The values Float.Nan,
+	/// <p/><b>NOTE</b>: The values Float.Nan,
 	/// Float.NEGATIVE_INFINITY and Float.POSITIVE_INFINITY are
 	/// not valid scores.  This collector will not properly
 	/// collect hits with such scores.
@@ -97,7 +97,7 @@
 		/// collect and whether documents are scored in order by the input
 		/// {@link Scorer} to {@link #SetScorer(Scorer)}.
 		/// 
-		/// <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>, and fill the array with sentinel
 		/// objects.

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Weight.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Weight.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Weight.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Weight.cs Mon Dec 14 14:13:03 2009
@@ -23,13 +23,13 @@
 {
 	
 	/// <summary> Expert: Calculate query weights and build query scorers.
-	/// <p>
+	/// <p/>
 	/// The purpose of {@link Weight} is to ensure searching does not
 	/// modify a {@link Query}, so that a {@link Query} instance can be reused. <br>
 	/// {@link Searcher} dependent state of the query should reside in the
 	/// {@link Weight}. <br>
 	/// {@link IndexReader} dependent state should reside in the {@link Scorer}.
-	/// <p>
+	/// <p/>
 	/// A <code>Weight</code> is used in the following way:
 	/// <ol>
 	/// <li>A <code>Weight</code> is constructed by a top-level query, given a
@@ -73,7 +73,7 @@
 		
 		/// <summary> Returns a {@link Scorer} which scores documents in/out-of order according
 		/// to <code>scoreDocsInOrder</code>.
-		/// <p>
+		/// <p/>
 		/// <b>NOTE:</b> even if <code>scoreDocsInOrder</code> is false, it is
 		/// recommended to check whether the returned <code>Scorer</code> indeed scores
 		/// documents out of order (i.e., call {@link #ScoresDocsOutOfOrder()}), as
@@ -113,7 +113,7 @@
 		/// {@link #Scorer(Lucene.Net.Index.IndexReader, boolean, boolean)} to
 		/// create a matching {@link Scorer} instance for a given {@link Collector}, or
 		/// vice versa.
-		/// <p>
+		/// <p/>
 		/// <b>NOTE:</b> the default implementation returns <code>false</code>, i.e.
 		/// the <code>Scorer</code> scores documents in-order.
 		/// </summary>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/WildcardQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/WildcardQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/WildcardQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/WildcardQuery.cs Mon Dec 14 14:13:03 2009
@@ -31,7 +31,7 @@
 	/// a Wildcard term should not start with one of the wildcards <code>*</code> or
 	/// <code>?</code>.
 	/// 
-	/// <p>This query uses the {@link
+	/// <p/>This query uses the {@link
 	/// MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}
 	/// rewrite method.
 	/// 

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/WildcardTermEnum.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/WildcardTermEnum.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/WildcardTermEnum.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/WildcardTermEnum.cs Mon Dec 14 14:13:03 2009
@@ -25,7 +25,7 @@
 	
 	/// <summary> Subclass of FilteredTermEnum for enumerating all terms that match the
 	/// specified wildcard filter term.
-	/// <p>
+	/// <p/>
 	/// Term enumerations are always ordered by Term.compareTo().  Each term in
 	/// the enumeration is greater than all that precede it.
 	/// 
@@ -42,7 +42,7 @@
 		internal bool endEnum = false;
 		
 		/// <summary> Creates a new <code>WildcardTermEnum</code>.
-		/// <p>
+		/// <p/>
 		/// After calling the constructor the enumeration is already pointing to the first 
 		/// valid term if such a term exists.
 		/// </summary>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/Directory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Store/Directory.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/Directory.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/Directory.cs Mon Dec 14 14:13:03 2009
@@ -26,7 +26,7 @@
 	/// are created.  Once a file is created it may only be opened for read, or
 	/// deleted.  Random access is permitted both when reading and writing.
 	/// 
-	/// <p> Java's i/o APIs not used directly, but rather all i/o is
+	/// <p/> Java's i/o APIs not used directly, but rather all i/o is
 	/// through this API.  This permits things such as: <ul>
 	/// <li> implementation of RAM-based indices;
 	/// <li> implementation indices stored in a database, via JDBC;
@@ -192,12 +192,12 @@
 		/// If a file in src already exists in dest then the
 		/// one in dest will be blindly overwritten.
 		/// 
-		/// <p><b>NOTE:</b> the source directory cannot change
+		/// <p/><b>NOTE:</b> the source directory cannot change
 		/// while this method is running.  Otherwise the results
 		/// are undefined and you could easily hit a
 		/// FileNotFoundException.
 		/// 
-		/// <p><b>NOTE:</b> this method only copies files that look
+		/// <p/><b>NOTE:</b> this method only copies files that look
 		/// like index files (ie, have extensions matching the
 		/// known extensions of index files).
 		/// 

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/FSDirectory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Store/FSDirectory.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/FSDirectory.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/FSDirectory.cs Mon Dec 14 14:13:03 2009
@@ -85,7 +85,7 @@
 	/// #open}.  For all others, you should instantiate the
 	/// desired implementation directly.
 	/// 
-	/// <p>The locking implementation is by default {@link
+	/// <p/>The locking implementation is by default {@link
 	/// NativeFSLockFactory}, but can be changed by
 	/// passing in a custom {@link LockFactory} instance.
 	/// The deprecated <code>getDirectory</code> methods default to use
@@ -101,7 +101,7 @@
 	/// SimpleFSLockFactory} (or {@link NativeFSLockFactory},
 	/// etc.) passing in your preferred lock directory.
 	/// 
-	/// <p><em>In 3.0 this class will become abstract.</em>
+	/// <p/><em>In 3.0 this class will become abstract.</em>
 	/// 
 	/// </summary>
 	/// <seealso cref="Directory">
@@ -497,13 +497,13 @@
 		/// best implementation given the current environment.
 		/// The directory returned uses the {@link NativeFSLockFactory}.
         /// 
-        /// <p>Currently this returns {@link SimpleFSDirectory} as
+        /// <p/>Currently this returns {@link SimpleFSDirectory} as
         /// NIOFSDirectory is currently not supported.
 		/// 
-		/// <p>Currently this returns {@link SimpleFSDirectory} as
+		/// <p/>Currently this returns {@link SimpleFSDirectory} as
 		/// NIOFSDirectory is currently not supported.
 		/// 
-		/// <p><b>NOTE</b>: this method may suddenly change which
+		/// <p/><b>NOTE</b>: this method may suddenly change which
 		/// implementation is returned from release to release, in
 		/// the event that higher performance defaults become
 		/// possible; if the precise implementation is important to
@@ -514,7 +514,7 @@
 		/// For optimal performance you should consider using
 		/// this implementation on 64 bit JVMs.
 		/// 
-		/// <p>See <a href="#subclasses">above</a> 
+		/// <p/>See <a href="#subclasses">above</a> 
 		/// </summary>
 		[System.Obsolete("Use the method that takes a DirectoryInfo, this will be removed in the 3.0 release")]
 		public static FSDirectory Open(System.IO.FileInfo path)
@@ -527,10 +527,10 @@
 		/// best implementation given the current environment.
 		/// The directory returned uses the {@link NativeFSLockFactory}.
 		/// 
-		/// <p>Currently this returns {@link SimpleFSDirectory} as
+		/// <p/>Currently this returns {@link SimpleFSDirectory} as
 		/// NIOFSDirectory is currently not supported.
 		/// 
-		/// <p><b>NOTE</b>: this method may suddenly change which
+		/// <p/><b>NOTE</b>: this method may suddenly change which
 		/// implementation is returned from release to release, in
 		/// the event that higher performance defaults become
 		/// possible; if the precise implementation is important to
@@ -541,7 +541,7 @@
 		/// For optimal performance you should consider using
 		/// this implementation on 64 bit JVMs.
 		/// 
-		/// <p>See <a href="#subclasses">above</a> 
+		/// <p/>See <a href="#subclasses">above</a> 
 		/// </summary>
 		public static FSDirectory Open(System.IO.DirectoryInfo path)
 		{
@@ -960,19 +960,19 @@
 		/// underlying file during {@link IndexInput#readBytes}.
 		/// The default value is {@link #DEFAULT_READ_CHUNK_SIZE};
 		/// 
-		/// <p> This was introduced due to <a
+		/// <p/> This was introduced due to <a
 		/// href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6478546">Sun
 		/// JVM Bug 6478546</a>, which throws an incorrect
 		/// OutOfMemoryError when attempting to read too many bytes
 		/// at once.  It only happens on 32bit JVMs with a large
 		/// maximum heap size.</p>
 		/// 
-		/// <p>Changes to this value will not impact any
+		/// <p/>Changes to this value will not impact any
 		/// already-opened {@link IndexInput}s.  You should call
 		/// this before attempting to open an index on the
 		/// directory.</p>
 		/// 
-		/// <p> <b>NOTE</b>: This value should be as large as
+		/// <p/> <b>NOTE</b>: This value should be as large as
 		/// possible to reduce any possible performance impact.  If
 		/// you still encounter an incorrect OutOfMemoryError,
 		/// trying lowering the chunk size.</p>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/FileSwitchDirectory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Store/FileSwitchDirectory.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/FileSwitchDirectory.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/FileSwitchDirectory.cs Mon Dec 14 14:13:03 2009
@@ -22,13 +22,13 @@
 	
 	/// <summary> Expert: A Directory instance that switches files between
 	/// two other Directory instances.
-	/// <p>Files with the specified extensions are placed in the
+	/// <p/>Files with the specified extensions are placed in the
 	/// primary directory; others are placed in the secondary
 	/// directory.  The provided Set must not change once passed
 	/// to this class, and must allow multiple threads to call
 	/// contains at once.</p>
 	/// 
-	/// <p><b>NOTE</b>: this API is new and experimental and is
+	/// <p/><b>NOTE</b>: this API is new and experimental and is
 	/// subject to suddenly change in the next release.
 	/// </summary>
 	

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/IndexInput.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Store/IndexInput.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/IndexInput.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/IndexInput.cs Mon Dec 14 14:13:03 2009
@@ -244,10 +244,10 @@
 		
 		/// <summary>Returns a clone of this stream.
 		/// 
-		/// <p>Clones of a stream access the same data, and are positioned at the same
+		/// <p/>Clones of a stream access the same data, and are positioned at the same
 		/// point as the stream they were cloned from.
 		/// 
-		/// <p>Expert: Subclasses must ensure that clones may be positioned at
+		/// <p/>Expert: Subclasses must ensure that clones may be positioned at
 		/// different points in the input from each other and from the stream they
 		/// were cloned from.
 		/// </summary>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/Lock.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Store/Lock.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/Lock.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/Lock.cs Mon Dec 14 14:13:03 2009
@@ -21,7 +21,7 @@
 {
 	
 	/// <summary>An interprocess mutex lock.
-	/// <p>Typical use might look like:<pre>
+	/// <p/>Typical use might look like:<pre>
 	/// new Lock.With(directory.makeLock("my.lock")) {
 	/// public Object doBody() {
 	/// <i>... code to execute while locked ...</i>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/LockFactory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Store/LockFactory.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/LockFactory.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/LockFactory.cs Mon Dec 14 14:13:03 2009
@@ -20,10 +20,10 @@
 namespace Lucene.Net.Store
 {
 	
-	/// <summary> <p>Base class for Locking implementation.  {@link Directory} uses
+	/// <summary> <p/>Base class for Locking implementation.  {@link Directory} uses
 	/// instances of this class to implement locking.</p>
 	/// 
-	/// <p>Note that there are some useful tools to verify that
+	/// <p/>Note that there are some useful tools to verify that
 	/// your LockFactory is working correctly: {@link
 	/// VerifyingLockFactory}, {@link LockStressTest}, {@link
 	/// LockVerifyServer}.</p>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/MMapDirectory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Store/MMapDirectory.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/MMapDirectory.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/MMapDirectory.cs Mon Dec 14 14:13:03 2009
@@ -26,7 +26,7 @@
 	/// mmap for reading, and {@link
 	/// SimpleFSDirectory.SimpleFSIndexOutput} for writing.
 	/// 
-	/// <p><b>NOTE</b>: memory mapping uses up a portion of the
+	/// <p/><b>NOTE</b>: memory mapping uses up a portion of the
 	/// virtual memory address space in your process equal to the
 	/// size of the file being mapped.  Before using this class,
 	/// be sure your have plenty of virtual address space, e.g. by
@@ -37,13 +37,13 @@
 	/// address space. If you get an OutOfMemoryException, it is recommened
 	/// to reduce the chunk size, until it works.
 	/// 
-	/// <p>Due to <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4724038">
+	/// <p/>Due to <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4724038">
 	/// this bug</a> in Sun's JRE, MMapDirectory's {@link IndexInput#close}
 	/// is unable to close the underlying OS file handle.  Only when GC
 	/// finally collects the underlying objects, which could be quite
 	/// some time later, will the file handle be closed.
 	/// 
-	/// <p>This will consume additional transient disk usage: on Windows,
+	/// <p/>This will consume additional transient disk usage: on Windows,
 	/// attempts to delete or overwrite the files will result in an
 	/// exception; on other platforms, which typically have a &quot;delete on
 	/// last close&quot; semantics, while such operations will succeed, the bytes
@@ -52,7 +52,7 @@
 	/// and you don't rely on overwriting files on Windows) but it's still
 	/// an important limitation to be aware of.
 	/// 
-	/// <p>This class supplies the workaround mentioned in the bug report
+	/// <p/>This class supplies the workaround mentioned in the bug report
 	/// (disabled by default, see {@link #setUseUnmap}), which may fail on
 	/// non-Sun JVMs. It forcefully unmaps the buffer on close by using
 	/// an undocumented internal cleanup functionality.
@@ -177,7 +177,7 @@
 		/// mentioned in the bug report. This hack may fail on non-Sun JVMs.
 		/// It forcefully unmaps the buffer on close by using
 		/// an undocumented internal cleanup functionality.
-		/// <p><b>NOTE:</b> Enabling this is completely unsupported
+		/// <p/><b>NOTE:</b> Enabling this is completely unsupported
 		/// by Java and may lead to JVM crashs if <code>IndexInput</code>
 		/// is closed while another thread is still accessing it (SIGSEGV).
 		/// </summary>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/NIOFSDirectory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Store/NIOFSDirectory.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/NIOFSDirectory.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/NIOFSDirectory.cs Mon Dec 14 14:13:03 2009
@@ -25,10 +25,10 @@
 	/// multiple threads to read from the same file without
 	/// synchronizing.
 	/// 
-	/// <p>This class only uses FileChannel when reading; writing
+	/// <p/>This class only uses FileChannel when reading; writing
 	/// is achieved with {@link SimpleFSDirectory.SimpleFSIndexOutput}.
 	/// 
-	/// <p><b>NOTE</b>: NIOFSDirectory is not recommended on Windows because of a bug
+	/// <p/><b>NOTE</b>: NIOFSDirectory is not recommended on Windows because of a bug
 	/// in how FileChannel.read is implemented in Sun's JRE.
 	/// Inside of the implementation the position is apparently
 	/// synchronized.  See <a

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/NativeFSLockFactory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Store/NativeFSLockFactory.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/NativeFSLockFactory.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/NativeFSLockFactory.cs Mon Dec 14 14:13:03 2009
@@ -20,7 +20,7 @@
 namespace Lucene.Net.Store
 {
 	
-	/// <summary> <p>Implements {@link LockFactory} using native OS file
+	/// <summary> <p/>Implements {@link LockFactory} using native OS file
 	/// locks.  Note that because this LockFactory relies on
 	/// java.nio.* APIs for locking, any problems with those APIs
 	/// will cause locking to fail.  Specifically, on certain NFS
@@ -32,16 +32,16 @@
 	/// first and work around the one limitation that a lock file
 	/// could be left when the JVM exits abnormally.</p>
 	/// 
-	/// <p>The primary benefit of {@link NativeFSLockFactory} is
+	/// <p/>The primary benefit of {@link NativeFSLockFactory} is
 	/// that lock files will be properly removed (by the OS) if
 	/// the JVM has an abnormal exit.</p>
 	/// 
-	/// <p>Note that, unlike {@link SimpleFSLockFactory}, the existence of
+	/// <p/>Note that, unlike {@link SimpleFSLockFactory}, the existence of
 	/// leftover lock files in the filesystem on exiting the JVM
 	/// is fine because the OS will free the locks held against
 	/// these files even though the files still remain.</p>
 	/// 
-	/// <p>If you suspect that this or any other LockFactory is
+	/// <p/>If you suspect that this or any other LockFactory is
 	/// not working properly in your environment, you can easily
 	/// test it by using {@link VerifyingLockFactory}, {@link
 	/// LockVerifyServer} and {@link LockStressTest}.</p>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/RAMDirectory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Store/RAMDirectory.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/RAMDirectory.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/RAMDirectory.cs Mon Dec 14 14:13:03 2009
@@ -49,9 +49,9 @@
 		/// <summary> Creates a new <code>RAMDirectory</code> instance from a different
 		/// <code>Directory</code> implementation.  This can be used to load
 		/// a disk-based index into memory.
-		/// <P>
+		/// <p/>
 		/// This should be used only with indices that can fit into memory.
-		/// <P>
+		/// <p/>
 		/// Note that the resulting <code>RAMDirectory</code> instance is fully
 		/// independent from the original <code>Directory</code> (it is a
 		/// complete copy).  Any subsequent changes to the

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/SimpleFSLockFactory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Store/SimpleFSLockFactory.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/SimpleFSLockFactory.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Store/SimpleFSLockFactory.cs Mon Dec 14 14:13:03 2009
@@ -20,10 +20,10 @@
 namespace Lucene.Net.Store
 {
 	
-	/// <summary> <p>Implements {@link LockFactory} using {@link
+	/// <summary> <p/>Implements {@link LockFactory} using {@link
 	/// File#createNewFile()}.</p>
 	/// 
-	/// <p><b>NOTE:</b> the <a target="_top"
+	/// <p/><b>NOTE:</b> the <a target="_top"
 	/// href="http://java.sun.com/j2se/1.4.2/docs/api/java/io/File.html#createNewFile()">javadocs
 	/// for <code>File.createNewFile</code></a> contain a vague
 	/// yet spooky warning about not using the API for file
@@ -32,7 +32,7 @@
 	/// bug</a>, and in fact the only known problem with using
 	/// this API for locking is that the Lucene write lock may
 	/// not be released when the JVM exits abnormally.</p>
-	/// <p>When this happens, a {@link LockObtainFailedException}
+	/// <p/>When this happens, a {@link LockObtainFailedException}
 	/// is hit when trying to create a writer, in which case you
 	/// need to explicitly clear the lock file first.  You can
 	/// either manually remove the file, or use the {@link
@@ -41,7 +41,7 @@
 	/// writing to the index otherwise you can easily corrupt
 	/// your index.</p>
 	/// 
-	/// <p>If you suspect that this or any other LockFactory is
+	/// <p/>If you suspect that this or any other LockFactory is
 	/// not working properly in your environment, you can easily
 	/// test it by using {@link VerifyingLockFactory}, {@link
 	/// LockVerifyServer} and {@link LockStressTest}.</p>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/AttributeImpl.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Util/AttributeImpl.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/AttributeImpl.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/AttributeImpl.cs Mon Dec 14 14:13:03 2009
@@ -22,7 +22,7 @@
 	
 	/// <summary> Base class for Attributes that can be added to a 
 	/// {@link Lucene.Net.Util.AttributeSource}.
-	/// <p>
+	/// <p/>
 	/// Attributes are used to add data in a dynamic, yet type-safe way to a source
 	/// of usually streamed objects, e. g. a {@link Lucene.Net.Analysis.TokenStream}.
 	/// </summary>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/AttributeSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Util/AttributeSource.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/AttributeSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/AttributeSource.cs Mon Dec 14 14:13:03 2009
@@ -36,7 +36,7 @@
 		public abstract class AttributeFactory
 		{
 			/// <summary> returns an {@link AttributeImpl} for the supplied {@link Attribute} interface class.
-			/// <p>Signature for Java 1.5: <code>public AttributeImpl createAttributeInstance(Class%lt;? extends Attribute&gt; attClass)</code>
+			/// <p/>Signature for Java 1.5: <code>public AttributeImpl createAttributeInstance(Class%lt;? extends Attribute&gt; attClass)</code>
 			/// </summary>
 			public abstract AttributeImpl CreateAttributeInstance(System.Type attClass);
 			

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/FieldCacheSanityChecker.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Util/FieldCacheSanityChecker.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/FieldCacheSanityChecker.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/FieldCacheSanityChecker.cs Mon Dec 14 14:13:03 2009
@@ -28,7 +28,7 @@
 	/// <summary> Provides methods for sanity checking that entries in the FieldCache 
 	/// are not wasteful or inconsistent.
 	/// </p>
-	/// <p>
+	/// <p/>
 	/// Lucene 2.9 Introduced numerous enhancements into how the FieldCache 
 	/// is used by the low levels of Lucene searching (for Sorting and 
 	/// ValueSourceQueries) to improve both the speed for Sorting, as well 
@@ -41,7 +41,7 @@
 	/// Unit tests) to check at run time if the FieldCache contains "insane" 
 	/// usages of the FieldCache.
 	/// </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.
@@ -93,7 +93,7 @@
 		
 		
 		/// <summary> Tests a CacheEntry[] for indication of "insane" cache usage.
-		/// <p>
+		/// <p/>
 		/// <B>NOTE:</b>FieldCache CreationPlaceholder objects are ignored.
 		/// (:TODO: is this a bad idea? are we masking a real problem?)
 		/// </p>
@@ -418,13 +418,13 @@
 			/// </summary>
 			public static readonly InsanityType SUBREADER = new InsanityType("SUBREADER");
 			
-			/// <summary> <p>
+			/// <summary> <p/>
 			/// Indicates entries have the same reader+fieldname but 
 			/// different cached values.  This can happen if different datatypes, 
 			/// or parsers are used -- and while it's not necessarily a bug 
 			/// it's typically an indication of a possible problem.
 			/// </p>
-			/// <p>
+			/// <p/>
 			/// <bPNOTE:</b> Only the reader, fieldname, and cached value are actually 
 			/// tested -- if two cache entries have different parsers or datatypes but 
 			/// the cached values are the same Object (== not just equal()) this method 

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/NumericUtils.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Util/NumericUtils.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/NumericUtils.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/NumericUtils.cs Mon Dec 14 14:13:03 2009
@@ -28,36 +28,36 @@
 	/// <summary> This is a helper class to generate prefix-encoded representations for numerical values
 	/// and supplies converters to represent float/double values as sortable integers/longs.
 	/// 
-	/// <p>To quickly execute range queries in Apache Lucene, a range is divided recursively
+	/// <p/>To quickly execute range queries in Apache Lucene, a range is divided recursively
 	/// into multiple intervals for searching: The center of the range is searched only with
 	/// the lowest possible precision in the trie, while the boundaries are matched
 	/// more exactly. This reduces the number of terms dramatically.
 	/// 
-	/// <p>This class generates terms to achive this: First the numerical integer values need to
+	/// <p/>This class generates terms to achive this: First the numerical integer values need to
 	/// be converted to strings. For that integer values (32 bit or 64 bit) are made unsigned
 	/// and the bits are converted to ASCII chars with each 7 bit. The resulting string is
 	/// sortable like the original integer value. Each value is also prefixed
 	/// (in the first char) by the <code>shift</code> value (number of bits removed) used
 	/// during encoding.
 	/// 
-	/// <p>To also index floating point numbers, this class supplies two methods to convert them
+	/// <p/>To also index floating point numbers, this class supplies two methods to convert them
 	/// to integer values by changing their bit layout: {@link #doubleToSortableLong},
 	/// {@link #floatToSortableInt}. You will have no precision loss by
 	/// converting floating point numbers to integers and back (only that the integer form
 	/// is not usable). Other data types like dates can easily converted to longs or ints (e.g.
 	/// date to long: {@link java.util.Date#getTime}).
 	/// 
-	/// <p>For easy usage, the trie algorithm is implemented for indexing inside
+	/// <p/>For easy usage, the trie algorithm is implemented for indexing inside
 	/// {@link NumericTokenStream} that can index <code>int</code>, <code>long</code>,
 	/// <code>float</code>, and <code>double</code>. For querying,
 	/// {@link NumericRangeQuery} and {@link NumericRangeFilter} implement the query part
 	/// for the same data types.
 	/// 
-	/// <p>This class can also be used, to generate lexicographically sortable (according
+	/// <p/>This class can also be used, to generate lexicographically sortable (according
 	/// {@link String#compareTo(String)}) representations of numeric data types for other
 	/// usages (e.g. sorting).
 	/// 
-	/// <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>
 	/// 
 	/// </summary>
@@ -147,7 +147,7 @@
 		/// <summary> This is a convenience method, that returns prefix coded bits of a long without
 		/// reducing the precision. It can be used to store the full precision value as a
 		/// stored field in index.
-		/// <p>To decode, use {@link #prefixCodedToLong}.
+		/// <p/>To decode, use {@link #prefixCodedToLong}.
 		/// </summary>
 		public static System.String LongToPrefixCoded(long val)
 		{
@@ -202,7 +202,7 @@
 		/// <summary> This is a convenience method, that returns prefix coded bits of an int without
 		/// reducing the precision. It can be used to store the full precision value as a
 		/// stored field in index.
-		/// <p>To decode, use {@link #prefixCodedToInt}.
+		/// <p/>To decode, use {@link #prefixCodedToInt}.
 		/// </summary>
 		public static System.String IntToPrefixCoded(int val)
 		{
@@ -352,7 +352,7 @@
 		/// {@link Lucene.Net.Search.BooleanQuery} for each call to its
 		/// {@link LongRangeBuilder#AddRange(String,String)}
 		/// method.
-		/// <p>This method is used by {@link NumericRangeQuery}.
+		/// <p/>This method is used by {@link NumericRangeQuery}.
 		/// </summary>
 		public static void  SplitLongRange(LongRangeBuilder builder, int precisionStep, long minBound, long maxBound)
 		{
@@ -364,7 +364,7 @@
 		/// {@link Lucene.Net.Search.BooleanQuery} for each call to its
 		/// {@link IntRangeBuilder#AddRange(String,String)}
 		/// method.
-		/// <p>This method is used by {@link NumericRangeQuery}.
+		/// <p/>This method is used by {@link NumericRangeQuery}.
 		/// </summary>
 		public static void  SplitIntRange(IntRangeBuilder builder, int precisionStep, int minBound, int maxBound)
 		{
@@ -436,7 +436,7 @@
 		
 		/// <summary> Expert: Callback for {@link #splitLongRange}.
 		/// You need to overwrite only one of the methods.
-		/// <p><font color="red"><b>NOTE:</b> This is a very low-level interface,
+		/// <p/><font color="red"><b>NOTE:</b> This is a very low-level interface,
 		/// the method signatures may change in later versions.</font>
 		/// </summary>
 		public abstract class LongRangeBuilder
@@ -461,7 +461,7 @@
 		
 		/// <summary> Expert: Callback for {@link #splitIntRange}.
 		/// You need to overwrite only one of the methods.
-		/// <p><font color="red"><b>NOTE:</b> This is a very low-level interface,
+		/// <p/><font color="red"><b>NOTE:</b> This is a very low-level interface,
 		/// the method signatures may change in later versions.</font>
 		/// </summary>
 		public abstract class IntRangeBuilder

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/OpenBitSet.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Util/OpenBitSet.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/OpenBitSet.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/OpenBitSet.cs Mon Dec 14 14:13:03 2009
@@ -104,7 +104,7 @@
 		/// with bit index 0 at the least significant bit, and bit index 63 at the most significant.
 		/// Given a bit index,
 		/// the word containing it is long[index/64], and it is at bit number index%64 within that word.
-		/// <p>
+		/// <p/>
 		/// numWords are the number of elements in the array that contain
 		/// set bits (non-zero longs).
 		/// numWords should be &lt= bits.length, and

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/PriorityQueue.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Util/PriorityQueue.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/PriorityQueue.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/PriorityQueue.cs Mon Dec 14 14:13:03 2009
@@ -24,7 +24,7 @@
 	/// least element can always be found in constant time.  Put()'s and pop()'s
 	/// require log(size) time.
 	/// 
-	/// <p><b>NOTE</b>: This class pre-allocates a full array of
+	/// <p/><b>NOTE</b>: This class pre-allocates a full array of
 	/// length <code>maxSize+1</code>, in {@link #initialize}.
 	/// 
 	/// </summary>

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/SortedVIntList.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Util/SortedVIntList.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/SortedVIntList.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/SortedVIntList.cs Mon Dec 14 14:13:03 2009
@@ -27,7 +27,7 @@
 	/// The code for compressing the differences between ascending integers was
 	/// borrowed from {@link Lucene.Net.Store.IndexInput} and
 	/// {@link Lucene.Net.Store.IndexOutput}.
-	/// <p>
+	/// <p/>
 	/// <b>NOTE:</b> this class assumes the stored integers are doc Ids (hence why it
 	/// extends {@link DocIdSet}). Therefore its {@link #Iterator()} assumes {@link
 	/// DocIdSetIterator#NO_MORE_DOCS} can be used as sentinel. If you intent to use

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/UnicodeUtil.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Util/UnicodeUtil.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/UnicodeUtil.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/UnicodeUtil.cs Mon Dec 14 14:13:03 2009
@@ -55,7 +55,7 @@
 	/// without always allocating a new byte[] as
 	/// String.getBytes("UTF-8") does.
 	/// 
-	/// <p><b>WARNING</b>: This API is a new and experimental and
+	/// <p/><b>WARNING</b>: This API is a new and experimental and
 	/// may suddenly change. </p>
 	/// </summary>
 	

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/Version.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Util/Version.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/Version.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Util/Version.cs Mon Dec 14 14:13:03 2009
@@ -30,7 +30,7 @@
 		/// <summary>Use this to get the latest & greatest settings, bug
 		/// fixes, etc, for Lucene.
 		/// 
-		/// <p><b>WARNING</b>: if you use this setting, and then
+		/// <p/><b>WARNING</b>: if you use this setting, and then
 		/// upgrade to a newer release of Lucene, sizable changes
 		/// may happen.  If precise back compatibility is important
 		/// then you should instead explicitly specify an actual



Mime
View raw message