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 [3/4] - in
/incubator/lucene.net/trunk/C#/src/Lucene.Net: Analysis/ Analysis/Standard/
Analysis/Tokenattributes/ Document/ Index/ QueryParser/ Search/
Search/Function/ Search/Payloads/ Search/Spans/ Store/ Util/
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/QueryParser/QueryParser.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/QueryParser/QueryParser.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/QueryParser/QueryParser.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/QueryParser/QueryParser.cs Mon Dec 14 14:13:03 2009
@@ -72,13 +72,13 @@
/// Clause ::= ["+", "-"] [<TERM> ":"] ( <TERM> | "(" Query ")" )
/// </pre>
///
- /// <p>
+ /// <p/>
/// Examples of appropriately formatted queries can be found in the <a
/// href="../../../../../../queryparsersyntax.html">query syntax
/// documentation</a>.
/// </p>
///
- /// <p>
+ /// <p/>
/// In {@link TermRangeQuery}s, QueryParser tries to detect date values, e.g.
/// <tt>date:[6/1/2005 TO 6/4/2005]</tt> produces a range query that searches
/// for "date" fields between 2005-06-01 and 2005-06-04. Note that the format
@@ -88,7 +88,7 @@
/// To use the new {@link DateTools} to convert dates, a
/// {@link Lucene.Net.Documents.DateTools.Resolution} has to be set.
/// </p>
- /// <p>
+ /// <p/>
/// The date resolution that shall be used for RangeQueries can be set
/// using {@link #SetDateResolution(DateTools.Resolution)}
/// or {@link #SetDateResolution(String, DateTools.Resolution)}. The former
@@ -96,7 +96,7 @@
/// be used to set field specific date resolutions. Field specific date
/// resolutions take, if set, precedence over the default date resolution.
/// </p>
- /// <p>
+ /// <p/>
/// If you use neither {@link DateField} nor {@link DateTools} in your
/// index, you can create your own
/// query parser that inherits QueryParser and overwrites
@@ -104,14 +104,14 @@
/// use a different method for date conversion.
/// </p>
///
- /// <p>Note that QueryParser is <em>not</em> thread-safe.</p>
+ /// <p/>Note that QueryParser is <em>not</em> thread-safe.</p>
///
- /// <p><b>NOTE</b>: there is a new QueryParser in contrib, which matches
+ /// <p/><b>NOTE</b>: there is a new QueryParser in contrib, which matches
/// the same syntax as this class, but is more modular,
/// enabling substantial customization to how a query is created.
/// </summary>
///
- /// <p><b>NOTE</b>: there is a new QueryParser in contrib, which matches
+ /// <p/><b>NOTE</b>: there is a new QueryParser in contrib, which matches
/// the same syntax as this class, but is more modular,
/// enabling substantial customization to how a query is created.
/// </summary>
@@ -311,12 +311,12 @@
/// <summary> Set to <code>true</code> to allow leading wildcard characters.
- /// <p>
+ /// <p/>
/// When set, <code>*</code> or <code>?</code> are allowed as
/// the first character of a PrefixQuery and WildcardQuery.
/// Note that this can produce very slow
/// queries on big indexes.
- /// <p>
+ /// <p/>
/// Default: false.
/// </summary>
public virtual void SetAllowLeadingWildcard(bool allowLeadingWildcard)
@@ -332,12 +332,12 @@
}
/// <summary> Set to <code>true</code> to enable position increments in result query.
- /// <p>
+ /// <p/>
/// When set, result phrase and multi-phrase queries will
/// be aware of position increments.
/// Useful when e.g. a StopFilter increases the position increment of
/// the token that follows an omitted token.
- /// <p>
+ /// <p/>
/// Default: false.
/// </summary>
public virtual void SetEnablePositionIncrements(bool enable)
@@ -1140,12 +1140,12 @@
/// parses an input term token that contains one or more wildcard
/// characters (? and *), but is not a prefix term token (one
/// that has just a single * character at the end)
- /// <p>
+ /// <p/>
/// Depending on settings, prefix term may be lower-cased
/// automatically. It will not go through the default Analyzer,
/// however, since normal Analyzers are unlikely to work properly
/// with wildcard templates.
- /// <p>
+ /// <p/>
/// Can be overridden by extending classes, to provide custom handling for
/// wildcard queries, which may be necessary due to missing analyzer calls.
///
@@ -1183,12 +1183,12 @@
/// character as its last character. Since this is a special case
/// of generic wildcard term, and such a query can be optimized easily,
/// this usually results in a different query object.
- /// <p>
+ /// <p/>
/// Depending on settings, a prefix term may be lower-cased
/// automatically. It will not go through the default Analyzer,
/// however, since normal Analyzers are unlikely to work properly
/// with wildcard templates.
- /// <p>
+ /// <p/>
/// Can be overridden by extending classes, to provide custom handling for
/// wild card queries, which may be necessary due to missing analyzer calls.
///
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/BooleanQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/BooleanQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/BooleanQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/BooleanQuery.cs Mon Dec 14 14:13:03 2009
@@ -150,17 +150,17 @@
/// <summary> Specifies a minimum number of the optional BooleanClauses
/// which must be satisfied.
///
- /// <p>
+ /// <p/>
/// By default no optional clauses are necessary for a match
/// (unless there are no required clauses). If this method is used,
/// then the specified number of clauses is required.
/// </p>
- /// <p>
+ /// <p/>
/// Use of this method is totally independent of specifying that
/// any specific clauses are required (or prohibited). This number will
/// only be compared against the number of matching optional clauses.
/// </p>
- /// <p>
+ /// <p/>
/// EXPERT NOTE: Using this method may force collecting docs in order,
/// regardless of whether setAllowDocsOutOfOrder(true) has been called.
/// </p>
@@ -222,7 +222,7 @@
/// <summary> Expert: the Weight for BooleanQuery, used to
/// normalize, score and explain these queries.
///
- /// <p>NOTE: this API and implementation is subject to
+ /// <p/>NOTE: this API and implementation is subject to
/// change suddenly in the next release.</p>
/// </summary>
[Serializable]
@@ -475,7 +475,7 @@
/// <summary> Expert: Indicates whether hit docs may be collected out of docid order.
///
- /// <p>
+ /// <p/>
/// Background: although the contract of the Scorer class requires that
/// documents be iterated in order of doc id, this was not true in early
/// versions of Lucene. Many pieces of functionality in the current Lucene code
@@ -485,7 +485,7 @@
/// queries.)
/// </p>
///
- /// <p>
+ /// <p/>
/// Specifics: By setting this option to true, docid N might be scored for a
/// single segment before docid N-1. Across multiple segments, docs may be
/// scored out of order regardless of this setting - it only applies to scoring
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Collector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Collector.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Collector.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Collector.cs Mon Dec 14 14:13:03 2009
@@ -22,18 +22,18 @@
namespace Lucene.Net.Search
{
- /// <summary> <p>Expert: Collectors are primarily meant to be used to
+ /// <summary> <p/>Expert: Collectors are primarily meant to be used to
/// gather raw results from a search, and implement sorting
/// or custom result filtering, collation, etc. </p>
///
- /// <p>As of 2.9, this class replaces the deprecated
+ /// <p/>As of 2.9, this class replaces the deprecated
/// HitCollector, and offers an API for efficient collection
/// of hits across sequential {@link IndexReader}s. {@link
/// IndexSearcher} advances the collector through each of the
/// sub readers, in an arbitrary order. This results in a
/// higher performance means of collection.</p>
///
- /// <p>Lucene's core collectors are derived from Collector.
+ /// <p/>Lucene's core collectors are derived from Collector.
/// Likely your application can use one of these classes, or
/// subclass {@link TopDocsCollector}, instead of
/// implementing Collector directly:
@@ -69,7 +69,7 @@
///
/// </ul>
///
- /// <p>Collector decouples the score from the collected doc:
+ /// <p/>Collector decouples the score from the collected doc:
/// the score computation is skipped entirely if it's not
/// needed. Collectors that do need the score should
/// implement the {@link #setScorer} method, to hold onto the
@@ -79,7 +79,7 @@
/// score for a single hit multiple times, you should use
/// {@link ScoreCachingWrappingScorer}. </p>
///
- /// <p><b>NOTE:</b> The doc that is passed to the collect
+ /// <p/><b>NOTE:</b> The doc that is passed to the collect
/// method is relative to the current reader. If your
/// collector needs to resolve this to the docID space of the
/// Multi*Reader, you must re-base it by recording the
@@ -112,11 +112,11 @@
/// });
/// </pre>
///
- /// <p>Not all collectors will need to rebase the docID. For
+ /// <p/>Not all collectors will need to rebase the docID. For
/// example, a collector that simply counts the total number
/// of hits would skip it.</p>
///
- /// <p><b>NOTE:</b> Prior to 2.9, Lucene silently filtered
+ /// <p/><b>NOTE:</b> Prior to 2.9, Lucene silently filtered
/// out hits with score <= 0. As of 2.9, the core Collectors
/// no longer do that. It's very unusual to have such hits
/// (a negative query boost, or function query returning
@@ -124,7 +124,7 @@
/// you need that behavior, use {@link
/// PositiveScoresOnlyCollector}.</p>
///
- /// <p><b>NOTE:</b> This API is experimental and might change
+ /// <p/><b>NOTE:</b> This API is experimental and might change
/// in incompatible ways in the next release.</p>
///
/// </summary>
@@ -143,7 +143,7 @@
/// <summary> Called once for every document matching a query, with the unbased document
/// number.
///
- /// <p>
+ /// <p/>
/// Note: This is called in an inner search loop. For good search performance,
/// implementations of this method should not call {@link Searcher#Doc(int)} or
/// {@link Lucene.Net.Index.IndexReader#Document(int)} on every hit.
@@ -166,7 +166,7 @@
/// <summary> Returns true iff this {@link Collector} can accept documents given to
/// {@link #Collect(int)} out of order.
- /// <p>
+ /// <p/>
/// NOTE: some collectors can work in either mode, with a more efficient
/// implementation for in-order docs collection. If your collector can work in
/// either mode, it is recommended that you create two variants of it, since
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ComplexExplanation.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/ComplexExplanation.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ComplexExplanation.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ComplexExplanation.cs Mon Dec 14 14:13:03 2009
@@ -56,7 +56,7 @@
}
/// <summary> Indicates whether or not this Explanation models a good match.
///
- /// <p>
+ /// <p/>
/// If the match status is explicitly set (i.e.: not null) this method
/// uses it; otherwise it defers to the superclass.
/// </p>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ConstantScoreRangeQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/ConstantScoreRangeQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ConstantScoreRangeQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ConstantScoreRangeQuery.cs Mon Dec 14 14:13:03 2009
@@ -23,13 +23,13 @@
/// <summary> A range query that returns a constant score equal to its boost for
/// all documents in the exclusive range of terms.
///
- /// <p>It does not have an upper bound on the number of clauses covered in the range.
+ /// <p/>It does not have an upper bound on the number of clauses covered in the range.
///
- /// <p>This query matches the documents looking for terms that fall into the
+ /// <p/>This query matches the documents looking for terms that fall into the
/// supplied range according to {@link String#compareTo(String)}. It is not intended
/// for numerical ranges, use {@link NumericRangeQuery} instead.
///
- /// <p>This query is hardwired to {@link MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}.
+ /// <p/>This query is hardwired to {@link MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}.
/// If you want to change this, use {@link TermRangeQuery} instead.
///
/// </summary>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DefaultSimilarity.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/DefaultSimilarity.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DefaultSimilarity.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DefaultSimilarity.cs Mon Dec 14 14:13:03 2009
@@ -34,7 +34,7 @@
/// FieldInvertState#GetLength()} - {@link
/// FieldInvertState#GetNumOverlap()}.
///
- /// <p><b>WARNING</b>: This API is new and experimental, and may suddenly
+ /// <p/><b>WARNING</b>: This API is new and experimental, and may suddenly
/// change.</p>
/// </summary>
public override float ComputeNorm(System.String field, FieldInvertState state)
@@ -91,7 +91,7 @@
/// norm. By default this is false, meaning overlap
/// tokens are counted just like non-overlap tokens.
///
- /// <p><b>WARNING</b>: This API is new and experimental, and may suddenly
+ /// <p/><b>WARNING</b>: This API is new and experimental, and may suddenly
/// change.</p>
///
/// </summary>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DisjunctionMaxQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/DisjunctionMaxQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DisjunctionMaxQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DisjunctionMaxQuery.cs Mon Dec 14 14:13:03 2009
@@ -92,7 +92,7 @@
/// <summary> Expert: the Weight for DisjunctionMaxQuery, used to
/// normalize, score and explain these queries.
///
- /// <p>NOTE: this API and implementation is subject to
+ /// <p/>NOTE: this API and implementation is subject to
/// change suddenly in the next release.</p>
/// </summary>
[Serializable]
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DisjunctionSumScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/DisjunctionSumScorer.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DisjunctionSumScorer.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DisjunctionSumScorer.cs Mon Dec 14 14:13:03 2009
@@ -43,7 +43,7 @@
/// <br>An exhausted scorer is immediately removed from the scorerDocQueue.
/// <br>If less than the minimumNrMatchers scorers
/// remain in the scorerDocQueue next() and skipTo() return false.
- /// <p>
+ /// <p/>
/// After each to call to next() or skipTo()
/// <code>currentSumScore</code> is the total score of the current matching doc,
/// <code>nrMatchers</code> is the number of matching scorers,
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DocIdSetIterator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/DocIdSetIterator.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DocIdSetIterator.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DocIdSetIterator.cs Mon Dec 14 14:13:03 2009
@@ -56,7 +56,7 @@
/// <li>{@link #NO_MORE_DOCS} if the iterator has exhausted.
/// <li>Otherwise it should return the doc ID it is currently on.
/// </ul>
- /// <p>
+ /// <p/>
/// <b>NOTE:</b> in 3.0, this method will become abstract.
///
/// </summary>
@@ -118,7 +118,7 @@
/// <summary> Advances to the first beyond the current whose document number is greater
/// than or equal to <i>target</i>. Returns the current document number or
/// {@link #NO_MORE_DOCS} if there are no more docs in the set.
- /// <p>
+ /// <p/>
/// Behaves as if written:
///
/// <pre>
@@ -131,18 +131,18 @@
/// </pre>
///
/// Some implementations are considerably more efficient than that.
- /// <p>
+ /// <p/>
/// <b>NOTE:</b> certain implemenations may return a different value (each
/// time) if called several times in a row with the same target.
- /// <p>
+ /// <p/>
/// <b>NOTE:</b> this method may be called with {@value #NO_MORE_DOCS} for
/// efficiency by some Scorers. If your implementation cannot efficiently
/// determine that it should exhaust, it is recommended that you check for that
/// value in each call to this method.
- /// <p>
+ /// <p/>
/// <b>NOTE:</b> after the iterator has exhausted you should not call this
/// method, as it may result in unpredicted behavior.
- /// <p>
+ /// <p/>
/// <b>NOTE:</b> in 3.0 this method will become abstract, following the removal
/// of {@link #SkipTo(int)}.
///
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Explanation.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Explanation.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Explanation.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Explanation.cs Mon Dec 14 14:13:03 2009
@@ -40,7 +40,7 @@
/// <summary> Indicates whether or not this Explanation models a good match.
///
- /// <p>
+ /// <p/>
/// By default, an Explanation represents a "match" if the value is positive.
/// </p>
/// </summary>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCache.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FieldCache.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCache.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCache.cs Mon Dec 14 14:13:03 2009
@@ -28,7 +28,7 @@
/// <summary> Expert: Maintains caches of term values.
///
- /// <p>Created: May 19, 2004 11:13:14 AM
+ /// <p/>Created: May 19, 2004 11:13:14 AM
///
/// </summary>
/// <since> lucene 1.4
@@ -84,7 +84,7 @@
}
/// <summary> EXPERT: A unique Identifier/Description for each item in the FieldCache.
/// Can be useful for logging/debugging.
- /// <p>
+ /// <p/>
/// <b>EXPERIMENTAL API:</b> This API is considered extremely advanced
/// and experimental. It may be removed or altered w/o warning in future
/// releases
@@ -633,13 +633,13 @@
/// <summary> EXPERT: Generates an array of CacheEntry objects representing all items
/// currently in the FieldCache.
- /// <p>
+ /// <p/>
/// NOTE: These CacheEntry objects maintain a strong refrence to the
/// Cached Values. Maintaining refrences to a CacheEntry the IndexReader
/// associated with it has garbage collected will prevent the Value itself
/// from being garbage collected when the Cache drops the WeakRefrence.
/// </p>
- /// <p>
+ /// <p/>
/// <b>EXPERIMENTAL API:</b> This API is considered extremely advanced
/// and experimental. It may be removed or altered w/o warning in future
/// releases
@@ -648,7 +648,7 @@
/// </summary>
CacheEntry[] GetCacheEntries();
- /// <summary> <p>
+ /// <summary> <p/>
/// EXPERT: Instructs the FieldCache to forcibly expunge all entries
/// from the underlying caches. This is intended only to be used for
/// test methods as a way to ensure a known base state of the Cache
@@ -656,7 +656,7 @@
/// It should not be relied on for "Cache maintenance" in general
/// application code.
/// </p>
- /// <p>
+ /// <p/>
/// <b>EXPERIMENTAL API:</b> This API is considered extremely advanced
/// and experimental. It may be removed or altered w/o warning in future
/// releases
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCacheImpl.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FieldCacheImpl.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCacheImpl.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCacheImpl.cs Mon Dec 14 14:13:03 2009
@@ -31,7 +31,7 @@
/// <summary> Expert: The default cache implementation, storing all values in memory.
/// A WeakHashMap is used for storage.
///
- /// <p>Created: May 19, 2004 4:40:36 PM
+ /// <p/>Created: May 19, 2004 4:40:36 PM
///
/// </summary>
/// <since> lucene 1.4
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCacheRangeFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FieldCacheRangeFilter.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCacheRangeFilter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCacheRangeFilter.cs Mon Dec 14 14:13:03 2009
@@ -27,11 +27,11 @@
/// <summary> A range filter built on top of a cached single term field (in {@link FieldCache}).
///
- /// <p>FieldCacheRangeFilter builds a single cache for the field the first time it is used.
+ /// <p/>FieldCacheRangeFilter builds a single cache for the field the first time it is used.
/// Each subsequent FieldCacheRangeFilter on the same field then reuses this cache,
/// even if the range itself changes.
///
- /// <p>This means that FieldCacheRangeFilter is much faster (sometimes more than 100x as fast)
+ /// <p/>This means that FieldCacheRangeFilter is much faster (sometimes more than 100x as fast)
/// as building a {@link TermRangeFilter} (or {@link ConstantScoreRangeQuery} on a {@link TermRangeFilter})
/// for each query, if using a {@link #newStringRange}. However, if the range never changes it
/// is slower (around 2x as slow) than building a CachingWrapperFilter on top of a single TermRangeFilter.
@@ -40,16 +40,16 @@
/// Furthermore, it does not need the numeric values encoded by {@link NumericField}. But
/// it has the problem that it only works with exact one value/document (see below).
///
- /// <p>As with all {@link FieldCache} based functionality, FieldCacheRangeFilter is only valid for
+ /// <p/>As with all {@link FieldCache} based functionality, FieldCacheRangeFilter is only valid for
/// fields which exact one term for each document (except for {@link #newStringRange}
/// where 0 terms are also allowed). Due to a restriction of {@link FieldCache}, for numeric ranges
/// all terms that do not have a numeric value, 0 is assumed.
///
- /// <p>Thus it works on dates, prices and other single value fields but will not work on
+ /// <p/>Thus it works on dates, prices and other single value fields but will not work on
/// regular text fields. It is preferable to use a <code>NOT_ANALYZED</code> field to ensure that
/// there is only a single term.
///
- /// <p>This class does not have an constructor, use one of the static factory methods available,
+ /// <p/>This class does not have an constructor, use one of the static factory methods available,
/// that create a correct instance for different data types supported by {@link FieldCache}.
/// </summary>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldComparator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FieldComparator.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldComparator.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldComparator.cs Mon Dec 14 14:13:03 2009
@@ -34,7 +34,7 @@
/// TopFieldCollector}. The concrete public FieldComparator
/// classes here correspond to the SortField types.
///
- /// <p>This API is designed to achieve high performance
+ /// <p/>This API is designed to achieve high performance
/// sorting, by exposing a tight interaction with {@link
/// FieldValueHitQueue} as it visits hits. Whenever a hit is
/// competitive, it's enrolled into a virtual slot, which is
@@ -43,7 +43,7 @@
/// during searching in case any internal state it's tracking
/// needs to be recomputed during these transitions.</p>
///
- /// <p>A comparator must define these functions:</p>
+ /// <p/>A comparator must define these functions:</p>
///
/// <ul>
///
@@ -1004,7 +1004,7 @@
/// #Compare(int,int)}} as if bottom were slot1 and the new
/// document were slot 2.
///
- /// <p>For a search that hits many results, this method
+ /// <p/>For a search that hits many results, this method
/// will be the hotspot (invoked by far the most
/// frequently).</p>
///
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldDoc.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FieldDoc.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldDoc.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldDoc.cs Mon Dec 14 14:13:03 2009
@@ -32,7 +32,7 @@
/// Integer, Float or String depending on the type of values
/// in the terms of each field.
///
- /// <p>Created: Feb 11, 2004 1:23:38 PM
+ /// <p/>Created: Feb 11, 2004 1:23:38 PM
///
/// </summary>
/// <since> lucene 1.4
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldDocSortedHitQueue.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FieldDocSortedHitQueue.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldDocSortedHitQueue.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldDocSortedHitQueue.cs Mon Dec 14 14:13:03 2009
@@ -25,7 +25,7 @@
/// <summary> Expert: Collects sorted results from Searchable's and collates them.
/// The elements put into this queue must be of type FieldDoc.
///
- /// <p>Created: Feb 11, 2004 2:04:21 PM
+ /// <p/>Created: Feb 11, 2004 2:04:21 PM
///
/// </summary>
/// <since> lucene 1.4
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldSortedHitQueue.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FieldSortedHitQueue.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldSortedHitQueue.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldSortedHitQueue.cs Mon Dec 14 14:13:03 2009
@@ -26,7 +26,7 @@
/// <summary> Expert: A hit queue for sorting by hits by terms in more than one field.
/// Uses <code>FieldCache.DEFAULT</code> for maintaining internal term lookup tables.
///
- /// <p>Created: Dec 8, 2003 12:56:03 PM
+ /// <p/>Created: Dec 8, 2003 12:56:03 PM
///
/// </summary>
/// <since> lucene 1.4
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldValueHitQueue.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FieldValueHitQueue.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldValueHitQueue.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldValueHitQueue.cs Mon Dec 14 14:13:03 2009
@@ -184,7 +184,7 @@
/// <summary> Creates a hit queue sorted by the given list of fields.
///
- /// <p><b>NOTE</b>: The instances returned by this method
+ /// <p/><b>NOTE</b>: The instances returned by this method
/// pre-allocate a full array of length <code>numHits</code>.
///
/// </summary>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Filter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Filter.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Filter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Filter.cs Mon Dec 14 14:13:03 2009
@@ -25,7 +25,7 @@
/// <summary>Abstract base class providing a mechanism to use a subset of an index
/// for restriction or permission of index search results.
- /// <p>
+ /// <p/>
/// <b>Note:</b> In Lucene 3.0 {@link #Bits(IndexReader)} will be removed
/// and {@link #GetDocIdSet(IndexReader)} will be defined as abstract.
/// All implementing classes must therefore implement {@link #GetDocIdSet(IndexReader)}
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FilteredQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FilteredQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FilteredQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FilteredQuery.cs Mon Dec 14 14:13:03 2009
@@ -26,11 +26,11 @@
/// <summary> A query that applies a filter to the results of another query.
///
- /// <p>Note: the bits are retrieved from the filter each time this
+ /// <p/>Note: the bits are retrieved from the filter each time this
/// query is used in a search - use a CachingWrapperFilter to avoid
/// regenerating the bits every time.
///
- /// <p>Created: Apr 20, 2004 8:58:29 AM
+ /// <p/>Created: Apr 20, 2004 8:58:29 AM
///
/// </summary>
/// <since> 1.4
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FilteredTermEnum.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FilteredTermEnum.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FilteredTermEnum.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FilteredTermEnum.cs Mon Dec 14 14:13:03 2009
@@ -24,7 +24,7 @@
{
/// <summary>Abstract class for enumerating a subset of all terms.
- /// <p>Term enumerations are always ordered by Term.compareTo(). Each term in
+ /// <p/>Term enumerations are always ordered by Term.compareTo(). Each term in
/// the enumeration is greater than all that precede it.
/// </summary>
public abstract class FilteredTermEnum:TermEnum
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ByteFieldSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/ByteFieldSource.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ByteFieldSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ByteFieldSource.cs Mon Dec 14 14:13:03 2009
@@ -28,7 +28,7 @@
/// using <code>getBytes()</code> and makes those values
/// available as other numeric types, casting as needed.
///
- /// <p><font color="#FF0000">
+ /// <p/><font color="#FF0000">
/// WARNING: The status of the <b>Search.Function</b> package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.</font>
@@ -37,7 +37,7 @@
/// <seealso cref="Lucene.Net.Search.Function.FieldCacheSource for requirements">
/// on the field.
///
- /// <p><b>NOTE</b>: with the switch in 2.9 to segment-based
+ /// <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
/// searching, if {@link #getValues} is invoked with a
/// composite (multi-segment) reader, this can easily cause
/// double RAM usage for the values in the FieldCache. It's
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/CustomScoreQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/CustomScoreQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/CustomScoreQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/CustomScoreQuery.cs Mon Dec 14 14:13:03 2009
@@ -39,7 +39,7 @@
/// </ol>
/// Subclasses can modify the computation by overriding {@link #CustomScore(int, float, float)}.
///
- /// <p><font color="#FF0000">
+ /// <p/><font color="#FF0000">
/// WARNING: The status of the <b>Search.Function</b> package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.</font>
@@ -172,16 +172,16 @@
/// <summary> Compute a custom score by the subQuery score and a number of
/// ValueSourceQuery scores.
- /// <p>
+ /// <p/>
/// Subclasses can override this method to modify the custom score.
- /// <p>
+ /// <p/>
/// If your custom scoring is different than the default herein you
/// should override at least one of the two customScore() methods.
/// If the number of ValueSourceQueries is always < 2 it is
/// sufficient to override the other
/// {@link #CustomScore(int, float, float) customScore()}
/// method, which is simpler.
- /// <p>
+ /// <p/>
/// The default computation herein is a multiplication of given scores:
/// <pre>
/// ModifiedScore = valSrcScore * valSrcScores[0] * valSrcScores[1] * ...
@@ -215,14 +215,14 @@
}
/// <summary> Compute a custom score by the subQuery score and the ValueSourceQuery score.
- /// <p>
+ /// <p/>
/// Subclasses can override this method to modify the custom score.
- /// <p>
+ /// <p/>
/// If your custom scoring is different than the default herein you
/// should override at least one of the two customScore() methods.
/// If the number of ValueSourceQueries is always < 2 it is
/// sufficient to override this customScore() method, which is simpler.
- /// <p>
+ /// <p/>
/// The default computation herein is a multiplication of the two scores:
/// <pre>
/// ModifiedScore = subQueryScore * valSrcScore
@@ -587,7 +587,7 @@
/// This may be useful when one wants full control over how scores are modified, and does
/// not care about normalizing by the ValueSource part.
/// One particular case where this is useful if for testing this query.
- /// <P>
+ /// <p/>
/// Note: only has effect when the ValueSource part is not null.
/// </summary>
public virtual bool IsStrict()
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/DocValues.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/DocValues.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/DocValues.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/DocValues.cs Mon Dec 14 14:13:03 2009
@@ -27,7 +27,7 @@
/// {@link Lucene.Net.Search.Function.ValueSource ValueSuorce}
/// for a particular field and reader.
///
- /// <p><font color="#FF0000">
+ /// <p/><font color="#FF0000">
/// WARNING: The status of the <b>Search.Function</b> package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.</font>
@@ -46,14 +46,14 @@
*/
/// <summary> Return doc value as a float.
- /// <P>Mandatory: every DocValues implementation must implement at least this method.
+ /// <p/>Mandatory: every DocValues implementation must implement at least this method.
/// </summary>
/// <param name="doc">document whose float value is requested.
/// </param>
public abstract float FloatVal(int doc);
/// <summary> Return doc value as an int.
- /// <P>Optional: DocValues implementation can (but don't have to) override this method.
+ /// <p/>Optional: DocValues implementation can (but don't have to) override this method.
/// </summary>
/// <param name="doc">document whose int value is requested.
/// </param>
@@ -63,7 +63,7 @@
}
/// <summary> Return doc value as a long.
- /// <P>Optional: DocValues implementation can (but don't have to) override this method.
+ /// <p/>Optional: DocValues implementation can (but don't have to) override this method.
/// </summary>
/// <param name="doc">document whose long value is requested.
/// </param>
@@ -73,7 +73,7 @@
}
/// <summary> Return doc value as a double.
- /// <P>Optional: DocValues implementation can (but don't have to) override this method.
+ /// <p/>Optional: DocValues implementation can (but don't have to) override this method.
/// </summary>
/// <param name="doc">document whose double value is requested.
/// </param>
@@ -83,7 +83,7 @@
}
/// <summary> Return doc value as a string.
- /// <P>Optional: DocValues implementation can (but don't have to) override this method.
+ /// <p/>Optional: DocValues implementation can (but don't have to) override this method.
/// </summary>
/// <param name="doc">document whose string value is requested.
/// </param>
@@ -102,7 +102,7 @@
}
/// <summary> Expert: for test purposes only, return the inner array of values, or null if not applicable.
- /// <p>
+ /// <p/>
/// Allows tests to verify that loaded values are:
/// <ol>
/// <li>indeed cached/reused.</li>
@@ -154,7 +154,7 @@
/// <summary> Returns the minimum of all values or <code>Float.NaN</code> if this
/// DocValues instance does not contain any value.
- /// <p>
+ /// <p/>
/// This operation is optional
/// </p>
///
@@ -170,7 +170,7 @@
/// <summary> Returns the maximum of all values or <code>Float.NaN</code> if this
/// DocValues instance does not contain any value.
- /// <p>
+ /// <p/>
/// This operation is optional
/// </p>
///
@@ -186,7 +186,7 @@
/// <summary> Returns the average of all values or <code>Float.NaN</code> if this
/// DocValues instance does not contain any value. *
- /// <p>
+ /// <p/>
/// This operation is optional
/// </p>
///
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FieldCacheSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/FieldCacheSource.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FieldCacheSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FieldCacheSource.cs Mon Dec 14 14:13:03 2009
@@ -25,21 +25,21 @@
/// <summary> Expert: A base class for ValueSource implementations that retrieve values for
/// a single field from the {@link Lucene.Net.Search.FieldCache FieldCache}.
- /// <p>
+ /// <p/>
/// Fields used herein nust be indexed (doesn't matter if these fields are stored or not).
- /// <p>
+ /// <p/>
/// It is assumed that each such indexed field is untokenized, or at least has a single token in a document.
/// For documents with multiple tokens of the same field, behavior is undefined (It is likely that current
/// code would use the value of one of these tokens, but this is not guaranteed).
- /// <p>
+ /// <p/>
/// Document with no tokens in this field are assigned the <code>Zero</code> value.
///
- /// <p><font color="#FF0000">
+ /// <p/><font color="#FF0000">
/// WARNING: The status of the <b>Search.Function</b> package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.</font>
///
- /// <p><b>NOTE</b>: with the switch in 2.9 to segment-based
+ /// <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
/// searching, if {@link #getValues} is invoked with a
/// composite (multi-segment) reader, this can easily cause
/// double RAM usage for the values in the FieldCache. It's
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FieldScoreQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/FieldScoreQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FieldScoreQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FieldScoreQuery.cs Mon Dec 14 14:13:03 2009
@@ -21,10 +21,10 @@
{
/// <summary> A query that scores each document as the value of the numeric input field.
- /// <p>
+ /// <p/>
/// The query matches all documents, and scores each document according to the numeric
/// value of that field.
- /// <p>
+ /// <p/>
/// It is assumed, and expected, that:
/// <ul>
/// <li>The field used here is indexed, and has exactly
@@ -32,12 +32,12 @@
/// <li>Best if this field is un_tokenized.</li>
/// <li>That token is parsable to the selected type.</li>
/// </ul>
- /// <p>
+ /// <p/>
/// Combining this query in a FunctionQuery allows much freedom in affecting document scores.
/// Note, that with this freedom comes responsibility: it is more than likely that the
/// default Lucene scoring is superior in quality to scoring modified as explained here.
/// However, in some cases, and certainly for research experiments, this capability may turn useful.
- /// <p>
+ /// <p/>
/// When contructing this query, select the appropriate type. That type should match the data stored in the
/// field. So in fact the "right" type should be selected before indexing. Type selection
/// has effect on the RAM usage:
@@ -47,14 +47,14 @@
/// <li>{@link Type#INT} consumes 4 * maxDocs bytes.</li>
/// <li>{@link Type#FLOAT} consumes 8 * maxDocs bytes.</li>
/// </ul>
- /// <p>
+ /// <p/>
/// <b>Caching:</b>
/// Values for the numeric field are loaded once and cached in memory for further use with the same IndexReader.
/// To take advantage of this, it is extremely important to reuse index-readers or index-searchers,
/// otherwise, for instance if for each query a new index reader is opened, large penalties would be
/// paid for loading the field values into memory over and over again!
///
- /// <p><font color="#FF0000">
+ /// <p/><font color="#FF0000">
/// WARNING: The status of the <b>Search.Function</b> package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.</font>
@@ -64,7 +64,7 @@
{
/// <summary> Type of score field, indicating how field values are interpreted/parsed.
- /// <p>
+ /// <p/>
/// The type selected at search search time should match the data stored in the field.
/// Different types have different RAM requirements:
/// <ul>
@@ -102,7 +102,7 @@
}
/// <summary> Create a FieldScoreQuery - a query that scores each document as the value of the numeric input field.
- /// <p>
+ /// <p/>
/// The <code>type</code> param tells how to parse the field string values into a numeric score value.
/// </summary>
/// <param name="field">the numeric field to be used.
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FloatFieldSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/FloatFieldSource.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FloatFieldSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FloatFieldSource.cs Mon Dec 14 14:13:03 2009
@@ -28,7 +28,7 @@
/// using <code>getFloats()</code> and makes those values
/// available as other numeric types, casting as needed.
///
- /// <p><font color="#FF0000">
+ /// <p/><font color="#FF0000">
/// WARNING: The status of the <b>Search.Function</b> package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.</font>
@@ -37,7 +37,7 @@
/// <seealso cref="Lucene.Net.Search.Function.FieldCacheSource for requirements">
/// on the field.
///
- /// <p><b>NOTE</b>: with the switch in 2.9 to segment-based
+ /// <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
/// searching, if {@link #getValues} is invoked with a
/// composite (multi-segment) reader, this can easily cause
/// double RAM usage for the values in the FieldCache. It's
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/IntFieldSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/IntFieldSource.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/IntFieldSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/IntFieldSource.cs Mon Dec 14 14:13:03 2009
@@ -28,7 +28,7 @@
/// using <code>getInts()</code> and makes those values
/// available as other numeric types, casting as needed.
///
- /// <p><font color="#FF0000">
+ /// <p/><font color="#FF0000">
/// WARNING: The status of the <b>Search.Function</b> package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.</font>
@@ -37,7 +37,7 @@
/// <seealso cref="Lucene.Net.Search.Function.FieldCacheSource for requirements">
/// on the field.
///
- /// <p><b>NOTE</b>: with the switch in 2.9 to segment-based
+ /// <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
/// searching, if {@link #getValues} is invoked with a
/// composite (multi-segment) reader, this can easily cause
/// double RAM usage for the values in the FieldCache. It's
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/MultiValueSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/MultiValueSource.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/MultiValueSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/MultiValueSource.cs Mon Dec 14 14:13:03 2009
@@ -28,7 +28,7 @@
/// against accidental double RAM usage in FieldCache when
/// a composite reader is passed to {@link #getValues}.
///
- /// <p><b>NOTE</b>: this class adds a CPU penalty to every
+ /// <p/><b>NOTE</b>: this class adds a CPU penalty to every
/// lookup, as it must resolve the incoming document to the
/// right sub-reader using a binary search.</p>
///
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/OrdFieldSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/OrdFieldSource.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/OrdFieldSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/OrdFieldSource.cs Mon Dec 14 14:13:03 2009
@@ -25,26 +25,26 @@
/// <summary> Expert: obtains the ordinal of the field value from the default Lucene
/// {@link Lucene.Net.Search.FieldCache Fieldcache} using getStringIndex().
- /// <p>
+ /// <p/>
/// The native lucene index order is used to assign an ordinal value for each field value.
/// <p
/// Field values (terms) are lexicographically ordered by unicode value, and numbered starting at 1.
- /// <p>
+ /// <p/>
/// Example:
/// <br>If there were only three field values: "apple","banana","pear"
/// <br>then ord("apple")=1, ord("banana")=2, ord("pear")=3
- /// <p>
+ /// <p/>
/// WARNING:
/// ord() depends on the position in an index and can thus change
/// when other documents are inserted or deleted,
/// or if a MultiSearcher is used.
///
- /// <p><font color="#FF0000">
+ /// <p/><font color="#FF0000">
/// WARNING: The status of the <b>Search.Function</b> package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.</font>
///
- /// <p><b>NOTE</b>: with the switch in 2.9 to segment-based
+ /// <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
/// searching, if {@link #getValues} is invoked with a
/// composite (multi-segment) reader, this can easily cause
/// double RAM usage for the values in the FieldCache. It's
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ReverseOrdFieldSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/ReverseOrdFieldSource.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ReverseOrdFieldSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ReverseOrdFieldSource.cs Mon Dec 14 14:13:03 2009
@@ -26,26 +26,26 @@
/// <summary> Expert: obtains the ordinal of the field value from the default Lucene
/// {@link Lucene.Net.Search.FieldCache FieldCache} using getStringIndex()
/// and reverses the order.
- /// <p>
+ /// <p/>
/// The native lucene index order is used to assign an ordinal value for each field value.
- /// <p>
+ /// <p/>
/// Field values (terms) are lexicographically ordered by unicode value, and numbered starting at 1.
/// <br>
/// Example of reverse ordinal (rord):
/// <br>If there were only three field values: "apple","banana","pear"
/// <br>then rord("apple")=3, rord("banana")=2, ord("pear")=1
- /// <p>
+ /// <p/>
/// WARNING:
/// rord() depends on the position in an index and can thus change
/// when other documents are inserted or deleted,
/// or if a MultiSearcher is used.
///
- /// <p><font color="#FF0000">
+ /// <p/><font color="#FF0000">
/// WARNING: The status of the <b>Search.Function</b> package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.</font>
///
- /// <p><b>NOTE</b>: with the switch in 2.9 to segment-based
+ /// <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
/// searching, if {@link #getValues} is invoked with a
/// composite (multi-segment) reader, this can easily cause
/// double RAM usage for the values in the FieldCache. It's
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ShortFieldSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/ShortFieldSource.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ShortFieldSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ShortFieldSource.cs Mon Dec 14 14:13:03 2009
@@ -28,7 +28,7 @@
/// using <code>getShorts()</code> and makes those values
/// available as other numeric types, casting as needed.
///
- /// <p><font color="#FF0000">
+ /// <p/><font color="#FF0000">
/// WARNING: The status of the <b>Search.Function</b> package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.</font>
@@ -37,7 +37,7 @@
/// <seealso cref="Lucene.Net.Search.Function.FieldCacheSource for requirements">
/// on the field.
///
- /// <p><b>NOTE</b>: with the switch in 2.9 to segment-based
+ /// <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
/// searching, if {@link #getValues} is invoked with a
/// composite (multi-segment) reader, this can easily cause
/// double RAM usage for the values in the FieldCache. It's
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ValueSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/ValueSource.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ValueSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ValueSource.cs Mon Dec 14 14:13:03 2009
@@ -23,13 +23,13 @@
{
/// <summary> Expert: source of values for basic function queries.
- /// <P>At its default/simplest form, values - one per doc - are used as the score of that doc.
- /// <P>Values are instantiated as
+ /// <p/>At its default/simplest form, values - one per doc - are used as the score of that doc.
+ /// <p/>Values are instantiated as
/// {@link Lucene.Net.Search.Function.DocValues DocValues} for a particular reader.
- /// <P>ValueSource implementations differ in RAM requirements: it would always be a factor
+ /// <p/>ValueSource implementations differ in RAM requirements: it would always be a factor
/// of the number of documents, but for each document the number of bytes can be 1, 2, 4, or 8.
///
- /// <p><font color="#FF0000">
+ /// <p/><font color="#FF0000">
/// WARNING: The status of the <b>Search.Function</b> package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.</font>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ValueSourceQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/ValueSourceQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ValueSourceQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ValueSourceQuery.cs Mon Dec 14 14:13:03 2009
@@ -27,15 +27,15 @@
/// <summary> Expert: A Query that sets the scores of document to the
/// values obtained from a {@link Lucene.Net.Search.Function.ValueSource ValueSource}.
- /// <p>
+ /// <p/>
/// This query provides a score for <em>each and every</em> undeleted document in the index.
- /// <p>
+ /// <p/>
/// The value source can be based on a (cached) value of an indexed field, but it
/// can also be based on an external source, e.g. values read from an external database.
- /// <p>
+ /// <p/>
/// Score is set as: Score(doc,query) = query.getBoost()<sup>2</sup> * valueSource(doc).
///
- /// <p><font color="#FF0000">
+ /// <p/><font color="#FF0000">
/// WARNING: The status of the <b>Search.Function</b> package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.</font>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FuzzyTermEnum.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FuzzyTermEnum.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FuzzyTermEnum.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FuzzyTermEnum.cs Mon Dec 14 14:13:03 2009
@@ -26,7 +26,7 @@
/// <summary>Subclass of FilteredTermEnum for enumerating all terms that are similiar
/// to the specified filter term.
///
- /// <p>Term enumerations are always ordered by Term.compareTo(). Each term in
+ /// <p/>Term enumerations are always ordered by Term.compareTo(). Each term in
/// the enumeration is greater than all that precede it.
/// </summary>
public sealed class FuzzyTermEnum:FilteredTermEnum
@@ -56,7 +56,7 @@
private int[] maxDistances = new int[TYPICAL_LONGEST_WORD_IN_INDEX];
/// <summary> Creates a FuzzyTermEnum with an empty prefix and a minSimilarity of 0.5f.
- /// <p>
+ /// <p/>
/// After calling the constructor the enumeration is already pointing to the first
/// valid term if such a term exists.
///
@@ -73,7 +73,7 @@
}
/// <summary> Creates a FuzzyTermEnum with an empty prefix.
- /// <p>
+ /// <p/>
/// After calling the constructor the enumeration is already pointing to the first
/// valid term if such a term exists.
///
@@ -94,7 +94,7 @@
/// <summary> Constructor for enumeration of all terms from specified <code>reader</code> which share a prefix of
/// length <code>prefixLength</code> with <code>term</code> and which have a fuzzy similarity >
/// <code>minSimilarity</code>.
- /// <p>
+ /// <p/>
/// After calling the constructor the enumeration is already pointing to the first
/// valid term if such a term exists.
///
@@ -184,7 +184,7 @@
return tmpArray;
}
- /// <summary> <p>Similarity returns a number that is 1.0f or less (including negative numbers)
+ /// <summary> <p/>Similarity returns a number that is 1.0f or less (including negative numbers)
/// based on how similar the Term is compared to a target term. It returns
/// exactly 0.0f when
/// <pre>
@@ -196,12 +196,12 @@
/// prefix that are identical and editDistance is the Levenshtein distance for
/// the two words.</p>
///
- /// <p>Embedded within this algorithm is a fail-fast Levenshtein distance
+ /// <p/>Embedded within this algorithm is a fail-fast Levenshtein distance
/// algorithm. The fail-fast algorithm differs from the standard Levenshtein
/// distance algorithm in that it is aborted if it is discovered that the
/// mimimum distance between the words is greater than some threshold.
///
- /// <p>To calculate the maximum distance threshold we use the following formula:
+ /// <p/>To calculate the maximum distance threshold we use the following formula:
/// <pre>
/// (1 - minimumSimilarity) * length</pre>
/// where length is the shortest term including any prefix that is not part of the
@@ -212,7 +212,7 @@
/// return (similarity > minimumSimilarity);</pre>
/// where distance is the Levenshtein distance for the two words.
/// </p>
- /// <p>Levenshtein distance (also known as edit distance) is a measure of similiarity
+ /// <p/>Levenshtein distance (also known as edit distance) is a measure of similiarity
/// between two strings where the distance is measured as the number of character
/// deletions, insertions or substitutions required to transform one string to
/// the other string.
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/HitCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/HitCollector.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/HitCollector.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/HitCollector.cs Mon Dec 14 14:13:03 2009
@@ -38,7 +38,7 @@
/// <summary>Called once for every document matching a query, with the document
/// number and its raw score.
///
- /// <P>If, for example, an application wished to collect all of the hits for a
+ /// <p/>If, for example, an application wished to collect all of the hits for a
/// query in a BitSet, then it might:<pre>
/// Searcher searcher = new IndexSearcher(indexReader);
/// final BitSet bits = new BitSet(indexReader.maxDoc());
@@ -49,13 +49,13 @@
/// });
/// </pre>
///
- /// <p>Note: This is called in an inner search loop. For good search
+ /// <p/>Note: This is called in an inner search loop. For good search
/// performance, implementations of this method should not call
/// {@link Searcher#Doc(int)} or
/// {@link Lucene.Net.Index.IndexReader#Document(int)} on every
/// document number encountered. Doing so can slow searches by an order
/// of magnitude or more.
- /// <p>Note: The <code>score</code> passed to this method is a raw score.
+ /// <p/>Note: The <code>score</code> passed to this method is a raw score.
/// In other words, the score will not necessarily be a float whose value is
/// between 0 and 1.
/// </summary>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/HitQueue.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/HitQueue.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/HitQueue.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/HitQueue.cs Mon Dec 14 14:13:03 2009
@@ -56,7 +56,7 @@
/// }
/// </pre>
///
- /// <p><b>NOTE</b>: This class pre-allocate a full array of
+ /// <p/><b>NOTE</b>: This class pre-allocate a full array of
/// length <code>size</code>.
///
/// </summary>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Hits.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Hits.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Hits.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Hits.cs Mon Dec 14 14:13:03 2009
@@ -24,13 +24,13 @@
{
/// <summary> A ranked list of documents, used to hold search results.
- /// <p>
+ /// <p/>
/// <b>Caution:</b> Iterate only over the hits needed. Iterating over all hits is
/// generally not desirable and may be the source of performance issues. If you
/// need to iterate over many or all hits, consider using the search method that
/// takes a {@link HitCollector}.
/// </p>
- /// <p>
+ /// <p/>
/// <b>Note:</b> Deleting matching documents concurrently with traversing the
/// hits, might, when deleting hits that were not yet retrieved, decrease
/// {@link #Length()}. In such case,
@@ -175,7 +175,7 @@
}
/// <summary>Returns the stored fields of the n<sup>th</sup> document in this set.
- /// <p>Documents are cached, so that repeated requests for the same element may
+ /// <p/>Documents are cached, so that repeated requests for the same element may
/// return the same Document object.
/// </summary>
/// <throws> CorruptIndexException if the index is corrupt </throws>
@@ -220,7 +220,7 @@
/// <summary> Returns a {@link HitIterator} to navigate the Hits. Each item returned
/// from {@link Iterator#next()} is a {@link Hit}.
- /// <p>
+ /// <p/>
/// <b>Caution:</b> Iterate only over the hits needed. Iterating over all
/// hits is generally not desirable and may be the source of
/// performance issues. If you need to iterate over many or all hits, consider
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/IndexSearcher.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/IndexSearcher.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/IndexSearcher.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/IndexSearcher.cs Mon Dec 14 14:13:03 2009
@@ -30,14 +30,14 @@
/// <summary>Implements search over a single IndexReader.
///
- /// <p>Applications usually need only call the inherited {@link #Search(Query)}
+ /// <p/>Applications usually need only call the inherited {@link #Search(Query)}
/// or {@link #Search(Query,Filter)} methods. For performance reasons it is
/// recommended to open only one IndexSearcher and use it for all of your searches.
///
- /// <p>Note that you can only access Hits from an IndexSearcher as long as it is
+ /// <p/>Note that you can only access Hits from an IndexSearcher as long as it is
/// not yet closed, otherwise an IOException will be thrown.
///
- /// <a name="thread-safety"></a><p><b>NOTE</b>: {@link
+ /// <a name="thread-safety"></a><p/><b>NOTE</b>: {@link
/// <code>IndexSearcher</code>} instances are completely
/// thread safe, meaning multiple threads can call any of its
/// methods, concurrently. If your application requires
@@ -200,7 +200,7 @@
/// whether or not the fields in the returned {@link FieldDoc} instances
/// should be set by specifying fillFields.<br>
///
- /// <p>
+ /// <p/>
/// NOTE: this does not compute scores by default. If you need scores, create
/// a {@link TopFieldCollector} instance by calling
/// {@link TopFieldCollector#create} and then pass that to
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiSearcher.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/MultiSearcher.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiSearcher.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiSearcher.cs Mon Dec 14 14:13:03 2009
@@ -29,7 +29,7 @@
/// <summary>Implements search over a set of <code>Searchables</code>.
///
- /// <p>Applications usually need only call the inherited {@link #Search(Query)}
+ /// <p/>Applications usually need only call the inherited {@link #Search(Query)}
/// or {@link #Search(Query,Filter)} methods.
/// </summary>
public class MultiSearcher:Searcher
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiTermQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/MultiTermQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiTermQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiTermQuery.cs Mon Dec 14 14:13:03 2009
@@ -30,12 +30,12 @@
/// containing a subset of terms provided by a {@link
/// FilteredTermEnum} enumeration.
///
- /// <p>This query cannot be used directly; you must subclass
+ /// <p/>This query cannot be used directly; you must subclass
/// it and define {@link #getEnum} to provide a {@link
/// FilteredTermEnum} that iterates through the terms to be
/// matched.
///
- /// <p><b>NOTE</b>: if {@link #setRewriteMethod} is either
+ /// <p/><b>NOTE</b>: if {@link #setRewriteMethod} is either
/// {@link #CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE} or {@link
/// #SCORING_BOOLEAN_QUERY_REWRITE}, you may encounter a
/// {@link BooleanQuery.TooManyClauses} exception during
@@ -45,7 +45,7 @@
/// #setRewriteMethod} to {@link #CONSTANT_SCORE_FILTER_REWRITE}
/// prevents this.
///
- /// <p>The recommended rewrite method is {@link
+ /// <p/>The recommended rewrite method is {@link
/// #CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}: it doesn't spend CPU
/// computing unhelpful scores, and it tries to pick the most
/// performant rewrite method given the query.
@@ -111,7 +111,7 @@
/// for that term. Matching documents are assigned a
/// constant score equal to the query's boost.
///
- /// <p> This method is faster than the BooleanQuery
+ /// <p/> This method is faster than the BooleanQuery
/// rewrite methods when the number of matched terms or
/// matched documents is non-trivial. Also, it will never
/// hit an errant {@link BooleanQuery.TooManyClauses}
@@ -169,7 +169,7 @@
/// to compute, so it's almost always better to use {@link
/// #CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} instead.
///
- /// <p><b>NOTE</b>: This rewrite method will hit {@link
+ /// <p/><b>NOTE</b>: This rewrite method will hit {@link
/// BooleanQuery.TooManyClauses} if the number of terms
/// exceeds {@link BooleanQuery#getMaxClauseCount}.
///
@@ -201,7 +201,7 @@
/// document receives a constant score equal to the
/// query's boost.
///
- /// <p><b>NOTE</b>: This rewrite method will hit {@link
+ /// <p/><b>NOTE</b>: This rewrite method will hit {@link
/// BooleanQuery.TooManyClauses} if the number of terms
/// exceeds {@link BooleanQuery#getMaxClauseCount}.
///
@@ -417,11 +417,11 @@
/// <summary> Expert: Return the number of unique terms visited during execution of the query.
/// If there are many of them, you may consider using another query type
/// or optimize your total term count in index.
- /// <p>This method is not thread safe, be sure to only call it when no query is running!
+ /// <p/>This method is not thread safe, be sure to only call it when no query is running!
/// If you re-use the same query instance for another
/// search, be sure to first reset the term counter
/// with {@link #clearTotalNumberOfTerms}.
- /// <p>On optimized indexes / no MultiReaders, you get the correct number of
+ /// <p/>On optimized indexes / no MultiReaders, you get the correct number of
/// unique terms for the whole index. Use this number to compare different queries.
/// For non-optimized indexes this number can also be achived in
/// non-constant-score mode. In constant-score mode you get the total number of
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiTermQueryWrapperFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/MultiTermQueryWrapperFilter.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiTermQueryWrapperFilter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiTermQueryWrapperFilter.cs Mon Dec 14 14:13:03 2009
@@ -28,11 +28,11 @@
/// <summary> A wrapper for {@link MultiTermQuery}, that exposes its
/// functionality as a {@link Filter}.
- /// <P>
+ /// <p/>
/// <code>MultiTermQueryWrapperFilter</code> is not designed to
/// be used by itself. Normally you subclass it to provide a Filter
/// counterpart for a {@link MultiTermQuery} subclass.
- /// <P>
+ /// <p/>
/// For example, {@link TermRangeFilter} and {@link PrefixFilter} extend
/// <code>MultiTermQueryWrapperFilter</code>.
/// This class also provides the functionality behind
@@ -134,7 +134,7 @@
/// <summary> Expert: Return the number of unique terms visited during execution of the filter.
/// If there are many of them, you may consider using another filter type
/// or optimize your total term count in index.
- /// <p>This method is not thread safe, be sure to only call it when no filter is running!
+ /// <p/>This method is not thread safe, be sure to only call it when no filter is running!
/// If you re-use the same filter instance for another
/// search, be sure to first reset the term counter
/// with {@link #clearTotalNumberOfTerms}.
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/NumericRangeFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/NumericRangeFilter.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/NumericRangeFilter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/NumericRangeFilter.cs Mon Dec 14 14:13:03 2009
@@ -29,7 +29,7 @@
/// numeric values using {@link NumericField} (expert: {@link
/// NumericTokenStream}).
///
- /// <p>You create a new NumericRangeFilter with the static
+ /// <p/>You create a new NumericRangeFilter with the static
/// factory methods, eg:
///
/// <pre>
@@ -43,7 +43,7 @@
/// See {@link NumericRangeQuery} for details on how Lucene
/// indexes and searches numeric valued fields.
///
- /// <p><font color="red"><b>NOTE:</b> This API is experimental and
+ /// <p/><font color="red"><b>NOTE:</b> This API is experimental and
/// might change in incompatible ways in the next
/// release.</font>
///
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/NumericRangeQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/NumericRangeQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/NumericRangeQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/NumericRangeQuery.cs Mon Dec 14 14:13:03 2009
@@ -28,7 +28,7 @@
namespace Lucene.Net.Search
{
- /// <summary> <p>A {@link Query} that matches numeric values within a
+ /// <summary> <p/>A {@link Query} that matches numeric values within a
/// specified range. To use this, you must first index the
/// numeric values using {@link NumericField} (expert: {@link
/// NumericTokenStream}). If your terms are instead textual,
@@ -36,7 +36,7 @@
/// NumericRangeFilter} is the filter equivalent of this
/// query.</p>
///
- /// <p>You create a new NumericRangeQuery with the static
+ /// <p/>You create a new NumericRangeQuery with the static
/// factory methods, eg:
///
/// <pre>
@@ -48,12 +48,12 @@
/// matches all documents whose float valued "weight" field
/// ranges from 0.3 to 0.10, inclusive.
///
- /// <p>The performance of NumericRangeQuery is much better
+ /// <p/>The performance of NumericRangeQuery is much better
/// than the corresponding {@link TermRangeQuery} because the
/// number of terms that must be searched is usually far
/// fewer, thanks to trie indexing, described below.</p>
///
- /// <p>You can optionally specify a <a
+ /// <p/>You can optionally specify a <a
/// href="#precisionStepDesc"><code>precisionStep</code></a>
/// when creating this query. This is necessary if you've
/// changed this configuration from its default (4) during
@@ -64,7 +64,7 @@
/// classes. See <a href="#precisionStepDesc">below</a> for
/// details.
///
- /// <p>This query defaults to {@linkplain
+ /// <p/>This query defaults to {@linkplain
/// MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} for
/// 32 bit (int/float) ranges with precisionStep ≤8 and 64
/// bit (long/double) ranges with precisionStep ≤6.
@@ -75,12 +75,12 @@
/// BooleanQuery rewrite methods without changing
/// BooleanQuery's default max clause count.
///
- /// <p><font color="red"><b>NOTE:</b> This API is experimental and
+ /// <p/><font color="red"><b>NOTE:</b> This API is experimental and
/// might change in incompatible ways in the next release.</font>
///
/// <br><h3>How it works</h3>
///
- /// <p>See the publication about <a target="_blank" href="http://www.panfmp.org">panFMP</a>,
+ /// <p/>See the publication about <a target="_blank" href="http://www.panfmp.org">panFMP</a>,
/// where this algorithm was described (referred to as <code>TrieRangeQuery</code>):
///
/// <blockquote><strong>Schindler, U, Diepenbroek, M</strong>, 2008.
@@ -89,7 +89,7 @@
/// <a href="http://dx.doi.org/10.1016/j.cageo.2008.02.023"
/// target="_blank">doi:10.1016/j.cageo.2008.02.023</a></blockquote>
///
- /// <p><em>A quote from this paper:</em> Because Apache Lucene is a full-text
+ /// <p/><em>A quote from this paper:</em> Because Apache Lucene is a full-text
/// search engine and not a conventional database, it cannot handle numerical ranges
/// (e.g., field value is inside user defined bounds, even dates are numerical values).
/// We have developed an extension to Apache Lucene that stores
@@ -101,7 +101,7 @@
/// The center of the range is searched only with the lowest possible precision in the <em>trie</em>,
/// while the boundaries are matched more exactly. This reduces the number of terms dramatically.</p>
///
- /// <p>For the variant that stores long values in 8 different precisions (each reduced by 8 bits) that
+ /// <p/>For the variant that stores long values in 8 different precisions (each reduced by 8 bits) that
/// uses a lowest precision of 1 byte, the index contains only a maximum of 256 distinct values in the
/// lowest precision. Overall, a range could consist of a theoretical maximum of
/// <code>7*255*2 + 255 = 3825</code> distinct terms (when there is a term for every distinct value of an
@@ -111,14 +111,14 @@
/// and a uniform value distribution).</p>
///
/// <a name="precisionStepDesc"><h3>Precision Step</h3>
- /// <p>You can choose any <code>precisionStep</code> when encoding values.
+ /// <p/>You can choose any <code>precisionStep</code> when encoding values.
/// Lower step values mean more precisions and so more terms in index (and index gets larger).
/// On the other hand, the maximum number of terms to match reduces, which optimized query speed.
/// The formula to calculate the maximum term count is:
/// <pre>
/// n = [ (bitsPerValue/precisionStep - 1) * (2^precisionStep - 1 ) * 2 ] + (2^precisionStep - 1 )
/// </pre>
- /// <p><em>(this formula is only correct, when <code>bitsPerValue/precisionStep</code> is an integer;
+ /// <p/><em>(this formula is only correct, when <code>bitsPerValue/precisionStep</code> is an integer;
/// in other cases, the value must be rounded up and the last summand must contain the modulo of the division as
/// precision step)</em>.
/// For longs stored using a precision step of 4, <code>n = 15*15*2 + 15 = 465</code>, and for a precision
@@ -127,7 +127,7 @@
/// be found out by testing. <b>Important:</b> You can index with a lower precision step value and test search speed
/// using a multiple of the original step value.</p>
///
- /// <p>Good values for <code>precisionStep</code> are depending on usage and data type:
+ /// <p/>Good values for <code>precisionStep</code> are depending on usage and data type:
/// <ul>
/// <li>The default for all data types is <b>4</b>, which is used, when no <code>precisionStep</code> is given.
/// <li>Ideal value in most cases for <em>64 bit</em> data types <em>(long, double)</em> is <b>6</b> or <b>8</b>.
@@ -140,7 +140,7 @@
/// Sorting is also possible with range query optimized fields using one of the above <code>precisionSteps</code>.
/// </ul>
///
- /// <p>Comparisons of the different types of RangeQueries on an index with about 500,000 docs showed
+ /// <p/>Comparisons of the different types of RangeQueries on an index with about 500,000 docs showed
/// that {@link TermRangeQuery} in boolean rewrite mode (with raised {@link BooleanQuery} clause count)
/// took about 30-40 secs to complete, {@link TermRangeQuery} in constant score filter rewrite mode took 5 secs
/// and executing this class took <100ms to complete (on an Opteron64 machine, Java 1.5, 8 bit
@@ -367,7 +367,7 @@
/// <summary> Subclass of FilteredTermEnum for enumerating all terms that match the
/// sub-ranges for trie range queries.
- /// <p>
+ /// <p/>
/// WARNING: This term enumeration is not guaranteed to be always ordered by
/// {@link Term#compareTo}.
/// The ordering depends on how {@link NumericUtils#splitLongRange} and
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ParallelMultiSearcher.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/ParallelMultiSearcher.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ParallelMultiSearcher.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ParallelMultiSearcher.cs Mon Dec 14 14:13:03 2009
@@ -26,7 +26,7 @@
/// <summary>Implements parallel search over a set of <code>Searchables</code>.
///
- /// <p>Applications usually need only call the inherited {@link #Search(Query)}
+ /// <p/>Applications usually need only call the inherited {@link #Search(Query)}
/// or {@link #Search(Query,Filter)} methods.
/// </summary>
public class ParallelMultiSearcher:MultiSearcher
@@ -196,9 +196,9 @@
/// <summary>Lower-level search API.
///
- /// <p>{@link Collector#Collect(int)} is called for every matching document.
+ /// <p/>{@link Collector#Collect(int)} is called for every matching document.
///
- /// <p>Applications should only use this if they need <i>all</i> of the
+ /// <p/>Applications should only use this if they need <i>all</i> of the
/// matching documents. The high-level search API ({@link
/// Searcher#Search(Query)}) is usually more efficient, as it skips
/// non-high-scoring hits.
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Payloads/BoostingTermQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Payloads/BoostingTermQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Payloads/BoostingTermQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Payloads/BoostingTermQuery.cs Mon Dec 14 14:13:03 2009
@@ -30,10 +30,10 @@
/// <summary> The BoostingTermQuery is very similar to the {@link Lucene.Net.Search.Spans.SpanTermQuery} except
/// that it factors in the value of the payload located at each of the positions where the
/// {@link Lucene.Net.Index.Term} occurs.
- /// <p>
+ /// <p/>
/// In order to take advantage of this, you must override {@link Lucene.Net.Search.Similarity#ScorePayload(String, byte[],int,int)}
/// which returns 1 by default.
- /// <p>
+ /// <p/>
/// Payload scores are averaged across term occurrences in the document.
///
/// </summary>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Payloads/PayloadTermQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Payloads/PayloadTermQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Payloads/PayloadTermQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Payloads/PayloadTermQuery.cs Mon Dec 14 14:13:03 2009
@@ -38,11 +38,11 @@
/// {@link Lucene.Net.Search.Spans.SpanTermQuery} except that it factors
/// in the value of the payload located at each of the positions where the
/// {@link Lucene.Net.Index.Term} occurs.
- /// <p>
+ /// <p/>
/// In order to take advantage of this, you must override
/// {@link Lucene.Net.Search.Similarity#ScorePayload(String, byte[],int,int)}
/// which returns 1 by default.
- /// <p>
+ /// <p/>
/// Payload scores are aggregated using a pluggable {@link PayloadFunction}.
///
/// </summary>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/PhraseQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/PhraseQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/PhraseQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/PhraseQuery.cs Mon Dec 14 14:13:03 2009
@@ -29,7 +29,7 @@
/// <summary>A Query that matches documents containing a particular sequence of terms.
/// A PhraseQuery is built by QueryParser for input like <code>"new york"</code>.
///
- /// <p>This query may be combined with other terms or queries with a {@link BooleanQuery}.
+ /// <p/>This query may be combined with other terms or queries with a {@link BooleanQuery}.
/// </summary>
[Serializable]
public class PhraseQuery:Query
@@ -48,14 +48,14 @@
/// <summary>Sets the number of other words permitted between words in query phrase.
/// If zero, then this is an exact phrase search. For larger values this works
/// like a <code>WITHIN</code> or <code>NEAR</code> operator.
- /// <p>The slop is in fact an edit-distance, where the units correspond to
+ /// <p/>The slop is in fact an edit-distance, where the units correspond to
/// moves of terms in the query phrase out of position. For example, to switch
/// the order of two words requires two moves (the first move places the words
/// atop one another), so to permit re-orderings of phrases, the slop must be
/// at least two.
- /// <p>More exact matches are scored higher than sloppier matches, thus search
+ /// <p/>More exact matches are scored higher than sloppier matches, thus search
/// results are sorted by exactness.
- /// <p>The slop is zero by default, requiring exact matches.
+ /// <p/>The slop is zero by default, requiring exact matches.
/// </summary>
public virtual void SetSlop(int s)
{
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/PrefixQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/PrefixQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/PrefixQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/PrefixQuery.cs Mon Dec 14 14:13:03 2009
@@ -27,7 +27,7 @@
/// <summary>A Query that matches documents containing terms with a specified prefix. A PrefixQuery
/// is built by QueryParser for input like <code>app*</code>.
///
- /// <p>This query uses the {@link
+ /// <p/>This query uses the {@link
/// MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}
/// rewrite method.
/// </summary>