You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by di...@apache.org on 2009/12/14 15:13:08 UTC
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/
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 "delete on
/// last close" 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> attClass)</code>
+ /// <p/>Signature for Java 1.5: <code>public AttributeImpl createAttributeInstance(Class%lt;? extends Attribute> 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 <= 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